ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
InDet::InDetExtensionProcessor Class Reference

Algorithm to process a TrackExtensionMap, refit the extended tracks and decide if the old track is to be replaced by the extended one. More...

#include <InDetExtensionProcessor.h>

Inheritance diagram for InDet::InDetExtensionProcessor:
Collaboration diagram for InDet::InDetExtensionProcessor:

Public Member Functions

 InDetExtensionProcessor (const std::string &name, ISvcLocator *pSvcLocator)
 Default Algorithm constructor with parameters. More...
 
virtual StatusCode initialize ()
 
virtual StatusCode execute (const EventContext &ctx) const
 
virtual StatusCode finalize ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

enum  StatIndex {
  iAll, iBarrel, iTransi, iEndcap,
  Nregions
}
 internal monitoring: categories for counting different types of extension results More...
 
enum  StatTrkType {
  nInput, nRecognised, nExtended, nRejected,
  nFailed, nRecoveryBremFits, nBremFits, nFits,
  nNotExtended, nLowScoreBremFits, nExtendedBrem, nTypes
}
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

MsgStream & dumpStat (MsgStream &out) const
 
TrackCollectioncreateExtendedTracks (const EventContext &ctx, const TrackCollection *tracks_in, const TrackExtensionMap *track_extension_map) const
 process events More...
 
Trk::TracktrackPlusExtension (const EventContext &ctx, const Trk::Track *, const std::vector< const Trk::MeasurementBase * > &) const
 internal structuring: creates new track with original one plus extension as outliers More...
 
void incrementRegionCounter (std::array< std::atomic< int >, 4 > &, const Trk::Track *, bool=true) const
 monitoring and validation: does success/failure counting for each detector region More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadHandleKey< TrackCollectionm_trackName
 
SG::ReadHandleKey< TrackExtensionMapm_extensionMapName
 
SG::WriteHandleKey< TrackCollectionm_newTrackName
 
PublicToolHandle< Trk::ITrackFitterm_trackFitter
 
ToolHandle< Trk::IExtendedTrackSummaryToolm_trackSummaryTool
 
PublicToolHandle< Trk::ITrackScoringToolm_scoringTool
 
BooleanProperty m_cosmics
 
Gaudi::Property< Trk::RunOutlierRemovalm_runOutlier
 
BooleanProperty m_keepFailedExtensionOnTrack
 
BooleanProperty m_refitPrds
 
IntegerProperty m_matEffects
 
BooleanProperty m_suppressHoleSearch
 
BooleanProperty m_tryBremFit
 
BooleanProperty m_caloSeededBrem
 
FloatProperty m_pTminBrem
 
Gaudi::Property< std::vector< float > > m_etabounds
 
Trk::ParticleHypothesis m_particleHypothesis {Trk::undefined}
 nomen est omen More...
 
std::array< std::array< std::atomic< int >, Nregions >, nTypes > m_counters ATLAS_THREAD_SAFE
 
std::atomic< int > m_Nevents ATLAS_THREAD_SAFE
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Algorithm to process a TrackExtensionMap, refit the extended tracks and decide if the old track is to be replaced by the extended one.

Author
Marku.nosp@m.s.El.nosp@m.sing@.nosp@m.cern.nosp@m..ch

Definition at line 37 of file InDetExtensionProcessor.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ StatIndex

internal monitoring: categories for counting different types of extension results

Enumerator
iAll 
iBarrel 
iTransi 
iEndcap 
Nregions 

Definition at line 108 of file InDetExtensionProcessor.h.

108  {
110  };

◆ StatTrkType

Enumerator
nInput 
nRecognised 
nExtended 
nRejected 
nFailed 
nRecoveryBremFits 
nBremFits 
nFits 
nNotExtended 
nLowScoreBremFits 
nExtendedBrem 
nTypes 

Definition at line 112 of file InDetExtensionProcessor.h.

Constructor & Destructor Documentation

◆ InDetExtensionProcessor()

InDet::InDetExtensionProcessor::InDetExtensionProcessor ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Default Algorithm constructor with parameters.

Definition at line 38 of file InDetExtensionProcessor.cxx.

38  :
39  AthReentrantAlgorithm(name, pSvcLocator),
40  m_counters{},
41  m_Nevents(0)
42 {}

Member Function Documentation

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ createExtendedTracks()

TrackCollection * InDet::InDetExtensionProcessor::createExtendedTracks ( const EventContext &  ctx,
const TrackCollection tracks_in,
const TrackExtensionMap track_extension_map 
) const
private

process events

Definition at line 93 of file InDetExtensionProcessor.cxx.

95  {
96  std::unique_ptr<TrackCollection> newTracks(std::make_unique<TrackCollection>());
97  std::array< std::array<std::atomic<int>, Nregions>, nTypes> counters{};
98  // loop over tracks
99  for (const Trk::Track* thisTrack : *pTracks) {
100  // statistics
101  incrementRegionCounter(counters[nInput], thisTrack, false);
102  ATH_MSG_DEBUG("evaluate input track : " << thisTrack);
103  // try to find this track in extension map
104  TrackExtensionMap::const_iterator pThisExtensionPair = trackExtensionMap->find(thisTrack);
105  // copy input track if this track is not found in list
106  if (pThisExtensionPair == trackExtensionMap->end()) {
107  ATH_MSG_DEBUG("track not in extension map, copy original track to output");
108  // copy track, set pattern info
109  std::unique_ptr<Trk::Track> ntrk(std::make_unique<Trk::Track>(*thisTrack));
110  ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
111  newTracks->push_back(std::move(ntrk));
112  // statistics
114  } else {
115  ATH_MSG_DEBUG("track found in extension map, processing...");
116  // statistics
118  // setup new track
119  std::unique_ptr<Trk::Track> newtrack;
120  // keep old track info
121  const Trk::TrackInfo oldTrackInfo = thisTrack->info();
122  // keep list of PRDs, initially assumed to be same size as pThisExtensionPair->second
123  const auto nRIO_OnTrack {pThisExtensionPair->second.size()};
124  std::vector<const Trk::PrepRawData*> vecPrd;
125  vecPrd.reserve(nRIO_OnTrack);
126  // --- refit PRD ?
127  if (m_refitPrds) {
128  auto getPrepRawDataPtr = [](const Trk::MeasurementBase* m) {
129  const auto& pRot = dynamic_cast <const Trk::RIO_OnTrack*>(m);
130  return pRot ? pRot->prepRawData() : nullptr;
131  };
132  const auto& theRIOs_OnTrack {pThisExtensionPair->second};
133  //NOTE: Assumes success; I don't remove any nullptrs which result! (could use copy_if)
134  std::transform(theRIOs_OnTrack.begin(), theRIOs_OnTrack.end(), std::back_inserter(vecPrd), getPrepRawDataPtr);
135  // we have the PRD Vector, we need to refit the track and see if it is better
136  ATH_MSG_DEBUG("fit track " << thisTrack << " with PRDs, number : " << vecPrd.size());
137  if (!m_cosmics) {
138  // normal event processing
139  if (m_tryBremFit && thisTrack->info().trackProperties(Trk::TrackInfo::BremFit)) {
140  ATH_MSG_DEBUG("brem fit of electron like track");
141  //statistics
143  // try brem fit of combined track
144  newtrack = m_trackFitter->fit(
145  ctx, *thisTrack, vecPrd, m_runOutlier, Trk::electron);
146  } else {
147  ATH_MSG_DEBUG("normal fit track");
148  //statistics
150  // normal fit of combined track
151  newtrack = m_trackFitter->fit(ctx,
152  *thisTrack, vecPrd, m_runOutlier, m_particleHypothesis);
153  if (!newtrack && m_tryBremFit &&
154  thisTrack->trackParameters()->front()->pT() > m_pTminBrem &&
155  (!m_caloSeededBrem || thisTrack->info().patternRecoInfo(
157  ATH_MSG_DEBUG("normal fit track failed, try to recover with brem fit");
158  // statistics
160  // try brem fit of combined track
161  newtrack=m_trackFitter->fit(ctx,*thisTrack, vecPrd, m_runOutlier, Trk::electron);
162  }
163  }
164  } else {
165  // ===> special case for cosmics
166  std::vector<const Trk::PrepRawData*> vecPrdComb;
167  // get track parameters
168  const Trk::Perigee* siPerigee = thisTrack->perigeeParameters();
169  if (!siPerigee) {
170  ATH_MSG_DEBUG("no perigee found on track, copy input");
171  // statistics
173  // copy track, set pattern info
174  std::unique_ptr<Trk::Track> ntrk(std::make_unique< Trk::Track>(*thisTrack));
175  ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
176  newTracks->push_back(std::move(ntrk));
177  } else {
178  // loop over extension RIO-on-tracks and add PRD it into vecPrdComb
180  pThisExtensionPair->first->measurementsOnTrack()->begin();
181  for (; RIOit != pThisExtensionPair->first->measurementsOnTrack()->end(); ++RIOit) {
182  const Trk::RIO_OnTrack* rot = dynamic_cast <const Trk::RIO_OnTrack*> (*RIOit);
183  if (!rot) ATH_MSG_ERROR("cast to ROT failed, should not happen here !");
184  else vecPrdComb.push_back(rot->prepRawData());
185  }
186  // merge lists
187  for (auto & i : vecPrd) {
188  double inprod =
189  (i->detectorElement()->surface(i->identify()).center() - siPerigee->position()).dot(
190  siPerigee->momentum());
191  if (inprod < 0) {
192  vecPrdComb.insert(vecPrdComb.begin(), i);
193  } else {
194  vecPrdComb.push_back(i);
195  }
196  }
197  //statistics
199  // normal fit of combined track
200  newtrack = m_trackFitter->fit(
201  ctx, vecPrdComb, *siPerigee, m_runOutlier, m_particleHypothesis);
202  }
203  }
204  } else {
205  const auto& RIOs_OnTrack {pThisExtensionPair->second};
206  // we have an extension map with RIO-on-tracks, we need to refit the track and see if it is better
207  ATH_MSG_DEBUG("fit track " << thisTrack << " with ROTs, number : " << RIOs_OnTrack.size());
208  if (!m_cosmics) {
209  if (m_tryBremFit && thisTrack->info().trackProperties(Trk::TrackInfo::BremFit)) {
210  ATH_MSG_DEBUG("brem fit of electron like track");
211  //statistics
213  // try brem fit of combined track
214  newtrack=m_trackFitter->fit(ctx,*thisTrack, RIOs_OnTrack, m_runOutlier, Trk::electron);
215  } else {
216  ATH_MSG_DEBUG("normal fit track");
217  //statistics
219  // fit combined track
220  newtrack=m_trackFitter->fit(ctx,*thisTrack, RIOs_OnTrack, m_runOutlier, m_particleHypothesis);
221  if (!newtrack && m_tryBremFit &&
222  thisTrack->trackParameters()->front()->pT() > m_pTminBrem &&
223  (!m_caloSeededBrem || thisTrack->info().patternRecoInfo(Trk::TrackInfo::TrackInCaloROI))) {
224  ATH_MSG_DEBUG("normal fit track failed, try to recover with brem fit");
225  // statistics
227  // try to recover with brem fit
228  newtrack=m_trackFitter->fit(ctx,*thisTrack, RIOs_OnTrack, m_runOutlier, Trk::electron);
229  }
230  }//end-if of normal track fit
231  } else {
232  // special case for cosmics
233  Trk::MeasurementSet rotSet;
234  // get track parameters
235  const Trk::Perigee* siPerigee = thisTrack->perigeeParameters();
236  if (!siPerigee) {
237  ATH_MSG_DEBUG("no perigee found on track, copy input");
238  // statistics
240  // copy track, set pattern info
241  std::unique_ptr<Trk::Track> ntrk(std::make_unique< Trk::Track>(*thisTrack));
242  ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
243  newTracks->push_back(std::move(ntrk));
244  } else {
245  // extract RIO-on-tracks from extension
247  pThisExtensionPair->first->measurementsOnTrack()->begin();
248  for (; RIOit != pThisExtensionPair->first->measurementsOnTrack()->end(); ++RIOit) {
249  rotSet.push_back(*RIOit);
250  }
251  // merge RIO-on-track lists
252  for (const auto *i : pThisExtensionPair->second) {
253  double inprod = (i->associatedSurface().center() - siPerigee->position()).dot(
254  siPerigee->momentum());
255  if (inprod < 0) {
256  rotSet.insert(rotSet.begin(), i);
257  } else {
258  rotSet.push_back(i);
259  }
260  }
261  ATH_MSG_DEBUG("normal fit track");
262  //statistics
264  // fit combined track
265  newtrack=m_trackFitter->fit(ctx,rotSet, *siPerigee, m_runOutlier, m_particleHypothesis);
266  }
267  }
268  }
269  if (!newtrack) {
270  ATH_MSG_DEBUG("refit of extended track failed, copy original track to output");
271  // statistics
273  // push track into output, does copy, needs fixing
275  newTracks->push_back(trackPlusExtension(ctx,thisTrack, pThisExtensionPair->second));
276  } else {
277  // copy track, set pattern info
278  std::unique_ptr<Trk::Track> ntrk(std::make_unique<Trk::Track>(*thisTrack));
279  ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
280  newTracks->push_back(std::move(ntrk));
281  }
282  } else {
283  // score old and new tool and decide which one to push back
284  Trk::TrackScore oldScore = m_scoringTool->score(*thisTrack);
285  ATH_MSG_DEBUG("original track has score : " << oldScore);
286  Trk::TrackScore newScore = Trk::TrackScore(0);
287  bool passBasicSelections = m_scoringTool->passBasicSelections(*newtrack);
288  if(passBasicSelections){
289  if (m_trackSummaryTool.isEnabled()) {
290  m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *newtrack, m_suppressHoleSearch);
291  }
292  bool recheckBasicSel = false;
293  newScore = m_scoringTool->score(*newtrack, recheckBasicSel);
294  }
295  ATH_MSG_DEBUG("new track has score : " << newScore);
296  // do we need to recover with a brem fit
297  if (newScore < oldScore && m_tryBremFit &&
299  thisTrack->trackParameters()->front()->pT() > m_pTminBrem &&
300  (!m_caloSeededBrem || thisTrack->info().patternRecoInfo(Trk::TrackInfo::TrackInCaloROI))) {
301  ATH_MSG_DEBUG("new track has low score, try to recover track using brem fit");
302  // statistics
304  std::unique_ptr<Trk::Track> newBremTrack;
305  // try to recover with brem fit
306  if (m_refitPrds) {
307  newBremTrack=m_trackFitter->fit(ctx,*thisTrack, vecPrd, m_runOutlier, Trk::electron);
308  } else {
309  newBremTrack=m_trackFitter->fit(ctx,*thisTrack, pThisExtensionPair->second, m_runOutlier, Trk::electron);
310  }
311  if (newBremTrack) {
312  // score again
313  // @TODO should score newBremTrack + only replace summary if passBasicSelection
314  if (m_trackSummaryTool.isEnabled()) {
315  m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *newBremTrack, m_suppressHoleSearch);
316  }
317  newScore = m_scoringTool->score(*newtrack);
318  ATH_MSG_DEBUG("recovered new track has score : " << newScore);
319  // copy pointer
320  newtrack = std::move(newBremTrack);
321  }
322  }
323  if (newScore >= oldScore) {
324  ATH_MSG_DEBUG("take extended track, it's better !");
325  // statistics
329  }
330  //storing the precedent info
331  newtrack->info().addPatternReco(oldTrackInfo);
332  // push track into output
334  newTracks->push_back(std::move(newtrack));
335  } else {
336  ATH_MSG_DEBUG("take original track, new one is worse !");
337  // statistics
339  // push track into output, does copy
340  std::unique_ptr<Trk::Track> ntrk;
342  ntrk.reset(trackPlusExtension(ctx,thisTrack, pThisExtensionPair->second));
343  } else {
344  ntrk = std::make_unique<Trk::Track>(*thisTrack);
345  }
347  newTracks->push_back(std::move(ntrk));
348  }
349  }
350  }
351  }
352 
353  {
354 
355  for (unsigned int itype = 0; itype < InDet::InDetExtensionProcessor::nTypes; itype++) m_counters[itype] += counters[itype];
356  }
357  return newTracks.release();
358 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ dumpStat()

MsgStream & InDet::InDetExtensionProcessor::dumpStat ( MsgStream &  out) const
private

Definition at line 456 of file InDetExtensionProcessor.cxx.

457 {
458  int iw = 9;
459  out.width(9);
460  out << "-------------------------------------------------------------------------------" << std::endl;
461  out << " Number of events processed : " << m_Nevents << std::endl;
462  out << " statistics by eta range ------All---Barrel---Trans.-- Endcap-- " << std::endl;
463  out << "-------------------------------------------------------------------------------" << std::endl;
464  out << " Number of tracks at input :" << std::setiosflags(std::ios::dec) << std::setw(iw)
465  << m_counters[InDet::InDetExtensionProcessor::nInput][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
466  << m_counters[InDet::InDetExtensionProcessor::nInput][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(iw)
467  << m_counters[InDet::InDetExtensionProcessor::nInput][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(iw)
469  out << " Number of not extended tracks :" << std::setiosflags(std::ios::dec) << std::setw(iw)
470  << m_counters[InDet::InDetExtensionProcessor::nNotExtended][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) <<
471  std::setw(iw)
472  << m_counters[InDet::InDetExtensionProcessor::nNotExtended][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
473  std::setw(iw)
474  << m_counters[InDet::InDetExtensionProcessor::nNotExtended][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
475  std::setw(iw)
477  out << " Number of proposed ext. roads :" << std::setiosflags(std::ios::dec) << std::setw(iw)
478  << m_counters[InDet::InDetExtensionProcessor::nRecognised][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
479  << m_counters[InDet::InDetExtensionProcessor::nRecognised][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(
480  iw)
481  << m_counters[InDet::InDetExtensionProcessor::nRecognised][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(
482  iw)
484  out << "-------------------------------------------------------------------------------" << std::endl;
485  out << " Number of track fits :" << std::setiosflags(std::ios::dec) << std::setw(iw)
486  << m_counters[InDet::InDetExtensionProcessor::nFits][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
487  << m_counters[InDet::InDetExtensionProcessor::nFits][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(iw)
488  << m_counters[InDet::InDetExtensionProcessor::nFits][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(iw)
490  if (m_tryBremFit) {
491  out << " + brem fits for electron tracks :" << std::setiosflags(std::ios::dec) << std::setw(iw)
492  << m_counters[InDet::InDetExtensionProcessor::nBremFits][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
493  << m_counters[InDet::InDetExtensionProcessor::nBremFits][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(
494  iw)
495  << m_counters[InDet::InDetExtensionProcessor::nBremFits][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(
496  iw)
498  out << " + brem fit to recover failed fit:" << std::setiosflags(std::ios::dec) << std::setw(iw)
499  << m_counters[InDet::InDetExtensionProcessor::nRecoveryBremFits][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) <<
500  std::setw(iw)
501  << m_counters[InDet::InDetExtensionProcessor::nRecoveryBremFits][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
502  std::setw(iw)
503  << m_counters[InDet::InDetExtensionProcessor::nRecoveryBremFits][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
504  std::setw(iw)
506  out << " + brem fit to recover low score :" << std::setiosflags(std::ios::dec) << std::setw(iw)
507  << m_counters[InDet::InDetExtensionProcessor::nLowScoreBremFits][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) <<
508  std::setw(iw)
509  << m_counters[InDet::InDetExtensionProcessor::nLowScoreBremFits][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
510  std::setw(iw)
511  << m_counters[InDet::InDetExtensionProcessor::nLowScoreBremFits][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
512  std::setw(iw)
514  }
515  out << "-------------------------------------------------------------------------------" << std::endl;
516  out << " Number of track fit failing :" << std::setiosflags(std::ios::dec) << std::setw(iw)
517  << m_counters[InDet::InDetExtensionProcessor::nFailed][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
518  << m_counters[InDet::InDetExtensionProcessor::nFailed][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(iw)
519  << m_counters[InDet::InDetExtensionProcessor::nFailed][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(iw)
521  out << " Number of rejected extensions :" << std::setiosflags(std::ios::dec) << std::setw(iw)
522  << m_counters[InDet::InDetExtensionProcessor::nRejected][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
523  << m_counters[InDet::InDetExtensionProcessor::nRejected][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
524  std::setw(iw)
525  << m_counters[InDet::InDetExtensionProcessor::nRejected][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
526  std::setw(iw)
528  out << " Number of successful extensions :" << std::setiosflags(std::ios::dec) << std::setw(iw)
529  << m_counters[InDet::InDetExtensionProcessor::nExtended][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
530  << m_counters[InDet::InDetExtensionProcessor::nExtended][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
531  std::setw(iw)
532  << m_counters[InDet::InDetExtensionProcessor::nExtended][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
533  std::setw(iw)
535  if (m_tryBremFit) {
536  out << " including brem fitted tracks :" << std::setiosflags(std::ios::dec) << std::setw(iw)
537  << m_counters[InDet::InDetExtensionProcessor::nExtendedBrem][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) <<
538  std::setw(iw)
539  << m_counters[InDet::InDetExtensionProcessor::nExtendedBrem][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
540  std::setw(iw)
541  << m_counters[InDet::InDetExtensionProcessor::nExtendedBrem][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
542  std::setw(iw)
544  }
545  out << "-------------------------------------------------------------------------------" << std::endl;
546  out << std::setiosflags(std::ios::fixed | std::ios::showpoint) << std::setprecision(2)
547  << " definition: ( 0.0 < Barrel < " << m_etabounds[0] << " < Transition < " << m_etabounds[1]
548  << " < Endcap < " << m_etabounds[2] << " )" << std::setprecision(-1) << std::endl;
549  out << "-------------------------------------------------------------------------------" << std::endl;
550  return out;
551 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode InDet::InDetExtensionProcessor::execute ( const EventContext &  ctx) const
virtual

Definition at line 71 of file InDetExtensionProcessor.cxx.

71  {
72  // process the extensions
75  SG::WriteHandle<TrackCollection> extendedTracksResult(m_newTrackName, ctx);
76  const auto nTracks {tracks->size()};
77  ATH_MSG_DEBUG("Number of Tracks found : " << nTracks);
78  // input statistics
79  {
80  ++m_Nevents;
82  }
83  ATH_CHECK(extendedTracksResult.record(std::unique_ptr<TrackCollection>(
84  createExtendedTracks(ctx, tracks.cptr(), trackExtensionMap.cptr()))));
85  ATH_MSG_DEBUG("Container '" << m_newTrackName.key()
86  << "' recorded in StoreGate, size : "
87  << extendedTracksResult->size());
88  if (extendedTracksResult->size() != nTracks) ATH_MSG_WARNING("Lost tracks after extension ??? This is a bug !");
89  return StatusCode::SUCCESS;
90 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ finalize()

StatusCode InDet::InDetExtensionProcessor::finalize ( )
virtual

Definition at line 446 of file InDetExtensionProcessor.cxx.

446  {
447  if (msgLvl(MSG::INFO)) {
448  MsgStream &out = msg(MSG::INFO);
449  out << "::finalize() -- statistics:" << std::endl;
450  dumpStat(out);
451  out << endmsg;
452  }
453  return StatusCode::SUCCESS;
454 }

◆ incrementRegionCounter()

void InDet::InDetExtensionProcessor::incrementRegionCounter ( std::array< std::atomic< int >, 4 > &  Ntracks,
const Trk::Track track,
bool  updateAll = true 
) const
private

monitoring and validation: does success/failure counting for each detector region

Definition at line 362 of file InDetExtensionProcessor.cxx.

363  {
364  if (updateAll) Ntracks[InDet::InDetExtensionProcessor::iAll] += 1;
365  // test
366  if (!track) {
367  ATH_MSG_ERROR("track pointer zero, should not happen!");
368  return;
369  }
370  const auto *const pTrackParameters {track->trackParameters()};
371  // use first parameter
372  if (not pTrackParameters) {
373  ATH_MSG_WARNING("No track parameters, needed for statistics code in Trk::SimpleAmbiguityProcessorTool!");
374  } else {
375  const double absEta = std::abs(pTrackParameters->front()->eta());
379  }
380 }

◆ initialize()

StatusCode InDet::InDetExtensionProcessor::initialize ( )
virtual

Definition at line 48 of file InDetExtensionProcessor.cxx.

48  {
49  ATH_MSG_DEBUG("InDetExtensionProcessor::initialize()");
50  ATH_CHECK(m_trackFitter.retrieve());
51  ATH_MSG_DEBUG("Retrieved tool " << m_trackFitter);
52  // Configuration of the material effects
54  //
55  ATH_CHECK(m_trackSummaryTool.retrieve(DisableTool {m_trackSummaryTool.name().empty()}));
56  ATH_CHECK(m_scoringTool.retrieve());
57  ATH_MSG_DEBUG("Retrieved tool " << m_scoringTool);
58  // brem fitting enabled ?
59  if (m_tryBremFit) ATH_MSG_DEBUG("Try brem fit and recovery for electron like tracks.");
60  //
61  ATH_CHECK(m_trackName.initialize());
63  ATH_CHECK(m_newTrackName.initialize());
64  return StatusCode::SUCCESS;
65 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ trackPlusExtension()

Trk::Track * InDet::InDetExtensionProcessor::trackPlusExtension ( const EventContext &  ctx,
const Trk::Track siTrack,
const std::vector< const Trk::MeasurementBase * > &  extension 
) const
private

internal structuring: creates new track with original one plus extension as outliers

Definition at line 385 of file InDetExtensionProcessor.cxx.

389 {
390  const auto& trackStatesOnSurfaces{ *(siTrack->trackStateOnSurfaces()) };
391  auto pExtendedTrajectory = std::make_unique<Trk::TrackStates>();
392 
393  pExtendedTrajectory->reserve(trackStatesOnSurfaces.size() + extension.size());
394  int nSiStates = 0, nExtStates = 0;
395  // copy existing si track as first part to new track - including all track pars since fit does not change
396  auto cloneTSOS = [](const Trk::TrackStateOnSurface* pTSOS) {
397  return new Trk::TrackStateOnSurface(*pTSOS);
398  };
399  std::transform(trackStatesOnSurfaces.begin(), trackStatesOnSurfaces.end(), std::back_inserter(
400  *pExtendedTrajectory), cloneTSOS);
401  nSiStates += trackStatesOnSurfaces.size();
402  // copy proposed (but failed) extension as second part onto new track - all hits flagged as outliers.
403  constexpr auto outlierDigit {1 << Trk::TrackStateOnSurface::Outlier};
404  constexpr std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> outlierPattern(outlierDigit);
405  //create new track state on surface
406  auto createNewTSOS = [outlierPattern](const Trk::MeasurementBase* pm) -> const Trk::TrackStateOnSurface*{
407  return new Trk::TrackStateOnSurface(pm->uniqueClone(), nullptr, nullptr, outlierPattern);
408  };
409  //Adding to cosmic tracks beginning or end depending on the direction of track
410  auto addNewTSOS_ForCosmics = [&pExtendedTrajectory, siTrack, createNewTSOS](const Trk::MeasurementBase* pm) {
411  const auto& perigee {siTrack->perigeeParameters()};
412  //the sign of this gives the direction
413  const double inprod = (pm->associatedSurface().center() - perigee->position()).dot(
414  perigee->momentum());
415  if (inprod < 0) {
416  pExtendedTrajectory->insert(pExtendedTrajectory->begin(), createNewTSOS(pm));
417  } else {
418  pExtendedTrajectory->push_back(createNewTSOS(pm));
419  }
420  };
421  //actual copying done here, using preceding lambda functions
422  if (not m_cosmics) {
423  std::transform(extension.begin(), extension.end(), std::back_inserter(*pExtendedTrajectory), createNewTSOS);
424  } else {
425  //difficult to use std::transform here, since don't know whether back or front are added to
426  for (const auto *const pMeasurementBase: extension) {
427  addNewTSOS_ForCosmics(pMeasurementBase);
428  }
429  }
430  nExtStates += pExtendedTrajectory->size();
431  const auto& pFitQuality {siTrack->fitQuality()};
432  Trk::Track* extTrack =
433  new Trk::Track(siTrack->info(), std::move(pExtendedTrajectory), (pFitQuality ? pFitQuality->uniqueClone() : nullptr));
434  if (m_trackSummaryTool.isEnabled()) {
435  m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *extTrack, m_suppressHoleSearch);
436  }
437  Trk::TrackScore extScore = m_scoringTool->score(*extTrack);
438  ATH_MSG_DEBUG("rejected extension saved as Trk::Track with " << nSiStates <<
439  " fitted hits and " << nExtStates << " additional Outliers, score :" << extScore);
440  return extTrack;
441 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

std::array< std::array<std::atomic<int>, Nregions>, nTypes > m_counters InDet::InDetExtensionProcessor::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 118 of file InDetExtensionProcessor.h.

◆ ATLAS_THREAD_SAFE [2/2]

std::atomic<int> m_Nevents InDet::InDetExtensionProcessor::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 119 of file InDetExtensionProcessor.h.

◆ m_caloSeededBrem

BooleanProperty InDet::InDetExtensionProcessor::m_caloSeededBrem
private
Initial value:
{
this, "caloSeededBrem", false, "calo seeded brem recovery"}

Definition at line 96 of file InDetExtensionProcessor.h.

◆ m_cosmics

BooleanProperty InDet::InDetExtensionProcessor::m_cosmics
private
Initial value:
{
this, "Cosmics", false, "switch whether we are running on cosmics"}

Definition at line 79 of file InDetExtensionProcessor.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_etabounds

Gaudi::Property<std::vector<float> > InDet::InDetExtensionProcessor::m_etabounds
private
Initial value:
{
this, "etaBounds", {0.8, 1.6, 2.10}, "eta intervals for internal monitoring"}

Definition at line 100 of file InDetExtensionProcessor.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_extensionMapName

SG::ReadHandleKey<TrackExtensionMap> InDet::InDetExtensionProcessor::m_extensionMapName
private
Initial value:
{
this, "ExtensionMap", "TrackExtensionMap", "Name of the input extension map"}

Definition at line 63 of file InDetExtensionProcessor.h.

◆ m_keepFailedExtensionOnTrack

BooleanProperty InDet::InDetExtensionProcessor::m_keepFailedExtensionOnTrack
private
Initial value:
{
this, "keepFailedExtension", true,
"switch whether to keep failed extension as outlier hits on the new track"}

Definition at line 83 of file InDetExtensionProcessor.h.

◆ m_matEffects

IntegerProperty InDet::InDetExtensionProcessor::m_matEffects
private
Initial value:
{
this, "matEffects", 3,
"particle hypothesis to assume for material effects in track fit"}

Definition at line 89 of file InDetExtensionProcessor.h.

◆ m_newTrackName

SG::WriteHandleKey<TrackCollection> InDet::InDetExtensionProcessor::m_newTrackName
private
Initial value:
{
this, "NewTrackName", "ExtendedTrack", "Name of the output Trackcollection"}

Definition at line 65 of file InDetExtensionProcessor.h.

◆ m_particleHypothesis

Trk::ParticleHypothesis InDet::InDetExtensionProcessor::m_particleHypothesis {Trk::undefined}
private

nomen est omen

Definition at line 105 of file InDetExtensionProcessor.h.

◆ m_pTminBrem

FloatProperty InDet::InDetExtensionProcessor::m_pTminBrem
private
Initial value:
{
this, "pTminBrem", 1000., "min pT for trying a brem recovery"}

Definition at line 98 of file InDetExtensionProcessor.h.

◆ m_refitPrds

BooleanProperty InDet::InDetExtensionProcessor::m_refitPrds
private
Initial value:
{
this, "RefitPrds", true,
"switch whether to do the fit with re-calibrated clusters (true) or not"}

Definition at line 86 of file InDetExtensionProcessor.h.

◆ m_runOutlier

Gaudi::Property<Trk::RunOutlierRemoval> InDet::InDetExtensionProcessor::m_runOutlier
private
Initial value:
{
this, "runOutlier", true, "switch whether to run outlier logics or not"}

Definition at line 81 of file InDetExtensionProcessor.h.

◆ m_scoringTool

PublicToolHandle<Trk::ITrackScoringTool> InDet::InDetExtensionProcessor::m_scoringTool
private
Initial value:
{
this, "ScoringTool", "Trk::TrackScoringTool",
"Toolhandle for the track scorer"}

Definition at line 75 of file InDetExtensionProcessor.h.

◆ m_suppressHoleSearch

BooleanProperty InDet::InDetExtensionProcessor::m_suppressHoleSearch
private
Initial value:
{
this, "suppressHoleSearch", false, "suppressing hole search for comparison"}

Definition at line 92 of file InDetExtensionProcessor.h.

◆ m_trackFitter

PublicToolHandle<Trk::ITrackFitter> InDet::InDetExtensionProcessor::m_trackFitter
private
Initial value:
{
this, "TrackFitter", "Trk::KalmanFitter/InDetTrackFitter",
"Toolhandle for the track fitter"}

Definition at line 68 of file InDetExtensionProcessor.h.

◆ m_trackName

SG::ReadHandleKey<TrackCollection> InDet::InDetExtensionProcessor::m_trackName
private
Initial value:
{
this, "TrackName", "Tracks", "Name of the input Trackcollection"}

Definition at line 61 of file InDetExtensionProcessor.h.

◆ m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> InDet::InDetExtensionProcessor::m_trackSummaryTool
private
Initial value:
{
this, "TrackSummaryTool", ""}

Definition at line 72 of file InDetExtensionProcessor.h.

◆ m_tryBremFit

BooleanProperty InDet::InDetExtensionProcessor::m_tryBremFit
private
Initial value:
{
this, "tryBremFit", false, "brem recovery mode"}

Definition at line 94 of file InDetExtensionProcessor.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
Trk::TrackInfo
Contains information about the 'fitter' of this track.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:32
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
InDet::InDetExtensionProcessor::m_trackFitter
PublicToolHandle< Trk::ITrackFitter > m_trackFitter
Definition: InDetExtensionProcessor.h:68
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
InDet::InDetExtensionProcessor::m_trackSummaryTool
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool
Definition: InDetExtensionProcessor.h:72
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
InDet::InDetExtensionProcessor::nInput
@ nInput
Definition: InDetExtensionProcessor.h:113
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
InDet::InDetExtensionProcessor::m_pTminBrem
FloatProperty m_pTminBrem
Definition: InDetExtensionProcessor.h:98
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
Trk::Track::info
const TrackInfo & info() const
Returns a const ref to info of a const tracks.
xAOD::JetInput::Track
@ Track
Definition: JetContainerInfo.h:61
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
InDet::InDetExtensionProcessor::m_suppressHoleSearch
BooleanProperty m_suppressHoleSearch
Definition: InDetExtensionProcessor.h:92
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
InDet::InDetExtensionProcessor::nRejected
@ nRejected
Definition: InDetExtensionProcessor.h:113
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
InDet::InDetExtensionProcessor::trackPlusExtension
Trk::Track * trackPlusExtension(const EventContext &ctx, const Trk::Track *, const std::vector< const Trk::MeasurementBase * > &) const
internal structuring: creates new track with original one plus extension as outliers
Definition: InDetExtensionProcessor.cxx:385
InDet::InDetExtensionProcessor::m_runOutlier
Gaudi::Property< Trk::RunOutlierRemoval > m_runOutlier
Definition: InDetExtensionProcessor.h:81
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
InDet::InDetExtensionProcessor::nRecognised
@ nRecognised
Definition: InDetExtensionProcessor.h:113
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
InDet::InDetExtensionProcessor::nExtended
@ nExtended
Definition: InDetExtensionProcessor.h:113
InDet::InDetExtensionProcessor::m_matEffects
IntegerProperty m_matEffects
Definition: InDetExtensionProcessor.h:89
Trk::TrackInfo::addPatternReco
void addPatternReco(const TrackInfo &)
A method adding just pattern recognition info without adding the actual properties.
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
InDet::InDetExtensionProcessor::m_keepFailedExtensionOnTrack
BooleanProperty m_keepFailedExtensionOnTrack
Definition: InDetExtensionProcessor.h:83
InDet::InDetExtensionProcessor::m_tryBremFit
BooleanProperty m_tryBremFit
Definition: InDetExtensionProcessor.h:94
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:85
InDet::InDetExtensionProcessor::iTransi
@ iTransi
Definition: InDetExtensionProcessor.h:109
InDet::InDetExtensionProcessor::Nregions
@ Nregions
Definition: InDetExtensionProcessor.h:109
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Trk::electron
@ electron
Definition: ParticleHypothesis.h:27
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
InDet::InDetExtensionProcessor::nLowScoreBremFits
@ nLowScoreBremFits
Definition: InDetExtensionProcessor.h:114
InDet::InDetExtensionProcessor::createExtendedTracks
TrackCollection * createExtendedTracks(const EventContext &ctx, const TrackCollection *tracks_in, const TrackExtensionMap *track_extension_map) const
process events
Definition: InDetExtensionProcessor.cxx:93
InDet::InDetExtensionProcessor::nTypes
@ nTypes
Definition: InDetExtensionProcessor.h:114
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
Trk::TrackInfo::InDetExtensionProcessor
@ InDetExtensionProcessor
Tracks with InDetExtensionProcessor used.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:111
Trk::TrackScore
float TrackScore
Definition: TrackScore.h:10
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::TrackInfo::BremFit
@ BremFit
A brem fit was performed on this track.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:78
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
InDet::InDetExtensionProcessor::iAll
@ iAll
Definition: InDetExtensionProcessor.h:109
Trk::TrackInfo::TrackInCaloROI
@ TrackInCaloROI
A track in a CaloROI.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:236
InDet::InDetExtensionProcessor::m_scoringTool
PublicToolHandle< Trk::ITrackScoringTool > m_scoringTool
Definition: InDetExtensionProcessor.h:75
InDet::InDetExtensionProcessor::m_refitPrds
BooleanProperty m_refitPrds
Definition: InDetExtensionProcessor.h:86
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
InDet::InDetExtensionProcessor::nNotExtended
@ nNotExtended
Definition: InDetExtensionProcessor.h:114
dot.dot
def dot(G, fn, nodesToHighlight=[])
Definition: dot.py:5
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
InDet::InDetExtensionProcessor::iBarrel
@ iBarrel
Definition: InDetExtensionProcessor.h:109
InDet::InDetExtensionProcessor::incrementRegionCounter
void incrementRegionCounter(std::array< std::atomic< int >, 4 > &, const Trk::Track *, bool=true) const
monitoring and validation: does success/failure counting for each detector region
Definition: InDetExtensionProcessor.cxx:362
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
Trk::MeasurementSet
std::vector< const MeasurementBase * > MeasurementSet
vector of fittable measurements
Definition: FitterTypes.h:30
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Trk::MeasurementBase
Definition: MeasurementBase.h:58
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
InDet::InDetExtensionProcessor::m_etabounds
Gaudi::Property< std::vector< float > > m_etabounds
Definition: InDetExtensionProcessor.h:100
InDet::InDetExtensionProcessor::nRecoveryBremFits
@ nRecoveryBremFits
Definition: InDetExtensionProcessor.h:113
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:225
InDet::InDetExtensionProcessor::m_trackName
SG::ReadHandleKey< TrackCollection > m_trackName
Definition: InDetExtensionProcessor.h:61
InDet::InDetExtensionProcessor::nExtendedBrem
@ nExtendedBrem
Definition: InDetExtensionProcessor.h:114
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
InDet::InDetExtensionProcessor::dumpStat
MsgStream & dumpStat(MsgStream &out) const
Definition: InDetExtensionProcessor.cxx:456
InDet::InDetExtensionProcessor::nFits
@ nFits
Definition: InDetExtensionProcessor.h:114
Trk::RIO_OnTrack::prepRawData
virtual const Trk::PrepRawData * prepRawData() const =0
returns the PrepRawData (also known as RIO) object to which this RIO_OnTrack is associated.
InDet::InDetExtensionProcessor::m_cosmics
BooleanProperty m_cosmics
Definition: InDetExtensionProcessor.h:79
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TauGNNUtils::Variables::absEta
bool absEta(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:234
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
InDet::InDetExtensionProcessor::m_caloSeededBrem
BooleanProperty m_caloSeededBrem
Definition: InDetExtensionProcessor.h:96
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Trk::TrackInfo::setPatternRecognitionInfo
void setPatternRecognitionInfo(const TrackPatternRecoInfo &patternReco)
Method setting the pattern recognition algorithm.
InDet::InDetExtensionProcessor::m_extensionMapName
SG::ReadHandleKey< TrackExtensionMap > m_extensionMapName
Definition: InDetExtensionProcessor.h:63
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Trk::TrackInfo::trackProperties
bool trackProperties(const TrackProperties &property) const
Access methods for track properties.
InDet::InDetExtensionProcessor::nBremFits
@ nBremFits
Definition: InDetExtensionProcessor.h:114
InDet::InDetExtensionProcessor::m_particleHypothesis
Trk::ParticleHypothesis m_particleHypothesis
nomen est omen
Definition: InDetExtensionProcessor.h:105
InDet::InDetExtensionProcessor::m_newTrackName
SG::WriteHandleKey< TrackCollection > m_newTrackName
Definition: InDetExtensionProcessor.h:65
InDet::InDetExtensionProcessor::nFailed
@ nFailed
Definition: InDetExtensionProcessor.h:113
InDet::InDetExtensionProcessor::iEndcap
@ iEndcap
Definition: InDetExtensionProcessor.h:109
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >