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

InDet::SiSPGNNTrackMaker is an algorithm that uses the GNN-based track finding tool to reconstruct tracks and the use track fitter to obtain track parameters. It turns a collection of Trk::Tracks. More...

#include <SiSPGNNTrackMaker.h>

Inheritance diagram for InDet::SiSPGNNTrackMaker:
Collaboration diagram for InDet::SiSPGNNTrackMaker:

Public Member Functions

 SiSPGNNTrackMaker (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual StatusCode initialize () override
 
virtual StatusCode execute (const EventContext &ctx) const override
 
virtual bool isClonable () const override
 Make this algorithm clonable. More...
 
MsgStream & dump (MsgStream &out) const
 
std::ostream & dump (std::ostream &out) const
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. 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

MsgStream & dumptools (MsgStream &out) const
 
MsgStream & dumpevent (MsgStream &out) const
 
int passEtaDepCuts (const Trk::Track &track) const
 
std::tuple< bool, int, std::unique_ptr< Trk::Track > > doFitAndCut (const EventContext &ctx, std::vector< const Trk::SpacePoint * > &spacePoints, std::vector< const Trk::PrepRawData * > &clusters, int &trackCounter) const
 Fits a track and applies quality cuts to determine if it should be kept. More...
 
int passEtaDepCuts (const Trk::Track *track, int nClusters, int nFreeClusters, int nPixels) const
 
bool prefitCheck (int nPix, int nStrip, int nClusters, int nSpacePoints) const
 
std::unique_ptr< Trk::Track > fitTrack (const EventContext &ctx, std::vector< const Trk::PrepRawData * > clusters, const Trk::TrackParameters &initial_params, int trackCounter) const
 
std::vector< const Trk::SpacePoint * > getSpacePoints (std::vector< uint32_t > trackIndices, std::vector< const Trk::SpacePoint * > allSpacePoints) const
 
std::vector< const Trk::PrepRawData * > spacePointsToClusters (std::vector< const Trk::SpacePoint * > spacePoints) const
 
std::vector< const Trk::PrepRawData * > getClusters (std::vector< std::vector< uint32_t >> clusterTracks, std::vector< const Trk::PrepRawData * > allClusters, int trackNumber) const
 
std::vector< const Trk::SpacePoint * > getSpacePointsInEvent (const EventContext &ctx, int eventNumber) const
 
std::vector< const Trk::SpacePoint * > getSpacePointsInEvent (const EventContext &ctx, const SG::ReadHandleKey< SpacePointContainer > &containerKey) const
 
std::vector< const Trk::SpacePoint * > getSpacePointsInEvent (const EventContext &ctx, const SG::ReadHandleKey< SpacePointOverlapCollection > &containerKey) const
 
std::vector< const Trk::PrepRawData * > getClustersInEvent (const EventContext &ctx, int eventNumber) const
 
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...
 

Protected Attributes

SG::ReadHandleKey< SpacePointContainer > m_SpacePointsPixelKey
 
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsSCTKey
 
SG::ReadHandleKey< SpacePointOverlapCollection > m_SpacePointsOverlapKey {this, "SpacePointsOverlapName", "ITkOverlapSpacePoints"}
 
SG::ReadHandleKey< InDet::PixelClusterContainer > m_ClusterPixelKey
 
SG::ReadHandleKey< InDet::SCT_ClusterContainer > m_ClusterStripKey
 
SG::WriteHandleKey< TrackCollection > m_outputTracksKey
 
ToolHandle< IGNNTrackFinder > m_gnnTrackFinder
 GNN-based track finding tool that produces track candidates. More...
 
ToolHandle< ISeedFitter > m_seedFitter
 
ToolHandle< Trk::ITrackFitter > m_trackFitter
 Track Fitter. More...
 
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool
 
ToolHandle< IGNNTrackReaderTool > m_gnnTrackReader
 
BooleanProperty m_areInputClusters
 
BooleanProperty m_doRecoTrackCuts
 
ServiceHandle< IInDetEtaDependentCutsSvc > m_etaDependentCutsSvc
 
IntegerProperty m_minClusters {this, "minClusters", 6, "Min number clusters"}
 
IntegerProperty m_minPixelClusters {this, "minPixelClusters", 1, "min pixel clusters"}
 
IntegerProperty m_minStripClusters
 
DoubleProperty m_pTmin {this, "pTmin", 400., "min pT"}
 
DoubleProperty m_etamax {this, "etamax", 4., "max reco eta"}
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

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

InDet::SiSPGNNTrackMaker is an algorithm that uses the GNN-based track finding tool to reconstruct tracks and the use track fitter to obtain track parameters. It turns a collection of Trk::Tracks.

Author
xiang.nosp@m.yang.nosp@m..ju@c.nosp@m.ern..nosp@m.ch

Definition at line 43 of file SiSPGNNTrackMaker.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ SiSPGNNTrackMaker()

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

Definition at line 13 of file SiSPGNNTrackMaker.cxx.

15  : AthReentrantAlgorithm(name, pSvcLocator)
16 {
17 
18 }

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 }

◆ 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;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, 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; }

◆ doFitAndCut()

std::tuple< bool, int, std::unique_ptr< Trk::Track > > InDet::SiSPGNNTrackMaker::doFitAndCut ( const EventContext &  ctx,
std::vector< const Trk::SpacePoint * > &  spacePoints,
std::vector< const Trk::PrepRawData * > &  clusters,
int &  trackCounter 
) const
protected

Fits a track and applies quality cuts to determine if it should be kept.

Parameters
ctxEvent context for conditions access
clustersVector of cluster measurements used to fit the track
initial_paramsInitial track parameters from seed finding
trackCounterIndex/ID of the track candidate being processed
Returns
std::tuple<bool, int, std::unique_ptr<Trk::Track>>
  • bool: Whether the fit was successful
  • int: Error/status code (0 for success, >0 for specific failure modes)
  • Track: The fitted track (nullptr if fit fails or track rejected)

This function performs the following steps:

  1. Fits the track using the provided clusters and initial parameters
  2. Checks basic kinematic cuts (pT, eta)
  3. Computes track summary (hits, holes)
  4. Applies eta-dependent quality cuts if configured

Error codes:

  • 0: Success, track passes all cuts
  • 1: Failed minimum silicon hits requirement
  • 2: Failed minimum pixel hits requirement
  • 3: Failed minimum pT requirement
  • 4: Failed maximum z0 requirement
  • 5: Failed maximum d0 requirement
  • 6: Failed maximum holes requirement
  • 999: Track fit failed
Note
The track fitting is performed using the configured track fitter tool
Quality cuts are configurable via job options

Definition at line 467 of file SiSPGNNTrackMaker.cxx.

473  {
474  // get cluster list
475  int nPIX(0), nStrip(0);
476 
477  for (const Trk::PrepRawData* cl : clusters) {
478  if (cl->type(Trk::PrepRawDataType::PixelCluster)) nPIX++;
479  if (cl->type(Trk::PrepRawDataType::SCT_Cluster)) nStrip++;
480  }
481 
482  ATH_MSG_DEBUG("Track " << trackCounter << " has " << spacePoints.size()
483  << " space points, " << clusters.size()
484  << " clusters, " << nPIX << " pixel clusters, "
485  << nStrip << " strip clusters");
486 
487  // check hit counts
488  if (not prefitCheck(nPIX, nStrip, clusters.size(), spacePoints.size())) {
489  ATH_MSG_DEBUG("Track " << trackCounter << " does not pass prefit cuts, skipping");
490  return std::make_tuple(false, 999, nullptr);
491  }
492 
493  // conformal mapping for track parameters
494  auto trkParameters = m_seedFitter->fit(spacePoints);
495  if (trkParameters == nullptr) {
496  ATH_MSG_DEBUG("Conformal mapping failed");
497  return std::make_tuple(false, 999, nullptr);
498  }
499 
500  std::unique_ptr<Trk::Track> track = fitTrack(ctx, clusters, *trkParameters, trackCounter);
501 
502  if (track == nullptr || track->perigeeParameters() == nullptr) {
503  ATH_MSG_DEBUG("Track " << trackCounter
504  << " fails the third chi2 fit, skipping");
505  return std::make_tuple(false, 999, nullptr);
506  }
507 
508  // compute pT and skip if pT too low
509  if (track->perigeeParameters()->pT() < m_pTmin) {
510  ATH_MSG_DEBUG("Track " << trackCounter
511  << "with pt = " << track->perigeeParameters()->pT()
512  << " has pT too low, skipping track!");
513  return std::make_tuple(false, 999, nullptr);
514  }
515 
516  // get rid of tracks with eta too large
517  if (std::abs(track->perigeeParameters()->eta()) > m_etamax) {
518  ATH_MSG_DEBUG("Track " << trackCounter << "with eta = "
519  << std::abs(track->perigeeParameters()->eta())
520  << " has eta too high, skipping track!");
521  return std::make_tuple(false, 999, nullptr);
522  }
523 
524  // if track fit succeeds, eta and pT within range, compute track summary. This is quite expensive.
525  m_trackSummaryTool->computeAndReplaceTrackSummary(
526  *track, false /* DO NOT suppress hole search*/);
527 
528  int passTrackCut = (m_doRecoTrackCuts) ? passEtaDepCuts(*track) : -1;
529 
530  return std::make_tuple(true, passTrackCut, std::move(track));
531 
532  }

◆ dump() [1/2]

MsgStream & InDet::SiSPGNNTrackMaker::dump ( MsgStream &  out) const

Definition at line 601 of file SiSPGNNTrackMaker.cxx.

602 {
603  out<<std::endl;
604  if(msgLvl(MSG::DEBUG)) return dumpevent(out);
605  else return dumptools(out);
606 }

◆ dump() [2/2]

std::ostream & InDet::SiSPGNNTrackMaker::dump ( std::ostream &  out) const

Definition at line 631 of file SiSPGNNTrackMaker.cxx.

632 {
633  return out;
634 }

◆ dumpevent()

MsgStream & InDet::SiSPGNNTrackMaker::dumpevent ( MsgStream &  out) const
protected

Definition at line 626 of file SiSPGNNTrackMaker.cxx.

627 {
628  return out;
629 }

◆ dumptools()

MsgStream & InDet::SiSPGNNTrackMaker::dumptools ( MsgStream &  out) const
protected

Definition at line 612 of file SiSPGNNTrackMaker.cxx.

613 {
614  out<<"| Location of output tracks | "
615  <<std::endl;
616  out<<"|----------------------------------------------------------------"
617  <<"----------------------------------------------------|"
618  <<std::endl;
619  return out;
620 }

◆ 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::SiSPGNNTrackMaker::execute ( const EventContext &  ctx) const
overridevirtual

Definition at line 84 of file SiSPGNNTrackMaker.cxx.

85 {
86  SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
87  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
88 
89  // get event info
90  uint32_t runNumber = ctx.eventID().run_number();
91  uint32_t eventNumber = ctx.eventID().event_number();
92 
93  // get all space points from event
94  std::vector<const Trk::SpacePoint*> spacePoints = getSpacePointsInEvent(ctx, eventNumber);
95 
96  // get all clusters from event
97  std::vector<const Trk::PrepRawData*> allClusters = getClustersInEvent(ctx, eventNumber);
98 
99  // get tracks from GNN chain
100  std::vector<std::vector<uint32_t> > TT;
101  std::vector<std::vector<uint32_t> > clusterTracks;
102  if (m_gnnTrackFinder.isSet()) {
103  ATH_CHECK(m_gnnTrackFinder->getTracks(spacePoints, TT));
104  } else if (m_gnnTrackReader.isSet()) {
105  // if track candidates are built from cluster, get both clusters and SPs
106  m_areInputClusters ?
107  m_gnnTrackReader->getTracks(runNumber, eventNumber, clusterTracks, TT) :
108  m_gnnTrackReader->getTracks(runNumber, eventNumber, TT);
109  } else {
110  ATH_MSG_ERROR("Both GNNTrackFinder and GNNTrackReader are not set");
111  return StatusCode::FAILURE;
112  }
113 
114  ATH_MSG_DEBUG("Event " << eventNumber << " obtained " << TT.size() << " Tracks");
115 
116  // loop over all track candidates
117  // and perform track fitting for each.
118  int trackCounter = -1;
119  std::vector<int> status_codes;
120  // track processing loop
121  for (auto& trackIndices : TT) {
122  // For each track candidate:
123  trackCounter++;
124 
125  // 1. Sort space points by distance from origin
126  std::vector<const Trk::SpacePoint*> trackCandidate = getSpacePoints(trackIndices, spacePoints);
127 
128  // 2. Get associated clusters
129  // if track candidates are built from cluster, get both clusters and SPs
130  std::vector<const Trk::PrepRawData*> clusters = m_areInputClusters ?
131  getClusters (clusterTracks, allClusters, trackCounter)
132  : spacePointsToClusters(trackCandidate) ;
133 
134  // 3. Perform track fitting:
135  // - Initial conformal mapping
136  // - First chi2 fit without outlier removal
137  // - Second chi2 fit with perigee parameters
138  // - Final fit with outlier removal
139  // 4. Apply quality cuts (pT, eta)
140  // 5. Compute track summary
141  // 6. Store track if it passes all criteria
142  auto [fitSuccess, passTrackCut, track] = doFitAndCut(ctx, trackCandidate, clusters, trackCounter);
143 
144  if (not fitSuccess) {
145  continue;
146  }
147 
148  if (passTrackCut <= 0) {
149  outputTracks->push_back(track.release());
150  }
151 
152  status_codes.push_back(passTrackCut);
153 
154  }
155 
156  if (m_doRecoTrackCuts) {
157  ATH_MSG_INFO("Event " << eventNumber << " has " << status_codes.size() << " tracks found, "
158  << std::count(status_codes.begin(), status_codes.end(), 0)
159  << " tracks remains after applying track cuts");
160  } else {
161  ATH_MSG_INFO("Event " << eventNumber << " has " << status_codes.size() << " tracks found, all tracks are kept");
162  }
163 
164  return StatusCode::SUCCESS;
165 }

◆ 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()) {
84  return m_extendedExtraObjects;
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  }

◆ fitTrack()

std::unique_ptr< Trk::Track > InDet::SiSPGNNTrackMaker::fitTrack ( const EventContext &  ctx,
std::vector< const Trk::PrepRawData * >  clusters,
const Trk::TrackParameters &  initial_params,
int  trackCounter 
) const
protected

Definition at line 534 of file SiSPGNNTrackMaker.cxx.

540  {
541 
542  Trk::ParticleHypothesis matEffects = Trk::pion;
543  // first fit the track with local parameters and without outlier removal.
544  std::unique_ptr<Trk::Track> track =
545  m_trackFitter->fit(ctx, clusters, initial_params, false, matEffects);
546 
547  if (track == nullptr || track->perigeeParameters() == nullptr) {
548  ATH_MSG_DEBUG("Track " << trackCounter
549  << " fails the first chi2 fit, skipping");
550  return track;
551  }
552 
553  // reject track with pT too low, default 400 MeV
554  if (track->perigeeParameters()->pT() < m_pTmin) {
555  ATH_MSG_DEBUG("Track " << trackCounter
556  << " fails the first chi2 fit, skipping");
557  return nullptr;
558  }
559 
560  // fit the track again with perigee parameters and without outlier
561  // removal.
562  track = m_trackFitter->fit(ctx, clusters, *track->perigeeParameters(),
563  false, matEffects);
564 
565  // track = m_trackFitter->fit(ctx, *track, false, matEffects);
566  if (track == nullptr || track->perigeeParameters() == nullptr) {
567  ATH_MSG_DEBUG("Track " << trackCounter
568  << " fails the second chi2 fit, skipping");
569  return track;
570  }
571  // finally fit with outlier removal
572  // track = m_trackFitter->fit(ctx, clusters, *track->perigeeParameters(), true,
573  // matEffects);
574 
575  return m_trackFitter->fit(ctx, clusters, *track->perigeeParameters(), true, matEffects);
576  }

◆ getClusters()

std::vector< const Trk::PrepRawData * > InDet::SiSPGNNTrackMaker::getClusters ( std::vector< std::vector< uint32_t >>  clusterTracks,
std::vector< const Trk::PrepRawData * >  allClusters,
int  trackNumber 
) const
protected

Definition at line 416 of file SiSPGNNTrackMaker.cxx.

420  {
421  std::vector<uint32_t> clusterIndices = clusterTracks[trackNumber];
422  std::vector<const Trk::PrepRawData*> clusters;
423  clusters.reserve(clusterIndices.size());
424  for (uint32_t id : clusterIndices) {
425  if (id > allClusters.size()) {
426  ATH_MSG_ERROR("Cluster index out of range");
427  continue;
428  }
429  clusters.push_back(allClusters[id]);
430  }
431  return clusters;
432 }

◆ getClustersInEvent()

std::vector< const Trk::PrepRawData * > InDet::SiSPGNNTrackMaker::getClustersInEvent ( const EventContext &  ctx,
int  eventNumber 
) const
protected

Definition at line 299 of file SiSPGNNTrackMaker.cxx.

302  {
303  std::vector<const Trk::PrepRawData*> allClusters;
304  if (m_areInputClusters) {
305  SG::ReadHandle<InDet::PixelClusterContainer> pixcontainer(m_ClusterPixelKey,
306  ctx);
307  SG::ReadHandle<InDet::SCT_ClusterContainer> strip_container(m_ClusterStripKey,
308  ctx);
309 
310  if (!pixcontainer.isValid()) {
311  ATH_MSG_ERROR("Pixel container invalid, returning");
312  return allClusters;
313  }
314 
315  if (!strip_container.isValid()) {
316  ATH_MSG_ERROR("Strip container invalid, returning");
317  return allClusters;
318  }
319 
320  auto pixcollection = pixcontainer->begin();
321  auto pixcollectionEnd = pixcontainer->end();
322  for (; pixcollection != pixcollectionEnd; ++pixcollection) {
323  if ((*pixcollection)->empty()) {
324  ATH_MSG_WARNING("Empty pixel cluster collection encountered");
325  continue;
326  }
327  auto const* clusterCollection = (*pixcollection);
328  auto thisCluster = clusterCollection->begin();
329  auto clusterEnd = clusterCollection->end();
330  for (; thisCluster != clusterEnd; ++thisCluster) {
331  const PixelCluster* cl = (*thisCluster);
332  allClusters.push_back(cl);
333  }
334  }
335 
336  auto strip_collection = strip_container->begin();
337  auto strip_collectionEnd = strip_container->end();
338  for (; strip_collection != strip_collectionEnd; ++strip_collection) {
339  if ((*strip_collection)->empty()) {
340  ATH_MSG_WARNING("Empty strip cluster collection encountered");
341  continue;
342  }
343  auto const* clusterCollection = (*strip_collection);
344  auto thisCluster = clusterCollection->begin();
345  auto clusterEnd = clusterCollection->end();
346  for (; thisCluster != clusterEnd; ++thisCluster) {
347  const SCT_Cluster* cl = (*thisCluster);
348  allClusters.push_back(cl);
349  }
350  }
351 
352  ATH_MSG_DEBUG("Event " << eventNumber << " has " << allClusters.size()
353  << " clusters");
354  }
355  return allClusters;
356 }

◆ getSpacePoints()

std::vector< const Trk::SpacePoint * > InDet::SiSPGNNTrackMaker::getSpacePoints ( std::vector< uint32_t >  trackIndices,
std::vector< const Trk::SpacePoint * >  allSpacePoints 
) const
protected

Definition at line 359 of file SiSPGNNTrackMaker.cxx.

362  {
363 
364  std::vector<const Trk::SpacePoint*> trackCandidate;
365  trackCandidate.reserve(trackIndices.size());
366 
367  std::vector<std::pair<double, const Trk::SpacePoint*> > distanceSortedSPs;
368 
369  // get track space points
370  // sort SPs in track by distance from origin
371  for (auto& id : trackIndices) {
373  if (id > allSpacePoints.size()) {
374  ATH_MSG_WARNING("SpacePoint index "
375  << id << " out of range: " << allSpacePoints.size());
376  continue;
377  }
378 
379  const Trk::SpacePoint* sp = allSpacePoints[id];
380 
381  // store distance - hit paire
382  if (sp != nullptr) {
383  distanceSortedSPs.push_back(
384  std::make_pair(
385  pow(sp->globalPosition().x(), 2) + pow(sp->globalPosition().y(), 2),
386  sp
387  )
388  );
389  }
390  }
391 
392  // sort by distance
393  std::sort(distanceSortedSPs.begin(), distanceSortedSPs.end());
394 
395  // add SP to trk candidate in the same order
396  for (size_t i = 0; i < distanceSortedSPs.size(); i++) {
397  trackCandidate.push_back(distanceSortedSPs[i].second);
398  }
399 
400  return trackCandidate;
401 }

◆ getSpacePointsInEvent() [1/3]

std::vector< const Trk::SpacePoint * > InDet::SiSPGNNTrackMaker::getSpacePointsInEvent ( const EventContext &  ctx,
const SG::ReadHandleKey< SpacePointContainer > &  containerKey 
) const
protected

Definition at line 250 of file SiSPGNNTrackMaker.cxx.

253  {
254  std::vector<const Trk::SpacePoint*> spacePoints;
255  if (not containerKey.empty()){
256 
257  SG::ReadHandle<SpacePointContainer> container{containerKey, ctx};
258 
259  if (container.isValid()){
260  // loop over spacepoint collection
261  auto spc = container->begin();
262  auto spce = container->end();
263  for(; spc != spce; ++spc){
264  const SpacePointCollection* spCollection = (*spc);
265  auto sp = spCollection->begin();
266  auto spe = spCollection->end();
267  for(; sp != spe; ++sp) {
268  const Trk::SpacePoint* spacePoint = (*sp);
269  spacePoints.push_back(spacePoint);
270  }
271  }
272  }
273  }
274 
275  return spacePoints;
276 }

◆ getSpacePointsInEvent() [2/3]

std::vector< const Trk::SpacePoint * > InDet::SiSPGNNTrackMaker::getSpacePointsInEvent ( const EventContext &  ctx,
const SG::ReadHandleKey< SpacePointOverlapCollection > &  containerKey 
) const
protected

Definition at line 278 of file SiSPGNNTrackMaker.cxx.

281  {
282 
283  std::vector<const Trk::SpacePoint*> spacePoints;
284 
285  if (not containerKey.empty()){
286 
287  SG::ReadHandle<SpacePointOverlapCollection> collection{containerKey, ctx};
288 
289  if (collection.isValid()){
290  for (const Trk::SpacePoint *sp : *collection) {
291  spacePoints.push_back(sp);
292  }
293  }
294  }
295 
296  return spacePoints;
297 }

◆ getSpacePointsInEvent() [3/3]

std::vector< const Trk::SpacePoint * > InDet::SiSPGNNTrackMaker::getSpacePointsInEvent ( const EventContext &  ctx,
int  eventNumber 
) const
protected

Definition at line 222 of file SiSPGNNTrackMaker.cxx.

225  {
226  std::vector<const Trk::SpacePoint*> spacePoints;
227 
228  int npixsp(0), nstrip(0), n_overlap(0);
229  for (const Trk::SpacePoint* sp : getSpacePointsInEvent(ctx, m_SpacePointsPixelKey)) {
230  spacePoints.push_back(sp);
231  npixsp++;
232  }
233  for (const Trk::SpacePoint* sp : getSpacePointsInEvent(ctx, m_SpacePointsSCTKey)) {
234  spacePoints.push_back(sp);
235  nstrip++;
236  }
237  for (const Trk::SpacePoint* sp : getSpacePointsInEvent(ctx, m_SpacePointsOverlapKey)) {
238  spacePoints.push_back(sp);
239  n_overlap++;
240  }
241  ATH_MSG_DEBUG("Event " << eventNumber << " has " << npixsp
242  << " pixel space points, " << nstrip
243  << " strips space points" << n_overlap
244  << " overlapping spacepoints" << spacePoints.size()
245  << " space points");
246 
247  return spacePoints;
248 }

◆ initialize()

StatusCode InDet::SiSPGNNTrackMaker::initialize ( )
overridevirtual

Definition at line 20 of file SiSPGNNTrackMaker.cxx.

21 {
22  ATH_CHECK(m_SpacePointsPixelKey.initialize());
23  ATH_CHECK(m_SpacePointsSCTKey.initialize());
24  ATH_CHECK(m_SpacePointsOverlapKey.initialize());
25  ATH_CHECK(m_ClusterPixelKey.initialize());
26  ATH_CHECK(m_ClusterStripKey.initialize());
27 
28  ATH_CHECK(m_outputTracksKey.initialize());
29 
30  ATH_CHECK(m_trackFitter.retrieve());
31  ATH_CHECK(m_seedFitter.retrieve());
32  ATH_CHECK(m_trackSummaryTool.retrieve());
33 
34  if (!m_gnnTrackFinder.empty() && !m_gnnTrackReader.empty()) {
35  ATH_MSG_ERROR("Use either track finder or track reader, not both.");
36  return StatusCode::FAILURE;
37  }
38 
39  if (!m_gnnTrackFinder.empty()) {
40  ATH_MSG_INFO("Use GNN Track Finder");
41  ATH_CHECK(m_gnnTrackFinder.retrieve());
42  }
43  if (!m_gnnTrackReader.empty()) {
44  ATH_MSG_INFO("Use GNN Track Reader");
45  ATH_CHECK(m_gnnTrackReader.retrieve());
46  }
47  if (m_areInputClusters) {
48  ATH_MSG_INFO("Use input clusters");
49  }
50  // retrieve eta dependent cut svc
51  ATH_CHECK(m_etaDependentCutsSvc.retrieve());
52 
53  ATH_MSG_INFO("Applying the following cuts during GNN-based track reconstruction: ");
54  ATH_MSG_INFO("Min pT: " << m_pTmin);
55  ATH_MSG_INFO("Max eta: " << m_etamax);
56  ATH_MSG_INFO("Min number of clusters: " << m_minClusters);
57  ATH_MSG_INFO("Min number of pixel clusters: " << m_minPixelClusters);
58  ATH_MSG_INFO("Min number of strip clusters: " << m_minStripClusters);
59 
60 
61  if (m_doRecoTrackCuts) {
62  ATH_MSG_INFO("Applying the following eta dependant track cuts after GNN-based track reconstruction: ");
63  std::vector <double> etaBins, minPT, maxz0, maxd0;
64  std::vector <int> minClusters, minPixelHits, maxHoles;
65  m_etaDependentCutsSvc->getValue(InDet::CutName::etaBins, etaBins);
66  ATH_MSG_INFO("Eta bins: " << etaBins );
67  m_etaDependentCutsSvc->getValue(InDet::CutName::minClusters, minClusters);
68  ATH_MSG_INFO("Min Si Hits: " << minClusters );
69  m_etaDependentCutsSvc->getValue(InDet::CutName::minPixelHits, minPixelHits);
70  ATH_MSG_INFO("Min pixel hits: " << minPixelHits );
71  m_etaDependentCutsSvc->getValue(InDet::CutName::maxHoles, maxHoles);
72  ATH_MSG_INFO("Max holes: " << maxHoles);
73  m_etaDependentCutsSvc->getValue(InDet::CutName::minPT, minPT);
74  ATH_MSG_INFO("Min pT: " << minPT);
75  m_etaDependentCutsSvc->getValue(InDet::CutName::maxZImpact, maxz0);
76  ATH_MSG_INFO("Max z0: " << maxz0);
77  m_etaDependentCutsSvc->getValue(InDet::CutName::maxPrimaryImpact, maxd0);
78  ATH_MSG_INFO("Max d0: " << maxd0);
79  }
80 
81  return StatusCode::SUCCESS;
82 }

◆ 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()

virtual bool InDet::SiSPGNNTrackMaker::isClonable ( ) const
inlineoverridevirtual

Make this algorithm clonable.

Reimplemented from AthReentrantAlgorithm.

Definition at line 50 of file SiSPGNNTrackMaker.h.

50 { return true; };

◆ 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.

◆ passEtaDepCuts() [1/2]

int InDet::SiSPGNNTrackMaker::passEtaDepCuts ( const Trk::Track &  track) const
protected

Definition at line 173 of file SiSPGNNTrackMaker.cxx.

174 {
175  const Trk::Perigee* origPerigee = track.perigeeParameters();
176  double pt = origPerigee->pT();
177 
178  double eta = std::abs(origPerigee->eta());
179 
180  double d0 = std::abs(origPerigee->parameters()[Trk::d0]);
181 
182  double z0 = std::abs(origPerigee->parameters()[Trk::z0]);
183 
184  int nHolesOnTrack = track.trackSummary()->get(Trk::numberOfPixelHoles) +
185  track.trackSummary()->get(Trk::numberOfSCTHoles);
186 
187  int nPixels = track.trackSummary()->get(Trk::numberOfPixelHits);
188  int nStrips = track.trackSummary()->get(Trk::numberOfSCTHits);
189  int nClusters = nPixels + nStrips;
190 
191  ATH_MSG_DEBUG("track params: " << pt << " " << eta << " " << d0 << " " << z0
192  << " " << nClusters << nStrips
193  << " " << nPixels);
194 
195  // min Si hits
196  if (nClusters < m_etaDependentCutsSvc->getMinSiHitsAtEta(eta))
197  return 1;
198 
199  // min pixel hits
200  if (nPixels < m_etaDependentCutsSvc->getMinPixelHitsAtEta(eta))
201  return 2;
202 
203  // min pT, default 400
204  if (pt < m_etaDependentCutsSvc->getMinPtAtEta(eta))
205  return 3;
206 
207  // max z0
208  if (z0 > m_etaDependentCutsSvc->getMaxZImpactAtEta(eta))
209  return 4;
210 
211  // max d0
212  if (d0 > m_etaDependentCutsSvc->getMaxPrimaryImpactAtEta(eta))
213  return 5;
214 
215  // max holes
216  if (nHolesOnTrack > m_etaDependentCutsSvc->getMaxSiHolesAtEta(eta))
217  return 6;
218 
219  return 0;
220 }

◆ passEtaDepCuts() [2/2]

int InDet::SiSPGNNTrackMaker::passEtaDepCuts ( const Trk::Track *  track,
int  nClusters,
int  nFreeClusters,
int  nPixels 
) const
protected

◆ prefitCheck()

bool InDet::SiSPGNNTrackMaker::prefitCheck ( int  nPix,
int  nStrip,
int  nClusters,
int  nSpacePoints 
) const
protected

Definition at line 168 of file SiSPGNNTrackMaker.cxx.

168  {
169  return nPix >= m_minPixelClusters && nStrip >= m_minStripClusters && nClusters >= m_minClusters && nSpacePoints >= 3;
170 }

◆ 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  }

◆ spacePointsToClusters()

std::vector< const Trk::PrepRawData * > InDet::SiSPGNNTrackMaker::spacePointsToClusters ( std::vector< const Trk::SpacePoint * >  spacePoints) const
protected

Definition at line 403 of file SiSPGNNTrackMaker.cxx.

405  {
406  std::vector<const Trk::PrepRawData*> clusters;
407  for (const Trk::SpacePoint* sp : spacePoints) {
408  clusters.push_back(sp->clusterList().first);
409  if (sp->clusterList().second != nullptr) {
410  clusters.push_back(sp->clusterList().second);
411  }
412  }
413  return clusters;
414 }

◆ 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  {
97  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
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.

◆ 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

◆ m_areInputClusters

BooleanProperty InDet::SiSPGNNTrackMaker::m_areInputClusters
protected
Initial value:
{
this, "areInputClusters", false,
"Read track candidates as list of clusters"}

Definition at line 105 of file SiSPGNNTrackMaker.h.

◆ m_ClusterPixelKey

SG::ReadHandleKey<InDet::PixelClusterContainer> InDet::SiSPGNNTrackMaker::m_ClusterPixelKey
protected
Initial value:
{
this, "PixelClusterContainer", "ITkPixelClusters"}

Definition at line 68 of file SiSPGNNTrackMaker.h.

◆ m_ClusterStripKey

SG::ReadHandleKey<InDet::SCT_ClusterContainer> InDet::SiSPGNNTrackMaker::m_ClusterStripKey
protected
Initial value:
{
this, "StripClusterContainer", "ITkStripClusters"}

Definition at line 70 of file SiSPGNNTrackMaker.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_doRecoTrackCuts

BooleanProperty InDet::SiSPGNNTrackMaker::m_doRecoTrackCuts
protected
Initial value:
{this, "doRecoTrackCuts", false,
"Apply Loose track cuts"}

Definition at line 108 of file SiSPGNNTrackMaker.h.

◆ m_etaDependentCutsSvc

ServiceHandle<IInDetEtaDependentCutsSvc> InDet::SiSPGNNTrackMaker::m_etaDependentCutsSvc
protected
Initial value:
{
this, "InDetEtaDependentCutsSvc", "InDetEtaDependentCutsSvc"}

Definition at line 111 of file SiSPGNNTrackMaker.h.

◆ m_etamax

DoubleProperty InDet::SiSPGNNTrackMaker::m_etamax {this, "etamax", 4., "max reco eta"}
protected

Definition at line 119 of file SiSPGNNTrackMaker.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_gnnTrackFinder

ToolHandle<IGNNTrackFinder> InDet::SiSPGNNTrackMaker::m_gnnTrackFinder
protected
Initial value:
{
this, "GNNTrackFinderTool",
"InDet::SiGNNTrackFinderTool", "Track Finder"
}

GNN-based track finding tool that produces track candidates.

@name Tool handles

Definition at line 82 of file SiSPGNNTrackMaker.h.

◆ m_gnnTrackReader

ToolHandle<IGNNTrackReaderTool> InDet::SiSPGNNTrackMaker::m_gnnTrackReader
protected
Initial value:
{
this, "GNNTrackReaderTool",
"InDet::GNNTrackReaderTool", "Track Reader"
}

Definition at line 97 of file SiSPGNNTrackMaker.h.

◆ m_minClusters

IntegerProperty InDet::SiSPGNNTrackMaker::m_minClusters {this, "minClusters", 6, "Min number clusters"}
protected

Definition at line 114 of file SiSPGNNTrackMaker.h.

◆ m_minPixelClusters

IntegerProperty InDet::SiSPGNNTrackMaker::m_minPixelClusters {this, "minPixelClusters", 1, "min pixel clusters"}
protected

Definition at line 115 of file SiSPGNNTrackMaker.h.

◆ m_minStripClusters

IntegerProperty InDet::SiSPGNNTrackMaker::m_minStripClusters
protected
Initial value:
{this, "minStripClusters", 0,
"Minimum number of strip clusters"}

Definition at line 116 of file SiSPGNNTrackMaker.h.

◆ m_outputTracksKey

SG::WriteHandleKey<TrackCollection> InDet::SiSPGNNTrackMaker::m_outputTracksKey
protected
Initial value:
{
this, "TracksLocation", "SiSPGNNTracks"}

Definition at line 74 of file SiSPGNNTrackMaker.h.

◆ m_pTmin

DoubleProperty InDet::SiSPGNNTrackMaker::m_pTmin {this, "pTmin", 400., "min pT"}
protected

Definition at line 118 of file SiSPGNNTrackMaker.h.

◆ m_seedFitter

ToolHandle<ISeedFitter> InDet::SiSPGNNTrackMaker::m_seedFitter
protected
Initial value:
{
this, "SeedFitterTool",
"InDet::SiSeedFitterTool", "Seed Fitter"
}

Definition at line 86 of file SiSPGNNTrackMaker.h.

◆ m_SpacePointsOverlapKey

SG::ReadHandleKey<SpacePointOverlapCollection> InDet::SiSPGNNTrackMaker::m_SpacePointsOverlapKey {this, "SpacePointsOverlapName", "ITkOverlapSpacePoints"}
protected

Definition at line 66 of file SiSPGNNTrackMaker.h.

◆ m_SpacePointsPixelKey

SG::ReadHandleKey<SpacePointContainer> InDet::SiSPGNNTrackMaker::m_SpacePointsPixelKey
protected
Initial value:
{
this, "SpacePointsPixelName", "ITkPixelSpacePoints"}

@name Data handles

Definition at line 62 of file SiSPGNNTrackMaker.h.

◆ m_SpacePointsSCTKey

SG::ReadHandleKey<SpacePointContainer> InDet::SiSPGNNTrackMaker::m_SpacePointsSCTKey
protected
Initial value:
{
this, "SpacePointsSCTName", "ITkStripSpacePoints"}

Definition at line 64 of file SiSPGNNTrackMaker.h.

◆ m_trackFitter

ToolHandle<Trk::ITrackFitter> InDet::SiSPGNNTrackMaker::m_trackFitter
protected
Initial value:
{
this, "TrackFitter",
"Trk::GlobalChi2Fitter/InDetTrackFitter", "Track Fitter"
}

Track Fitter.

Definition at line 91 of file SiSPGNNTrackMaker.h.

◆ m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> InDet::SiSPGNNTrackMaker::m_trackSummaryTool
protected
Initial value:
{
this, "TrackSummaryTool", "InDetTrackSummaryTool"}

Definition at line 95 of file SiSPGNNTrackMaker.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::numberOfPixelHits
@ numberOfPixelHits
number of pixel layers on track with absence of hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:57
Trk::SpacePoint
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:35
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
InDet::SiSPGNNTrackMaker::getClustersInEvent
std::vector< const Trk::PrepRawData * > getClustersInEvent(const EventContext &ctx, int eventNumber) const
Definition: SiSPGNNTrackMaker.cxx:299
PixelCluster
Definition: Trigger/TrigAccel/TrigCudaFitter/src/PixelCluster.h:8
InDet::SiSPGNNTrackMaker::m_doRecoTrackCuts
BooleanProperty m_doRecoTrackCuts
Definition: SiSPGNNTrackMaker.h:108
InDet::SiSPGNNTrackMaker::m_gnnTrackFinder
ToolHandle< IGNNTrackFinder > m_gnnTrackFinder
GNN-based track finding tool that produces track candidates.
Definition: SiSPGNNTrackMaker.h:82
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
InDet::SiSPGNNTrackMaker::m_SpacePointsPixelKey
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsPixelKey
Definition: SiSPGNNTrackMaker.h:62
Trk::SpacePoint::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
Interface method to get the global Position.
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePoint.h:146
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
ConvertOldUJHistosToNewHistos.etaBins
list etaBins
Definition: ConvertOldUJHistosToNewHistos.py:145
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
test_pyathena.pt
pt
Definition: test_pyathena.py:11
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
Trk::z0
@ z0
Definition: ParamDefs.h:64
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
InDet::SiSPGNNTrackMaker::m_minPixelClusters
IntegerProperty m_minPixelClusters
Definition: SiSPGNNTrackMaker.h:115
InDet::SiSPGNNTrackMaker::m_etaDependentCutsSvc
ServiceHandle< IInDetEtaDependentCutsSvc > m_etaDependentCutsSvc
Definition: SiSPGNNTrackMaker.h:111
InDet::SiSPGNNTrackMaker::m_SpacePointsOverlapKey
SG::ReadHandleKey< SpacePointOverlapCollection > m_SpacePointsOverlapKey
Definition: SiSPGNNTrackMaker.h:66
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
InDet::SiSPGNNTrackMaker::passEtaDepCuts
int passEtaDepCuts(const Trk::Track &track) const
Definition: SiSPGNNTrackMaker.cxx:173
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
Trk::numberOfSCTHoles
@ numberOfSCTHoles
number of Holes in both sides of a SCT module
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:73
InDet::SiSPGNNTrackMaker::m_pTmin
DoubleProperty m_pTmin
Definition: SiSPGNNTrackMaker.h:118
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
InDet::SiSPGNNTrackMaker::m_outputTracksKey
SG::WriteHandleKey< TrackCollection > m_outputTracksKey
Definition: SiSPGNNTrackMaker.h:74
SCT_Cluster
Definition: Trigger/TrigAccel/TrigCudaFitter/src/SCT_Cluster.h:8
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
InDet::SiSPGNNTrackMaker::getSpacePoints
std::vector< const Trk::SpacePoint * > getSpacePoints(std::vector< uint32_t > trackIndices, std::vector< const Trk::SpacePoint * > allSpacePoints) const
Definition: SiSPGNNTrackMaker.cxx:359
Trk::ParticleHypothesis
ParticleHypothesis
Definition: ParticleHypothesis.h:25
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::etaBins
@ etaBins
Definition: IInDetEtaDependentCutsSvc.h:13
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
InDet::SiSPGNNTrackMaker::m_ClusterStripKey
SG::ReadHandleKey< InDet::SCT_ClusterContainer > m_ClusterStripKey
Definition: SiSPGNNTrackMaker.h:70
lumiFormat.i
int i
Definition: lumiFormat.py:85
InDet::SiSPGNNTrackMaker::dumpevent
MsgStream & dumpevent(MsgStream &out) const
Definition: SiSPGNNTrackMaker.cxx:626
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Trk::numberOfSCTHits
@ numberOfSCTHits
number of SCT holes
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:71
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trk::pion
@ pion
Definition: ParticleHypothesis.h:29
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
InDet::SiSPGNNTrackMaker::m_trackFitter
ToolHandle< Trk::ITrackFitter > m_trackFitter
Track Fitter.
Definition: SiSPGNNTrackMaker.h:91
InDet::SiSPGNNTrackMaker::getClusters
std::vector< const Trk::PrepRawData * > getClusters(std::vector< std::vector< uint32_t >> clusterTracks, std::vector< const Trk::PrepRawData * > allClusters, int trackNumber) const
Definition: SiSPGNNTrackMaker.cxx:416
InDet::SiSPGNNTrackMaker::prefitCheck
bool prefitCheck(int nPix, int nStrip, int nClusters, int nSpacePoints) const
Definition: SiSPGNNTrackMaker.cxx:168
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
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
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
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
InDet::maxHoles
@ maxHoles
Definition: IInDetEtaDependentCutsSvc.h:14
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
InDet::SiSPGNNTrackMaker::m_areInputClusters
BooleanProperty m_areInputClusters
Definition: SiSPGNNTrackMaker.h:105
Trk::numberOfPixelHoles
@ numberOfPixelHoles
number of pixels which have a ganged ambiguity.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:59
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Trk::PrepRawData
Definition: PrepRawData.h:62
MuonGM::nStrips
int nStrips(const MuonGM::TgcReadoutElement &readoutEle, int layer)
Definition: MuonDetDescr/MuonGeoModelTest/src/GeoModelTgcTest.cxx:46
InDet::SiSPGNNTrackMaker::fitTrack
std::unique_ptr< Trk::Track > fitTrack(const EventContext &ctx, std::vector< const Trk::PrepRawData * > clusters, const Trk::TrackParameters &initial_params, int trackCounter) const
Definition: SiSPGNNTrackMaker.cxx:534
InDet::minClusters
@ minClusters
Definition: IInDetEtaDependentCutsSvc.h:15
InDet::SiSPGNNTrackMaker::m_minClusters
IntegerProperty m_minClusters
Definition: SiSPGNNTrackMaker.h:114
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
InDet::SiSPGNNTrackMaker::m_seedFitter
ToolHandle< ISeedFitter > m_seedFitter
Definition: SiSPGNNTrackMaker.h:86
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
Trk::d0
@ d0
Definition: ParamDefs.h:63
Trk::PrepRawDataType::PixelCluster
@ PixelCluster
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
InDet::minPT
@ minPT
Definition: IInDetEtaDependentCutsSvc.h:15
xAOD::TauJetParameters::nStrip
@ nStrip
Get number of strips.
Definition: TauDefs.h:204
InDet::SiSPGNNTrackMaker::m_trackSummaryTool
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool
Definition: SiSPGNNTrackMaker.h:95
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
a
TList * a
Definition: liststreamerinfos.cxx:10
h
Trk::PrepRawDataType::SCT_Cluster
@ SCT_Cluster
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TRT::Track::trackNumber
@ trackNumber
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:75
InDet::SiSPGNNTrackMaker::m_minStripClusters
IntegerProperty m_minStripClusters
Definition: SiSPGNNTrackMaker.h:116
SpacePointCollection
Definition: SpacePointCollection.h:40
DEBUG
#define DEBUG
Definition: page_access.h:11
InDet::SiSPGNNTrackMaker::m_etamax
DoubleProperty m_etamax
Definition: SiSPGNNTrackMaker.h:119
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
InDet::SiSPGNNTrackMaker::dumptools
MsgStream & dumptools(MsgStream &out) const
Definition: SiSPGNNTrackMaker.cxx:612
InDet::minPixelHits
@ minPixelHits
Definition: IInDetEtaDependentCutsSvc.h:15
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
InDet::SiSPGNNTrackMaker::spacePointsToClusters
std::vector< const Trk::PrepRawData * > spacePointsToClusters(std::vector< const Trk::SpacePoint * > spacePoints) const
Definition: SiSPGNNTrackMaker.cxx:403
InDet::SiSPGNNTrackMaker::doFitAndCut
std::tuple< bool, int, std::unique_ptr< Trk::Track > > doFitAndCut(const EventContext &ctx, std::vector< const Trk::SpacePoint * > &spacePoints, std::vector< const Trk::PrepRawData * > &clusters, int &trackCounter) const
Fits a track and applies quality cuts to determine if it should be kept.
Definition: SiSPGNNTrackMaker.cxx:467
InDet::SiSPGNNTrackMaker::m_ClusterPixelKey
SG::ReadHandleKey< InDet::PixelClusterContainer > m_ClusterPixelKey
Definition: SiSPGNNTrackMaker.h:68
InDet::SiSPGNNTrackMaker::getSpacePointsInEvent
std::vector< const Trk::SpacePoint * > getSpacePointsInEvent(const EventContext &ctx, int eventNumber) const
Definition: SiSPGNNTrackMaker.cxx:222
Analysis::TT
@ TT
Definition: JpsiFinder.h:36
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
InDet::SiSPGNNTrackMaker::m_SpacePointsSCTKey
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsSCTKey
Definition: SiSPGNNTrackMaker.h:64
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
InDet::SiSPGNNTrackMaker::m_gnnTrackReader
ToolHandle< IGNNTrackReaderTool > m_gnnTrackReader
Definition: SiSPGNNTrackMaker.h:97
ServiceHandle< ICondSvc >
Generated on Sun Dec 22 2024 22:00:55 for ATLAS Offline Software by   doxygen 1.8.18