ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Static 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  BranchState
 
struct  CKF_pimpl
 

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, kNNoEstimatedParams, kNOutputTracks, kNRejectedRefinedSeeds,
  kNSelectedTracks, kNStoppedTracksMaxHoles, kMultipleBranches, kNoSecond,
  kNStoppedTracksMinPt, kNStoppedTracksMaxEta, kNTotalSharedHits, kNStat
}
 
using EventStats = std::vector< std::array< unsigned int, kNStat > >
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode initializeMeasurementSelector ()
 
StatusCode findTracks (const EventContext &ctx, const Acts::TrackingGeometry &trackingGeometry, const ActsTrk::DetectorElementToActsGeometryIdMap &detectorElementToGeoId, const detail::TrackFindingMeasurements &measurements, std::optional< detail::SharedHitCounter > &sharedHits, detail::DuplicateSeedDetector &duplicateSeedDetector, const ActsTrk::SeedContainer &seeds, const InDetDD::SiDetectorElementCollection &detElements, ActsTrk::MutableTrackContainer &tracksContainer, std::size_t seedCollectionIndex, const char *seedType, EventStats &event_stat) const
 invoke track finding procedure More...
 
void storeSeedInfo (const detail::RecoTrackContainer &tracksContainer, const detail::RecoTrackContainerProxy &track, detail::DuplicateSeedDetector &duplicateSeedDetector) const
 
CKF_pimpltrackFinder ()
 
const CKF_pimpltrackFinder () const
 
void checkPixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track) const
 
std::array< bool, 3 > selectPixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track, double eta) 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...
 

Static Private Member Functions

static xAOD::UncalibMeasType measurementType (const detail::RecoTrackContainer::TrackStateProxy &trackState)
 
static void addPixelStripCounts (detail::RecoTrackContainer &tracksContainer)
 
static void initPixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track)
 
static void updatePixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateType typeFlags, xAOD::UncalibMeasType detType)
 
static void copyPixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackProxy &other)
 

Private Attributes

ToolHandle< GenericMonitoringToolm_monTool {this, "MonTool", "", "Monitoring tool"}
 
ToolHandle< IActsExtrapolationToolm_extrapolationTool {this, "ExtrapolationTool", ""}
 
ToolHandle< IActsTrackingGeometryToolm_trackingGeometryTool {this, "TrackingGeometryTool", ""}
 
ToolHandle< ActsTrk::TrackStatePrinterToolm_trackStatePrinter {this, "TrackStatePrinter", "", "optional track state printer"}
 
ToolHandle< ActsTrk::IActsToTrkConverterToolm_ATLASConverterTool {this, "ATLASConverterTool", ""}
 
ToolHandle< ActsTrk::ITrackParamsEstimationToolm_paramEstimationTool {this, "TrackParamsEstimationTool", "", "Track Param Estimation from Seeds"}
 
ToolHandle< ActsTrk::IFitterToolm_fitterTool {this, "FitterTool", "", "Fitter Tool for Seeds"}
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_pixelCalibTool
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_stripCalibTool
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_hgtdCalibTool
 
SG::ReadHandleKeyArray< ActsTrk::SeedContainerm_seedContainerKeys {this, "SeedContainerKeys", {}, "Seed containers"}
 
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollectionm_detEleCollKeys {this, "DetectorElementsKeys", {}, "Keys of input SiDetectorElementCollection"}
 
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainerm_uncalibratedMeasurementContainerKeys {this, "UncalibratedMeasurementContainerKeys", {}, "input cluster collections"}
 
SG::ReadCondHandleKey< ActsTrk::DetectorElementToActsGeometryIdMapm_detectorElementToGeometryIdMapKey
 
SG::WriteHandleKey< ActsTrk::TrackContainerm_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< std::vector< bool > > m_refitSeeds {this, "refitSeeds", {}, "Run KalmanFitter on seeds before passing to CKF, specified separately for each seed collection"}
 
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< bool > > m_reverseSearch {this, "reverseSearch", {}, "Whether to run the finding in seed parameter direction (false or not specified) or reverse direction (true), specified separately for each seed collection"}
 
Gaudi::Property< double > m_branchStopperPtMinFactor {this, "branchStopperPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the branch stopper"}
 
Gaudi::Property< double > m_branchStopperAbsEtaMaxExtra {this, "branchStopperAbsEtaMaxExtra", 0.0, "increase absEtaMax cut when used in the branch stopper"}
 
Gaudi::Property< bool > m_countSharedHits {this, "countSharedHits", true, "add shared hit flags to tracks"}
 
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< double > > m_d0Min {this, "d0Min", {}, "TrackSelector: d0Min"}
 
Gaudi::Property< std::vector< double > > m_d0Max {this, "d0Max", {}, "TrackSelector: d0Max"}
 
Gaudi::Property< std::vector< double > > m_z0Min {this, "z0Min", {}, "TrackSelector: z0Min"}
 
Gaudi::Property< std::vector< double > > m_z0Max {this, "z0Max", {}, "TrackSelector: z0Max"}
 
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< bool > m_addPixelStripCounts {this, "addPixelStripCounts", true, "keep separate pixel and strip counts and apply the following cuts"}
 
Gaudi::Property< std::vector< std::size_t > > m_minPixelHits {this, "minPixelHits", {}, "minimum number of pixel hits"}
 
Gaudi::Property< std::vector< std::size_t > > m_minStripHits {this, "minStripHits", {}, "minimum number of strip hits"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxPixelHoles {this, "maxPixelHoles", {}, "maximum number of pixel holes"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxStripHoles {this, "maxStripHoles", {}, "maximum number of strip holes"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxPixelOutliers {this, "maxPixelOutliers", {}, "maximum number of pixel outliers"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxStripOutliers {this, "maxStripOutliers", {}, "maximum number of strip outliers"}
 
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::IMeasurementSelectorm_measurementSelector
 
std::unique_ptr< CKF_pimplm_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
 

Static Private Attributes

static constexpr BranchState s_branchState {}
 

Detailed Description

Definition at line 67 of file TrackFindingAlg.h.

Member Typedef Documentation

◆ EventStats

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

Definition at line 183 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 
kNNoEstimatedParams 
kNOutputTracks 
kNRejectedRefinedSeeds 
kNSelectedTracks 
kNStoppedTracksMaxHoles 
kMultipleBranches 
kNoSecond 
kNStoppedTracksMinPt 
kNStoppedTracksMaxEta 
kNTotalSharedHits 
kNStat 

Definition at line 164 of file TrackFindingAlg.h.

Constructor & Destructor Documentation

◆ TrackFindingAlg()

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

Definition at line 60 of file TrackFindingAlg.cxx.

62  : AthReentrantAlgorithm(name, pSvcLocator)
63  {
64  }

◆ ~TrackFindingAlg()

ActsTrk::TrackFindingAlg::~TrackFindingAlg ( )
virtualdefault

Member Function Documentation

◆ addPixelStripCounts()

void ActsTrk::TrackFindingAlg::addPixelStripCounts ( detail::RecoTrackContainer tracksContainer)
staticprivate

Definition at line 936 of file TrackFindingAlg.cxx.

937  {
938  tracksContainer.addColumn<unsigned int>("nPixelHits");
939  tracksContainer.addColumn<unsigned int>("nStripHits");
940  tracksContainer.addColumn<unsigned int>("nPixelHoles");
941  tracksContainer.addColumn<unsigned int>("nStripHoles");
942  tracksContainer.addColumn<unsigned int>("nPixelOutliers");
943  tracksContainer.addColumn<unsigned int>("nStripOutliers");
944  }

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

◆ checkPixelStripCounts()

void ActsTrk::TrackFindingAlg::checkPixelStripCounts ( const detail::RecoTrackContainer::TrackProxy &  track) const
private

Definition at line 994 of file TrackFindingAlg.cxx.

995  {
996  // This check will fail if there are other types (HGTD, MS?) of hits, holes, or outliers.
997  // The check can be removed when it is no longer appropriate.
998  if (track.nMeasurements() != s_branchState.nPixelHits(track) + s_branchState.nStripHits(track))
999  ATH_MSG_WARNING("mismatched hit count: total (" << track.nMeasurements()
1000  << ") != pixel (" << s_branchState.nPixelHits(track)
1001  << ") + strip (" << s_branchState.nStripHits(track) << ")");
1002  if (track.nHoles() < s_branchState.nPixelHoles(track) + s_branchState.nStripHoles(track)) // allow extra HGTD holes
1003  ATH_MSG_WARNING("mismatched hole count: total (" << track.nHoles()
1004  << ") < pixel (" << s_branchState.nPixelHoles(track)
1005  << ") + strip (" << s_branchState.nStripHoles(track) << ")");
1007  ATH_MSG_WARNING("mismatched outlier count: total (" << track.nOutliers()
1008  << ") != pixel (" << s_branchState.nPixelOutliers(track)
1009  << ") + strip (" << s_branchState.nStripOutliers(track) << ")");
1010  };

◆ computeStatSum()

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

Definition at line 1267 of file TrackFindingAlg.cxx.

1268  {
1269  std::size_t out = 0u;
1270  for (std::size_t category_i = seed_collection * seedCollectionStride() + static_cast<std::size_t>(counter_i);
1271  category_i < (seed_collection + 1) * seedCollectionStride();
1272  ++category_i)
1273  {
1274  assert(category_i < stat.size());
1275  out += stat[category_i][counter_i];
1276  }
1277  return out;
1278  }

◆ copyPixelStripCounts()

void ActsTrk::TrackFindingAlg::copyPixelStripCounts ( const detail::RecoTrackContainer::TrackProxy &  track,
const detail::RecoTrackContainer::TrackProxy &  other 
)
staticprivate

◆ copyStats()

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

Definition at line 1056 of file TrackFindingAlg.cxx.

1057  {
1058  std::lock_guard<std::mutex> lock(m_mutex);
1059  std::size_t category_i = 0;
1060  for (const std::array<unsigned int, kNStat> &src_stat : event_stat)
1061  {
1062  std::array<std::size_t, kNStat> &dest_stat = m_stat[category_i++];
1063  for (std::size_t i = 0; i < src_stat.size(); ++i)
1064  {
1065  assert(i < dest_stat.size());
1066  dest_stat[i] += src_stat[i];
1067  }
1068  }
1069  }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ 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 264 of file TrackFindingAlg.cxx.

265  {
266  ATH_MSG_DEBUG("Executing " << name() << " ... ");
267 
268  auto timer = Monitored::Timer<std::chrono::milliseconds>("TIME_execute");
269  auto mon_nTracks = Monitored::Scalar<int>("nTracks");
270  auto mon = Monitored::Group(m_monTool, timer, mon_nTracks);
271 
272  // ================================================== //
273  // ===================== INPUTS ===================== //
274  // ================================================== //
275 
276  // SEED TRIPLETS
277  std::vector<const ActsTrk::SeedContainer *> seedContainers;
278  seedContainers.reserve(m_seedContainerKeys.size());
279  std::size_t total_seeds = 0;
280  for (const auto &seedContainerKey : m_seedContainerKeys)
281  {
282  ATH_MSG_DEBUG("Reading input collection with key " << seedContainerKey.key());
283  SG::ReadHandle<ActsTrk::SeedContainer> seedsHandle = SG::makeHandle(seedContainerKey, ctx);
284  ATH_CHECK(seedsHandle.isValid());
285  seedContainers.push_back(seedsHandle.cptr());
286  ATH_MSG_DEBUG("Retrieved " << seedContainers.back()->size() << " input elements from key " << seedContainerKey.key());
287  total_seeds += seedContainers.back()->size();
288  }
289 
290  // MEASUREMENTS
291  std::vector<const xAOD::UncalibratedMeasurementContainer *> uncalibratedMeasurementContainers;
292  uncalibratedMeasurementContainers.reserve(m_uncalibratedMeasurementContainerKeys.size());
293  for (const auto &uncalibratedMeasurementContainerKey : m_uncalibratedMeasurementContainerKeys)
294  {
295  ATH_MSG_DEBUG("Reading input collection with key " << uncalibratedMeasurementContainerKey.key());
296  SG::ReadHandle<xAOD::UncalibratedMeasurementContainer> uncalibratedMeasurementContainerHandle = SG::makeHandle(uncalibratedMeasurementContainerKey, ctx);
297  ATH_CHECK(uncalibratedMeasurementContainerHandle.isValid());
298  uncalibratedMeasurementContainers.push_back(uncalibratedMeasurementContainerHandle.cptr());
299  ATH_MSG_DEBUG("Retrieved " << uncalibratedMeasurementContainers.back()->size() << " input elements from key " << uncalibratedMeasurementContainerKey.key());
300  }
301 
303  detectorElementToGeometryIdMap{m_detectorElementToGeometryIdMapKey, ctx};
304  ATH_CHECK(detectorElementToGeometryIdMap.isValid());
305 
306  detail::DuplicateSeedDetector duplicateSeedDetector(total_seeds, m_skipDuplicateSeeds);
307  for (std::size_t icontainer = 0; icontainer < seedContainers.size(); ++icontainer)
308  {
309  duplicateSeedDetector.addSeeds(icontainer, *seedContainers[icontainer]);
310  }
311 
312  detail::TrackFindingMeasurements measurements(uncalibratedMeasurementContainers.size() /* number of measurement containers*/);
313  std::optional<detail::SharedHitCounter> sharedHits;
314  if (m_countSharedHits || m_trackStatePrinter.isSet())
315  sharedHits.emplace(uncalibratedMeasurementContainers.size());
316  const Acts::TrackingGeometry *
317  acts_tracking_geometry = m_trackingGeometryTool->trackingGeometry().get();
318  ATH_CHECK(acts_tracking_geometry != nullptr);
319 
320  for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer) {
321  ATH_MSG_DEBUG("Create " << uncalibratedMeasurementContainers[icontainer]->size() << " source links from measurements in " << m_uncalibratedMeasurementContainerKeys[icontainer].key());
322  measurements.addMeasurements(icontainer,
323  *uncalibratedMeasurementContainers[icontainer],
324  **detectorElementToGeometryIdMap);
325  if (sharedHits.has_value())
326  sharedHits->addMeasurements(*uncalibratedMeasurementContainers[icontainer]);
327  }
328  ATH_MSG_DEBUG("measurement index size = " << sharedHits->measurementIndexer().size());
329 
330  if (m_trackStatePrinter.isSet()) {
331  m_trackStatePrinter->printMeasurements(ctx, uncalibratedMeasurementContainers, **detectorElementToGeometryIdMap, measurements.measurementOffsets());
332  }
333 
334  // ================================================== //
335  // ===================== CONDS ====================== //
336  // ================================================== //
337 
338  std::vector<const InDetDD::SiDetectorElementCollection*> detElementsCollections;
339  detElementsCollections.reserve(m_detEleCollKeys.size());
340  for (const auto &detEleCollKey : m_detEleCollKeys)
341  {
342  ATH_MSG_DEBUG("Reading input collection with key " << detEleCollKey.key());
344  ATH_CHECK(detEleHandle.isValid());
345  detElementsCollections.push_back(detEleHandle.cptr());
346  }
347 
348  // ================================================== //
349  // ===================== COMPUTATION ================ //
350  // ================================================== //
351  ActsTrk::MutableTrackContainer tracksContainer;
352  EventStats event_stat;
353  event_stat.resize(m_stat.size());
354 
355  // Perform the track finding for all initial parameters.
356  for (std::size_t icontainer = 0; icontainer < seedContainers.size(); ++icontainer)
357  {
358  ATH_CHECK(findTracks(ctx,
359  *acts_tracking_geometry,
360  **detectorElementToGeometryIdMap,
361  measurements,
362  sharedHits,
363  duplicateSeedDetector,
364  *seedContainers.at(icontainer),
365  *detElementsCollections.at(icontainer),
366  tracksContainer,
367  icontainer,
368  icontainer < m_seedLabels.size() ? m_seedLabels[icontainer].c_str() : m_seedContainerKeys[icontainer].key().c_str(),
369  event_stat));
370  }
371 
372  ATH_MSG_DEBUG(" \\__ Created " << tracksContainer.size() << " tracks");
373 
374  mon_nTracks = tracksContainer.size();
375 
376  copyStats(event_stat);
377 
378  std::unique_ptr<ActsTrk::TrackContainer> constTracksContainer = m_tracksBackendHandlesHelper.moveToConst(std::move(tracksContainer),
379  m_trackingGeometryTool->getGeometryContext(ctx).context(), ctx);
380  // ================================================== //
381  // ===================== OUTPUTS ==================== //
382  // ================================================== //
383  auto trackContainerHandle = SG::makeHandle(m_trackContainerKey, ctx);
384  ATH_MSG_DEBUG(" \\__ Tracks Container `" << m_trackContainerKey.key() << "` created ...");
385 
386  ATH_CHECK(trackContainerHandle.record(std::move(constTracksContainer)));
387  if (!trackContainerHandle.isValid())
388  {
389  ATH_MSG_FATAL("Failed to write TrackContainer with key " << m_trackContainerKey.key());
390  return StatusCode::FAILURE;
391  }
392 
393  return StatusCode::SUCCESS;
394  }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

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

◆ filterPassed()

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

Definition at line 135 of file AthReentrantAlgorithm.h.

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

◆ finalize()

StatusCode ActsTrk::TrackFindingAlg::finalize ( )
overridevirtual

Definition at line 256 of file TrackFindingAlg.cxx.

257  {
258  printStatTables();
259  return StatusCode::SUCCESS;
260  }

◆ findTracks()

StatusCode ActsTrk::TrackFindingAlg::findTracks ( const EventContext &  ctx,
const Acts::TrackingGeometry &  trackingGeometry,
const ActsTrk::DetectorElementToActsGeometryIdMap detectorElementToGeoId,
const detail::TrackFindingMeasurements measurements,
std::optional< detail::SharedHitCounter > &  sharedHits,
detail::DuplicateSeedDetector duplicateSeedDetector,
const ActsTrk::SeedContainer seeds,
const InDetDD::SiDetectorElementCollection detElements,
ActsTrk::MutableTrackContainer tracksContainer,
std::size_t  seedCollectionIndex,
const char *  seedType,
EventStats event_stat 
) const
private

invoke track finding procedure

Parameters
ctx- event context
trackingGeometry- Acts tracking geometry
detectorElementToGeoId- map Trk detector element to Acts Geometry id
measurements- measurements container used in MeasurementSelector
sharedHits- measurements container used for shared hit counting
duplicateSeedDetector- duplicate seed detector
seeds- spacepoint triplet seeds
detElements- Trk detector elements
tracksContainer- output tracks
seedCollectionIndex- index of this collection of seeds
seedType- name of type of seeds (strip or pixel) - only used for messages
event_stat- stats, just for this event

Definition at line 399 of file TrackFindingAlg.cxx.

411  {
412  ATH_MSG_DEBUG(name() << "::" << __FUNCTION__);
413 
414  // Construct a perigee surface as the target surface
415  auto pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3::Zero());
416 
417  Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
418  Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
419  // CalibrationContext converter not implemented yet.
420  Acts::CalibrationContext calContext = Acts::CalibrationContext();
421 
422  using AtlUncalibSourceLinkAccessor = detail::UncalibSourceLinkAccessor;
423 
424  AtlUncalibSourceLinkAccessor slAccessor(measurements.measurementRanges());
425  Acts::SourceLinkAccessorDelegate<detail::UncalibSourceLinkAccessor::Iterator> slAccessorDelegate;
426  slAccessorDelegate.connect<&detail::UncalibSourceLinkAccessor::range>(&slAccessor);
427 
428  Acts::PropagatorPlainOptions plainOptions{tgContext, mfContext};
429  Acts::PropagatorPlainOptions plainSecondOptions{tgContext, mfContext};
430 
431  plainOptions.maxSteps = m_maxPropagationStep;
432  plainOptions.direction = Acts::Direction::Forward;
433  plainSecondOptions.maxSteps = m_maxPropagationStep;
434  plainSecondOptions.direction = plainOptions.direction.invert();
435 
436  // Set the CombinatorialKalmanFilter options
437  using TrackFinderOptions = Acts::CombinatorialKalmanFilterOptions<detail::UncalibSourceLinkAccessor::Iterator, detail::RecoTrackContainer>;
438  TrackFinderOptions options(tgContext,
439  mfContext,
440  calContext,
441  slAccessorDelegate,
442  trackFinder().ckfExtensions,
443  plainOptions,
444  pSurface.get());
445  if (!m_useDefaultMeasurementSelector.value()) {
446  m_measurementSelector->connect( &options.trackStateCandidateCreator );
447  }
448  TrackFinderOptions secondOptions(tgContext,
449  mfContext,
450  calContext,
451  slAccessorDelegate,
452  trackFinder().ckfExtensions,
453  plainSecondOptions,
454  pSurface.get());
455  secondOptions.targetSurface = pSurface.get();
456  if (!m_useDefaultMeasurementSelector.value()) {
457  m_measurementSelector->connect( &secondOptions.trackStateCandidateCreator );
458  }
459  secondOptions.skipPrePropagationUpdate = true;
460 
461  // ActsTrk::MutableTrackContainer tracksContainerTemp;
462  Acts::VectorTrackContainer trackBackend;
463  Acts::VectorMultiTrajectory trackStateBackend;
464  detail::RecoTrackContainer tracksContainerTemp(trackBackend, trackStateBackend);
465 
466  if (m_addPixelStripCounts) {
467  addPixelStripCounts(tracksContainerTemp);
468  }
469 
470  // Measurement calibration
471  // N.B. OnTrackCalibrator expects disabled tool handles when no calibration is requested.
472  // Therefore, passing them without checking if they are enabled is safe.
473 
474  auto calibrator = detail::OnTrackCalibrator<detail::RecoTrackStateContainer>(trackingGeometry,
475  detectorElementToGeoId,
479 
480  if (m_useDefaultMeasurementSelector.value()) {
481  // for default measurement selector need connect calibrator
482  options.extensions.calibrator.connect<&detail::OnTrackCalibrator<detail::RecoTrackStateContainer>::calibrate>(&calibrator);
483  secondOptions.extensions.calibrator.connect<&detail::OnTrackCalibrator<detail::RecoTrackStateContainer>::calibrate>(&calibrator);
484  }
485 
486  const auto &trackSelectorCfg = trackFinder().trackSelector.config();
487  auto getCuts = [&trackSelectorCfg](double eta) -> const Acts::TrackSelector::Config & {
488  // return the last bin for |eta|>=4 or nan
489  return (!(std::abs(eta) < trackSelectorCfg.absEtaEdges.back())) ? trackSelectorCfg.cutSets.back()
490  : (std::abs(eta) < trackSelectorCfg.absEtaEdges.front()) ? trackSelectorCfg.cutSets.front()
491  : trackSelectorCfg.getCuts(eta);
492  };
493 
494  std::size_t category_i = 0;
495 
496  using BranchStopperResult = Acts::CombinatorialKalmanFilterBranchStopperResult;
497  auto stopBranch = [&](const detail::RecoTrackContainer::TrackProxy &track,
498  const detail::RecoTrackContainer::TrackStateProxy &trackState) -> BranchStopperResult {
499 
500  if (m_addPixelStripCounts) {
501  updatePixelStripCounts(track, trackState.typeFlags(), measurementType(trackState));
503  }
504 
505  if (m_trackStatePrinter.isSet()) {
506  m_trackStatePrinter->printTrackState(tgContext, trackState, sharedHits->measurementIndexer(), true);
507  }
508 
509  if (!m_doBranchStopper)
510  return BranchStopperResult::Continue;
511 
512  const auto &parameters = trackState.hasFiltered() ? trackState.filtered() : trackState.predicted();
513  double eta = -std::log(std::tan(0.5 * parameters[Acts::eBoundTheta]));
514  const auto &cutSet = getCuts(eta);
515 
516  if (typeIndex < m_ptMinMeasurements.size() &&
517  !(track.nMeasurements() < m_ptMinMeasurements[typeIndex])) {
518  double pT = std::sin(parameters[Acts::eBoundTheta]) / parameters[Acts::eBoundQOverP];
519  if (std::abs(pT) < cutSet.ptMin * m_branchStopperPtMinFactor) {
520  ++event_stat[category_i][kNStoppedTracksMinPt];
521  ATH_MSG_DEBUG("CkfBranchStopper: drop branch with q*pT="
522  << pT << " after "
523  << track.nMeasurements() << " measurements");
524  return BranchStopperResult::StopAndDrop;
525  }
526  }
527 
528  if (typeIndex < m_absEtaMaxMeasurements.size() &&
529  !(track.nMeasurements() < m_absEtaMaxMeasurements[typeIndex]) &&
530  !(std::abs(eta) < trackSelectorCfg.absEtaEdges.back() + m_branchStopperAbsEtaMaxExtra)) {
531  ++event_stat[category_i][kNStoppedTracksMaxEta];
532  ATH_MSG_DEBUG("CkfBranchStopper: drop branch with eta="
533  << eta << " after "
534  << track.nMeasurements() << " measurements");
535  return BranchStopperResult::StopAndDrop;
536  }
537 
538  bool enoughMeasurements = (track.nMeasurements() >= cutSet.minMeasurements);
539  bool tooManyHoles = (track.nHoles() > cutSet.maxHoles);
540  bool tooManyOutliers = (track.nOutliers() > cutSet.maxOutliers);
541 
542  if (m_addPixelStripCounts) {
543  auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] = selectPixelStripCounts(track, eta);
544  enoughMeasurements = enoughMeasurements && enoughMeasurementsPS;
545  tooManyHoles = tooManyHoles || tooManyHolesPS;
546  tooManyOutliers = tooManyOutliers || tooManyOutliersPS;
547  }
548 
549  if (!(tooManyHoles || tooManyOutliers))
550  return BranchStopperResult::Continue;
551 
552  if (!enoughMeasurements)
553  ++event_stat[category_i][kNStoppedTracksMaxHoles];
554  if (m_addPixelStripCounts) {
555  ATH_MSG_DEBUG("CkfBranchStopper: stop and "
556  << (enoughMeasurements ? "keep" : "drop")
557  << " branch with nHoles=" << track.nHoles()
558  << " (" << s_branchState.nPixelHoles(track)
559  << " pixel+" << s_branchState.nStripHoles(track)
560  << " strip), nOutliers=" << track.nOutliers()
563  << "), nMeasurements=" << track.nMeasurements()
564  << " (" << s_branchState.nPixelHits(track)
565  << "+" << s_branchState.nStripHits(track)
566  << ")");
567  } else {
568  ATH_MSG_DEBUG("CkfBranchStopper: stop and "
569  << (enoughMeasurements ? "keep" : "drop")
570  << " branch with nHoles=" << track.nHoles()
571  << ", nOutliers=" << track.nOutliers()
572  << ", nMeasurements=" << track.nMeasurements());
573  }
574 
575  return enoughMeasurements ? BranchStopperResult::StopAndKeep
576  : BranchStopperResult::StopAndDrop;
577  };
578 
579  options.extensions.branchStopper.connect(stopBranch);
580 
581  Acts::PropagatorOptions<detail::Stepper::Options, detail::Navigator::Options,
582  Acts::ActorList<Acts::MaterialInteractor>>
583  extrapolationOptions(tgContext, mfContext);
584 
585  Acts::TrackExtrapolationStrategy extrapolationStrategy =
587 
588  // Perform the track finding for all initial parameters
589  ATH_MSG_DEBUG("Invoke track finding with " << seeds.size() << ' ' << seedType << " seeds.");
590 
591  std::size_t nPrinted = 0;
592  auto printSeed = [&](std::size_t iseed, const Acts::BoundTrackParameters &seedParameters, bool isKF = false)
593  {
594  if (!m_trackStatePrinter.isSet())
595  return;
596  if (!nPrinted++)
597  {
598  ATH_MSG_INFO("CKF results for " << seeds.size() << ' ' << seedType << " seeds:");
599  }
600  m_trackStatePrinter->printSeed(tgContext, *seeds[iseed], seedParameters, sharedHits->measurementIndexer(), iseed, isKF);
601  };
602 
603  // Loop over the track finding results for all initial parameters
604  for (std::size_t iseed = 0; iseed < seeds.size(); ++iseed)
605  {
606  category_i = typeIndex * (m_statEtaBins.size() + 1);
607  tracksContainerTemp.clear();
608 
609  const bool reverseSearch = (typeIndex < m_reverseSearch.size() && m_reverseSearch[typeIndex]);
610  const bool refitSeeds = (typeIndex < m_refitSeeds.size() && m_refitSeeds[typeIndex]);
611  const bool useTopSp = reverseSearch && !refitSeeds;
612 
613  auto getSeedCategory = [this, useTopSp](std::size_t typeIndex, const ActsTrk::Seed& seed) -> std::size_t {
614  const xAOD::SpacePoint* sp = useTopSp ? seed.sp().back() : seed.sp().front();
616  double etaSeed = std::atanh(pos[2] / pos.norm());
617  return getStatCategory(typeIndex, etaSeed);
618  };
619 
620  const bool isDupSeed = duplicateSeedDetector.isDuplicate(typeIndex, iseed);
621  if (isDupSeed) {
622  ATH_MSG_DEBUG("skip " << seedType << " seed " << iseed << " - already found");
623  category_i = getSeedCategory(typeIndex, *seeds[iseed]);
624  ++event_stat[category_i][kNTotalSeeds];
625  ++event_stat[category_i][kNDuplicateSeeds];
626  if (!m_trackStatePrinter.isSet()) continue; // delay continue to estimate track parms for TrackStatePrinter?
627  }
628 
629  plainOptions.direction = reverseSearch ? Acts::Direction::Backward : Acts::Direction::Forward;
630  plainSecondOptions.direction = plainOptions.direction.invert();
631  options.targetSurface = reverseSearch ? pSurface.get() : nullptr;
632  secondOptions.targetSurface = reverseSearch ? nullptr : pSurface.get();
633  // TODO since the second pass is strictly an extension we should have a separate branch stopper which never drops and always extrapolates to the target surface
634 
635  const ActsTrk::Seed& seed = *seeds[iseed];
636 
637  // Estimate Track Parameters
638  auto retrieveSurfaceFunction =
639  [this, &detElements, useTopSp] (const ActsTrk::Seed& seed) -> const Acts::Surface& {
640  const xAOD::SpacePoint* sp = useTopSp ? seed.sp().back() : seed.sp().front();
641  const InDetDD::SiDetectorElement* element = detElements.getDetectorElement(
642  useTopSp ? sp->elementIdList().back()
643  : sp->elementIdList().front());
644  const Trk::Surface& atlas_surface = element->surface();
645  return this->m_ATLASConverterTool->trkSurfaceToActsSurface(atlas_surface);
646  };
647 
648  std::optional<Acts::BoundTrackParameters> optTrackParams =
649  m_paramEstimationTool->estimateTrackParameters(ctx,
650  seed,
651  tgContext,
652  mfContext,
653  retrieveSurfaceFunction,
654  useTopSp);
655 
656  if (!optTrackParams) {
657  ATH_MSG_DEBUG("Failed to estimate track parameters for seed " << iseed);
658  if (!isDupSeed) {
659  category_i = getSeedCategory(typeIndex, seed);
660  ++event_stat[category_i][kNNoEstimatedParams];
661  }
662  continue;
663  }
664 
665  Acts::BoundTrackParameters* initialParameters = &(*optTrackParams);
666  printSeed(iseed, *initialParameters);
667  if (isDupSeed) continue; // skip now if not done before
668 
669  double etaInitial = -std::log(std::tan(0.5 * initialParameters->theta()));
670  category_i = getStatCategory(typeIndex, etaInitial);
671  ++event_stat[category_i][kNTotalSeeds]; // also updated for duplicate seeds
672  ++event_stat[category_i][kNUsedSeeds];
673 
674  std::unique_ptr<Acts::BoundTrackParameters> refitSeedParameters;
675  if (refitSeeds)
676  {
677  // Perform KF before CKF
678  const auto fittedSeedCollection = m_fitterTool->fit(ctx, *seeds[iseed], *initialParameters,
679  tgContext, mfContext, calContext,
680  detectorElementToGeoId);
681  if (not fittedSeedCollection)
682  {
683  ATH_MSG_WARNING("KF Fitted Track is nullptr");
684  }
685  else if (fittedSeedCollection->size() != 1)
686  {
687  ATH_MSG_WARNING("KF produced " << fittedSeedCollection->size() << " tracks but should produce 1!");
688  }
689  else
690  {
691  const auto fittedSeed = fittedSeedCollection->getTrack(0);
692  const auto trackState = reverseSearch ? fittedSeed.outermostTrackState()
693  : fittedSeed.innermostTrackState().value();
694  const auto boundParameters = fittedSeed.createParametersFromState(trackState);
695 
696  // Check pTmin requirement
697  double etaSeed = -std::log(std::tan(0.5 * boundParameters.parameters()[Acts::eBoundTheta]));
698  const auto &cutSet = getCuts(etaSeed);
699  if (boundParameters.transverseMomentum() < cutSet.ptMin)
700  {
701  ATH_MSG_VERBOSE("min pt requirement not satisfied after param refinement: pt min is " << cutSet.ptMin << " but Refined params have pt of " << boundParameters.transverseMomentum());
702  ++event_stat[category_i][kNRejectedRefinedSeeds];
703  continue;
704  }
705 
706  // Pass the refined params to the CKF
707  refitSeedParameters = std::make_unique<Acts::BoundTrackParameters>(boundParameters);
708  initialParameters = refitSeedParameters.get();
709  printSeed(iseed, *initialParameters, true);
710  }
711  }
712 
713  // Get the Acts tracks, given this seed
714  // Result here contains a vector of TrackProxy objects
715 
716  auto result = trackFinder().ckf.findTracks(*initialParameters, options, tracksContainerTemp);
717 
718  // The result for this seed
719  if (not result.ok()) {
720  ATH_MSG_WARNING("Track finding failed for " << seedType << " seed " << iseed << " with error" << result.error());
721  continue;
722  }
723  auto &tracksForSeed = result.value();
724 
725  size_t ntracks = 0;
726 
727  // lambda to collect together all the things we do with a viable track.
729  // if the the perigeeSurface was not hit (in particular the case for the inside-out pass,
730  // the track has no reference surface and the extrapolation to the perigee has not been done
731  // yet.
732  if (!track.hasReferenceSurface()) {
733  auto extrapolationResult = Acts::extrapolateTrackToReferenceSurface(
734  track, *pSurface, trackFinder().extrapolator, extrapolationOptions,
735  extrapolationStrategy, logger());
736  if (!extrapolationResult.ok()) {
737  ATH_MSG_WARNING("Extrapolation for seed "
738  << iseed << " and " << track.index()
739  << " failed with error " << extrapolationResult.error()
740  << " dropping track candidate.");
741  return;
742  }
743  }
744 
745  Acts::trimTrack(track, true, true, true);
746  Acts::calculateTrackQuantities(track);
747  if (m_addPixelStripCounts) {
749  for (const auto trackState : track.trackStatesReversed()) {
750  updatePixelStripCounts(track, trackState.typeFlags(), measurementType(trackState));
751  }
753  }
754 
755  ++ntracks;
756  ++event_stat[category_i][kNOutputTracks];
757 
758  auto selectPixelStripCountsFinal = [this](const detail::RecoTrackContainer::TrackProxy &track) {
759  if (!m_addPixelStripCounts) return true;
760  double eta = -std::log(std::tan(0.5 * track.theta()));
761  auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] = selectPixelStripCounts(track, eta);
762  return enoughMeasurementsPS && !tooManyHolesPS && !tooManyOutliersPS;
763  };
764  if (trackFinder().trackSelector.isValidTrack(track) &&
765  selectPixelStripCountsFinal(track)) {
766 
767  // Fill the track infos into the duplicate seed detector
768  if (m_skipDuplicateSeeds) {
769  storeSeedInfo(tracksContainerTemp, track, duplicateSeedDetector);
770  }
771 
772  // copy selected track into output tracksContainer
773  auto destProxy = tracksContainer.getTrack(tracksContainer.addTrack());
774  destProxy.copyFrom(track, true); // make sure we copy track states!
775 
776  if (m_countSharedHits) {
777  auto [nShared, nBadTrackMeasurements] = sharedHits->computeSharedHits(destProxy, tracksContainer);
778  if (nBadTrackMeasurements > 0)
779  ATH_MSG_ERROR("computeSharedHits: " << nBadTrackMeasurements << " track measurements not found in input for " << seedType << " seed " << iseed << " track");
780  ATH_MSG_DEBUG("found " << destProxy.nSharedHits() << " shared hits in " << seedType << " seed " << iseed << " track");
781  event_stat[category_i][kNTotalSharedHits] += nShared;
782  }
783 
784  ++event_stat[category_i][kNSelectedTracks];
785 
786  if (m_trackStatePrinter.isSet()) {
787  m_trackStatePrinter->printTrack(tgContext, tracksContainer, destProxy, sharedHits->measurementIndexer());
788  }
789 
790  } else {
791  ATH_MSG_DEBUG("Track " << ntracks << " from " << seedType << " seed " << iseed << " failed track selection");
792  if (m_trackStatePrinter.isSet()) {
793  m_trackStatePrinter->printTrack(tgContext, tracksContainerTemp, track, sharedHits->measurementIndexer(), true);
794  }
795  }
796  };
797 
798  std::size_t nfirst = 0;
799  for (auto &firstTrack : tracksForSeed) {
800  std::size_t nsecond = 0;
801 
802  auto smoothingResult = Acts::smoothTrack(tgContext, firstTrack, logger(), Acts::MbfSmoother());
803  if (!smoothingResult.ok()) {
804  ATH_MSG_DEBUG("Smoothing for seed "
805  << iseed << " and first track " << firstTrack.index()
806  << " failed with error " << smoothingResult.error());
807  continue;
808  }
809 
810  if (m_doTwoWay) {
811  std::optional<detail::RecoTrackStateContainerProxy> firstMeasurement;
812  for (auto st : firstTrack.trackStatesReversed()) {
813  bool isMeasurement = st.typeFlags().test(Acts::TrackStateFlag::MeasurementFlag);
814  bool isOutlier = st.typeFlags().test(Acts::TrackStateFlag::OutlierFlag);
815  // We are excluding non measurement states and outlier here. Those can
816  // decrease resolution because only the smoothing corrected the very
817  // first prediction as filtering is not possible.
818  if (isMeasurement && !isOutlier)
819  firstMeasurement = st;
820  }
821 
822  if (firstMeasurement.has_value()) {
823  Acts::BoundTrackParameters secondInitialParameters = firstTrack.createParametersFromState(*firstMeasurement);
824 
825  if (!secondInitialParameters.referenceSurface().insideBounds(secondInitialParameters.localPosition())) { // #3751
826  ATH_MSG_DEBUG("Smoothing of first pass fit produced out-of-bounds parameters relative to the surface, '"
827  << secondInitialParameters.referenceSurface().name()
828  << "'. Skipping second pass for " << seedType << " seed " << iseed << " track " << nfirst);
829  } else {
830  auto rootBranch = tracksContainerTemp.makeTrack();
831  rootBranch.copyFrom(firstTrack, false); // #3534
833  copyPixelStripCounts(rootBranch, firstTrack);
834  auto secondResult = trackFinder().ckf.findTracks(secondInitialParameters, secondOptions, tracksContainerTemp, rootBranch);
835 
836  if (not secondResult.ok()) {
837  ATH_MSG_WARNING("Second track finding failed for " << seedType << " seed " << iseed << " track " << nfirst << " with error" << secondResult.error());
838  } else {
839  // store the original previous state to restore it later
840  auto originalFirstMeasurementPrevious = firstMeasurement->previous();
841 
842  auto &secondTracksForSeed = secondResult.value();
843  for (auto &secondTrack : secondTracksForSeed) {
844  secondTrack.reverseTrackStates(true);
845 
846  firstMeasurement->previous() = secondTrack.outermostTrackState().index();
847  secondTrack.tipIndex() = firstTrack.tipIndex();
848 
849  if (reverseSearch) {
850  // smooth the full track
851  auto secondSmoothingResult = Acts::smoothTrack(tgContext, secondTrack, logger());
852  if (!secondSmoothingResult.ok()) {
853  ATH_MSG_WARNING("Second smoothing for seed " << iseed << " and track " << secondTrack.index() << " failed with error " << secondSmoothingResult.error());
854  continue;
855  }
856 
857  secondTrack.reverseTrackStates(true);
858  }
859 
860  addTrack(secondTrack);
861 
862  ++nsecond;
863  }
864 
865  // restore the original previous state for the first track
866  firstMeasurement->previous() = originalFirstMeasurementPrevious;
867  }
868  }
869  }
870  }
871  if (nsecond == 0) {
872  if (m_doTwoWay) {
873  ATH_MSG_DEBUG("No viable result from second track finding for " << seedType << " seed " << iseed << " track " << nfirst);
874  ++event_stat[category_i][kNoSecond];
875  }
876 
877  addTrack(firstTrack);
878  }
879  nfirst++;
880  }
881  if (ntracks == 0) {
882  ATH_MSG_DEBUG("Track finding found no track candidates for " << seedType << " seed " << iseed);
883  ++event_stat[category_i][kNoTrack];
884  } else if (ntracks >= 2) {
885  ++event_stat[category_i][kMultipleBranches];
886  }
887  if (m_trackStatePrinter.isSet())
888  std::cout << std::flush;
889  }
890 
891  ATH_MSG_DEBUG("Completed " << seedType << " track finding with " << computeStatSum(typeIndex, kNOutputTracks, event_stat) << " track candidates.");
892 
893  return StatusCode::SUCCESS;
894  }

◆ getStatCategory()

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

Definition at line 1257 of file TrackFindingAlg.cxx.

1258  {
1259  std::vector<float>::const_iterator bin_iter = std::upper_bound(m_statEtaBins.begin(),
1260  m_statEtaBins.end(),
1261  m_useAbsEtaForStat ? std::abs(eta) : eta);
1262  std::size_t category_i = seed_collection * seedCollectionStride() + static_cast<std::size_t>(bin_iter - m_statEtaBins.begin());
1263  assert(category_i < m_stat.size());
1264  return category_i;
1265  }

◆ initialize()

StatusCode ActsTrk::TrackFindingAlg::initialize ( )
overridevirtual

Definition at line 70 of file TrackFindingAlg.cxx.

71  {
72  ATH_MSG_INFO("Initializing " << name() << " ... ");
73  ATH_MSG_DEBUG("Properties Summary:");
77  ATH_MSG_DEBUG(" " << m_etaBins);
85  ATH_MSG_DEBUG(" " << m_doTwoWay);
88  ATH_MSG_DEBUG(" " << m_phiMin);
89  ATH_MSG_DEBUG(" " << m_phiMax);
90  ATH_MSG_DEBUG(" " << m_etaMin);
91  ATH_MSG_DEBUG(" " << m_etaMax);
92  ATH_MSG_DEBUG(" " << m_absEtaMin);
93  ATH_MSG_DEBUG(" " << m_absEtaMax);
94  ATH_MSG_DEBUG(" " << m_ptMin);
95  ATH_MSG_DEBUG(" " << m_ptMax);
96  ATH_MSG_DEBUG(" " << m_z0Min);
97  ATH_MSG_DEBUG(" " << m_z0Max);
101  ATH_MSG_DEBUG(" " << m_maxHoles);
108  ATH_MSG_DEBUG(" " << m_maxChi2);
110  ATH_MSG_DEBUG(" " << m_seedLabels);
114 
115  // Read and Write handles
116  ATH_CHECK(m_seedContainerKeys.initialize());
117  ATH_CHECK(m_detEleCollKeys.initialize());
122 
123  if (m_seedContainerKeys.size() != m_detEleCollKeys.size())
124  {
125  ATH_MSG_FATAL("There are " << m_detEleCollKeys.size() << " DetectorElementsKeys, but " << m_seedContainerKeys.size() << " SeedContainerKeys");
126  return StatusCode::FAILURE;
127  }
128 
129  if (m_detEleCollKeys.size() != m_seedLabels.size())
130  {
131  ATH_MSG_FATAL("There are " << m_seedLabels.size() << " SeedLabels, but " << m_detEleCollKeys.size() << " DetectorElementsKeys");
132  return StatusCode::FAILURE;
133  }
134 
135  ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
136  ATH_CHECK(m_trackingGeometryTool.retrieve());
137  ATH_CHECK(m_extrapolationTool.retrieve());
138  ATH_CHECK(m_trackStatePrinter.retrieve(EnableTool{not m_trackStatePrinter.empty()}));
139  ATH_CHECK(m_ATLASConverterTool.retrieve());
140  ATH_CHECK(m_paramEstimationTool.retrieve());
141  ATH_CHECK(m_fitterTool.retrieve());
142  ATH_CHECK(m_pixelCalibTool.retrieve(EnableTool{not m_pixelCalibTool.empty()}));
143  ATH_CHECK(m_stripCalibTool.retrieve(EnableTool{not m_stripCalibTool.empty()}));
144  ATH_CHECK(m_hgtdCalibTool.retrieve(EnableTool{not m_hgtdCalibTool.empty()}));
145 
146  m_logger = makeActsAthenaLogger(this, "Acts");
147 
148  auto magneticField = std::make_unique<ATLASMagneticFieldWrapper>();
149  auto trackingGeometry = m_trackingGeometryTool->trackingGeometry();
150 
151  detail::Stepper stepper(std::move(magneticField));
152  detail::Navigator::Config cfg{trackingGeometry};
153  cfg.resolvePassive = false;
154  cfg.resolveMaterial = true;
155  cfg.resolveSensitive = true;
156  detail::Navigator navigator(cfg, logger().cloneWithSuffix("Navigator"));
157  detail::Propagator propagator(std::move(stepper), std::move(navigator), logger().cloneWithSuffix("Prop"));
158 
159  // Using the CKF propagator as extrapolator
160  detail::Extrapolator extrapolator = propagator;
161 
162  std::vector<double> etaBins;
163  // m_etaBins (from flags.Tracking.ActiveConfig.etaBins) includes a dummy first and last bin, which we ignore
164  if (m_etaBins.size() > 2) {
165  etaBins.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
166  }
167  Acts::MeasurementSelectorCuts measurementSelectorCuts{etaBins};
168 
169  if (!m_chi2CutOff.empty())
170  measurementSelectorCuts.chi2CutOff = m_chi2CutOff;
171  if (!m_chi2OutlierCutOff.empty() && m_chi2OutlierCutOff.size() == m_chi2CutOff.size())
172  measurementSelectorCuts.chi2CutOffOutlier = m_chi2OutlierCutOff;
173  if (!m_numMeasurementsCutOff.empty())
174  measurementSelectorCuts.numMeasurementsCutOff = m_numMeasurementsCutOff;
175 
176  Acts::MeasurementSelector::Config measurementSelectorCfg{{Acts::GeometryIdentifier(), std::move(measurementSelectorCuts)}};
177  Acts::MeasurementSelector measurementSelector(measurementSelectorCfg);
178 
179  std::vector<double> absEtaEdges;
180  absEtaEdges.reserve(etaBins.size() + 2);
181  if (etaBins.empty())
182  {
183  absEtaEdges.push_back(0.0);
184  absEtaEdges.push_back(std::numeric_limits<double>::infinity());
185  }
186  else
187  {
188  absEtaEdges.push_back(m_absEtaMin);
189  absEtaEdges.insert(absEtaEdges.end(), etaBins.begin(), etaBins.end());
190  absEtaEdges.push_back(m_absEtaMax);
191  }
192 
193  auto setCut = [](auto &cfgVal, const auto &cuts, size_t ind) -> void
194  {
195  if (cuts.empty())
196  return;
197  cfgVal = (ind < cuts.size()) ? cuts[ind] : cuts[cuts.size() - 1];
198  };
199 
200  Acts::TrackSelector::EtaBinnedConfig trackSelectorCfg{std::move(absEtaEdges)};
201  if (etaBins.empty())
202  {
203  assert(trackSelectorCfg.cutSets.size() == 1);
204  trackSelectorCfg.cutSets[0].absEtaMin = m_absEtaMin;
205  trackSelectorCfg.cutSets[0].absEtaMax = m_absEtaMax;
206  }
207  size_t cutIndex = 0;
208  for (auto &cfg : trackSelectorCfg.cutSets)
209  {
210  setCut(cfg.phiMin, m_phiMin, cutIndex);
211  setCut(cfg.phiMax, m_phiMax, cutIndex);
212  setCut(cfg.etaMin, m_etaMin, cutIndex);
213  setCut(cfg.etaMax, m_etaMax, cutIndex);
214  setCut(cfg.ptMin, m_ptMin, cutIndex);
215  setCut(cfg.ptMax, m_ptMax, cutIndex);
216  setCut(cfg.loc0Min, m_d0Min, cutIndex);
217  setCut(cfg.loc0Max, m_d0Max, cutIndex);
218  setCut(cfg.loc1Min, m_z0Min, cutIndex);
219  setCut(cfg.loc1Max, m_z0Max, cutIndex);
220  setCut(cfg.minMeasurements, m_minMeasurements, cutIndex);
221  setCut(cfg.maxHoles, m_maxHoles, cutIndex);
222  setCut(cfg.maxOutliers, m_maxOutliers, cutIndex);
223  setCut(cfg.maxSharedHits, m_maxSharedHits, cutIndex);
224  setCut(cfg.maxChi2, m_maxChi2, cutIndex);
225  ++cutIndex;
226  }
227 
228  ATH_MSG_INFO(trackSelectorCfg);
229 
230  if (!m_useDefaultMeasurementSelector.value()) {
231  // initializer measurement selector and connect it to the delegates of the track finder optins
233  }
234  else if (!m_chi2OutlierCutOff.empty()) {
235  ATH_MSG_DEBUG("chi2OutlierCutOff set but not supported when using the default measurement selector.");
236  }
237 
238  detail::CKF_config ckfConfig{
239  std::move(extrapolator),
240  {std::move(propagator), logger().cloneWithSuffix("CKF")},
241  measurementSelector,
242  {},
243  trackSelectorCfg};
244 
245  m_trackFinder = std::make_unique<CKF_pimpl>(std::move(ckfConfig));
246 
247  trackFinder().ckfExtensions.updater.connect<&ActsTrk::detail::FitterHelperFunctions::gainMatrixUpdate<detail::RecoTrackStateContainer>>();
248  trackFinder().ckfExtensions.measurementSelector.connect<&Acts::MeasurementSelector::select<detail::RecoTrackStateContainer>>(&trackFinder().measurementSelector);
249  initStatTables();
250 
251  return StatusCode::SUCCESS;
252  }

◆ initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingAlg::initializeMeasurementSelector ( )
private

Definition at line 1281 of file TrackFindingAlg.cxx.

1281  {
1282  std::vector<std::pair<float, float> > chi2CutOffOutlier ;
1283  chi2CutOffOutlier .reserve( m_chi2CutOff.size() );
1284  if (!m_chi2OutlierCutOff.empty()) {
1285  if (m_chi2CutOff.size() != m_chi2OutlierCutOff.size()) {
1286  ATH_MSG_ERROR("Outlier chi2 cut off provided but number of elements does not agree with"
1287  " chi2 cut off for measurements which however is required: "
1288  << m_chi2CutOff.size() << " != " << m_chi2OutlierCutOff.size());
1289  return StatusCode::FAILURE;
1290  }
1291  }
1292  unsigned int idx=0;
1293  for (const auto &elm : m_chi2CutOff) {
1294  chi2CutOffOutlier.push_back( std::make_pair(static_cast<float>(elm),
1295  idx < m_chi2OutlierCutOff.size()
1296  ? static_cast<float>(m_chi2OutlierCutOff[idx])
1298  ++idx;
1299  }
1300  std::vector<float> etaBinsf;
1301  if (m_etaBins.size() > 2) {
1302  etaBinsf.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
1303  }
1304 
1306  etaBinsf,
1307  chi2CutOffOutlier,
1308  m_numMeasurementsCutOff.value());
1309 
1310  return m_measurementSelector ? StatusCode::SUCCESS : StatusCode::FAILURE;
1311  }

◆ initPixelStripCounts()

void ActsTrk::TrackFindingAlg::initPixelStripCounts ( const detail::RecoTrackContainer::TrackProxy &  track)
staticprivate

Definition at line 947 of file TrackFindingAlg.cxx.

◆ initStatTables()

void ActsTrk::TrackFindingAlg::initStatTables ( )
private

Definition at line 1037 of file TrackFindingAlg.cxx.

1038  {
1039  if (!m_statEtaBins.empty())
1040  {
1041  m_useAbsEtaForStat = (m_statEtaBins[0] > 0.);
1042  float last_eta = m_statEtaBins[0];
1043  for (float eta : m_statEtaBins)
1044  {
1045  if (eta < last_eta)
1046  {
1047  ATH_MSG_FATAL("Eta bins for statistics counter not in ascending order.");
1048  }
1049  last_eta = eta;
1050  }
1051  }
1052  m_stat.resize(nSeedCollections() * seedCollectionStride());
1053  }

◆ 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

◆ logger()

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

Private access to the logger.

Definition at line 276 of file TrackFindingAlg.h.

277  {
278  return *m_logger;
279  }

◆ measurementType()

xAOD::UncalibMeasType ActsTrk::TrackFindingAlg::measurementType ( const detail::RecoTrackContainer::TrackStateProxy &  trackState)
staticprivate

Definition at line 919 of file TrackFindingAlg.cxx.

920  {
921  if (trackState.hasReferenceSurface()) {
922  if (const auto *actsDetElem = dynamic_cast<const ActsDetectorElement *>(trackState.referenceSurface().associatedDetectorElement())) {
923  if (const auto *detElem = dynamic_cast<const InDetDD::SiDetectorElement *>(actsDetElem->upstreamDetectorElement())) {
924  if (detElem->isPixel()) {
926  } else if (detElem->isSCT()) {
928  }
929  }
930  }
931  }
933  }

◆ 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 260 of file TrackFindingAlg.h.

261  {
262  return m_seedLabels.size();
263  }

◆ 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 1072 of file TrackFindingAlg.cxx.

1073  {
1074  if (msgLvl(MSG::INFO))
1075  {
1076  std::vector<std::string> stat_labels =
1078  {
1079  std::make_pair(kNTotalSeeds, "Input seeds"),
1080  std::make_pair(kNoTrackParam, "No track parameters"),
1081  std::make_pair(kNUsedSeeds, "Used seeds"),
1082  std::make_pair(kNoTrack, "Cannot find track"),
1083  std::make_pair(kNDuplicateSeeds, "Duplicate seeds"),
1084  std::make_pair(kNNoEstimatedParams, "Initial param estimation failed"),
1085  std::make_pair(kNRejectedRefinedSeeds, "Rejected refined parameters"),
1086  std::make_pair(kNOutputTracks, "CKF tracks"),
1087  std::make_pair(kNSelectedTracks, "selected tracks"),
1088  std::make_pair(kNStoppedTracksMaxHoles, "Stopped tracks reaching max holes"),
1089  std::make_pair(kMultipleBranches, "Seeds with more than one branch"),
1090  std::make_pair(kNoSecond, "Tracks failing second CKF"),
1091  std::make_pair(kNStoppedTracksMinPt, "Stopped tracks below pT cut"),
1092  std::make_pair(kNStoppedTracksMaxEta, "Stopped tracks above max eta"),
1093  std::make_pair(kNTotalSharedHits, "Total shared hits")
1094  });
1095  assert(stat_labels.size() == kNStat);
1096  std::vector<std::string> categories;
1097  categories.reserve(m_seedLabels.size() + 1);
1098  categories.insert(categories.end(), m_seedLabels.begin(), m_seedLabels.end());
1099  categories.push_back("ALL");
1100 
1101  std::vector<std::string> eta_labels;
1102  eta_labels.reserve(m_statEtaBins.size() + 2);
1103  for (std::size_t eta_bin_i = 0; eta_bin_i < m_statEtaBins.size() + 2; ++eta_bin_i)
1104  {
1105  eta_labels.push_back(TableUtils::makeEtaBinLabel(m_statEtaBins, eta_bin_i, m_useAbsEtaForStat));
1106  }
1107 
1108  // vector used as 3D array stat[ eta_bin ][ stat_i ][ seed_type]
1109  // stat_i = [0, kNStat)
1110  // eta_bin = [0, m_statEtaBins.size()+2 ); eta_bin == m_statEtaBinsSize()+1 means sum of all etaBins
1111  // seed_type = [0, nSeedCollections()+1) seed_type == nSeedCollections() means sum of all seed collections
1112  std::vector<std::size_t> stat =
1113  TableUtils::createCounterArrayWithProjections<std::size_t>(nSeedCollections(),
1114  m_statEtaBins.size() + 1,
1115  m_stat);
1116 
1117  // the extra columns and rows for the projections are addeded internally:
1118  std::size_t stat_stride =
1120  m_statEtaBins.size() + 1,
1121  kNStat);
1122  std::size_t eta_stride =
1124  m_statEtaBins.size() + 1,
1125  kNStat);
1126  std::stringstream table_out;
1127 
1128  if (m_dumpAllStatEtaBins.value())
1129  {
1130  // dump for each counter a table with one row per eta bin
1131  std::size_t max_label_width = TableUtils::maxLabelWidth(stat_labels) + TableUtils::maxLabelWidth(eta_labels);
1132  for (std::size_t stat_i = 0; stat_i < kNStat; ++stat_i)
1133  {
1134  std::size_t dest_idx_offset = stat_i * stat_stride;
1135  table_out << makeTable(stat, dest_idx_offset, eta_stride,
1136  eta_labels,
1137  categories)
1138  .columnWidth(10)
1139  // only dump the footer for the last eta bin i.e. total
1140  .dumpHeader(stat_i == 0)
1141  .dumpFooter(stat_i + 1 == kNStat)
1142  .separateLastRow(true) // separate the sum of all eta bins
1143  .minLabelWidth(max_label_width)
1144  .labelPrefix(stat_labels.at(stat_i));
1145  }
1146  }
1147  else
1148  {
1149  // dump one table with one row per counter showing the total eta range
1150  for (std::size_t eta_bin_i = (m_dumpAllStatEtaBins.value() ? 0 : m_statEtaBins.size() + 1);
1151  eta_bin_i < m_statEtaBins.size() + 2;
1152  ++eta_bin_i)
1153  {
1154  std::size_t dest_idx_offset = eta_bin_i * eta_stride;
1155  table_out << makeTable(stat, dest_idx_offset, stat_stride,
1156  stat_labels,
1157  categories,
1158  eta_labels.at(eta_bin_i))
1159  .columnWidth(10)
1160  // only dump the footer for the last eta bin i.e. total
1161  .dumpFooter(!m_dumpAllStatEtaBins.value() || eta_bin_i == m_statEtaBins.size() + 1);
1162  }
1163  }
1164  ATH_MSG_INFO("statistics:\n"
1165  << table_out.str());
1166  table_out.str("");
1167 
1168  // define retios first element numerator, second element denominator
1169  // each element contains a vector of counter and a multiplier e.g. +- 1
1170  // ratios are computed as (sum_i stat[stat_i] * multiplier_i ) / (sum_j stat[stat_j] * multiplier_j )
1171  auto [ratio_labels, ratio_def] =
1173  std::vector<TableUtils::SummandDefinition>{
1177  // no track counted as used but want to include it as failed
1179  }, // failed seeds i.e. seeds which are not duplicates but did not produce a track
1180  std::vector<TableUtils::SummandDefinition>{TableUtils::defineSummand(kNTotalSeeds, 1)}),
1182  TableUtils::defineSimpleRatio("Rejected refined params / seeds", kNRejectedRefinedSeeds, kNTotalSeeds),
1184  TableUtils::defineSimpleRatio("selected tracks / used seeds", kNSelectedTracks, kNUsedSeeds),
1185  TableUtils::defineSimpleRatio("branched tracks / used seeds", kMultipleBranches, kNUsedSeeds),
1186  TableUtils::defineSimpleRatio("no 2nd CKF / CKF tracks", kNoSecond, kNOutputTracks),
1187  TableUtils::defineSimpleRatio("shared hits / CKF tracks", kNTotalSharedHits, kNOutputTracks)});
1188 
1189  std::vector<float> ratio = TableUtils::computeRatios(ratio_def,
1190  nSeedCollections() + 1,
1191  m_statEtaBins.size() + 2,
1192  stat);
1193 
1194  // the extra columns and rows for the projections are _not_ added internally
1195  std::size_t ratio_stride = TableUtils::ratioStride(nSeedCollections() + 1,
1196  m_statEtaBins.size() + 2,
1197  ratio_def);
1198  std::size_t ratio_eta_stride = TableUtils::subCategoryStride(nSeedCollections() + 1,
1199  m_statEtaBins.size() + 2,
1200  ratio_def);
1201 
1202  std::size_t max_label_width = TableUtils::maxLabelWidth(ratio_labels) + TableUtils::maxLabelWidth(eta_labels);
1203  if (m_dumpAllStatEtaBins.value())
1204  {
1205  // show for each ratio a table with one row per eta bin
1206  for (std::size_t ratio_i = 0; ratio_i < ratio_labels.size(); ++ratio_i)
1207  {
1208  table_out << makeTable(ratio,
1209  ratio_i * ratio_stride,
1210  ratio_eta_stride,
1211  eta_labels,
1212  categories)
1213  .columnWidth(10)
1214  // only dump the footer for the last eta bin i.e. total
1215  .dumpHeader(ratio_i == 0)
1216  .dumpFooter(ratio_i + 1 == ratio_labels.size())
1217  .separateLastRow(true) // separate the sum of las
1218  .minLabelWidth(max_label_width)
1219  .labelPrefix(ratio_labels.at(ratio_i));
1220  }
1221  }
1222  else
1223  {
1224  // dump one table with one row per ratio showing the total eta range
1225  table_out << makeTable(ratio,
1226  (m_statEtaBins.size() + 1) * ratio_eta_stride + 0 * ratio_stride,
1227  ratio_stride,
1228  ratio_labels,
1229  categories)
1230  .columnWidth(10)
1231  // only dump the footer for the last eta bin i.e. total
1232  .minLabelWidth(max_label_width)
1233  .dumpFooter(false);
1234 
1235  // also dump a table for final tracks over seeds (ratio_i==3) showing one row per eta bin
1236  eta_labels.erase(eta_labels.end() - 1); // drop last line of table which shows again all eta bins summed.
1237  constexpr std::size_t ratio_i = 3;
1238  table_out << makeTable(ratio,
1239  ratio_i * ratio_stride,
1240  ratio_eta_stride,
1241  eta_labels,
1242  categories)
1243  .columnWidth(10)
1244  .dumpHeader(false)
1245  // only dump the footer for the last eta bin i.e. total
1246  .dumpFooter(!m_dumpAllStatEtaBins.value() || ratio_i + 1 == ratio_labels.size())
1247  .separateLastRow(false)
1248  .minLabelWidth(max_label_width)
1249  .labelPrefix(ratio_labels.at(ratio_i));
1250  }
1251 
1252  ATH_MSG_INFO("Ratios:\n"
1253  << table_out.str());
1254  }
1255  }

◆ 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 264 of file TrackFindingAlg.h.

265  {
266  return m_statEtaBins.size() + 1;
267  }

◆ selectPixelStripCounts()

std::array< bool, 3 > ActsTrk::TrackFindingAlg::selectPixelStripCounts ( const detail::RecoTrackContainer::TrackProxy &  track,
double  eta 
) const
private

Definition at line 1013 of file TrackFindingAlg.cxx.

1014  {
1015  bool enoughMeasurements = true, tooManyHoles = false, tooManyOutliers = false;
1016  const auto &trackSelectorCfg = trackFinder().trackSelector.config();
1017  std::size_t etaBin = (std::abs(eta) < trackSelectorCfg.absEtaEdges.front()) ? 0
1018  : (std::abs(eta) >= trackSelectorCfg.absEtaEdges.back()) ? trackSelectorCfg.absEtaEdges.size() - 1
1019  : trackSelectorCfg.binIndex(eta);
1020  auto cutMin = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
1021  return !cutSet.empty() && (val < (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
1022  };
1023  auto cutMax = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
1024  return !cutSet.empty() && (val > (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
1025  };
1026  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nPixelHits(track), m_minPixelHits);
1027  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nStripHits(track), m_minStripHits);
1028  tooManyHoles = tooManyHoles || cutMax(s_branchState.nPixelHoles(track), m_maxPixelHoles);
1029  tooManyHoles = tooManyHoles || cutMax(s_branchState.nStripHoles(track), m_maxStripHoles);
1030  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nPixelOutliers(track), m_maxPixelOutliers);
1031  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nStripOutliers(track), m_maxStripOutliers);
1032  return {enoughMeasurements, tooManyHoles, tooManyOutliers};
1033  }

◆ 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 detail::RecoTrackContainer tracksContainer,
const detail::RecoTrackContainerProxy track,
detail::DuplicateSeedDetector duplicateSeedDetector 
) const
private

Definition at line 897 of file TrackFindingAlg.cxx.

899  {
900 
901  const auto lastMeasurementIndex = track.tipIndex();
902  duplicateSeedDetector.newTrajectory();
903 
904  tracksContainer.trackStateContainer().visitBackwards(
905  lastMeasurementIndex,
906  [&duplicateSeedDetector](const detail::RecoTrackStateContainer::ConstTrackStateProxy &state) -> void
907  {
908  // Check there is a source link
909  if (not state.hasUncalibratedSourceLink())
910  return;
911 
912  // Fill the duplicate selector
913  auto sl = state.getUncalibratedSourceLink().template get<ATLASUncalibSourceLink>();
914  duplicateSeedDetector.addMeasurement(sl);
915  }); // end visitBackwards
916  }

◆ sysExecute()

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

Execute an algorithm.

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

Definition at line 67 of file AthReentrantAlgorithm.cxx.

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

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

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

◆ sysStart()

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

Handle START transition.

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

◆ trackFinder() [1/2]

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

Definition at line 57 of file TrackFindingAlg.cxx.

57 { return *m_trackFinder; }

◆ trackFinder() [2/2]

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

Definition at line 58 of file TrackFindingAlg.cxx.

58 { return *m_trackFinder; }

◆ updatePixelStripCounts()

void ActsTrk::TrackFindingAlg::updatePixelStripCounts ( const detail::RecoTrackContainer::TrackProxy &  track,
Acts::ConstTrackStateType  typeFlags,
xAOD::UncalibMeasType  detType 
)
staticprivate

Definition at line 958 of file TrackFindingAlg.cxx.

961  {
963  if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
965  } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
967  } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
969  }
970  } else if (detType == xAOD::UncalibMeasType::StripClusterType) {
971  if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
973  } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
975  } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
977  }
978  }
979  }

◆ 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 272 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 273 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 135 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 120 of file TrackFindingAlg.h.

◆ m_absEtaMin

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

Definition at line 134 of file TrackFindingAlg.h.

◆ m_addPixelStripCounts

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_addPixelStripCounts {this, "addPixelStripCounts", true, "keep separate pixel and strip counts and apply the following cuts"}
private

Definition at line 149 of file TrackFindingAlg.h.

◆ m_ATLASConverterTool

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

Definition at line 87 of file TrackFindingAlg.h.

◆ m_branchStopperAbsEtaMaxExtra

Gaudi::Property<double> ActsTrk::TrackFindingAlg::m_branchStopperAbsEtaMaxExtra {this, "branchStopperAbsEtaMaxExtra", 0.0, "increase absEtaMax cut when used in the branch stopper"}
private

Definition at line 125 of file TrackFindingAlg.h.

◆ m_branchStopperPtMinFactor

Gaudi::Property<double> ActsTrk::TrackFindingAlg::m_branchStopperPtMinFactor {this, "branchStopperPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the branch stopper"}
private

Definition at line 124 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 116 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 117 of file TrackFindingAlg.h.

◆ m_countSharedHits

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_countSharedHits {this, "countSharedHits", true, "add shared hit flags to tracks"}
private

Definition at line 126 of file TrackFindingAlg.h.

◆ m_d0Max

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

Definition at line 139 of file TrackFindingAlg.h.

◆ m_d0Min

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

Definition at line 138 of file TrackFindingAlg.h.

◆ m_detectorElementToGeometryIdMapKey

SG::ReadCondHandleKey<ActsTrk::DetectorElementToActsGeometryIdMap> ActsTrk::TrackFindingAlg::m_detectorElementToGeometryIdMapKey
private
Initial value:
{this, "DetectorElementToActsGeometryIdMapKey", "DetectorElementToActsGeometryIdMap",
"Map which associates detector elements to Acts Geometry IDs"}

Definition at line 103 of file TrackFindingAlg.h.

◆ m_detEleCollKeys

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

Definition at line 100 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 121 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 122 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 160 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 114 of file TrackFindingAlg.h.

◆ m_etaMax

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

Definition at line 133 of file TrackFindingAlg.h.

◆ m_etaMin

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

Definition at line 132 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 84 of file TrackFindingAlg.h.

◆ m_fitterTool

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

Definition at line 89 of file TrackFindingAlg.h.

◆ m_hgtdCalibTool

ToolHandle<ActsTrk::IOnTrackCalibratorTool<detail::RecoTrackStateContainer> > ActsTrk::TrackFindingAlg::m_hgtdCalibTool
private
Initial value:
{
this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"}

Definition at line 94 of file TrackFindingAlg.h.

◆ m_logger

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

logging instance

Definition at line 282 of file TrackFindingAlg.h.

◆ m_maxChi2

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

Definition at line 147 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 144 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 145 of file TrackFindingAlg.h.

◆ m_maxPixelHoles

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_maxPixelHoles {this, "maxPixelHoles", {}, "maximum number of pixel holes"}
private

Definition at line 152 of file TrackFindingAlg.h.

◆ m_maxPixelOutliers

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_maxPixelOutliers {this, "maxPixelOutliers", {}, "maximum number of pixel outliers"}
private

Definition at line 154 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 111 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 146 of file TrackFindingAlg.h.

◆ m_maxStripHoles

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_maxStripHoles {this, "maxStripHoles", {}, "maximum number of strip holes"}
private

Definition at line 153 of file TrackFindingAlg.h.

◆ m_maxStripOutliers

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_maxStripOutliers {this, "maxStripOutliers", {}, "maximum number of strip outliers"}
private

Definition at line 155 of file TrackFindingAlg.h.

◆ m_measurementSelector

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

Definition at line 230 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 143 of file TrackFindingAlg.h.

◆ m_minPixelHits

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_minPixelHits {this, "minPixelHits", {}, "minimum number of pixel hits"}
private

Definition at line 150 of file TrackFindingAlg.h.

◆ m_minStripHits

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingAlg::m_minStripHits {this, "minStripHits", {}, "minimum number of strip hits"}
private

Definition at line 151 of file TrackFindingAlg.h.

◆ m_monTool

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

Definition at line 83 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 118 of file TrackFindingAlg.h.

◆ m_paramEstimationTool

ToolHandle< ActsTrk::ITrackParamsEstimationTool > ActsTrk::TrackFindingAlg::m_paramEstimationTool {this, "TrackParamsEstimationTool", "", "Track Param Estimation from Seeds"}
private

Definition at line 88 of file TrackFindingAlg.h.

◆ m_phiMax

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

Definition at line 131 of file TrackFindingAlg.h.

◆ m_phiMin

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

Definition at line 130 of file TrackFindingAlg.h.

◆ m_pixelCalibTool

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

Definition at line 90 of file TrackFindingAlg.h.

◆ m_ptMax

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

Definition at line 137 of file TrackFindingAlg.h.

◆ m_ptMin

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

Definition at line 136 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 119 of file TrackFindingAlg.h.

◆ m_refitSeeds

Gaudi::Property<std::vector<bool> > ActsTrk::TrackFindingAlg::m_refitSeeds {this, "refitSeeds", {}, "Run KalmanFitter on seeds before passing to CKF, specified separately for each seed collection"}
private

Definition at line 113 of file TrackFindingAlg.h.

◆ m_reverseSearch

Gaudi::Property<std::vector<bool> > ActsTrk::TrackFindingAlg::m_reverseSearch {this, "reverseSearch", {}, "Whether to run the finding in seed parameter direction (false or not specified) or reverse direction (true), specified separately for each seed collection"}
private

Definition at line 123 of file TrackFindingAlg.h.

◆ m_seedContainerKeys

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

Definition at line 99 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 159 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 112 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 158 of file TrackFindingAlg.h.

◆ m_stripCalibTool

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

Definition at line 92 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 107 of file TrackFindingAlg.h.

◆ m_trackFinder

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

Definition at line 231 of file TrackFindingAlg.h.

◆ m_trackingGeometryTool

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

Definition at line 85 of file TrackFindingAlg.h.

◆ m_tracksBackendHandlesHelper

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

Definition at line 108 of file TrackFindingAlg.h.

◆ m_trackStatePrinter

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

Definition at line 86 of file TrackFindingAlg.h.

◆ m_uncalibratedMeasurementContainerKeys

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

Definition at line 102 of file TrackFindingAlg.h.

◆ m_useAbsEtaForStat

bool ActsTrk::TrackFindingAlg::m_useAbsEtaForStat = false
private

Definition at line 271 of file TrackFindingAlg.h.

◆ m_useDefaultMeasurementSelector

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

Definition at line 162 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.

◆ m_z0Max

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

Definition at line 141 of file TrackFindingAlg.h.

◆ m_z0Min

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

Definition at line 140 of file TrackFindingAlg.h.

◆ s_branchState

constexpr BranchState ActsTrk::TrackFindingAlg::s_branchState {}
staticconstexprprivate

Definition at line 243 of file TrackFindingAlg.h.


The documentation for this class was generated from the following files:
ActsTrk::TrackFindingAlg::m_maxPixelHoles
Gaudi::Property< std::vector< std::size_t > > m_maxPixelHoles
Definition: TrackFindingAlg.h:152
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
test_pyathena.eta
eta
Definition: test_pyathena.py:10
ActsTrk::TrackFindingAlg::m_hgtdCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_hgtdCalibTool
Definition: TrackFindingAlg.h:94
ActsTrk::TrackFindingAlg::kNNoEstimatedParams
@ kNNoEstimatedParams
Definition: TrackFindingAlg.h:171
ActsTrk::TrackFindingAlg::findTracks
StatusCode findTracks(const EventContext &ctx, const Acts::TrackingGeometry &trackingGeometry, const ActsTrk::DetectorElementToActsGeometryIdMap &detectorElementToGeoId, const detail::TrackFindingMeasurements &measurements, std::optional< detail::SharedHitCounter > &sharedHits, detail::DuplicateSeedDetector &duplicateSeedDetector, const ActsTrk::SeedContainer &seeds, const InDetDD::SiDetectorElementCollection &detElements, ActsTrk::MutableTrackContainer &tracksContainer, std::size_t seedCollectionIndex, const char *seedType, EventStats &event_stat) const
invoke track finding procedure
Definition: TrackFindingAlg.cxx:399
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ActsTrk::TrackFindingAlg::m_extrapolationTool
ToolHandle< IActsExtrapolationTool > m_extrapolationTool
Definition: TrackFindingAlg.h:84
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
ActsTrk::TrackFindingAlg::selectPixelStripCounts
std::array< bool, 3 > selectPixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track, double eta) const
Definition: TrackFindingAlg.cxx:1013
ActsTrk::TrackFindingAlg::m_maxSharedHits
Gaudi::Property< std::vector< std::size_t > > m_maxSharedHits
Definition: TrackFindingAlg.h:146
ActsTrk::TrackFindingAlg::m_statEtaBins
Gaudi::Property< std::vector< float > > m_statEtaBins
Definition: TrackFindingAlg.h:158
get_generator_info.result
result
Definition: get_generator_info.py:21
ActsTrk::TrackFindingAlg::kNStoppedTracksMaxEta
@ kNStoppedTracksMaxEta
Definition: TrackFindingAlg.h:179
ActsTrk::TrackFindingAlg::m_trackingGeometryTool
ToolHandle< IActsTrackingGeometryTool > m_trackingGeometryTool
Definition: TrackFindingAlg.h:85
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
ActsTrk::TrackFindingAlg::m_branchStopperAbsEtaMaxExtra
Gaudi::Property< double > m_branchStopperAbsEtaMaxExtra
Definition: TrackFindingAlg.h:125
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:194
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
ActsTrk::TrackFindingAlg::logger
const Acts::Logger & logger() const
Private access to the logger.
Definition: TrackFindingAlg.h:276
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
ActsTrk::detail::Navigator
Acts::Navigator Navigator
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:31
xAOD::UncalibMeasType::StripClusterType
@ StripClusterType
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:135
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
ActsTrk::TrackFindingAlg::m_maxStripHoles
Gaudi::Property< std::vector< std::size_t > > m_maxStripHoles
Definition: TrackFindingAlg.h:153
ActsTrk::TrackFindingAlg::measurementType
static xAOD::UncalibMeasType measurementType(const detail::RecoTrackContainer::TrackStateProxy &trackState)
Definition: TrackFindingAlg.cxx:919
ActsTrk::TrackFindingAlg::m_detectorElementToGeometryIdMapKey
SG::ReadCondHandleKey< ActsTrk::DetectorElementToActsGeometryIdMap > m_detectorElementToGeometryIdMapKey
Definition: TrackFindingAlg.h:104
ActsTrk::detail::CKF_config::trackSelector
Acts::TrackSelector trackSelector
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:49
ActsTrk::detail::Extrapolator
Propagator Extrapolator
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:34
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::BranchState::nPixelOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nPixelOutliers
Definition: TrackFindingAlg.h:240
ActsTrk::TrackFindingAlg::m_paramEstimationTool
ToolHandle< ActsTrk::ITrackParamsEstimationTool > m_paramEstimationTool
Definition: TrackFindingAlg.h:88
ActsTrk::TrackFindingAlg::addPixelStripCounts
static void addPixelStripCounts(detail::RecoTrackContainer &tracksContainer)
Definition: TrackFindingAlg.cxx:936
ActsTrk::TrackFindingAlg::kNoTrack
@ kNoTrack
Definition: TrackFindingAlg.h:169
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
InDetDD::SolidStateDetectorElementBase::surface
Trk::Surface & surface()
Element Surface.
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:206
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
xAOD::SpacePoint_v1::ConstVectorMap
Eigen::Map< const Eigen::Matrix< float, 3, 1 > > ConstVectorMap
Definition: SpacePoint_v1.h:31
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:130
TableUtils::defineSimpleRatio
RatioDefinition defineSimpleRatio(T numerator, T denominator)
Definition: TableUtils.h:382
ActsTrk::TrackFindingAlg::initPixelStripCounts
static void initPixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track)
Definition: TrackFindingAlg.cxx:947
ActsTrk::TrackFindingAlg::m_refitSeeds
Gaudi::Property< std::vector< bool > > m_refitSeeds
Definition: TrackFindingAlg.h:113
xAOD::SpacePoint_v1
Definition: SpacePoint_v1.h:29
ActsTrk::TrackFindingAlg::trackFinder
CKF_pimpl & trackFinder()
Definition: TrackFindingAlg.cxx:57
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_branchStopperPtMinFactor
Gaudi::Property< double > m_branchStopperPtMinFactor
Definition: TrackFindingAlg.h:124
ActsTrk::TrackFindingAlg::BranchState::nStripHoles
static constexpr Acts::ProxyAccessor< unsigned int > nStripHoles
Definition: TrackFindingAlg.h:239
ActsTrk::TrackFindingAlg::m_maxOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxOutliers
Definition: TrackFindingAlg.h:145
ActsTrk::TrackFindingAlg::kNOutputTracks
@ kNOutputTracks
Definition: TrackFindingAlg.h:172
ActsTrk::TrackFindingAlg::kNUsedSeeds
@ kNUsedSeeds
Definition: TrackFindingAlg.h:168
ActsTrk::TrackFindingAlg::m_useAbsEtaForStat
bool m_useAbsEtaForStat
Definition: TrackFindingAlg.h:271
ActsTrk::detail::RecoTrackContainerProxy
RecoTrackContainer::TrackProxy RecoTrackContainerProxy
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:24
ActsTrk::TrackFindingAlg::BranchState::nStripOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nStripOutliers
Definition: TrackFindingAlg.h:241
ActsTrk::TrackFindingAlg::kNoTrackParam
@ kNoTrackParam
Definition: TrackFindingAlg.h:167
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ActsTrk::TrackFindingAlg::m_seedContainerKeys
SG::ReadHandleKeyArray< ActsTrk::SeedContainer > m_seedContainerKeys
Definition: TrackFindingAlg.h:99
ActsTrk::TrackFindingAlg::m_minPixelHits
Gaudi::Property< std::vector< std::size_t > > m_minPixelHits
Definition: TrackFindingAlg.h:150
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
ActsTrk::detail::RecoTrackContainer
Acts::TrackContainer< Acts::VectorTrackContainer, Acts::VectorMultiTrajectory > RecoTrackContainer
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:23
xAOD::SpacePoint_v1::globalPosition
ConstVectorMap globalPosition() const
Returns the global position of the pixel cluster.
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
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_z0Min
Gaudi::Property< std::vector< double > > m_z0Min
Definition: TrackFindingAlg.h:140
ActsTrk::TrackFindingAlg::m_maxPropagationStep
Gaudi::Property< unsigned int > m_maxPropagationStep
Definition: TrackFindingAlg.h:111
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
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
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
ActsTrk::TrackFindingAlg::nSeedCollections
std::size_t nSeedCollections() const
Definition: TrackFindingAlg.h:260
ActsTrk::detail::getMeasurementSelector
std::unique_ptr< ActsTrk::IMeasurementSelector > getMeasurementSelector(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:333
ActsTrk::TrackFindingAlg::BranchState::nPixelHoles
static constexpr Acts::ProxyAccessor< unsigned int > nPixelHoles
Definition: TrackFindingAlg.h:238
xAOD::SpacePoint_v1::elementIdList
const std::vector< DetectorIDHashType > & elementIdList() const
Returns the IdentifierHash of the spacepoint (corresponds to the detector element IdentifierHash)
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
ActsTrk::TrackFindingAlg::m_uncalibratedMeasurementContainerKeys
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainer > m_uncalibratedMeasurementContainerKeys
Definition: TrackFindingAlg.h:102
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:1056
ActsTrk::TrackFindingAlg::m_chi2OutlierCutOff
Gaudi::Property< std::vector< double > > m_chi2OutlierCutOff
Definition: TrackFindingAlg.h:117
ActsTrk::TrackFindingAlg::printStatTables
void printStatTables() const
Definition: TrackFindingAlg.cxx:1072
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
ActsTrk::detail::UncalibSourceLinkAccessor
GenUncalibSourceLinkAccessor< MeasurementRangeList > UncalibSourceLinkAccessor
Definition: AtlasUncalibSourceLinkAccessor.h:205
ActsTrk::TrackFindingAlg::s_branchState
static constexpr BranchState s_branchState
Definition: TrackFindingAlg.h:243
ActsTrk::TrackFindingAlg::computeStatSum
std::size_t computeStatSum(std::size_t seed_collection, EStat counter_i, const EventStats &stat) const
Definition: TrackFindingAlg.cxx:1267
ActsTrk::TrackFindingAlg::kNDuplicateSeeds
@ kNDuplicateSeeds
Definition: TrackFindingAlg.h:170
ActsTrk::TrackFindingAlg::m_addPixelStripCounts
Gaudi::Property< bool > m_addPixelStripCounts
Definition: TrackFindingAlg.h:149
ActsTrk::TrackFindingAlg::m_seedLabels
Gaudi::Property< std::vector< std::string > > m_seedLabels
Definition: TrackFindingAlg.h:159
xAOD::etaBin
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap etaBin
Definition: L2StandAloneMuon_v1.cxx:148
ActsTrk::TrackFindingAlg::m_countSharedHits
Gaudi::Property< bool > m_countSharedHits
Definition: TrackFindingAlg.h:126
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
xAOD::addTrack
@ addTrack
Definition: TrackingPrimitives.h:465
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
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
ActsTrk::TrackFindingAlg::m_stripCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_stripCalibTool
Definition: TrackFindingAlg.h:92
makeTable
TableUtils::StatTable< T > makeTable(const std::array< T, N > &counter, const std::array< std::string, N > &label)
Definition: TableUtils.h:521
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
TableUtils::maxLabelWidth
std::size_t maxLabelWidth(const T_Collection &col)
Definition: TableUtils.h:288
ActsTrk::detail::OnTrackCalibrator::calibrate
void calibrate(const Acts::GeometryContext &geoctx, const Acts::CalibrationContext &cctx, const Acts::SourceLink &link, TrackStateProxy state) const
lumiFormat.i
int i
Definition: lumiFormat.py:85
ActsTrk::TrackFindingAlg::m_d0Max
Gaudi::Property< std::vector< double > > m_d0Max
Definition: TrackFindingAlg.h:139
ActsTrk::detail::GenUncalibSourceLinkAccessor::range
std::pair< Iterator, Iterator > range(const Acts::Surface &surface) const
Definition: AtlasUncalibSourceLinkAccessor.h:161
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:136
ActsTrk::TrackFindingAlg::m_detEleCollKeys
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollection > m_detEleCollKeys
Definition: TrackFindingAlg.h:100
ActsTrk::TrackFindingAlg::storeSeedInfo
void storeSeedInfo(const detail::RecoTrackContainer &tracksContainer, const detail::RecoTrackContainerProxy &track, detail::DuplicateSeedDetector &duplicateSeedDetector) const
Definition: TrackFindingAlg.cxx:897
ActsTrk::TrackFindingAlg::initializeMeasurementSelector
StatusCode initializeMeasurementSelector()
Definition: TrackFindingAlg.cxx:1281
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:93
xAOD::Other
@ Other
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsTrk::Seed
Acts::Seed< xAOD::SpacePoint, 3ul > Seed
Definition: Seed.h:12
ActsTrk::TrackFindingAlg::kNStoppedTracksMinPt
@ kNStoppedTracksMinPt
Definition: TrackFindingAlg.h:178
ActsTrk::TrackFindingAlg::m_absEtaMin
Gaudi::Property< double > m_absEtaMin
Definition: TrackFindingAlg.h:134
python.AtlRunQueryLib.options
options
Definition: AtlRunQueryLib.py:379
ActsDetectorElement
Definition: ActsDetectorElement.h:42
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
ActsTrk::detail::CKF_config::ckf
CKF ckf
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:44
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_maxPixelOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxPixelOutliers
Definition: TrackFindingAlg.h:154
ActsTrk::TrackFindingAlg::m_numMeasurementsCutOff
Gaudi::Property< std::vector< size_t > > m_numMeasurementsCutOff
Definition: TrackFindingAlg.h:118
ActsTrk::TrackFindingAlg::m_useDefaultMeasurementSelector
Gaudi::Property< bool > m_useDefaultMeasurementSelector
Definition: TrackFindingAlg.h:162
ActsTrk::TrackFindingAlg::m_ATLASConverterTool
ToolHandle< ActsTrk::IActsToTrkConverterTool > m_ATLASConverterTool
Definition: TrackFindingAlg.h:87
beamspotman.stat
stat
Definition: beamspotman.py:266
ActsTrk::TrackFindingAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrackFindingAlg.h:83
ActsTrk::TrackFindingAlg::m_trackStatePrinter
ToolHandle< ActsTrk::TrackStatePrinterTool > m_trackStatePrinter
Definition: TrackFindingAlg.h:86
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:230
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:173
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::checkPixelStripCounts
void checkPixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track) const
Definition: TrackFindingAlg.cxx:994
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:228
checkNSWValTree.Options
Options
Definition: checkNSWValTree.py:15
ActsTrk::TrackFindingAlg::kMultipleBranches
@ kMultipleBranches
Definition: TrackFindingAlg.h:176
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
ActsTrk::TrackFindingAlg::BranchState::nPixelHits
static constexpr Acts::ProxyAccessor< unsigned int > nPixelHits
Definition: TrackFindingAlg.h:236
ActsTrk::TrackFindingAlg::m_z0Max
Gaudi::Property< std::vector< double > > m_z0Max
Definition: TrackFindingAlg.h:141
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
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:116
ActsTrk::detail::Stepper
Acts::SympyStepper Stepper
Adapted from Acts Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithmFunction....
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:30
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
ActsTrk::TrackFindingAlg::copyPixelStripCounts
static void copyPixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackProxy &other)
Definition: TrackFindingAlg.cxx:982
ActsTrk::TrackFindingAlg::m_doBranchStopper
Gaudi::Property< bool > m_doBranchStopper
Definition: TrackFindingAlg.h:121
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
ActsTrk::TrackFindingAlg::m_maxStripOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxStripOutliers
Definition: TrackFindingAlg.h:155
ActsTrk::TrackFindingAlg::m_skipDuplicateSeeds
Gaudi::Property< bool > m_skipDuplicateSeeds
Definition: TrackFindingAlg.h:112
mergePhysValFiles.categories
list categories
Definition: PhysicsAnalysis/JetTagging/JetTagValidation/JetTagDQA/scripts/mergePhysValFiles.py:18
ActsTrk::detail::CKF_config::measurementSelector
Acts::MeasurementSelector measurementSelector
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:46
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:1257
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
ActsTrk::TrackFindingAlg::BranchState::nStripHits
static constexpr Acts::ProxyAccessor< unsigned int > nStripHits
Definition: TrackFindingAlg.h:237
ActsTrk::TrackFindingAlg::m_minStripHits
Gaudi::Property< std::vector< std::size_t > > m_minStripHits
Definition: TrackFindingAlg.h:151
ActsTrk::TrackFindingAlg::initStatTables
void initStatTables()
Definition: TrackFindingAlg.cxx:1037
ActsTrk::detail::Propagator
Acts::Propagator< Stepper, Navigator > Propagator
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:32
h
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:295
ActsTrk::TrackFindingAlg::m_etaMin
Gaudi::Property< std::vector< double > > m_etaMin
Definition: TrackFindingAlg.h:132
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ActsTrk::TrackFindingAlg::kNStat
@ kNStat
Definition: TrackFindingAlg.h:181
ActsTrk::TrackFindingAlg::m_minMeasurements
Gaudi::Property< std::vector< std::size_t > > m_minMeasurements
Definition: TrackFindingAlg.h:143
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
ActsTrk::TrackFindingAlg::updatePixelStripCounts
static void updatePixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateType typeFlags, xAOD::UncalibMeasType detType)
Definition: TrackFindingAlg.cxx:958
DeMoScan.first
bool first
Definition: DeMoScan.py:536
ActsTrk::TrackFindingAlg::m_ptMinMeasurements
Gaudi::Property< std::vector< std::size_t > > m_ptMinMeasurements
Definition: TrackFindingAlg.h:119
plotBeamSpotMon.mon
mon
Definition: plotBeamSpotMon.py:67
ActsTrk::TrackFindingAlg::m_logger
std::unique_ptr< const Acts::Logger > m_logger
logging instance
Definition: TrackFindingAlg.h:282
ActsTrk::TrackFindingAlg::kNTotalSharedHits
@ kNTotalSharedHits
Definition: TrackFindingAlg.h:180
ActsTrk::TrackFindingAlg::m_tracksBackendHandlesHelper
ActsTrk::MutableTrackContainerHandlesHelper m_tracksBackendHandlesHelper
Definition: TrackFindingAlg.h:108
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
ActsTrk::TrackFindingAlg::m_trackFinder
std::unique_ptr< CKF_pimpl > m_trackFinder
Definition: TrackFindingAlg.h:231
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:122
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
ActsTrk::TrackFindingAlg::EventStats
std::vector< std::array< unsigned int, kNStat > > EventStats
Definition: TrackFindingAlg.h:183
ActsTrk::TrackFindingAlg::m_trackContainerKey
SG::WriteHandleKey< ActsTrk::TrackContainer > m_trackContainerKey
Definition: TrackFindingAlg.h:107
ActsTrk::TrackFindingAlg::m_reverseSearch
Gaudi::Property< std::vector< bool > > m_reverseSearch
Definition: TrackFindingAlg.h:123
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
ActsTrk::TrackFindingAlg::kNTotalSeeds
@ kNTotalSeeds
Definition: TrackFindingAlg.h:166
ActsTrk::TrackFindingAlg::kNSelectedTracks
@ kNSelectedTracks
Definition: TrackFindingAlg.h:174
ActsTrk::TrackFindingAlg::kNoSecond
@ kNoSecond
Definition: TrackFindingAlg.h:177
ActsTrk::TrackFindingAlg::m_etaBins
Gaudi::Property< std::vector< double > > m_etaBins
Definition: TrackFindingAlg.h:114
ActsTrk::TrackFindingAlg::m_absEtaMaxMeasurements
Gaudi::Property< std::vector< std::size_t > > m_absEtaMaxMeasurements
Definition: TrackFindingAlg.h:120
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
ActsTrk::TrackFindingAlg::m_maxChi2
Gaudi::Property< std::vector< double > > m_maxChi2
Definition: TrackFindingAlg.h:147
ActsTrk::TrackFindingAlg::seedCollectionStride
std::size_t seedCollectionStride() const
Definition: TrackFindingAlg.h:264
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:137
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:131
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
ActsTrk::MutableTrackContainer
Definition: TrackContainer.h:122
ActsTrk::TrackFindingAlg::m_dumpAllStatEtaBins
Gaudi::Property< bool > m_dumpAllStatEtaBins
Definition: TrackFindingAlg.h:160
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
InDetDD::SiDetectorElementCollection::getDetectorElement
const SiDetectorElement * getDetectorElement(const IdentifierHash &hash) const
Definition: SiDetectorElementCollection.cxx:15
ActsTrk::TrackFindingAlg::m_etaMax
Gaudi::Property< std::vector< double > > m_etaMax
Definition: TrackFindingAlg.h:133
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
ActsTrk::detail::CKF_config::ckfExtensions
Acts::CombinatorialKalmanFilterExtensions< RecoTrackContainer > ckfExtensions
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:47
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
xAOD::UncalibMeasType::PixelClusterType
@ PixelClusterType
ActsTrk::TrackFindingAlg::kNStoppedTracksMaxHoles
@ kNStoppedTracksMaxHoles
Definition: TrackFindingAlg.h:175
fitman.k
k
Definition: fitman.py:528
ActsTrk::TrackFindingAlg::m_fitterTool
ToolHandle< ActsTrk::IFitterTool > m_fitterTool
Definition: TrackFindingAlg.h:89
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
ActsTrk::TrackFindingAlg::m_pixelCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_pixelCalibTool
Definition: TrackFindingAlg.h:90
ServiceHandle< ICondSvc >
ActsTrk::TrackFindingAlg::m_d0Min
Gaudi::Property< std::vector< double > > m_d0Min
Definition: TrackFindingAlg.h:138
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition: ReadCondHandle.h:67
ActsTrk::TrackFindingAlg::m_maxHoles
Gaudi::Property< std::vector< std::size_t > > m_maxHoles
Definition: TrackFindingAlg.h:144