ATLAS Offline Software
Classes | Public Types | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ActsTrk::TrackFindingAlg Class Reference

#include <TrackFindingAlg.h>

Inheritance diagram for ActsTrk::TrackFindingAlg:
Collaboration diagram for ActsTrk::TrackFindingAlg:

Classes

struct  CKF_pimpl
 

Public Types

using RecoTrackContainer = Acts::TrackContainer< Acts::VectorTrackContainer, Acts::VectorMultiTrajectory >
 
using RecoTrackContainerProxy = RecoTrackContainer::TrackProxy
 
using RecoTrackStateContainer = Acts::VectorMultiTrajectory
 
using RecoTrackStateContainerProxy = RecoTrackStateContainer::TrackStateProxy
 

Public Member Functions

 TrackFindingAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TrackFindingAlg ()
 
virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual StatusCode execute (const EventContext &ctx) const override
 
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  EStat : std::size_t {
  kNTotalSeeds, kNoTrackParam, kNUsedSeeds, kNoTrack,
  kNDuplicateSeeds, kNOutputTracks, kNRejectedRefinedSeeds, kNSelectedTracks,
  kNStoppedTracksMaxHoles, kMultipleBranches, kNoSecond, kNStoppedTracksMinPt,
  kNStoppedTracksMaxEta, kNStat
}
 
using EventStats = std::vector< std::array< unsigned int, kNStat > >
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode initializeMeasurementSelector ()
 
StatusCode findTracks (const EventContext &ctx, const TrackFindingMeasurements &measurements, DuplicateSeedDetector &duplicateSeedDetector, const ActsTrk::BoundTrackParametersContainer &estimatedTrackParameters, const ActsTrk::SeedContainer *seeds, ActsTrk::MutableTrackContainer &tracksContainer, size_t seedCollectionIndex, const char *seedType, EventStats &event_stat) const
 invoke track finding procedure More...
 
void storeSeedInfo (const RecoTrackContainer &tracksContainer, const RecoTrackContainerProxy &track, DuplicateSeedDetector &duplicateSeedDetector) const
 
CKF_pimpl & trackFinder ()
 
const CKF_pimpl & trackFinder () const
 
void initStatTables ()
 
void copyStats (const EventStats &event_stat) const
 
void printStatTables () const
 
std::size_t nSeedCollections () const
 
std::size_t seedCollectionStride () const
 
std::size_t getStatCategory (std::size_t seed_collection, float eta) const
 
std::size_t computeStatSum (std::size_t seed_collection, EStat counter_i, const EventStats &stat) const
 
const Acts::Logger & logger () const
 Private access to the logger. 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

ToolHandle< GenericMonitoringTool > m_monTool {this, "MonTool", "", "Monitoring tool"}
 
ToolHandle< IActsExtrapolationTool > m_extrapolationTool {this, "ExtrapolationTool", ""}
 
ToolHandle< IActsTrackingGeometryTool > m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
 
ToolHandle< ActsTrk::IActsToTrkConverterTool > m_ATLASConverterTool {this, "ATLASConverterTool", ""}
 
ToolHandle< ActsTrk::TrackStatePrinter > m_trackStatePrinter {this, "TrackStatePrinter", "", "optional track state printer"}
 
ToolHandle< ActsTrk::IFitterTool > m_fitterTool {this, "FitterTool", "", "Fitter Tool for Seeds"}
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< RecoTrackStateContainer > > m_pixelCalibTool
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< RecoTrackStateContainer > > m_stripCalibTool
 
SG::ReadHandleKeyArray< ActsTrk::SeedContainer > m_seedContainerKeys {this, "SeedContainerKeys", {}, "Seed containers"}
 
SG::ReadHandleKeyArray< ActsTrk::BoundTrackParametersContainer > m_estimatedTrackParametersKeys {this, "EstimatedTrackParametersKeys", {}, "containers of estimated track parameters from seeding"}
 
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainer > m_uncalibratedMeasurementContainerKeys {this, "UncalibratedMeasurementContainerKeys", {}, "input cluster collections"}
 
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollection > m_detEleCollKeys {this, "DetectorElementCollectionKeys", {}, "input SiDetectorElementCollection"}
 
SG::WriteHandleKey< ActsTrk::TrackContainer > m_trackContainerKey {this, "ACTSTracksLocation", "", "Output track collection (ActsTrk variant)"}
 
ActsTrk::MutableTrackContainerHandlesHelper m_tracksBackendHandlesHelper
 
Gaudi::Property< unsigned int > m_maxPropagationStep {this, "maxPropagationStep", 1000, "Maximum number of steps for one propagate call"}
 
Gaudi::Property< bool > m_skipDuplicateSeeds {this, "skipDuplicateSeeds", true, "skip duplicate seeds before calling CKF"}
 
Gaudi::Property< bool > m_refitSeeds {this, "refitSeeds", false, "Run KalmanFitter on seeds before passing to CKF"}
 
Gaudi::Property< std::vector< double > > m_etaBins {this, "etaBins", {}, "bins in |eta| to specify variable selections"}
 
Gaudi::Property< std::vector< double > > m_chi2CutOff {this, "chi2CutOff", {}, "MeasurementSelector: maximum local chi2 contribution"}
 
Gaudi::Property< std::vector< double > > m_chi2OutlierCutOff {this, "chi2OutlierCutOff", {}, "MeasurementSelector: maximum local chi2 contribution for outlier"}
 
Gaudi::Property< std::vector< size_t > > m_numMeasurementsCutOff {this, "numMeasurementsCutOff", {}, "MeasurementSelector: maximum number of associated measurements on a single surface"}
 
Gaudi::Property< std::vector< std::size_t > > m_ptMinMeasurements {this, "ptMinMeasurements", {}, "if specified for the given seed collection, applies ptMin cut in branch stopper once ptMinMinMeasurements have been encountered"}
 
Gaudi::Property< std::vector< std::size_t > > m_absEtaMaxMeasurements {this, "absEtaMaxMeasurements", {}, "if specified for the given seed collection, applies absEtaMax cut in branch stopper once absEtaMaxMeasurements have been encountered"}
 
Gaudi::Property< bool > m_doBranchStopper {this, "doBranchStopper", true, "use branch stopper"}
 
Gaudi::Property< bool > m_doTwoWay {this, "doTwoWay", true, "run CKF twice, first with forward propagation with smoothing, then with backward propagation"}
 
Gaudi::Property< std::vector< double > > m_phiMin {this, "phiMin", {}, "TrackSelector: phiMin"}
 
Gaudi::Property< std::vector< double > > m_phiMax {this, "phiMax", {}, "TrackSelector: phiMax"}
 
Gaudi::Property< std::vector< double > > m_etaMin {this, "etaMin", {}, "TrackSelector: etaMin"}
 
Gaudi::Property< std::vector< double > > m_etaMax {this, "etaMax", {}, "TrackSelector: etaMax"}
 
Gaudi::Property< double > m_absEtaMin {this, "absEtaMin", 0.0, "TrackSelector: absEtaMin"}
 
Gaudi::Property< double > m_absEtaMax {this, "absEtaMax", std::numeric_limits<double>::max(), "TrackSelector: absEtaMax"}
 
Gaudi::Property< std::vector< double > > m_ptMin {this, "ptMin", {}, "TrackSelector: ptMin"}
 
Gaudi::Property< std::vector< double > > m_ptMax {this, "ptMax", {}, "TrackSelector: ptMax"}
 
Gaudi::Property< std::vector< std::size_t > > m_minMeasurements {this, "minMeasurements", {}, "TrackSelector: minMeasurements"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxHoles {this, "maxHoles", {}, "TrackSelector: maxHoles"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxOutliers {this, "maxOutliers", {}, "TrackSelector: maxOutliers"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxSharedHits {this, "maxSharedHits", {}, "TrackSelector: maxSharedHits"}
 
Gaudi::Property< std::vector< double > > m_maxChi2 {this, "maxChi2", {}, "TrackSelector: maxChi2"}
 
Gaudi::Property< std::vector< float > > m_statEtaBins {this, "StatisticEtaBins", {-4, -2.6, -2, 0, 2., 2.6, 4}, "Gather statistics separately for these bins."}
 
Gaudi::Property< std::vector< std::string > > m_seedLabels {this, "SeedLabels", {}, "One label per seed key used in outputs"}
 
Gaudi::Property< bool > m_dumpAllStatEtaBins {this, "DumpEtaBinsForAll", false, "Dump eta bins of all statistics counter."}
 
Gaudi::Property< bool > m_useDefaultMeasurementSelector {this, "UseDefaultActsMeasurementSelector", true, ""}
 
std::unique_ptr< ActsTrk::IMeasurementSelector > m_measurementSelector
 
std::unique_ptr< CKF_pimpl > m_trackFinder
 
bool m_useAbsEtaForStat = false
 
std::mutex m_mutex ATLAS_THREAD_SAFE
 
std::vector< std::array< std::size_t, kNStat > > m_stat ATLAS_THREAD_SAFE {}
 
std::unique_ptr< const Acts::Logger > m_logger
 logging instance More...
 
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

Definition at line 66 of file TrackFindingAlg.h.

Member Typedef Documentation

◆ EventStats

using ActsTrk::TrackFindingAlg::EventStats = std::vector<std::array<unsigned int, kNStat> >
private

Definition at line 163 of file TrackFindingAlg.h.

◆ RecoTrackContainer

using ActsTrk::TrackFindingAlg::RecoTrackContainer = Acts::TrackContainer<Acts::VectorTrackContainer, Acts::VectorMultiTrajectory>

Definition at line 69 of file TrackFindingAlg.h.

◆ RecoTrackContainerProxy

using ActsTrk::TrackFindingAlg::RecoTrackContainerProxy = RecoTrackContainer::TrackProxy

Definition at line 71 of file TrackFindingAlg.h.

◆ RecoTrackStateContainer

using ActsTrk::TrackFindingAlg::RecoTrackStateContainer = Acts::VectorMultiTrajectory

Definition at line 72 of file TrackFindingAlg.h.

◆ RecoTrackStateContainerProxy

using ActsTrk::TrackFindingAlg::RecoTrackStateContainerProxy = RecoTrackStateContainer::TrackStateProxy

Definition at line 73 of file TrackFindingAlg.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ EStat

enum ActsTrk::TrackFindingAlg::EStat : std::size_t
private
Enumerator
kNTotalSeeds 
kNoTrackParam 
kNUsedSeeds 
kNoTrack 
kNDuplicateSeeds 
kNOutputTracks 
kNRejectedRefinedSeeds 
kNSelectedTracks 
kNStoppedTracksMaxHoles 
kMultipleBranches 
kNoSecond 
kNStoppedTracksMinPt 
kNStoppedTracksMaxEta 
kNStat 

Definition at line 146 of file TrackFindingAlg.h.

147  {
148  kNTotalSeeds,
149  kNoTrackParam,
150  kNUsedSeeds,
151  kNoTrack,
152  kNDuplicateSeeds,
153  kNOutputTracks,
154  kNRejectedRefinedSeeds,
155  kNSelectedTracks,
156  kNStoppedTracksMaxHoles,
157  kMultipleBranches,
158  kNoSecond,
159  kNStoppedTracksMinPt,
160  kNStoppedTracksMaxEta,
161  kNStat
162  };

Constructor & Destructor Documentation

◆ TrackFindingAlg()

ActsTrk::TrackFindingAlg::TrackFindingAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 57 of file TrackFindingAlg.cxx.

59  : AthReentrantAlgorithm(name, pSvcLocator)
60  {
61  }

◆ ~TrackFindingAlg()

ActsTrk::TrackFindingAlg::~TrackFindingAlg ( )
virtualdefault

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 }

◆ computeStatSum()

std::size_t ActsTrk::TrackFindingAlg::computeStatSum ( std::size_t  seed_collection,
EStat  counter_i,
const EventStats &  stat 
) const
inlineprivate

Definition at line 1035 of file TrackFindingAlg.cxx.

1036  {
1037  std::size_t out = 0u;
1038  for (std::size_t category_i = seed_collection * seedCollectionStride() + static_cast<std::size_t>(counter_i);
1039  category_i < (seed_collection + 1) * seedCollectionStride();
1040  ++category_i)
1041  {
1042  assert(category_i < stat.size());
1043  out += stat[category_i][counter_i];
1044  }
1045  return out;
1046  }

◆ copyStats()

void ActsTrk::TrackFindingAlg::copyStats ( const EventStats &  event_stat) const
private

Definition at line 827 of file TrackFindingAlg.cxx.

828  {
829  std::lock_guard<std::mutex> lock(m_mutex);
830  std::size_t category_i = 0;
831  for (const std::array<unsigned int, kNStat> &src_stat : event_stat)
832  {
833  std::array<std::size_t, kNStat> &dest_stat = m_stat[category_i++];
834  for (std::size_t i = 0; i < src_stat.size(); ++i)
835  {
836  assert(i < dest_stat.size());
837  dest_stat[i] += src_stat[i];
838  }
839  }
840  }

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

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

Definition at line 244 of file TrackFindingAlg.cxx.

245  {
246  ATH_MSG_DEBUG("Executing " << name() << " ... ");
247 
248  auto timer = Monitored::Timer<std::chrono::milliseconds>("TIME_execute");
249  auto mon_nTracks = Monitored::Scalar<int>("nTracks");
250  auto mon = Monitored::Group(m_monTool, timer, mon_nTracks);
251 
252  // ================================================== //
253  // ===================== INPUTS ===================== //
254  // ================================================== //
255 
256  // SEED PARAMETERS
257  std::vector<const ActsTrk::BoundTrackParametersContainer *> estimatedTrackParametersContainers;
258  estimatedTrackParametersContainers.reserve(m_estimatedTrackParametersKeys.size());
259  for (const auto &estimatedTrackParametersKey : m_estimatedTrackParametersKeys)
260  {
261  ATH_MSG_DEBUG("Reading input collection with key " << estimatedTrackParametersKey.key());
262  SG::ReadHandle<ActsTrk::BoundTrackParametersContainer> estimatedTrackParametersHandle = SG::makeHandle(estimatedTrackParametersKey, ctx);
263  ATH_CHECK(estimatedTrackParametersHandle.isValid());
264  estimatedTrackParametersContainers.push_back(estimatedTrackParametersHandle.cptr());
265  ATH_MSG_DEBUG("Retrieved " << estimatedTrackParametersContainers.back()->size() << " input elements from key " << estimatedTrackParametersKey.key());
266  }
267 
268  // SEED TRIPLETS
269  std::vector<const ActsTrk::SeedContainer *> seedContainers;
270  seedContainers.reserve(m_seedContainerKeys.size());
271  std::size_t total_seeds = 0;
272  for (const auto &seedContainerKey : m_seedContainerKeys)
273  {
274  ATH_MSG_DEBUG("Reading input collection with key " << seedContainerKey.key());
275  SG::ReadHandle<ActsTrk::SeedContainer> seedsHandle = SG::makeHandle(seedContainerKey, ctx);
276  ATH_CHECK(seedsHandle.isValid());
277  seedContainers.push_back(seedsHandle.cptr());
278  ATH_MSG_DEBUG("Retrieved " << seedContainers.back()->size() << " input elements from key " << seedContainerKey.key());
279  total_seeds += seedContainers.back()->size();
280  }
281 
282  // MEASUREMENTS
283  std::vector<const xAOD::UncalibratedMeasurementContainer *> uncalibratedMeasurementContainers;
284  uncalibratedMeasurementContainers.reserve(m_uncalibratedMeasurementContainerKeys.size());
285  std::size_t measTotal = 0;
286  for (const auto &uncalibratedMeasurementContainerKey : m_uncalibratedMeasurementContainerKeys)
287  {
288  ATH_MSG_DEBUG("Reading input collection with key " << uncalibratedMeasurementContainerKey.key());
289  SG::ReadHandle<xAOD::UncalibratedMeasurementContainer> uncalibratedMeasurementContainerHandle = SG::makeHandle(uncalibratedMeasurementContainerKey, ctx);
290  ATH_CHECK(uncalibratedMeasurementContainerHandle.isValid());
291  uncalibratedMeasurementContainers.push_back(uncalibratedMeasurementContainerHandle.cptr());
292  ATH_MSG_DEBUG("Retrieved " << uncalibratedMeasurementContainers.back()->size() << " input elements from key " << uncalibratedMeasurementContainerKey.key());
293  measTotal += uncalibratedMeasurementContainers.back()->size();
294  }
295 
296  std::vector<const InDetDD::SiDetectorElementCollection *> detEleColl;
297  detEleColl.reserve(m_detEleCollKeys.size());
298  for (const auto &detEleCollKey : m_detEleCollKeys)
299  {
300  ATH_MSG_DEBUG("Reading input condition data with key " << detEleCollKey.key());
301  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> detEleCollHandle(detEleCollKey, ctx);
302  ATH_CHECK(detEleCollHandle.isValid());
303  detEleColl.push_back(detEleCollHandle.retrieve());
304  if (detEleColl.back() == nullptr)
305  {
306  ATH_MSG_FATAL(detEleCollKey.fullKey() << " is not available.");
307  return StatusCode::FAILURE;
308  }
309  ATH_MSG_DEBUG("Retrieved " << detEleColl.back()->size() << " input condition elements from key " << detEleCollKey.key());
310  }
311 
312  DuplicateSeedDetector duplicateSeedDetector(total_seeds, m_skipDuplicateSeeds);
313  for (std::size_t icontainer = 0; icontainer < seedContainers.size(); ++icontainer)
314  {
315  if (!seedContainers[icontainer])
316  continue;
317  duplicateSeedDetector.addSeeds(icontainer, *seedContainers[icontainer]);
318  }
319 
320  TrackFindingMeasurements measurements(measTotal);
321 
322  // @TODO make this condition data
323  for (std::size_t icontainer = 0; icontainer < detEleColl.size(); ++icontainer) {
324  xAOD::UncalibMeasType measType =
325  !uncalibratedMeasurementContainers[icontainer]->empty() ? uncalibratedMeasurementContainers[icontainer]->at(0)->type()
326  : xAOD::UncalibMeasType::Other;
327  measurements.addDetectorElements(measType, *detEleColl[icontainer], m_ATLASConverterTool);
328  }
329 
330  // NB. must complete all addDetectorElements() before addMeasurements(), so don't combine these loops!
331  for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer) {
332  ATH_MSG_DEBUG("Create " << uncalibratedMeasurementContainers[icontainer]->size() << " source links from measurements in " << m_uncalibratedMeasurementContainerKeys[icontainer].key());
333  measurements.addMeasurements(icontainer, *uncalibratedMeasurementContainers[icontainer], *detEleColl[icontainer], m_ATLASConverterTool);
334  }
335 
336  if (!m_trackStatePrinter.empty()) {
337  m_trackStatePrinter->printMeasurements(ctx, uncalibratedMeasurementContainers, detEleColl, measurements.measurementOffsets());
338  }
339 
340 
341  // ================================================== //
342  // ===================== COMPUTATION ================ //
343  // ================================================== //
344  ActsTrk::MutableTrackContainer tracksContainer;
345  EventStats event_stat;
346  event_stat.resize(m_stat.size());
347 
348  // Perform the track finding for all initial parameters.
349  // Until the CKF can do a backward search, start with the pixel seeds
350  // (will become relevant when we can remove pixel/strip duplicates).
351  // Afterwards, we could start with strips where the occupancy is lower.
352  for (std::size_t icontainer = 0; icontainer < estimatedTrackParametersContainers.size(); ++icontainer)
353  {
354  if (estimatedTrackParametersContainers[icontainer]->empty())
355  continue;
356  ATH_CHECK(findTracks(ctx,
357  measurements,
358  duplicateSeedDetector,
359  *estimatedTrackParametersContainers[icontainer],
360  seedContainers[icontainer],
361  tracksContainer,
362  icontainer,
363  icontainer < m_seedLabels.size() ? m_seedLabels[icontainer].c_str() : m_seedContainerKeys[icontainer].key().c_str(),
364  event_stat));
365  }
366 
367  ATH_MSG_DEBUG(" \\__ Created " << tracksContainer.size() << " tracks");
368 
369  mon_nTracks = tracksContainer.size();
370 
371  copyStats(event_stat);
372 
373  std::unique_ptr<ActsTrk::TrackContainer> constTracksContainer = m_tracksBackendHandlesHelper.moveToConst(std::move(tracksContainer),
374  m_trackingGeometryTool->getGeometryContext(ctx).context(), ctx);
375  // ================================================== //
376  // ===================== OUTPUTS ==================== //
377  // ================================================== //
378  auto trackContainerHandle = SG::makeHandle(m_trackContainerKey, ctx);
379  ATH_MSG_DEBUG(" \\__ Tracks Container `" << m_trackContainerKey.key() << "` created ...");
380 
381  ATH_CHECK(trackContainerHandle.record(std::move(constTracksContainer)));
382  if (!trackContainerHandle.isValid())
383  {
384  ATH_MSG_FATAL("Failed to write TrackContainer with key " << m_trackContainerKey.key());
385  return StatusCode::FAILURE;
386  }
387 
388  return StatusCode::SUCCESS;
389  }

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

◆ finalize()

StatusCode ActsTrk::TrackFindingAlg::finalize ( )
overridevirtual

Definition at line 236 of file TrackFindingAlg.cxx.

237  {
238  printStatTables();
239  return StatusCode::SUCCESS;
240  }

◆ findTracks()

StatusCode ActsTrk::TrackFindingAlg::findTracks ( const EventContext &  ctx,
const TrackFindingMeasurements &  measurements,
DuplicateSeedDetector &  duplicateSeedDetector,
const ActsTrk::BoundTrackParametersContainer &  estimatedTrackParameters,
const ActsTrk::SeedContainer *  seeds,
ActsTrk::MutableTrackContainer &  tracksContainer,
size_t  seedCollectionIndex,
const char *  seedType,
EventStats &  event_stat 
) const
private

invoke track finding procedure

Parameters
ctx- event context
measurements- measurements container
estimatedTrackParameters- estimates
seeds- spacepoint triplet seeds
tracksContainer- output tracks
tracksCollection- auxiliary output for downstream tools compatibility (to be removed in the future)
seedCollectionIndex- index of seeds in measurements
seedTypename of type of seeds (strip or pixel) - only used for messages

Definition at line 394 of file TrackFindingAlg.cxx.

403  {
404  ATH_MSG_DEBUG(name() << "::" << __FUNCTION__);
405 
406  if (seeds && seeds->size() != estimatedTrackParameters.size())
407  {
408  // should be the same, but we can cope if not
409  ATH_MSG_WARNING("Have " << seeds->size() << " " << seedType << " seeds, but " << estimatedTrackParameters.size() << "estimated track parameters");
410  }
411 
412  // Construct a perigee surface as the target surface
413  auto pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3::Zero());
414 
415  Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
416  Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
417  // CalibrationContext converter not implemented yet.
418  Acts::CalibrationContext calContext = Acts::CalibrationContext();
419 
420  using AtlUncalibSourceLinkAccessor = UncalibSourceLinkAccessor;
421 
422  AtlUncalibSourceLinkAccessor slAccessor(measurements.orderedGeoIds(),
423  measurements.measurementRanges());
424  Acts::SourceLinkAccessorDelegate<UncalibSourceLinkAccessor::Iterator> slAccessorDelegate;
425  slAccessorDelegate.connect<&UncalibSourceLinkAccessor::range>(&slAccessor);
426 
427  // Set the CombinatorialKalmanFilter options
428  using TrackFinderOptions = Acts::CombinatorialKalmanFilterOptions<UncalibSourceLinkAccessor::Iterator, RecoTrackStateContainer>;
429  TrackFinderOptions options(tgContext,
430  mfContext,
431  calContext,
432  slAccessorDelegate,
433  trackFinder().ckfExtensions,
434  trackFinder().pOptions,
435  pSurface.get());
436  if (!m_useDefaultMeasurementSelector.value()) {
437  m_measurementSelector->connect( &options.trackStateCandidateCreator );
438  }
439  std::optional<TrackFinderOptions> secondOptions;
440  if (m_doTwoWay) {
441  secondOptions.emplace(tgContext,
442  mfContext,
443  calContext,
444  slAccessorDelegate,
445  trackFinder().ckfExtensions,
446  trackFinder().pSecondOptions,
447  pSurface.get());
448  secondOptions->targetSurface = pSurface.get();
449  if (!m_useDefaultMeasurementSelector.value()) {
450  m_measurementSelector->connect( &secondOptions->trackStateCandidateCreator);
451  }
452  }
453 
454  // ActsTrk::MutableTrackContainer tracksContainerTemp;
455  Acts::VectorTrackContainer trackBackend;
456  Acts::VectorMultiTrajectory trackStateBackend;
457  RecoTrackContainer tracksContainerTemp(trackBackend, trackStateBackend);
458 
459  // Measurement calibration
460  // N.B. OnTrackCalibrator expects disabled tool handles when no calibration is requested.
461  // Therefore, passing them without checking if they are enabled is safe.
462 
463  auto calibrator = OnTrackCalibrator<RecoTrackStateContainer>(
464  *m_ATLASConverterTool,
465  measurements.trackingSurfaceHelper(),
466  m_pixelCalibTool,
467  m_stripCalibTool);
468 
469  if (m_useDefaultMeasurementSelector.value()) {
470  // for default measurement selector need connect calibrator
471  options.extensions.calibrator.connect<&OnTrackCalibrator<RecoTrackStateContainer>::calibrate>(&calibrator);
472  if (m_doTwoWay) {
473  secondOptions->extensions.calibrator.connect<&OnTrackCalibrator<RecoTrackStateContainer>::calibrate>(&calibrator);
474  }
475  }
476 
477  const auto &trackSelectorCfg = trackFinder().trackSelector.config();
478  auto getCuts = [&trackSelectorCfg](double eta) -> const Acts::TrackSelector::Config & {
479  return (std::abs(eta) < trackSelectorCfg.absEtaEdges.front()) ? trackSelectorCfg.cutSets.front()
480  : (std::abs(eta) >= trackSelectorCfg.absEtaEdges.back()) ? trackSelectorCfg.cutSets.back()
481  : trackSelectorCfg.getCuts(eta);
482  };
483 
484  std::size_t category_i = 0;
485  const auto measurementContainerOffsets = measurements.measurementContainerOffsets();
486 
487  using BranchStopperResult = Acts::CombinatorialKalmanFilterBranchStopperResult;
488  auto stopBranch = [&](const Acts::CombinatorialKalmanFilterTipState &tipState,
489  RecoTrackStateContainer::TrackStateProxy &trackState) -> BranchStopperResult {
490  if (!m_trackStatePrinter.empty()) {
491  m_trackStatePrinter->printTrackState(tgContext, trackState, measurementContainerOffsets, true);
492  }
493 
494  if (!m_doBranchStopper)
495  return BranchStopperResult::Continue;
496 
497  const auto &parameters = trackState.hasFiltered() ? trackState.filtered() : trackState.predicted();
498  double eta = -std::log(std::tan(0.5 * parameters[Acts::eBoundTheta]));
499  const auto &cutSet = getCuts(eta);
500 
501  if (typeIndex < m_ptMinMeasurements.size() &&
502  !(tipState.nMeasurements < m_ptMinMeasurements[typeIndex])) {
503  double pT = std::sin(parameters[Acts::eBoundTheta]) / parameters[Acts::eBoundQOverP];
504  if (std::abs(pT) < cutSet.ptMin) {
505  ++event_stat[category_i][kNStoppedTracksMinPt];
506  ATH_MSG_DEBUG("CkfBranchStopper: drop branch with q*pT="
507  << pT << " after "
508  << tipState.nMeasurements << " measurements");
509  return BranchStopperResult::StopAndDrop;
510  }
511  }
512 
513  if (typeIndex < m_absEtaMaxMeasurements.size() &&
514  !(tipState.nMeasurements < m_absEtaMaxMeasurements[typeIndex]) &&
515  !(std::abs(eta) < trackSelectorCfg.absEtaEdges.back())) {
516  ++event_stat[category_i][kNStoppedTracksMaxEta];
517  ATH_MSG_DEBUG("CkfBranchStopper: drop branch with eta="
518  << eta << " after "
519  << tipState.nMeasurements << " measurements");
520  return BranchStopperResult::StopAndDrop;
521  }
522 
523  // https://github.com/acts-project/acts/blob/v35.0.0/Core/include/Acts/TrackFinding/MeasurementSelector.ipp#L99
524  // counts any other measurement anywhere on the surface as an outlier, so does not register as a hole.
525  // We really want to count them as holes.
526  if (!(tipState.nHoles > cutSet.maxHoles || tipState.nOutliers > cutSet.maxOutliers))
527  return BranchStopperResult::Continue;
528 
529  bool enoughMeasurements = !(tipState.nMeasurements < cutSet.minMeasurements);
530  if (!enoughMeasurements)
531  ++event_stat[category_i][kNStoppedTracksMaxHoles];
532  ATH_MSG_DEBUG("CkfBranchStopper: stop and "
533  << (enoughMeasurements ? "keep" : "drop")
534  << " branch with nHoles=" << tipState.nHoles
535  << ", nOutliers=" << tipState.nOutliers
536  << ", nMeasurements=" << tipState.nMeasurements);
537  return enoughMeasurements ? BranchStopperResult::StopAndKeep
538  : BranchStopperResult::StopAndDrop;
539  };
540 
541  options.extensions.branchStopper.connect(stopBranch);
542  if (m_doTwoWay)
543  secondOptions->extensions.branchStopper.connect(stopBranch);
544 
545  Acts::PropagatorOptions<Acts::ActionList<Acts::MaterialInteractor>,
546  Acts::AbortList<Acts::EndOfWorldReached>>
547  extrapolationOptions(tgContext, mfContext);
548 
549  Acts::TrackExtrapolationStrategy extrapolationStrategy =
550  Acts::TrackExtrapolationStrategy::firstOrLast;
551 
552  // Perform the track finding for all initial parameters
553  ATH_MSG_DEBUG("Invoke track finding with " << estimatedTrackParameters.size() << ' ' << seedType << " seeds.");
554 
555  std::size_t nPrinted = 0;
556  auto printSeed = [&](std::size_t iseed, const Acts::BoundTrackParameters &seedParameters, bool isKF = false)
557  {
558  if (m_trackStatePrinter.empty() || !seeds)
559  return;
560  if (!nPrinted++)
561  {
562  ATH_MSG_INFO("CKF results for " << estimatedTrackParameters.size() << ' ' << seedType << " seeds:");
563  }
564  m_trackStatePrinter->printSeed(tgContext, *(*seeds)[iseed], seedParameters, measurements.measurementOffset(typeIndex), iseed, isKF);
565  };
566 
567  // Loop over the track finding results for all initial parameters
568  for (std::size_t iseed = 0; iseed < estimatedTrackParameters.size(); ++iseed)
569  {
570  category_i = typeIndex * (m_statEtaBins.size() + 1);
571  tracksContainerTemp.clear();
572 
573  if (!estimatedTrackParameters[iseed])
574  {
575  ATH_MSG_WARNING("No " << seedType << " seed " << iseed);
576  ++event_stat[category_i][kNoTrackParam];
577  continue;
578  }
579 
580  const Acts::BoundTrackParameters *initialParameters = estimatedTrackParameters[iseed];
581  printSeed(iseed, *initialParameters);
582 
583  double eta = -std::log(std::tan(0.5 * initialParameters->theta()));
584  category_i = getStatCategory(typeIndex, eta);
585  ++event_stat[category_i][kNTotalSeeds];
586 
587  if (duplicateSeedDetector.isDuplicate(typeIndex, iseed))
588  {
589  ATH_MSG_DEBUG("skip " << seedType << " seed " << iseed << " - already found");
590  ++event_stat[category_i][kNDuplicateSeeds];
591  continue;
592  }
593 
594  // Get the Acts tracks, given this seed
595  // Result here contains a vector of TrackProxy objects
596  ++event_stat[category_i][kNUsedSeeds];
597 
598  std::unique_ptr<Acts::BoundTrackParameters> seedParameters;
599  if (m_refitSeeds)
600  {
601  // Perform KF before CKF
602  const auto fittedSeedCollection = m_fitterTool->fit(ctx, *(*seeds)[iseed], *initialParameters,
603  tgContext, mfContext, calContext,
604  measurements.trackingSurfaceHelper());
605  if (not fittedSeedCollection)
606  {
607  ATH_MSG_WARNING("KF Fitted Track is nullptr");
608  }
609  else if (fittedSeedCollection->size() != 1)
610  {
611  ATH_MSG_WARNING("KF produced " << fittedSeedCollection->size() << " tracks but should produce 1!");
612  }
613  else
614  {
615  // Check pTmin requirement
616  const auto fittedSeed = fittedSeedCollection->getTrack(0);
617 
618  double etaSeed = -std::log(std::tan(0.5 * fittedSeed.parameters()[Acts::eBoundTheta]));
619  const auto &cutSet = getCuts(etaSeed);
620  if (fittedSeed.transverseMomentum() < cutSet.ptMin)
621  {
622  ATH_MSG_VERBOSE("min pt requirement not satisfied after param refinement: pt min is " << cutSet.ptMin << " but Refined params have pt of " << fittedSeed.transverseMomentum());
623  ++event_stat[category_i][kNRejectedRefinedSeeds];
624  continue;
625  }
626 
627  seedParameters.reset(new Acts::BoundTrackParameters(fittedSeed.referenceSurface().getSharedPtr(),
628  fittedSeed.parameters(),
629  fittedSeed.covariance(),
630  fittedSeed.particleHypothesis()));
631  printSeed(iseed, *seedParameters, true);
632 
633  // Pass the refined params to the CKF
634  initialParameters = seedParameters.get();
635  }
636  }
637 
638  auto result = trackFinder().ckf.findTracks(*initialParameters, options, tracksContainerTemp);
639 
640  // The result for this seed
641  if (not result.ok()) {
642  ATH_MSG_WARNING("Track finding failed for " << seedType << " seed " << iseed << " with error" << result.error());
643  continue;
644  }
645  auto &tracksForSeed = result.value();
646 
647  size_t ntracks = 0;
648 
649  // lambda to collect together all the things we do with a viable track.
650  auto addTrack = [&](const RecoTrackContainerProxy &track) {
651  if (!m_trackStatePrinter.empty()) {
652  m_trackStatePrinter->printTrack(tgContext, tracksContainerTemp, track, measurementContainerOffsets);
653  }
654 
655  // Fill the track infos into the duplicate seed detector
656  if (m_skipDuplicateSeeds) {
657  storeSeedInfo(tracksContainerTemp, track, duplicateSeedDetector);
658  }
659 
660  ++ntracks;
661  ++event_stat[category_i][kNOutputTracks];
662 
663  // copy selected tracks into output tracksContainer
664  if (trackFinder().trackSelector.isValidTrack(track)) {
665  auto destProxy = tracksContainer.getTrack(tracksContainer.addTrack());
666  destProxy.copyFrom(track, true); // make sure we copy track states!
667  ++event_stat[category_i][kNSelectedTracks];
668  } else {
669  ATH_MSG_DEBUG("Track " << ntracks << " from " << seedType << " seed " << iseed << " failed track selection");
670  }
671  };
672 
673  std::size_t nfirst = 0;
674  for (auto &firstTrack : tracksForSeed) {
675  std::size_t nsecond = 0;
676 
677  auto smoothingResult = Acts::smoothTrack(tgContext, firstTrack, logger());
678  if (!smoothingResult.ok()) {
679  ATH_MSG_DEBUG("Smoothing for seed "
680  << iseed << " and first track " << firstTrack.index()
681  << " failed with error " << smoothingResult.error());
682  continue;
683  }
684 
685  if (m_doTwoWay) {
686  std::optional<RecoTrackStateContainerProxy> firstState;
687  for (auto st : firstTrack.trackStatesReversed()) {
688  bool isMeasurement = st.typeFlags().test(Acts::TrackStateFlag::MeasurementFlag);
689  bool isOutlier = st.typeFlags().test(Acts::TrackStateFlag::OutlierFlag);
690  // We are excluding non measurement states and outlier here. Those can
691  // decrease resolution because only the smoothing corrected the very
692  // first prediction as filtering is not possible.
693  if (isMeasurement && !isOutlier)
694  firstState = st;
695  }
696 
697  if (firstState.has_value()) {
698  Acts::BoundTrackParameters secondInitialParameters(
699  firstState->referenceSurface().getSharedPtr(),
700  firstState->parameters(), firstState->covariance(),
701  initialParameters->particleHypothesis());
702 
703  auto secondResult = trackFinder().ckf.findTracks(secondInitialParameters, *secondOptions, tracksContainerTemp);
704 
705  if (not secondResult.ok()) {
706  ATH_MSG_WARNING("Second track finding failed for " << seedType << " seed " << iseed << " track " << nfirst << " with error" << secondResult.error());
707  } else {
708  auto firstFirstState = std::next(firstTrack.trackStatesReversed().begin(),
709  firstTrack.nTrackStates() - 1);
710 
711  auto &secondTracksForSeed = secondResult.value();
712  for (auto &secondTrack : secondTracksForSeed) {
713  if (secondTrack.nTrackStates() < 2) {
714  ATH_MSG_DEBUG("Second track from " << seedType << " seed " << iseed << " track " << nfirst << " has only " << secondTrack.nTrackStates() << " track states");
715  continue;
716  }
717 
718  secondTrack.reverseTrackStates(true);
719 
720  (*firstFirstState).previous() = (*std::next(secondTrack.trackStatesReversed().begin())).index();
721  secondTrack.tipIndex() = firstTrack.tipIndex();
722 
723  Acts::calculateTrackQuantities(secondTrack);
724 
725  auto extrapolationResult = Acts::extrapolateTrackToReferenceSurface(
726  secondTrack, *pSurface, trackFinder().extrapolator, extrapolationOptions,
727  extrapolationStrategy, logger());
728  if (!extrapolationResult.ok()) {
729  ATH_MSG_WARNING("Extrapolation for seed "
730  << iseed << " and second track " << secondTrack.index()
731  << " failed with error " << extrapolationResult.error());
732 
733  // restore first track
734  (*firstFirstState).previous() = Acts::kTrackIndexInvalid;
735 
736  continue;
737  }
738 
739  addTrack(secondTrack);
740 
741  // restore first track
742  (*firstFirstState).previous() = Acts::kTrackIndexInvalid;
743 
744  ++nsecond;
745  }
746  }
747  }
748  }
749  if (nsecond == 0) {
750  if (m_doTwoWay) {
751  ATH_MSG_DEBUG("No viable result from second track finding for " << seedType << " seed " << iseed << " track " << nfirst);
752  ++event_stat[category_i][kNoSecond];
753  }
754 
755  auto extrapolationResult = Acts::extrapolateTrackToReferenceSurface(
756  firstTrack, *pSurface, trackFinder().extrapolator, extrapolationOptions,
757  extrapolationStrategy, logger());
758  if (!extrapolationResult.ok()) {
759  ATH_MSG_WARNING("Extrapolation for seed "
760  << iseed << " and first " << firstTrack.index()
761  << " failed with error " << extrapolationResult.error());
762  continue;
763  }
764 
765  addTrack(firstTrack);
766  }
767  nfirst++;
768  }
769  if (ntracks == 0) {
770  ATH_MSG_DEBUG("Track finding found no track candidates for " << seedType << " seed " << iseed);
771  ++event_stat[category_i][kNoTrack];
772  } else if (ntracks >= 2) {
773  ++event_stat[category_i][kMultipleBranches];
774  }
775  if (!m_trackStatePrinter.empty())
776  std::cout << std::flush;
777  }
778 
779  ATH_MSG_DEBUG("Completed " << seedType << " track finding with " << computeStatSum(typeIndex, kNOutputTracks, event_stat) << " track candidates.");
780 
781  return StatusCode::SUCCESS;
782  }

◆ getStatCategory()

std::size_t ActsTrk::TrackFindingAlg::getStatCategory ( std::size_t  seed_collection,
float  eta 
) const
inlineprivate

Definition at line 1025 of file TrackFindingAlg.cxx.

1026  {
1027  std::vector<float>::const_iterator bin_iter = std::upper_bound(m_statEtaBins.begin(),
1028  m_statEtaBins.end(),
1029  m_useAbsEtaForStat ? std::abs(eta) : eta);
1030  std::size_t category_i = seed_collection * seedCollectionStride() + static_cast<std::size_t>(bin_iter - m_statEtaBins.begin());
1031  assert(category_i < m_stat.size());
1032  return category_i;
1033  }

◆ initialize()

StatusCode ActsTrk::TrackFindingAlg::initialize ( )
overridevirtual

Definition at line 67 of file TrackFindingAlg.cxx.

68  {
69  ATH_MSG_INFO("Initializing " << name() << " ... ");
70  ATH_MSG_DEBUG("Properties Summary:");
71  ATH_MSG_DEBUG(" " << m_maxPropagationStep);
72  ATH_MSG_DEBUG(" " << m_skipDuplicateSeeds);
73  ATH_MSG_DEBUG(" " << m_refitSeeds);
74  ATH_MSG_DEBUG(" " << m_etaBins);
75  ATH_MSG_DEBUG(" " << m_chi2CutOff);
76  ATH_MSG_DEBUG(" " << m_chi2OutlierCutOff);
77  ATH_MSG_DEBUG(" " << m_numMeasurementsCutOff);
78  ATH_MSG_DEBUG(" " << m_ptMinMeasurements);
79  ATH_MSG_DEBUG(" " << m_absEtaMaxMeasurements);
80  ATH_MSG_DEBUG(" " << m_doBranchStopper);
81  ATH_MSG_DEBUG(" " << m_doTwoWay);
82  ATH_MSG_DEBUG(" " << m_phiMin);
83  ATH_MSG_DEBUG(" " << m_phiMax);
84  ATH_MSG_DEBUG(" " << m_etaMin);
85  ATH_MSG_DEBUG(" " << m_etaMax);
86  ATH_MSG_DEBUG(" " << m_absEtaMin);
87  ATH_MSG_DEBUG(" " << m_absEtaMax);
88  ATH_MSG_DEBUG(" " << m_ptMin);
89  ATH_MSG_DEBUG(" " << m_ptMax);
90  ATH_MSG_DEBUG(" " << m_minMeasurements);
91  ATH_MSG_DEBUG(" " << m_maxHoles);
92  ATH_MSG_DEBUG(" " << m_maxOutliers);
93  ATH_MSG_DEBUG(" " << m_maxSharedHits);
94  ATH_MSG_DEBUG(" " << m_maxChi2);
95  ATH_MSG_DEBUG(" " << m_statEtaBins);
96  ATH_MSG_DEBUG(" " << m_seedLabels);
97  ATH_MSG_DEBUG(" " << m_dumpAllStatEtaBins);
98 
99  // Read and Write handles
100  ATH_CHECK(m_seedContainerKeys.initialize());
101  ATH_CHECK(m_uncalibratedMeasurementContainerKeys.initialize());
102  ATH_CHECK(m_detEleCollKeys.initialize());
103  ATH_CHECK(m_estimatedTrackParametersKeys.initialize());
104  ATH_CHECK(m_trackContainerKey.initialize());
105  ATH_CHECK(m_tracksBackendHandlesHelper.initialize(ActsTrk::prefixFromTrackContainerName(m_trackContainerKey.key())));
106 
107  if (m_estimatedTrackParametersKeys.size() != m_seedLabels.size())
108  {
109  ATH_MSG_FATAL("There are " << m_seedLabels.size() << " SeedLabels, but " << m_estimatedTrackParametersKeys.size() << " EstimatedTrackParametersKeys");
110  return StatusCode::FAILURE;
111  }
112 
113  if (m_seedContainerKeys.size() != m_estimatedTrackParametersKeys.size())
114  {
115  ATH_MSG_FATAL("There are " << m_estimatedTrackParametersKeys.size() << " EstimatedTrackParametersKeys, but " << m_seedContainerKeys.size() << " SeedContainerKeys");
116  return StatusCode::FAILURE;
117  }
118 
119  if (m_detEleCollKeys.size() != m_uncalibratedMeasurementContainerKeys.size())
120  {
121  ATH_MSG_FATAL("There are " << m_uncalibratedMeasurementContainerKeys.size() << " UncalibratedMeasurementContainerKeys, but " << m_detEleCollKeys.size() << " DetEleCollKeys");
122  return StatusCode::FAILURE;
123  }
124 
125  ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
126  ATH_CHECK(m_trackingGeometryTool.retrieve());
127  ATH_CHECK(m_extrapolationTool.retrieve());
128  ATH_CHECK(m_ATLASConverterTool.retrieve());
129  ATH_CHECK(m_trackStatePrinter.retrieve(EnableTool{not m_trackStatePrinter.empty()}));
130  ATH_CHECK(m_fitterTool.retrieve());
131  ATH_CHECK(m_pixelCalibTool.retrieve(EnableTool{not m_pixelCalibTool.empty()}));
132  ATH_CHECK(m_stripCalibTool.retrieve(EnableTool{not m_stripCalibTool.empty()}));
133 
134  m_logger = makeActsAthenaLogger(this, "Acts");
135 
136  auto magneticField = std::make_unique<ATLASMagneticFieldWrapper>();
137  auto trackingGeometry = m_trackingGeometryTool->trackingGeometry();
138 
139  Stepper stepper(std::move(magneticField));
140  Navigator::Config cfg{trackingGeometry};
141  cfg.resolvePassive = false;
142  cfg.resolveMaterial = true;
143  cfg.resolveSensitive = true;
144  Navigator navigator(cfg, logger().cloneWithSuffix("Navigator"));
145  Propagator propagator(std::move(stepper), std::move(navigator), logger().cloneWithSuffix("Prop"));
146 
147  // Using the CKF propagator as extrapolator
148  Extrapolator extrapolator = propagator;
149 
150  std::vector<double> etaBins;
151  // m_etaBins (from flags.Tracking.ActiveConfig.etaBins) includes a dummy first and last bin, which we ignore
152  if (m_etaBins.size() > 2) {
153  etaBins.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
154  }
155  Acts::MeasurementSelectorCuts measurementSelectorCuts{etaBins};
156 
157  if (!m_chi2CutOff.empty())
158  measurementSelectorCuts.chi2CutOff = m_chi2CutOff;
159  if (!m_numMeasurementsCutOff.empty())
160  measurementSelectorCuts.numMeasurementsCutOff = m_numMeasurementsCutOff;
161 
162  Acts::MeasurementSelector::Config measurementSelectorCfg{{Acts::GeometryIdentifier(), std::move(measurementSelectorCuts)}};
163  Acts::MeasurementSelector measurementSelector(measurementSelectorCfg);
164 
165  std::vector<double> absEtaEdges;
166  absEtaEdges.reserve(etaBins.size() + 2);
167  if (etaBins.empty())
168  {
169  absEtaEdges.push_back(0.0);
170  absEtaEdges.push_back(std::numeric_limits<double>::infinity());
171  }
172  else
173  {
174  absEtaEdges.push_back(m_absEtaMin);
175  absEtaEdges.insert(absEtaEdges.end(), etaBins.begin(), etaBins.end());
176  absEtaEdges.push_back(m_absEtaMax);
177  }
178 
179  auto setCut = [](auto &cfgVal, const auto &cuts, size_t ind) -> void
180  {
181  if (cuts.empty())
182  return;
183  cfgVal = (ind < cuts.size()) ? cuts[ind] : cuts[cuts.size() - 1];
184  };
185 
186  Acts::TrackSelector::EtaBinnedConfig trackSelectorCfg{std::move(absEtaEdges)};
187  if (etaBins.empty())
188  {
189  assert(trackSelectorCfg.cutSets.size() == 1);
190  trackSelectorCfg.cutSets[0].absEtaMin = m_absEtaMin;
191  trackSelectorCfg.cutSets[0].absEtaMax = m_absEtaMax;
192  }
193  size_t cutIndex = 0;
194  for (auto &cfg : trackSelectorCfg.cutSets)
195  {
196  setCut(cfg.phiMin, m_phiMin, cutIndex);
197  setCut(cfg.phiMax, m_phiMax, cutIndex);
198  setCut(cfg.etaMin, m_etaMin, cutIndex);
199  setCut(cfg.etaMax, m_etaMax, cutIndex);
200  setCut(cfg.ptMin, m_ptMin, cutIndex);
201  setCut(cfg.ptMax, m_ptMax, cutIndex);
202  setCut(cfg.minMeasurements, m_minMeasurements, cutIndex);
203  setCut(cfg.maxHoles, m_maxHoles, cutIndex);
204  setCut(cfg.maxOutliers, m_maxOutliers, cutIndex);
205  setCut(cfg.maxSharedHits, m_maxSharedHits, cutIndex);
206  setCut(cfg.maxChi2, m_maxChi2, cutIndex);
207  ++cutIndex;
208  }
209 
210  ATH_MSG_INFO(trackSelectorCfg);
211 
212  if (!m_useDefaultMeasurementSelector.value()) {
213  // initializer measurement selector and connect it to the delegates of the track finder optins
214  ATH_CHECK( initializeMeasurementSelector());
215  }
216  else if (!m_chi2OutlierCutOff.empty()) {
217  ATH_MSG_DEBUG("chi2OutlierCutOff set but not supported when using the default measurement selector.");
218  }
219 
220  m_trackFinder.reset(new CKF_pimpl{CKF_config{std::move(extrapolator), {std::move(propagator), logger().cloneWithSuffix("CKF")}, measurementSelector, {}, {}, {}, trackSelectorCfg}});
221 
222  trackFinder().pOptions.maxSteps = m_maxPropagationStep;
223  trackFinder().pSecondOptions.maxSteps = m_maxPropagationStep;
224  trackFinder().pOptions.direction = Acts::Direction::Forward;
225  trackFinder().pSecondOptions.direction = trackFinder().pOptions.direction.invert();
226 
227  trackFinder().ckfExtensions.updater.connect<&ActsTrk::FitterHelperFunctions::gainMatrixUpdate<RecoTrackStateContainer>>();
228  trackFinder().ckfExtensions.measurementSelector.connect<&Acts::MeasurementSelector::select<RecoTrackStateContainer>>(&trackFinder().measurementSelector);
229  initStatTables();
230 
231  return StatusCode::SUCCESS;
232  }

◆ initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingAlg::initializeMeasurementSelector ( )
private

Definition at line 1049 of file TrackFindingAlg.cxx.

1049  {
1050  std::vector<std::pair<float, float> > chi2CutOffOutlier ;
1051  chi2CutOffOutlier .reserve( m_chi2CutOff.size() );
1052  if (!m_chi2OutlierCutOff.empty()) {
1053  if (m_chi2CutOff.size() != m_chi2OutlierCutOff.size()) {
1054  ATH_MSG_ERROR("Outlier chi2 cut off provided but number of elements does not agree with"
1055  " chi2 cut off for measurements which however is required: "
1056  << m_chi2CutOff.size() << " != " << m_chi2OutlierCutOff.size());
1057  return StatusCode::FAILURE;
1058  }
1059  }
1060  unsigned int idx=0;
1061  for (const auto &elm : m_chi2CutOff) {
1062  chi2CutOffOutlier.push_back( std::make_pair(static_cast<float>(elm),
1063  idx < m_chi2OutlierCutOff.size()
1064  ? static_cast<float>(m_chi2OutlierCutOff[idx])
1065  : std::numeric_limits<float>::max()) );
1066  ++idx;
1067  }
1068  std::vector<float> etaBinsf;
1069  if (m_etaBins.size() > 2) {
1070  etaBinsf.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
1071  }
1072 
1073  m_measurementSelector = ActsTrk::getMeasurementSelector(*m_ATLASConverterTool,
1074  m_pixelCalibTool.isEnabled() ? &(*m_pixelCalibTool) : nullptr,
1075  etaBinsf,
1076  chi2CutOffOutlier,
1077  m_numMeasurementsCutOff.value());
1078 
1079  return m_measurementSelector ? StatusCode::SUCCESS : StatusCode::FAILURE;
1080  }

◆ initStatTables()

void ActsTrk::TrackFindingAlg::initStatTables ( )
private

Definition at line 808 of file TrackFindingAlg.cxx.

809  {
810  if (!m_statEtaBins.empty())
811  {
812  m_useAbsEtaForStat = (m_statEtaBins[0] > 0.);
813  float last_eta = m_statEtaBins[0];
814  for (float eta : m_statEtaBins)
815  {
816  if (eta < last_eta)
817  {
818  ATH_MSG_FATAL("Eta bins for statistics counter not in ascending order.");
819  }
820  last_eta = eta;
821  }
822  }
823  m_stat.resize(nSeedCollections() * seedCollectionStride());
824  }

◆ 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

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

45 {
46  // Reentrant algorithms are clonable.
47  return true;
48 }

◆ logger()

const Acts::Logger& ActsTrk::TrackFindingAlg::logger ( ) const
inlineprivate

Private access to the logger.

Definition at line 228 of file TrackFindingAlg.h.

229  {
230  return *m_logger;
231  }

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

◆ nSeedCollections()

std::size_t ActsTrk::TrackFindingAlg::nSeedCollections ( ) const
inlineprivate

Definition at line 212 of file TrackFindingAlg.h.

213  {
214  return m_seedLabels.size();
215  }

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

◆ printStatTables()

void ActsTrk::TrackFindingAlg::printStatTables ( ) const
private

Definition at line 843 of file TrackFindingAlg.cxx.

844  {
845  if (msgLvl(MSG::INFO))
846  {
847  std::vector<std::string> stat_labels =
848  TableUtils::makeLabelVector(kNStat,
849  {
850  std::make_pair(kNTotalSeeds, "Input seeds"),
851  std::make_pair(kNoTrackParam, "No track parameters"),
852  std::make_pair(kNUsedSeeds, "Used seeds"),
853  std::make_pair(kNoTrack, "Cannot find track"),
854  std::make_pair(kNDuplicateSeeds, "Duplicate seeds"),
855  std::make_pair(kNRejectedRefinedSeeds, "Rejected refined parameters"),
856  std::make_pair(kNOutputTracks, "CKF tracks"),
857  std::make_pair(kNSelectedTracks, "selected tracks"),
858  std::make_pair(kNStoppedTracksMaxHoles, "Stopped tracks reaching max holes"),
859  std::make_pair(kMultipleBranches, "Seeds with more than one branch"),
860  std::make_pair(kNoSecond, "Tracks failing second CKF"),
861  std::make_pair(kNStoppedTracksMinPt, "Stopped tracks below pT cut"),
862  std::make_pair(kNStoppedTracksMaxEta, "Stopped tracks above max eta"),
863  });
864  assert(stat_labels.size() == kNStat);
865  std::vector<std::string> categories;
866  categories.reserve(m_seedLabels.size() + 1);
867  categories.insert(categories.end(), m_seedLabels.begin(), m_seedLabels.end());
868  categories.push_back("ALL");
869 
870  std::vector<std::string> eta_labels;
871  eta_labels.reserve(m_statEtaBins.size() + 2);
872  for (std::size_t eta_bin_i = 0; eta_bin_i < m_statEtaBins.size() + 2; ++eta_bin_i)
873  {
874  eta_labels.push_back(TableUtils::makeEtaBinLabel(m_statEtaBins, eta_bin_i, m_useAbsEtaForStat));
875  }
876 
877  // vector used as 3D array stat[ eta_bin ][ stat_i ][ seed_type]
878  // stat_i = [0, kNStat)
879  // eta_bin = [0, m_statEtaBins.size()+2 ); eta_bin == m_statEtaBinsSize()+1 means sum of all etaBins
880  // seed_type = [0, nSeedCollections()+1) seed_type == nSeedCollections() means sum of all seed collections
881  std::vector<std::size_t> stat =
882  TableUtils::createCounterArrayWithProjections<std::size_t>(nSeedCollections(),
883  m_statEtaBins.size() + 1,
884  m_stat);
885 
886  // the extra columns and rows for the projections are addeded internally:
887  std::size_t stat_stride =
888  TableUtils::counterStride(nSeedCollections(),
889  m_statEtaBins.size() + 1,
890  kNStat);
891  std::size_t eta_stride =
892  TableUtils::subCategoryStride(nSeedCollections(),
893  m_statEtaBins.size() + 1,
894  kNStat);
895  std::stringstream table_out;
896 
897  if (m_dumpAllStatEtaBins.value())
898  {
899  // dump for each counter a table with one row per eta bin
900  std::size_t max_label_width = TableUtils::maxLabelWidth(stat_labels) + TableUtils::maxLabelWidth(eta_labels);
901  for (std::size_t stat_i = 0; stat_i < kNStat; ++stat_i)
902  {
903  std::size_t dest_idx_offset = stat_i * stat_stride;
904  table_out << makeTable(stat, dest_idx_offset, eta_stride,
905  eta_labels,
906  categories)
907  .columnWidth(10)
908  // only dump the footer for the last eta bin i.e. total
909  .dumpHeader(stat_i == 0)
910  .dumpFooter(stat_i + 1 == kNStat)
911  .separateLastRow(true) // separate the sum of all eta bins
912  .minLabelWidth(max_label_width)
913  .labelPrefix(stat_labels.at(stat_i));
914  }
915  }
916  else
917  {
918  // dump one table with one row per counter showing the total eta range
919  for (std::size_t eta_bin_i = (m_dumpAllStatEtaBins.value() ? 0 : m_statEtaBins.size() + 1);
920  eta_bin_i < m_statEtaBins.size() + 2;
921  ++eta_bin_i)
922  {
923  std::size_t dest_idx_offset = eta_bin_i * eta_stride;
924  table_out << makeTable(stat, dest_idx_offset, stat_stride,
925  stat_labels,
926  categories,
927  eta_labels.at(eta_bin_i))
928  .columnWidth(10)
929  // only dump the footer for the last eta bin i.e. total
930  .dumpFooter(!m_dumpAllStatEtaBins.value() || eta_bin_i == m_statEtaBins.size() + 1);
931  }
932  }
933  ATH_MSG_INFO("statistics:\n"
934  << table_out.str());
935  table_out.str("");
936 
937  // define retios first element numerator, second element denominator
938  // each element contains a vector of counter and a multiplier e.g. +- 1
939  // ratios are computed as (sum_i stat[stat_i] * multiplier_i ) / (sum_j stat[stat_j] * multiplier_j )
940  auto [ratio_labels, ratio_def] =
941  TableUtils::splitRatioDefinitionsAndLabels({TableUtils::makeRatioDefinition("failed / seeds ",
942  std::vector<TableUtils::SummandDefinition>{
943  TableUtils::defineSummand(kNTotalSeeds, 1),
944  TableUtils::defineSummand(kNUsedSeeds, -1),
945  TableUtils::defineSummand(kNDuplicateSeeds, -1),
946  // no track counted as used but want to include it as failed
947  TableUtils::defineSummand(kNoTrack, 1),
948  }, // failed seeds i.e. seeds which are not duplicates but did not produce a track
949  std::vector<TableUtils::SummandDefinition>{TableUtils::defineSummand(kNTotalSeeds, 1)}),
950  TableUtils::defineSimpleRatio("duplication / seeds", kNDuplicateSeeds, kNTotalSeeds),
951  TableUtils::defineSimpleRatio("Rejected refined params / seeds", kNRejectedRefinedSeeds, kNTotalSeeds),
952  TableUtils::defineSimpleRatio("selected / CKF tracks", kNSelectedTracks, kNOutputTracks),
953  TableUtils::defineSimpleRatio("selected tracks / used seeds", kNSelectedTracks, kNUsedSeeds),
954  TableUtils::defineSimpleRatio("branched tracks / used seeds", kMultipleBranches, kNUsedSeeds),
955  TableUtils::defineSimpleRatio("no 2nd CKF / CKF tracks", kNoSecond, kNOutputTracks)});
956 
957  std::vector<float> ratio = TableUtils::computeRatios(ratio_def,
958  nSeedCollections() + 1,
959  m_statEtaBins.size() + 2,
960  stat);
961 
962  // the extra columns and rows for the projections are _not_ added internally
963  std::size_t ratio_stride = TableUtils::ratioStride(nSeedCollections() + 1,
964  m_statEtaBins.size() + 2,
965  ratio_def);
966  std::size_t ratio_eta_stride = TableUtils::subCategoryStride(nSeedCollections() + 1,
967  m_statEtaBins.size() + 2,
968  ratio_def);
969 
970  std::size_t max_label_width = TableUtils::maxLabelWidth(ratio_labels) + TableUtils::maxLabelWidth(eta_labels);
971  if (m_dumpAllStatEtaBins.value())
972  {
973  // show for each ratio a table with one row per eta bin
974  for (std::size_t ratio_i = 0; ratio_i < ratio_labels.size(); ++ratio_i)
975  {
976  table_out << makeTable(ratio,
977  ratio_i * ratio_stride,
978  ratio_eta_stride,
979  eta_labels,
980  categories)
981  .columnWidth(10)
982  // only dump the footer for the last eta bin i.e. total
983  .dumpHeader(ratio_i == 0)
984  .dumpFooter(ratio_i + 1 == ratio_labels.size())
985  .separateLastRow(true) // separate the sum of las
986  .minLabelWidth(max_label_width)
987  .labelPrefix(ratio_labels.at(ratio_i));
988  }
989  }
990  else
991  {
992  // dump one table with one row per ratio showing the total eta range
993  table_out << makeTable(ratio,
994  (m_statEtaBins.size() + 1) * ratio_eta_stride + 0 * ratio_stride,
995  ratio_stride,
996  ratio_labels,
997  categories)
998  .columnWidth(10)
999  // only dump the footer for the last eta bin i.e. total
1000  .minLabelWidth(max_label_width)
1001  .dumpFooter(false);
1002 
1003  // also dump a table for final tracks over seeds (ratio_i==3) showing one row per eta bin
1004  eta_labels.erase(eta_labels.end() - 1); // drop last line of table which shows again all eta bins summed.
1005  constexpr std::size_t ratio_i = 3;
1006  table_out << makeTable(ratio,
1007  ratio_i * ratio_stride,
1008  ratio_eta_stride,
1009  eta_labels,
1010  categories)
1011  .columnWidth(10)
1012  .dumpHeader(false)
1013  // only dump the footer for the last eta bin i.e. total
1014  .dumpFooter(!m_dumpAllStatEtaBins.value() || ratio_i + 1 == ratio_labels.size())
1015  .separateLastRow(false)
1016  .minLabelWidth(max_label_width)
1017  .labelPrefix(ratio_labels.at(ratio_i));
1018  }
1019 
1020  ATH_MSG_INFO("Ratios:\n"
1021  << table_out.str());
1022  }
1023  }

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

◆ seedCollectionStride()

std::size_t ActsTrk::TrackFindingAlg::seedCollectionStride ( ) const
inlineprivate

Definition at line 216 of file TrackFindingAlg.h.

217  {
218  return m_statEtaBins.size() + 1;
219  }

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

◆ storeSeedInfo()

void ActsTrk::TrackFindingAlg::storeSeedInfo ( const RecoTrackContainer &  tracksContainer,
const RecoTrackContainerProxy &  track,
DuplicateSeedDetector &  duplicateSeedDetector 
) const
private

Definition at line 785 of file TrackFindingAlg.cxx.

787  {
788 
789  const auto lastMeasurementIndex = track.tipIndex();
790  duplicateSeedDetector.newTrajectory();
791 
792  tracksContainer.trackStateContainer().visitBackwards(
793  lastMeasurementIndex,
794  [&duplicateSeedDetector](const RecoTrackStateContainer::ConstTrackStateProxy &state) -> void
795  {
796  // Check there is a source link
797  if (not state.hasUncalibratedSourceLink())
798  return;
799 
800  // Fill the duplicate selector
801  auto sl = state.getUncalibratedSourceLink().template get<ATLASUncalibSourceLink>();
802  duplicateSeedDetector.addMeasurement(sl);
803  }); // end visitBackwards
804  }

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

◆ trackFinder() [1/2]

TrackFindingAlg::CKF_pimpl & ActsTrk::TrackFindingAlg::trackFinder ( )
private

Definition at line 54 of file TrackFindingAlg.cxx.

54 { return *m_trackFinder; }

◆ trackFinder() [2/2]

const TrackFindingAlg::CKF_pimpl & ActsTrk::TrackFindingAlg::trackFinder ( ) const
private

Definition at line 55 of file TrackFindingAlg.cxx.

55 { return *m_trackFinder; }

◆ 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::mutex m_mutex ActsTrk::TrackFindingAlg::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 224 of file TrackFindingAlg.h.

◆ ATLAS_THREAD_SAFE [2/2]

std::vector<std::array<std::size_t, kNStat> > m_stat ActsTrk::TrackFindingAlg::ATLAS_THREAD_SAFE {}
mutableprivate

Definition at line 225 of file TrackFindingAlg.h.

◆ m_absEtaMax

Gaudi::Property<double> ActsTrk::TrackFindingAlg::m_absEtaMax {this, "absEtaMax", std::numeric_limits<double>::max(), "TrackSelector: absEtaMax"}
private

Definition at line 130 of file TrackFindingAlg.h.

◆ m_absEtaMaxMeasurements

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_absEtaMaxMeasurements {this, "absEtaMaxMeasurements", {}, "if specified for the given seed collection, applies absEtaMax cut in branch stopper once absEtaMaxMeasurements have been encountered"}
private

Definition at line 119 of file TrackFindingAlg.h.

◆ m_absEtaMin

Gaudi::Property<double> ActsTrk::TrackFindingAlg::m_absEtaMin {this, "absEtaMin", 0.0, "TrackSelector: absEtaMin"}
private

Definition at line 129 of file TrackFindingAlg.h.

◆ m_ATLASConverterTool

ToolHandle<ActsTrk::IActsToTrkConverterTool> ActsTrk::TrackFindingAlg::m_ATLASConverterTool {this, "ATLASConverterTool", ""}
private

Definition at line 90 of file TrackFindingAlg.h.

◆ m_chi2CutOff

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_chi2CutOff {this, "chi2CutOff", {}, "MeasurementSelector: maximum local chi2 contribution"}
private

Definition at line 115 of file TrackFindingAlg.h.

◆ m_chi2OutlierCutOff

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_chi2OutlierCutOff {this, "chi2OutlierCutOff", {}, "MeasurementSelector: maximum local chi2 contribution for outlier"}
private

Definition at line 116 of file TrackFindingAlg.h.

◆ m_detEleCollKeys

SG::ReadCondHandleKeyArray<InDetDD::SiDetectorElementCollection> ActsTrk::TrackFindingAlg::m_detEleCollKeys {this, "DetectorElementCollectionKeys", {}, "input SiDetectorElementCollection"}
private

Definition at line 104 of file TrackFindingAlg.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_doBranchStopper

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_doBranchStopper {this, "doBranchStopper", true, "use branch stopper"}
private

Definition at line 120 of file TrackFindingAlg.h.

◆ m_doTwoWay

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_doTwoWay {this, "doTwoWay", true, "run CKF twice, first with forward propagation with smoothing, then with backward propagation"}
private

Definition at line 121 of file TrackFindingAlg.h.

◆ m_dumpAllStatEtaBins

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_dumpAllStatEtaBins {this, "DumpEtaBinsForAll", false, "Dump eta bins of all statistics counter."}
private

Definition at line 142 of file TrackFindingAlg.h.

◆ m_estimatedTrackParametersKeys

SG::ReadHandleKeyArray<ActsTrk::BoundTrackParametersContainer> ActsTrk::TrackFindingAlg::m_estimatedTrackParametersKeys {this, "EstimatedTrackParametersKeys", {}, "containers of estimated track parameters from seeding"}
private

Definition at line 101 of file TrackFindingAlg.h.

◆ m_etaBins

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_etaBins {this, "etaBins", {}, "bins in |eta| to specify variable selections"}
private

Definition at line 113 of file TrackFindingAlg.h.

◆ m_etaMax

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_etaMax {this, "etaMax", {}, "TrackSelector: etaMax"}
private

Definition at line 128 of file TrackFindingAlg.h.

◆ m_etaMin

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_etaMin {this, "etaMin", {}, "TrackSelector: etaMin"}
private

Definition at line 127 of file TrackFindingAlg.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_extrapolationTool

ToolHandle<IActsExtrapolationTool> ActsTrk::TrackFindingAlg::m_extrapolationTool {this, "ExtrapolationTool", ""}
private

Definition at line 88 of file TrackFindingAlg.h.

◆ m_fitterTool

ToolHandle<ActsTrk::IFitterTool> ActsTrk::TrackFindingAlg::m_fitterTool {this, "FitterTool", "", "Fitter Tool for Seeds"}
private

Definition at line 92 of file TrackFindingAlg.h.

◆ m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::TrackFindingAlg::m_logger
private

logging instance

Definition at line 234 of file TrackFindingAlg.h.

◆ m_maxChi2

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_maxChi2 {this, "maxChi2", {}, "TrackSelector: maxChi2"}
private

Definition at line 137 of file TrackFindingAlg.h.

◆ m_maxHoles

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_maxHoles {this, "maxHoles", {}, "TrackSelector: maxHoles"}
private

Definition at line 134 of file TrackFindingAlg.h.

◆ m_maxOutliers

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_maxOutliers {this, "maxOutliers", {}, "TrackSelector: maxOutliers"}
private

Definition at line 135 of file TrackFindingAlg.h.

◆ m_maxPropagationStep

Gaudi::Property<unsigned int> ActsTrk::TrackFindingAlg::m_maxPropagationStep {this, "maxPropagationStep", 1000, "Maximum number of steps for one propagate call"}
private

Definition at line 110 of file TrackFindingAlg.h.

◆ m_maxSharedHits

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_maxSharedHits {this, "maxSharedHits", {}, "TrackSelector: maxSharedHits"}
private

Definition at line 136 of file TrackFindingAlg.h.

◆ m_measurementSelector

std::unique_ptr<ActsTrk::IMeasurementSelector> ActsTrk::TrackFindingAlg::m_measurementSelector
private

Definition at line 204 of file TrackFindingAlg.h.

◆ m_minMeasurements

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_minMeasurements {this, "minMeasurements", {}, "TrackSelector: minMeasurements"}
private

Definition at line 133 of file TrackFindingAlg.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> ActsTrk::TrackFindingAlg::m_monTool {this, "MonTool", "", "Monitoring tool"}
private

Definition at line 87 of file TrackFindingAlg.h.

◆ m_numMeasurementsCutOff

Gaudi::Property<std::vector<size_t> > ActsTrk::TrackFindingAlg::m_numMeasurementsCutOff {this, "numMeasurementsCutOff", {}, "MeasurementSelector: maximum number of associated measurements on a single surface"}
private

Definition at line 117 of file TrackFindingAlg.h.

◆ m_phiMax

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_phiMax {this, "phiMax", {}, "TrackSelector: phiMax"}
private

Definition at line 126 of file TrackFindingAlg.h.

◆ m_phiMin

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_phiMin {this, "phiMin", {}, "TrackSelector: phiMin"}
private

Definition at line 125 of file TrackFindingAlg.h.

◆ m_pixelCalibTool

ToolHandle<ActsTrk::IOnTrackCalibratorTool<RecoTrackStateContainer> > ActsTrk::TrackFindingAlg::m_pixelCalibTool
private
Initial value:
{
this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"}

Definition at line 93 of file TrackFindingAlg.h.

◆ m_ptMax

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_ptMax {this, "ptMax", {}, "TrackSelector: ptMax"}
private

Definition at line 132 of file TrackFindingAlg.h.

◆ m_ptMin

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_ptMin {this, "ptMin", {}, "TrackSelector: ptMin"}
private

Definition at line 131 of file TrackFindingAlg.h.

◆ m_ptMinMeasurements

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_ptMinMeasurements {this, "ptMinMeasurements", {}, "if specified for the given seed collection, applies ptMin cut in branch stopper once ptMinMinMeasurements have been encountered"}
private

Definition at line 118 of file TrackFindingAlg.h.

◆ m_refitSeeds

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_refitSeeds {this, "refitSeeds", false, "Run KalmanFitter on seeds before passing to CKF"}
private

Definition at line 112 of file TrackFindingAlg.h.

◆ m_seedContainerKeys

SG::ReadHandleKeyArray<ActsTrk::SeedContainer> ActsTrk::TrackFindingAlg::m_seedContainerKeys {this, "SeedContainerKeys", {}, "Seed containers"}
private

Definition at line 100 of file TrackFindingAlg.h.

◆ m_seedLabels

Gaudi::Property<std::vector<std::string> > ActsTrk::TrackFindingAlg::m_seedLabels {this, "SeedLabels", {}, "One label per seed key used in outputs"}
private

Definition at line 141 of file TrackFindingAlg.h.

◆ m_skipDuplicateSeeds

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_skipDuplicateSeeds {this, "skipDuplicateSeeds", true, "skip duplicate seeds before calling CKF"}
private

Definition at line 111 of file TrackFindingAlg.h.

◆ m_statEtaBins

Gaudi::Property<std::vector<float> > ActsTrk::TrackFindingAlg::m_statEtaBins {this, "StatisticEtaBins", {-4, -2.6, -2, 0, 2., 2.6, 4}, "Gather statistics separately for these bins."}
private

Definition at line 140 of file TrackFindingAlg.h.

◆ m_stripCalibTool

ToolHandle<ActsTrk::IOnTrackCalibratorTool<RecoTrackStateContainer> > ActsTrk::TrackFindingAlg::m_stripCalibTool
private
Initial value:
{
this, "StripCalibrator", "", "Opt. strip measurement calibrator"}

Definition at line 95 of file TrackFindingAlg.h.

◆ m_trackContainerKey

SG::WriteHandleKey<ActsTrk::TrackContainer> ActsTrk::TrackFindingAlg::m_trackContainerKey {this, "ACTSTracksLocation", "", "Output track collection (ActsTrk variant)"}
private

Definition at line 106 of file TrackFindingAlg.h.

◆ m_trackFinder

std::unique_ptr<CKF_pimpl> ActsTrk::TrackFindingAlg::m_trackFinder
private

Definition at line 205 of file TrackFindingAlg.h.

◆ m_trackingGeometryTool

ToolHandle<IActsTrackingGeometryTool> ActsTrk::TrackFindingAlg::m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
private

Definition at line 89 of file TrackFindingAlg.h.

◆ m_tracksBackendHandlesHelper

ActsTrk::MutableTrackContainerHandlesHelper ActsTrk::TrackFindingAlg::m_tracksBackendHandlesHelper
private

Definition at line 107 of file TrackFindingAlg.h.

◆ m_trackStatePrinter

ToolHandle<ActsTrk::TrackStatePrinter> ActsTrk::TrackFindingAlg::m_trackStatePrinter {this, "TrackStatePrinter", "", "optional track state printer"}
private

Definition at line 91 of file TrackFindingAlg.h.

◆ m_uncalibratedMeasurementContainerKeys

SG::ReadHandleKeyArray<xAOD::UncalibratedMeasurementContainer> ActsTrk::TrackFindingAlg::m_uncalibratedMeasurementContainerKeys {this, "UncalibratedMeasurementContainerKeys", {}, "input cluster collections"}
private

Definition at line 103 of file TrackFindingAlg.h.

◆ m_useAbsEtaForStat

bool ActsTrk::TrackFindingAlg::m_useAbsEtaForStat = false
private

Definition at line 223 of file TrackFindingAlg.h.

◆ m_useDefaultMeasurementSelector

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_useDefaultMeasurementSelector {this, "UseDefaultActsMeasurementSelector", true, ""}
private

Definition at line 144 of file TrackFindingAlg.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:
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ActsTrk::TrackFindingAlg::m_extrapolationTool
ToolHandle< IActsExtrapolationTool > m_extrapolationTool
Definition: TrackFindingAlg.h:88
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
ActsTrk::TrackFindingAlg::m_maxSharedHits
Gaudi::Property< std::vector< std::size_t > > m_maxSharedHits
Definition: TrackFindingAlg.h:136
ActsTrk::TrackFindingAlg::m_statEtaBins
Gaudi::Property< std::vector< float > > m_statEtaBins
Definition: TrackFindingAlg.h:140
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
ActsTrk::TrackFindingAlg::kNStoppedTracksMaxEta
@ kNStoppedTracksMaxEta
Definition: TrackFindingAlg.h:160
ActsTrk::TrackFindingAlg::m_trackingGeometryTool
ToolHandle< IActsTrackingGeometryTool > m_trackingGeometryTool
Definition: TrackFindingAlg.h:89
ActsTrk::MutableTrackContainerHandlesHelper::moveToConst
std::unique_ptr< ActsTrk::TrackContainer > moveToConst(ActsTrk::MutableTrackContainer &&tc, const Acts::GeometryContext &geoContext, const EventContext &evtContext) const
produces ActsTrk::ConstTrackContainer with all backends stored in SG
Definition: TrackContainerHandlesHelper.cxx:130
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FullCPAlgorithmsTest_eljob.flush
flush
Definition: FullCPAlgorithmsTest_eljob.py:168
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
ActsTrk::TrackFindingAlg::logger
const Acts::Logger & logger() const
Private access to the logger.
Definition: TrackFindingAlg.h:228
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
ActsTrk::TrackFindingAlg::m_absEtaMax
Gaudi::Property< double > m_absEtaMax
Definition: TrackFindingAlg.h:130
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
ActsTrk::TrackFindingAlg::kNoTrack
@ kNoTrack
Definition: TrackFindingAlg.h:151
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
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
ActsTrk::TrackFindingAlg::m_phiMin
Gaudi::Property< std::vector< double > > m_phiMin
Definition: TrackFindingAlg.h:125
TableUtils::defineSimpleRatio
RatioDefinition defineSimpleRatio(T numerator, T denominator)
Definition: TableUtils.h:382
ActsTrk::TrackFindingAlg::trackFinder
CKF_pimpl & trackFinder()
Definition: TrackFindingAlg.cxx:54
ActsTrk::prefixFromTrackContainerName
std::string prefixFromTrackContainerName(const std::string &tracks)
Parse TrackContainer name to get the prefix for backends The name has to contain XYZTracks,...
Definition: TrackContainerHandlesHelper.cxx:18
ActsTrk::TrackFindingAlg::m_maxOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxOutliers
Definition: TrackFindingAlg.h:135
ActsTrk::TrackFindingAlg::kNOutputTracks
@ kNOutputTracks
Definition: TrackFindingAlg.h:153
ActsTrk::TrackFindingAlg::kNUsedSeeds
@ kNUsedSeeds
Definition: TrackFindingAlg.h:150
ActsTrk::TrackFindingAlg::m_useAbsEtaForStat
bool m_useAbsEtaForStat
Definition: TrackFindingAlg.h:223
ActsTrk::TrackFindingAlg::kNoTrackParam
@ kNoTrackParam
Definition: TrackFindingAlg.h:149
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ActsTrk::TrackFindingAlg::m_seedContainerKeys
SG::ReadHandleKeyArray< ActsTrk::SeedContainer > m_seedContainerKeys
Definition: TrackFindingAlg.h:100
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:83
ActsTrk::MutableTrackContainerHandlesHelper::initialize
StatusCode initialize(const std::string &prefix)
Sets up the handles.
Definition: TrackContainerHandlesHelper.cxx:51
python.utils.AtlRunQueryTimer.timer
def timer(name, disabled=False)
Definition: AtlRunQueryTimer.py:86
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
ActsTrk::TrackFindingAlg::m_maxPropagationStep
Gaudi::Property< unsigned int > m_maxPropagationStep
Definition: TrackFindingAlg.h:110
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ActsTrk::TrackFindingAlg::storeSeedInfo
void storeSeedInfo(const RecoTrackContainer &tracksContainer, const RecoTrackContainerProxy &track, DuplicateSeedDetector &duplicateSeedDetector) const
Definition: TrackFindingAlg.cxx:785
TableUtils::subCategoryStride
constexpr std::size_t subCategoryStride([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::size_t n_counter)
Definition: TableUtils.h:302
ActsTrk::UncalibSourceLinkAccessor
GenUncalibSourceLinkAccessor< MeasurementRangeList > UncalibSourceLinkAccessor
Definition: AtlasUncalibSourceLinkAccessor.h:199
ActsTrk::TrackFindingAlg::nSeedCollections
std::size_t nSeedCollections() const
Definition: TrackFindingAlg.h:212
ActsTrk::TrackFindingAlg::m_estimatedTrackParametersKeys
SG::ReadHandleKeyArray< ActsTrk::BoundTrackParametersContainer > m_estimatedTrackParametersKeys
Definition: TrackFindingAlg.h:101
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
ActsTrk::TrackFindingAlg::m_uncalibratedMeasurementContainerKeys
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainer > m_uncalibratedMeasurementContainerKeys
Definition: TrackFindingAlg.h:103
makeActsAthenaLogger
std::unique_ptr< const Acts::Logger > makeActsAthenaLogger(IMessageSvc *svc, const std::string &name, int level, std::optional< std::string > parent_name)
Definition: Tracking/Acts/ActsInterop/src/Logger.cxx:64
ActsTrk::TrackFindingAlg::copyStats
void copyStats(const EventStats &event_stat) const
Definition: TrackFindingAlg.cxx:827
ActsTrk::TrackFindingAlg::m_chi2OutlierCutOff
Gaudi::Property< std::vector< double > > m_chi2OutlierCutOff
Definition: TrackFindingAlg.h:116
ActsTrk::TrackFindingAlg::printStatTables
void printStatTables() const
Definition: TrackFindingAlg.cxx:843
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
ActsTrk::TrackFindingAlg::computeStatSum
std::size_t computeStatSum(std::size_t seed_collection, EStat counter_i, const EventStats &stat) const
Definition: TrackFindingAlg.cxx:1035
ActsTrk::TrackFindingAlg::kNDuplicateSeeds
@ kNDuplicateSeeds
Definition: TrackFindingAlg.h:152
ActsTrk::TrackFindingAlg::m_seedLabels
Gaudi::Property< std::vector< std::string > > m_seedLabels
Definition: TrackFindingAlg.h:141
ActsTrk::TrackFindingAlg::RecoTrackContainerProxy
RecoTrackContainer::TrackProxy RecoTrackContainerProxy
Definition: TrackFindingAlg.h:71
xAOD::addTrack
@ addTrack
Definition: TrackingPrimitives.h:465
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
TableUtils::counterStride
constexpr std::size_t counterStride([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::size_t n_counter)
Definition: TableUtils.h:307
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
python.web.makeTable
def makeTable(name, ids)
Definition: web.py:28
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
TableUtils::maxLabelWidth
std::size_t maxLabelWidth(const T_Collection &col)
Definition: TableUtils.h:288
lumiFormat.i
int i
Definition: lumiFormat.py:92
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ActsTrk::TrackFindingAlg::m_ptMin
Gaudi::Property< std::vector< double > > m_ptMin
Definition: TrackFindingAlg.h:131
ActsTrk::TrackFindingAlg::m_detEleCollKeys
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollection > m_detEleCollKeys
Definition: TrackFindingAlg.h:104
ActsTrk::TrackFindingAlg::initializeMeasurementSelector
StatusCode initializeMeasurementSelector()
Definition: TrackFindingAlg.cxx:1049
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:93
ActsTrk::TrackFindingAlg::findTracks
StatusCode findTracks(const EventContext &ctx, const TrackFindingMeasurements &measurements, DuplicateSeedDetector &duplicateSeedDetector, const ActsTrk::BoundTrackParametersContainer &estimatedTrackParameters, const ActsTrk::SeedContainer *seeds, ActsTrk::MutableTrackContainer &tracksContainer, size_t seedCollectionIndex, const char *seedType, EventStats &event_stat) const
invoke track finding procedure
Definition: TrackFindingAlg.cxx:394
xAOD::Other
@ Other
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsTrk::TrackFindingAlg::kNStoppedTracksMinPt
@ kNStoppedTracksMinPt
Definition: TrackFindingAlg.h:159
ActsTrk::TrackFindingAlg::m_absEtaMin
Gaudi::Property< double > m_absEtaMin
Definition: TrackFindingAlg.h:129
python.AtlRunQueryLib.options
options
Definition: AtlRunQueryLib.py:379
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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
ActsTrk::TrackFindingAlg::m_numMeasurementsCutOff
Gaudi::Property< std::vector< size_t > > m_numMeasurementsCutOff
Definition: TrackFindingAlg.h:117
ActsTrk::TrackFindingAlg::m_useDefaultMeasurementSelector
Gaudi::Property< bool > m_useDefaultMeasurementSelector
Definition: TrackFindingAlg.h:144
beamspotman.stat
stat
Definition: beamspotman.py:266
ActsTrk::TrackFindingAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrackFindingAlg.h:87
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
ActsTrk::TrackFindingAlg::m_measurementSelector
std::unique_ptr< ActsTrk::IMeasurementSelector > m_measurementSelector
Definition: TrackFindingAlg.h:204
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
ActsTrk::TrackFindingAlg::kNRejectedRefinedSeeds
@ kNRejectedRefinedSeeds
Definition: TrackFindingAlg.h:154
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
ActsTrk::TrackFindingAlg::RecoTrackContainer
Acts::TrackContainer< Acts::VectorTrackContainer, Acts::VectorMultiTrajectory > RecoTrackContainer
Definition: TrackFindingAlg.h:70
ActsTrk::GenUncalibSourceLinkAccessor::range
std::pair< Iterator, Iterator > range(const Acts::Surface &surface) const
Definition: AtlasUncalibSourceLinkAccessor.h:151
TableUtils::makeLabelVector
std::vector< std::string > makeLabelVector(T_index n_entries, std::initializer_list< std::pair< T_index, T_string > > a_list)
Definition: TableUtils.h:273
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
ActsTrk::TrackFindingAlg::kMultipleBranches
@ kMultipleBranches
Definition: TrackFindingAlg.h:157
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
ActsTrk::OnTrackCalibrator::calibrate
void calibrate(const Acts::GeometryContext &geoctx, const Acts::CalibrationContext &cctx, const Acts::SourceLink &link, TrackStateProxy state) const
ActsTrk::getMeasurementSelector
std::unique_ptr< ActsTrk::IMeasurementSelector > getMeasurementSelector([[maybe_unused]] const ActsTrk::IActsToTrkConverterTool &ATLASConverterTool, const ActsTrk::IOnBoundStateCalibratorTool *onTrackCalibratorTool, const std::vector< float > &etaBinsf, const std::vector< std::pair< float, float > > &chi2CutOffOutlier, const std::vector< size_t > &numMeasurementsCutOff)
Definition: AtlasMeasurementSelector.cxx:345
WriteCaloSwCorrections.cfg
cfg
Definition: WriteCaloSwCorrections.py:23
TableUtils::splitRatioDefinitionsAndLabels
std::tuple< std::vector< std::string >, std::vector< RatioDefinition > > splitRatioDefinitionsAndLabels(std::initializer_list< std::tuple< std::string, RatioDefinition > > a_ratio_list)
Definition: TableUtils.h:446
ActsTrk::TrackFindingAlg::m_chi2CutOff
Gaudi::Property< std::vector< double > > m_chi2CutOff
Definition: TrackFindingAlg.h:115
ActsTrk::TrackFindingAlg::m_doBranchStopper
Gaudi::Property< bool > m_doBranchStopper
Definition: TrackFindingAlg.h:120
TableUtils::makeEtaBinLabel
std::string makeEtaBinLabel(const std::vector< float > &eta_bins, std::size_t eta_bin_i, bool abs_eta=false)
Definition: TableUtils.h:512
DeMoScan.index
string index
Definition: DeMoScan.py:362
ActsTrk::TrackFindingAlg::m_skipDuplicateSeeds
Gaudi::Property< bool > m_skipDuplicateSeeds
Definition: TrackFindingAlg.h:111
mergePhysValFiles.categories
list categories
Definition: PhysicsAnalysis/JetTagging/JetTagValidation/JetTagDQA/scripts/mergePhysValFiles.py:18
a
TList * a
Definition: liststreamerinfos.cxx:10
ActsTrk::TrackFindingAlg::getStatCategory
std::size_t getStatCategory(std::size_t seed_collection, float eta) const
Definition: TrackFindingAlg.cxx:1025
ActsTrk::TrackFindingAlg::initStatTables
void initStatTables()
Definition: TrackFindingAlg.cxx:808
h
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:295
ActsTrk::TrackFindingAlg::m_etaMin
Gaudi::Property< std::vector< double > > m_etaMin
Definition: TrackFindingAlg.h:127
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ActsTrk::TrackFindingAlg::kNStat
@ kNStat
Definition: TrackFindingAlg.h:161
ActsTrk::TrackFindingAlg::m_minMeasurements
Gaudi::Property< std::vector< std::size_t > > m_minMeasurements
Definition: TrackFindingAlg.h:133
ActsTrk::TrackFindingAlg::m_ptMinMeasurements
Gaudi::Property< std::vector< std::size_t > > m_ptMinMeasurements
Definition: TrackFindingAlg.h:118
plotBeamSpotMon.mon
mon
Definition: plotBeamSpotMon.py:67
ActsTrk::TrackFindingAlg::m_logger
std::unique_ptr< const Acts::Logger > m_logger
logging instance
Definition: TrackFindingAlg.h:234
ActsTrk::TrackFindingAlg::m_trackStatePrinter
ToolHandle< ActsTrk::TrackStatePrinter > m_trackStatePrinter
Definition: TrackFindingAlg.h:91
ActsTrk::TrackFindingAlg::m_tracksBackendHandlesHelper
ActsTrk::MutableTrackContainerHandlesHelper m_tracksBackendHandlesHelper
Definition: TrackFindingAlg.h:107
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xAOD::UncalibMeasType
UncalibMeasType
Define the type of the uncalibrated measurement.
Definition: MeasurementDefs.h:24
ActsTrk::TrackFindingAlg::m_trackFinder
std::unique_ptr< CKF_pimpl > m_trackFinder
Definition: TrackFindingAlg.h:205
ActsTrk::TrackFindingAlg::m_stripCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< RecoTrackStateContainer > > m_stripCalibTool
Definition: TrackFindingAlg.h:95
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
ActsTrk::TrackFindingAlg::m_doTwoWay
Gaudi::Property< bool > m_doTwoWay
Definition: TrackFindingAlg.h:121
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
ActsTrk::TrackFindingAlg::EventStats
std::vector< std::array< unsigned int, kNStat > > EventStats
Definition: TrackFindingAlg.h:163
ActsTrk::TrackFindingAlg::m_trackContainerKey
SG::WriteHandleKey< ActsTrk::TrackContainer > m_trackContainerKey
Definition: TrackFindingAlg.h:106
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
ActsTrk::TrackFindingAlg::kNTotalSeeds
@ kNTotalSeeds
Definition: TrackFindingAlg.h:148
ActsTrk::TrackFindingAlg::kNSelectedTracks
@ kNSelectedTracks
Definition: TrackFindingAlg.h:155
ActsTrk::TrackFindingAlg::kNoSecond
@ kNoSecond
Definition: TrackFindingAlg.h:158
ActsTrk::TrackFindingAlg::m_etaBins
Gaudi::Property< std::vector< double > > m_etaBins
Definition: TrackFindingAlg.h:113
ActsTrk::TrackFindingAlg::m_absEtaMaxMeasurements
Gaudi::Property< std::vector< std::size_t > > m_absEtaMaxMeasurements
Definition: TrackFindingAlg.h:119
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
ActsTrk::TrackFindingAlg::m_maxChi2
Gaudi::Property< std::vector< double > > m_maxChi2
Definition: TrackFindingAlg.h:137
ActsTrk::TrackFindingAlg::seedCollectionStride
std::size_t seedCollectionStride() const
Definition: TrackFindingAlg.h:216
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
TableUtils::makeRatioDefinition
std::tuple< std::string, RatioDefinition > makeRatioDefinition(std::string &&name, std::vector< SummandDefinition > &&numerator, std::vector< SummandDefinition > &&denominator)
Definition: TableUtils.h:436
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
ActsTrk::TrackFindingAlg::m_ptMax
Gaudi::Property< std::vector< double > > m_ptMax
Definition: TrackFindingAlg.h:132
TableUtils::ratioStride
constexpr std::size_t ratioStride([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::vector< RatioDefinition > &ratio_def)
Definition: TableUtils.h:471
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
TableUtils::computeRatios
std::vector< float > computeRatios(const std::vector< RatioDefinition > &ratio_def, const std::size_t categories, const std::size_t sub_categories, const std::vector< std::size_t > &counter)
Definition: TableUtils.cxx:21
TableUtils::defineSummand
SummandDefinition defineSummand(T counter_idx, int multiplier)
Definition: TableUtils.h:400
ActsTrk::TrackFindingAlg::m_phiMax
Gaudi::Property< std::vector< double > > m_phiMax
Definition: TrackFindingAlg.h:126
ActsTrk::MutableTrackContainer
Definition: TrackContainer.h:122
ActsTrk::TrackFindingAlg::m_dumpAllStatEtaBins
Gaudi::Property< bool > m_dumpAllStatEtaBins
Definition: TrackFindingAlg.h:142
ActsTrk::TrackFindingAlg::m_pixelCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< RecoTrackStateContainer > > m_pixelCalibTool
Definition: TrackFindingAlg.h:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
ActsTrk::TrackFindingAlg::m_etaMax
Gaudi::Property< std::vector< double > > m_etaMax
Definition: TrackFindingAlg.h:128
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
ActsTrk::TrackFindingAlg::kNStoppedTracksMaxHoles
@ kNStoppedTracksMaxHoles
Definition: TrackFindingAlg.h:156
fitman.k
k
Definition: fitman.py:528
ActsTrk::TrackFindingAlg::m_fitterTool
ToolHandle< ActsTrk::IFitterTool > m_fitterTool
Definition: TrackFindingAlg.h:92
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
ActsTrk::TrackFindingAlg::m_refitSeeds
Gaudi::Property< bool > m_refitSeeds
Definition: TrackFindingAlg.h:112
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
ActsTrk::TrackFindingAlg::m_maxHoles
Gaudi::Property< std::vector< std::size_t > > m_maxHoles
Definition: TrackFindingAlg.h:134
ActsTrk::TrackFindingAlg::m_ATLASConverterTool
ToolHandle< ActsTrk::IActsToTrkConverterTool > m_ATLASConverterTool
Definition: TrackFindingAlg.h:90
Generated on Tue Jul 2 2024 22:11:22 for ATLAS Offline Software by   doxygen 1.8.18