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

#include <TrackFindingBaseAlg.h>

Inheritance diagram for ActsTrk::TrackFindingBaseAlg:
Collaboration diagram for ActsTrk::TrackFindingBaseAlg:

Classes

struct  BranchState
 
struct  CKF_pimpl
 
struct  DetectorContextHolder
 
struct  MeasurementSelectorConfig
 
struct  TrackFindingDefaultOptions
 

Public Member Functions

 TrackFindingBaseAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~TrackFindingBaseAlg ()
 
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, V, H > &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 Types

enum  EStat : std::size_t {
  kNTotalSeeds, kNoTrackParam, kNUsedSeeds, kNoTrack,
  kNDuplicateSeeds, kNNoEstimatedParams, kNOutputTracks, kNRejectedRefinedSeeds,
  kNSelectedTracks, kNStoppedTracksMaxHoles, kMultipleBranches, kNoSecond,
  kNStoppedTracksMinPt, kNStoppedTracksMaxEta, kNTotalSharedHits, kNForcedSeedMeasurements,
  kNStat
}
 
using TrackFinderOptions = Acts::CombinatorialKalmanFilterOptions< detail::RecoTrackContainer >
 
using EventStats = std::vector< std::array< unsigned int, kNStat > >
 
using TrkProxy = Acts::TrackProxy< Acts::VectorTrackContainer, Acts::VectorMultiTrajectory, Acts::detail::RefHolder, false >
 
using BranchStopperResult = Acts::CombinatorialKalmanFilterBranchStopperResult
 

Protected Member Functions

CKF_pimpl & trackFinder ()
 
const CKF_pimpl & trackFinder () const
 
StatusCode initializeMeasurementSelector ()
 
std::unique_ptr< ActsTrk::IMeasurementSelector > setMeasurementSelector (const detail::TrackFindingMeasurements &measurements, TrackFinderOptions &options) const
 Setup and attach measurement selector to KF options. More...
 
TrackFindingDefaultOptions getDefaultOptions (const DetectorContextHolder &detContext, const detail::TrackFindingMeasurements &measurements, const Acts::PerigeeSurface *pSurface) const
 Get CKF options for first and second pass + pointer to MeasurementSelector. More...
 
template<class HandleArrayKeyType , class ContainerType >
StatusCode getContainersFromKeys (const EventContext &ctx, HandleArrayKeyType &handleKeyArray, std::vector< const ContainerType * > &outputContainers, std::size_t &sum) const
 Take the array of handle keys and for each key retrieve containers, then append them to the output vector. More...
 
const Acts::TrackSelector::Config & getCuts (double eta) const
 Retrieves track selector configuration for given eta value. More...
 
template<class MeasurementSource >
std::unique_ptr< Acts::BoundTrackParameters > doRefit (const MeasurementSource &measurement, const Acts::BoundTrackParameters &initialParameters, const DetectorContextHolder &detContext, const bool paramsAtOutermostSurface) const
 Perform Kalman Filter fit and update given initialParameters. More...
 
std::vector< typename detail::RecoTrackContainer::TrackProxy > doTwoWayTrackFinding (const detail::RecoTrackStateContainerProxy &firstMeasurement, const TrkProxy &trackProxy, detail::RecoTrackContainer &tracksContainerTemp, const TrackFinderOptions &options) const
 Perform two-way track finding. More...
 
BranchStopperResult stopBranch (const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackStateProxy &trackState, const Acts::TrackSelector::EtaBinnedConfig &trackSelectorCfg, const Acts::GeometryContext &tgContext, const detail::MeasurementIndex &measurementIndex, const std::size_t typeIndex, EventStats::value_type &event_stat_category_i) const
 Branch stopper. More...
 
void checkCounts (const detail::RecoTrackContainer::TrackProxy &track) const
 
std::array< bool, 3 > selectCounts (const detail::RecoTrackContainer::TrackProxy &track, double eta) const
 
bool selectCountsFinal (const detail::RecoTrackContainer::TrackProxy &track) const
 
const Acts::Logger & logger () const
 Private access to the logger. More...
 
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
 
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...
 

Static Protected Member Functions

static xAOD::UncalibMeasType measurementType (const detail::RecoTrackContainer::TrackStateProxy &trackState)
 
static void addCounts (detail::RecoTrackContainer &tracksContainer)
 
static void initCounts (const detail::RecoTrackContainer::TrackProxy &track)
 
static void updateCounts (const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateType typeFlags, xAOD::UncalibMeasType detType)
 
static void copyCounts (const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackProxy &other)
 

Protected Attributes

struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig m_measurementSelectorConfig
 
std::unique_ptr< CKF_pimpl > m_trackFinder
 
detail::xAODUncalibMeasSurfAcc m_unalibMeasSurfAcc {}
 
ToolHandle< GenericMonitoringTool > m_monTool {this, "MonTool", "", "Monitoring tool"}
 
ToolHandle< IActsExtrapolationTool > m_extrapolationTool {this, "ExtrapolationTool", ""}
 
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
 
ToolHandle< ActsTrk::TrackStatePrinterTool > m_trackStatePrinter {this, "TrackStatePrinter", "", "optional track state printer"}
 
ToolHandle< ActsTrk::IActsToTrkConverterTool > m_ATLASConverterTool {this, "ATLASConverterTool", ""}
 
ToolHandle< ActsTrk::IFitterTool > m_fitterTool {this, "FitterTool", "", "Fitter Tool for Seeds"}
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_pixelCalibTool {this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"}
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_stripCalibTool {this, "StripCalibrator", "", "Opt. strip measurement calibrator"}
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_hgtdCalibTool {this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"}
 
SG::WriteHandleKey< ActsTrk::TrackContainer > m_trackContainerKey {this, "ACTSTracksLocation", "", "Output track collection (ActsTrk variant)"}
 
ActsTrk::MutableTrackContainerHandlesHelper m_tracksBackendHandlesHelper {this}
 
Gaudi::Property< unsigned int > m_maxPropagationStep {this, "maxPropagationStep", 1000, "Maximum number of steps for one propagate call"}
 
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< 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< double > m_branchStopperMeasCutReduce {this, "branchStopperMeasCutReduce", 2, "how much to reduce the minMeas requirement for the branch stopper"}
 
Gaudi::Property< double > m_branchStopperAbsEtaMeasCut {this, "branchStopperAbsEtaMeasCut", 1.2, "the minimum |eta| to apply the reduction to the minMeas requirement for the branch stopper"}
 
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_addCounts {this, "addCounts", true, "keep separate pixel, strip and hgtd 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_minHgtdHits {this, "minHgtdHits", {}, "minimum number of hgtd 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_maxHgtdHoles {this, "maxHgtdHoles", {}, "maximum number of hgtd 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< std::size_t > > m_maxHgtdOutliers {this, "maxHgtdOutliers", {}, "maximum number of hgtd outliers"}
 
Gaudi::Property< std::vector< std::uint32_t > > m_endOfWorldVolumeIds {this, "EndOfTheWorldVolumeIds", {}, ""}
 
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."}
 
std::unique_ptr< const Acts::Logger > m_logger
 logging instance More...
 
bool m_useAbsEtaForStat = false
 
std::mutex m_mutex ATLAS_THREAD_SAFE
 
std::vector< std::array< std::size_t, kNStat > > m_stat ATLAS_THREAD_SAFE {}
 

Static Protected Attributes

static constexpr BranchState s_branchState {}
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 44 of file TrackFindingBaseAlg.h.

Member Typedef Documentation

◆ BranchStopperResult

using ActsTrk::TrackFindingBaseAlg::BranchStopperResult = Acts::CombinatorialKalmanFilterBranchStopperResult
protected

Definition at line 271 of file TrackFindingBaseAlg.h.

◆ EventStats

using ActsTrk::TrackFindingBaseAlg::EventStats = std::vector<std::array<unsigned int, kNStat> >
protected

Definition at line 176 of file TrackFindingBaseAlg.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ TrackFinderOptions

using ActsTrk::TrackFindingBaseAlg::TrackFinderOptions = Acts::CombinatorialKalmanFilterOptions<detail::RecoTrackContainer>
protected

Definition at line 54 of file TrackFindingBaseAlg.h.

◆ TrkProxy

using ActsTrk::TrackFindingBaseAlg::TrkProxy = Acts::TrackProxy<Acts::VectorTrackContainer, Acts::VectorMultiTrajectory, Acts::detail::RefHolder, false>
protected

Definition at line 246 of file TrackFindingBaseAlg.h.

Member Enumeration Documentation

◆ EStat

enum ActsTrk::TrackFindingBaseAlg::EStat : std::size_t
protected
Enumerator
kNTotalSeeds 
kNoTrackParam 
kNUsedSeeds 
kNoTrack 
kNDuplicateSeeds 
kNNoEstimatedParams 
kNOutputTracks 
kNRejectedRefinedSeeds 
kNSelectedTracks 
kNStoppedTracksMaxHoles 
kMultipleBranches 
kNoSecond 
kNStoppedTracksMinPt 
kNStoppedTracksMaxEta 
kNTotalSharedHits 
kNForcedSeedMeasurements 
kNStat 

Definition at line 155 of file TrackFindingBaseAlg.h.

156  {
157  kNTotalSeeds,
158  kNoTrackParam,
159  kNUsedSeeds,
160  kNoTrack,
161  kNDuplicateSeeds,
162  kNNoEstimatedParams,
163  kNOutputTracks,
164  kNRejectedRefinedSeeds,
165  kNSelectedTracks,
166  kNStoppedTracksMaxHoles,
167  kMultipleBranches,
168  kNoSecond,
169  kNStoppedTracksMinPt,
170  kNStoppedTracksMaxEta,
171  kNTotalSharedHits,
172  kNForcedSeedMeasurements,
173  kNStat
174  };

Constructor & Destructor Documentation

◆ TrackFindingBaseAlg()

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

Definition at line 22 of file TrackFindingBaseAlg.cxx.

22 : AthReentrantAlgorithm(name, pSvcLocator) {}

◆ ~TrackFindingBaseAlg()

ActsTrk::TrackFindingBaseAlg::~TrackFindingBaseAlg ( )
default

Member Function Documentation

◆ addCounts()

void ActsTrk::TrackFindingBaseAlg::addCounts ( detail::RecoTrackContainer &  tracksContainer)
staticprotected

Definition at line 384 of file TrackFindingBaseAlg.cxx.

385  {
386  tracksContainer.addColumn<unsigned int>("nPixelHits");
387  tracksContainer.addColumn<unsigned int>("nStripHits");
388  tracksContainer.addColumn<unsigned int>("nHgtdHits");
389  tracksContainer.addColumn<unsigned int>("nPixelHoles");
390  tracksContainer.addColumn<unsigned int>("nStripHoles");
391  tracksContainer.addColumn<unsigned int>("nHgtdHoles");
392  tracksContainer.addColumn<unsigned int>("nPixelOutliers");
393  tracksContainer.addColumn<unsigned int>("nStripOutliers");
394  tracksContainer.addColumn<unsigned int>("nHgtdOutliers");
395  }

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
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 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ checkCounts()

void ActsTrk::TrackFindingBaseAlg::checkCounts ( const detail::RecoTrackContainer::TrackProxy &  track) const
protected

Definition at line 454 of file TrackFindingBaseAlg.cxx.

454  {
455  // This check will fail if there are other types (HGTD, MS?) of hits, holes, or outliers.
456  // The check can be removed when it is no longer appropriate.
457  if (track.nMeasurements() != s_branchState.nPixelHits(track) + s_branchState.nStripHits(track) + s_branchState.nHgtdHits(track))
458  ATH_MSG_WARNING("mismatched hit count: total (" << track.nMeasurements()
459  << ") != pixel (" << s_branchState.nPixelHits(track)
460  << ") + strip (" << s_branchState.nStripHits(track)
461  << ") + hgtd (" << s_branchState.nHgtdHits(track)
462  << ")");
463  if (track.nHoles() != s_branchState.nPixelHoles(track) + s_branchState.nStripHoles(track) + s_branchState.nHgtdHoles(track))
464  ATH_MSG_WARNING("mismatched hole count: total (" << track.nHoles()
465  << ") < pixel (" << s_branchState.nPixelHoles(track)
466  << ") + strip (" << s_branchState.nStripHoles(track)
467  << ") + hgtd (" << s_branchState.nHgtdHoles(track)
468  << ")");
469  if (track.nOutliers() != s_branchState.nPixelOutliers(track) + s_branchState.nStripOutliers(track) + s_branchState.nHgtdOutliers(track))
470  ATH_MSG_WARNING("mismatched outlier count: total (" << track.nOutliers()
471  << ") != pixel (" << s_branchState.nPixelOutliers(track)
472  << ") + strip (" << s_branchState.nStripOutliers(track)
473  << ") + hgtd (" << s_branchState.nHgtdOutliers(track)
474  << ")");
475  };

◆ computeStatSum()

std::size_t ActsTrk::TrackFindingBaseAlg::computeStatSum ( std::size_t  seed_collection,
EStat  counter_i,
const EventStats &  stat 
) const
protected

Definition at line 760 of file TrackFindingBaseAlg.cxx.

760  {
761  std::size_t out = 0u;
762  for (std::size_t category_i = seed_collection * seedCollectionStride();
763  category_i < (seed_collection + 1) * seedCollectionStride();
764  ++category_i)
765  {
766  assert(category_i < stat.size());
767  out += stat[category_i][counter_i];
768  }
769  return out;
770  }

◆ copyCounts()

void ActsTrk::TrackFindingBaseAlg::copyCounts ( const detail::RecoTrackContainer::TrackProxy &  track,
const detail::RecoTrackContainer::TrackProxy &  other 
)
staticprotected

Definition at line 440 of file TrackFindingBaseAlg.cxx.

442  {
443  s_branchState.nPixelHits(track) = s_branchState.nPixelHits(other);
444  s_branchState.nStripHits(track) = s_branchState.nStripHits(other);
445  s_branchState.nHgtdHits(track) = s_branchState.nHgtdHits(other);
446  s_branchState.nPixelHoles(track) = s_branchState.nPixelHoles(other);
447  s_branchState.nStripHoles(track) = s_branchState.nStripHoles(other);
448  s_branchState.nHgtdHoles(track) = s_branchState.nHgtdHoles(other);
449  s_branchState.nPixelOutliers(track) = s_branchState.nPixelOutliers(other);
450  s_branchState.nStripOutliers(track) = s_branchState.nStripOutliers(other);
451  s_branchState.nHgtdOutliers(track) = s_branchState.nHgtdOutliers(other);
452  }

◆ copyStats()

void ActsTrk::TrackFindingBaseAlg::copyStats ( const EventStats &  event_stat) const
protected

Definition at line 550 of file TrackFindingBaseAlg.cxx.

550  {
551  std::lock_guard<std::mutex> lock(m_mutex);
552  std::size_t category_i = 0;
553  for (const std::array<unsigned int, kNStat> &src_stat : event_stat)
554  {
555  std::array<std::size_t, kNStat> &dest_stat = m_stat[category_i++];
556  for (std::size_t i = 0; i < src_stat.size(); ++i)
557  {
558  assert(i < dest_stat.size());
559  dest_stat[i] += src_stat[i];
560  }
561  }
562  }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ doRefit()

template<class MeasurementSource >
std::unique_ptr<Acts::BoundTrackParameters> ActsTrk::TrackFindingBaseAlg::doRefit ( const MeasurementSource &  measurement,
const Acts::BoundTrackParameters &  initialParameters,
const DetectorContextHolder &  detContext,
const bool  paramsAtOutermostSurface 
) const
protected

Perform Kalman Filter fit and update given initialParameters.

Template Parameters
MeasurementSourceType of measurement source: ActsTrk::Seed or (in future) ActsTrk::ProtoTrack
Parameters
measurementMeasurement source for KF
initialParametersParameters to use in KF
detContextStruct holding geometry, magnetic field and calibration contexts
paramsAtOutermostSurfaceFlag for searching in reverse direction
Returns
Unique pointer to updated parameters

◆ doTwoWayTrackFinding()

std::vector< typename detail::RecoTrackContainer::TrackProxy > ActsTrk::TrackFindingBaseAlg::doTwoWayTrackFinding ( const detail::RecoTrackStateContainerProxy &  firstMeasurement,
const TrkProxy &  trackProxy,
detail::RecoTrackContainer &  tracksContainerTemp,
const TrackFinderOptions &  options 
) const
protected

Perform two-way track finding.

Parameters
addTrackFunction or lambda which adds newly found track to container
trackProxyTrack proxy object
tracksContainerTempTrack proxy container
optionsFit options
tgContextGeometry context
reverseSearchFlag for searching in reverse direction
seedTypeSeed type (only used for warnings/debug printouts)
iseedSeed number (only used for warnings/debug printouts)
itrackTrack number (only used for warnings/debug printouts)
Returns
Number of found tracks

Definition at line 235 of file TrackFindingBaseAlg.cxx.

238  {
239  if (not m_doTwoWay) return {};
240 
241  // Create initial parameters for the propagation
242  Acts::BoundTrackParameters secondInitialParameters = trackProxy.createParametersFromState(detail::RecoConstTrackStateContainerProxy{firstMeasurement});
243  if (!secondInitialParameters.referenceSurface().insideBounds(secondInitialParameters.localPosition())) { // #3751
244  return {};
245  }
246 
247  auto rootBranch = tracksContainerTemp.makeTrack();
248  rootBranch.copyFromWithoutStates(trackProxy); // #3534
249  if (m_addCounts) {
250  copyCounts(rootBranch, trackProxy);
251  }
252 
253  // perform track finding
254  auto secondResult =
255  trackFinder().ckf.findTracks(secondInitialParameters, options, tracksContainerTemp, rootBranch);
256  if (not secondResult.ok()) {
257  return {};
258  }
259  return secondResult.value();
260  }

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

Reimplemented in ActsTrk::TrackFindingAlg.

Definition at line 170 of file TrackFindingBaseAlg.cxx.

170  {
171  ATH_MSG_FATAL("execute() method from the base class was called! Implement proper execute() method in the derived class!");
172 
173  return StatusCode::FAILURE;
174  }

◆ 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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
94  return m_extendedExtraObjects;
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ finalize()

StatusCode ActsTrk::TrackFindingBaseAlg::finalize ( )
overridevirtual

Reimplemented in ActsTrk::TrackFindingAlg.

Definition at line 176 of file TrackFindingBaseAlg.cxx.

176  {
177  printStatTables();
178 
179  return StatusCode::SUCCESS;
180  }

◆ getContainersFromKeys()

template<class HandleArrayKeyType , class ContainerType >
StatusCode ActsTrk::TrackFindingBaseAlg::getContainersFromKeys ( const EventContext &  ctx,
HandleArrayKeyType &  handleKeyArray,
std::vector< const ContainerType * > &  outputContainers,
std::size_t &  sum 
) const
protected

Take the array of handle keys and for each key retrieve containers, then append them to the output vector.

Template Parameters
HandleArrayKeyTypeType of the list of handle keys
ContainerTypeType of the output container
Parameters
ctxEvent context
handleKeyArrayList of handle keys
outputContainersVector of output containers
sumNumber of total elements in all retrieved containers
Returns
Status code

◆ getCuts()

const Acts::TrackSelector::Config & ActsTrk::TrackFindingBaseAlg::getCuts ( double  eta) const
protected

Retrieves track selector configuration for given eta value.

Parameters
etatrack candidate eta value

Definition at line 226 of file TrackFindingBaseAlg.cxx.

226  {
227  const auto &trackSelectorCfg = trackFinder().trackSelector.config();
228  // return the last bin for |eta|>=4 or nan
229  return (!(std::abs(eta) < trackSelectorCfg.absEtaEdges.back())) ? trackSelectorCfg.cutSets.back()
230  : (std::abs(eta) < trackSelectorCfg.absEtaEdges.front()) ? trackSelectorCfg.cutSets.front()
231  : trackSelectorCfg.getCuts(eta);
232  };

◆ getDefaultOptions()

TrackFindingBaseAlg::TrackFindingDefaultOptions ActsTrk::TrackFindingBaseAlg::getDefaultOptions ( const DetectorContextHolder &  detContext,
const detail::TrackFindingMeasurements &  measurements,
const Acts::PerigeeSurface *  pSurface 
) const
protected

Get CKF options for first and second pass + pointer to MeasurementSelector.

Parameters
detContextObject holding detector-related context
measurements<easurements container used in MeasurementSelector
pSurfaceRaw pointer to perigee surface

Definition at line 199 of file TrackFindingBaseAlg.cxx.

202  {
203  Acts::PropagatorPlainOptions plainOptions{detContext.geometry, detContext.magField};
204  plainOptions.maxSteps = m_maxPropagationStep;
205  plainOptions.direction = Acts::Direction::Forward();
206  plainOptions.endOfWorldVolumeIds = m_endOfWorldVolumeIds;
207 
208  // Set the CombinatorialKalmanFilter options
209  TrackFinderOptions options(detContext.geometry, detContext.magField, detContext.calib,
210  trackFinder().ckfExtensions, plainOptions, pSurface);
211 
212  std::unique_ptr<ActsTrk::IMeasurementSelector> measurementSelector = setMeasurementSelector(measurements, options);
213 
214  Acts::PropagatorPlainOptions plainSecondOptions{detContext.geometry, detContext.magField};
215  plainSecondOptions.maxSteps = m_maxPropagationStep;
216  plainSecondOptions.direction = plainOptions.direction.invert();
217 
218  TrackFinderOptions secondOptions(detContext.geometry, detContext.magField, detContext.calib,
219  options.extensions, plainSecondOptions, pSurface);
220  secondOptions.targetSurface = pSurface;
221  secondOptions.skipPrePropagationUpdate = true;
222 
223  return {std::move(options), std::move(secondOptions), std::move(measurementSelector)};
224  };

◆ getStatCategory()

std::size_t ActsTrk::TrackFindingBaseAlg::getStatCategory ( std::size_t  seed_collection,
float  eta 
) const
protected

Definition at line 751 of file TrackFindingBaseAlg.cxx.

751  {
752  std::vector<float>::const_iterator bin_iter = std::upper_bound(m_statEtaBins.begin(),
753  m_statEtaBins.end(),
754  m_useAbsEtaForStat ? std::abs(eta) : eta);
755  std::size_t category_i = seed_collection * seedCollectionStride() + static_cast<std::size_t>(bin_iter - m_statEtaBins.begin());
756  assert(category_i < m_stat.size());
757  return category_i;
758  }

◆ initCounts()

void ActsTrk::TrackFindingBaseAlg::initCounts ( const detail::RecoTrackContainer::TrackProxy &  track)
staticprotected

Definition at line 397 of file TrackFindingBaseAlg.cxx.

398  {
399  s_branchState.nPixelHits(track) = 0;
400  s_branchState.nStripHits(track) = 0;
401  s_branchState.nHgtdHits(track) = 0;
402  s_branchState.nPixelHoles(track) = 0;
403  s_branchState.nStripHoles(track) = 0;
404  s_branchState.nHgtdHoles(track) = 0;
405  s_branchState.nPixelOutliers(track) = 0;
406  s_branchState.nStripOutliers(track) = 0;
407  s_branchState.nHgtdOutliers(track) = 0;
408  }

◆ initialize()

StatusCode ActsTrk::TrackFindingBaseAlg::initialize ( )
overridevirtual

Reimplemented in ActsTrk::TrackFindingAlg.

Definition at line 26 of file TrackFindingBaseAlg.cxx.

26  {
27  ATH_MSG_DEBUG("Properties Summary:");
28  ATH_MSG_DEBUG(" " << m_maxPropagationStep);
29  ATH_MSG_DEBUG(" " << m_etaBins);
30  ATH_MSG_DEBUG(" " << m_chi2CutOff);
31  ATH_MSG_DEBUG(" " << m_chi2OutlierCutOff);
32  ATH_MSG_DEBUG(" " << m_numMeasurementsCutOff);
33  ATH_MSG_DEBUG(" " << m_ptMinMeasurements);
34  ATH_MSG_DEBUG(" " << m_absEtaMaxMeasurements);
35  ATH_MSG_DEBUG(" " << m_doBranchStopper);
36  ATH_MSG_DEBUG(" " << m_addCounts);
37  ATH_MSG_DEBUG(" " << m_doTwoWay);
38  ATH_MSG_DEBUG(" " << m_phiMin);
39  ATH_MSG_DEBUG(" " << m_phiMax);
40  ATH_MSG_DEBUG(" " << m_etaMin);
41  ATH_MSG_DEBUG(" " << m_etaMax);
42  ATH_MSG_DEBUG(" " << m_absEtaMin);
43  ATH_MSG_DEBUG(" " << m_absEtaMax);
44  ATH_MSG_DEBUG(" " << m_ptMin);
45  ATH_MSG_DEBUG(" " << m_ptMax);
46  ATH_MSG_DEBUG(" " << m_d0Min);
47  ATH_MSG_DEBUG(" " << m_d0Max);
48  ATH_MSG_DEBUG(" " << m_z0Min);
49  ATH_MSG_DEBUG(" " << m_z0Max);
50  ATH_MSG_DEBUG(" " << m_minMeasurements);
51  ATH_MSG_DEBUG(" " << m_minPixelHits);
52  ATH_MSG_DEBUG(" " << m_minStripHits);
53  ATH_MSG_DEBUG(" " << m_maxHoles);
54  ATH_MSG_DEBUG(" " << m_maxPixelHoles);
55  ATH_MSG_DEBUG(" " << m_maxStripHoles);
56  ATH_MSG_DEBUG(" " << m_maxOutliers);
57  ATH_MSG_DEBUG(" " << m_maxPixelOutliers);
58  ATH_MSG_DEBUG(" " << m_maxStripOutliers);
59  ATH_MSG_DEBUG(" " << m_maxSharedHits);
60  ATH_MSG_DEBUG(" " << m_maxChi2);
61  ATH_MSG_DEBUG(" " << m_branchStopperPtMinFactor);
62  ATH_MSG_DEBUG(" " << m_branchStopperAbsEtaMaxExtra);
63  ATH_MSG_DEBUG(" " << m_branchStopperMeasCutReduce);
64  ATH_MSG_DEBUG(" " << m_branchStopperAbsEtaMeasCut);
65  ATH_MSG_DEBUG(" " << m_endOfWorldVolumeIds);
66 
67  m_logger = makeActsAthenaLogger(this, "Acts");
68 
69  // Read and Write handles
70  ATH_CHECK(m_trackContainerKey.initialize());
71  ATH_CHECK(m_tracksBackendHandlesHelper.initialize(ActsTrk::prefixFromTrackContainerName(m_trackContainerKey.key())));
72 
73  ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
74  ATH_CHECK(m_trackingGeometryTool.retrieve());
75  ATH_CHECK(m_extrapolationTool.retrieve());
76  ATH_CHECK(m_trackStatePrinter.retrieve(EnableTool{not m_trackStatePrinter.empty()}));
77  ATH_CHECK(m_ATLASConverterTool.retrieve());
78  ATH_CHECK(m_fitterTool.retrieve());
79  ATH_CHECK(m_pixelCalibTool.retrieve(EnableTool{not m_pixelCalibTool.empty()}));
80  ATH_CHECK(m_stripCalibTool.retrieve(EnableTool{not m_stripCalibTool.empty()}));
81  ATH_CHECK(m_hgtdCalibTool.retrieve(EnableTool{not m_hgtdCalibTool.empty()}));
82 
83  auto magneticField = std::make_unique<ATLASMagneticFieldWrapper>();
84  auto trackingGeometry = m_trackingGeometryTool->trackingGeometry();
85 
86  detail::Stepper stepper(std::move(magneticField));
87  detail::Navigator::Config config{trackingGeometry};
88  config.resolvePassive = false;
89  config.resolveMaterial = true;
90  config.resolveSensitive = true;
91  detail::Navigator navigator(config, logger().cloneWithSuffix("Navigator"));
92  detail::Propagator propagator(std::move(stepper), std::move(navigator), logger().cloneWithSuffix("Prop"));
93 
94  // Using the CKF propagator as extrapolator
95  detail::Extrapolator extrapolator = propagator;
96 
97  // m_etaBins (from flags.Tracking.ActiveConfig.etaBins) includes a dummy first and last bin, which we ignore
98  std::vector<double> absEtaEdges;
99  if (m_etaBins.size() <= 2)
100  {
101  absEtaEdges.reserve(2ul);
102  absEtaEdges.push_back(0.0);
103  absEtaEdges.push_back(std::numeric_limits<double>::infinity());
104  }
105  else
106  {
107  absEtaEdges.reserve(m_etaBins.size());
108  absEtaEdges.push_back(m_absEtaMin);
109  absEtaEdges.insert(absEtaEdges.end(), m_etaBins.begin() + 1, m_etaBins.end() - 1);
110  absEtaEdges.push_back(m_absEtaMax);
111  }
112 
113  auto setCut = [](auto &cfgVal, const auto &cuts, size_t ind) -> void
114  {
115  if (cuts.empty())
116  return;
117  cfgVal = (ind < cuts.size()) ? cuts[ind] : cuts[cuts.size() - 1];
118  };
119 
120  Acts::TrackSelector::EtaBinnedConfig trackSelectorCfg{std::move(absEtaEdges)};
121  if (m_etaBins.size() <= 2)
122  {
123  assert(trackSelectorCfg.cutSets.size() == 1);
124  trackSelectorCfg.cutSets[0].absEtaMin = m_absEtaMin;
125  trackSelectorCfg.cutSets[0].absEtaMax = m_absEtaMax;
126  }
127  size_t cutIndex = 0;
128  for (auto &cfg : trackSelectorCfg.cutSets)
129  {
130  setCut(cfg.phiMin, m_phiMin, cutIndex);
131  setCut(cfg.phiMax, m_phiMax, cutIndex);
132  setCut(cfg.etaMin, m_etaMin, cutIndex);
133  setCut(cfg.etaMax, m_etaMax, cutIndex);
134  setCut(cfg.ptMin, m_ptMin, cutIndex);
135  setCut(cfg.ptMax, m_ptMax, cutIndex);
136  setCut(cfg.loc0Min, m_d0Min, cutIndex);
137  setCut(cfg.loc0Max, m_d0Max, cutIndex);
138  setCut(cfg.loc1Min, m_z0Min, cutIndex);
139  setCut(cfg.loc1Max, m_z0Max, cutIndex);
140  setCut(cfg.minMeasurements, m_minMeasurements, cutIndex);
141  setCut(cfg.maxHoles, m_maxHoles, cutIndex);
142  setCut(cfg.maxOutliers, m_maxOutliers, cutIndex);
143  setCut(cfg.maxSharedHits, m_maxSharedHits, cutIndex);
144  setCut(cfg.maxChi2, m_maxChi2, cutIndex);
145  ++cutIndex;
146  }
147 
148  ATH_MSG_DEBUG(trackSelectorCfg);
149 
150  // initializer measurement selector and connect it to the delegates of the track finder optins
151  ATH_CHECK(initializeMeasurementSelector());
152 
153  detail::CKF_config ckfConfig{
154  std::move(extrapolator),
155  detail::CKF{std::move(propagator), logger().cloneWithSuffix("CKF")},
156  {},
157  Acts::TrackSelector{trackSelectorCfg}};
158 
159  m_trackFinder = std::make_unique<CKF_pimpl>(std::move(ckfConfig));
160 
161  trackFinder().ckfExtensions.updater.connect<&ActsTrk::detail::FitterHelperFunctions::gainMatrixUpdate<detail::RecoTrackStateContainer>>();
162 
163  m_unalibMeasSurfAcc = detail::xAODUncalibMeasSurfAcc {m_trackingGeometryTool.get()};
164 
165  initStatTables();
166 
167  return StatusCode::SUCCESS;
168  }

◆ initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector ( )
protected

Definition at line 503 of file TrackFindingBaseAlg.cxx.

503  {
504  std::vector<std::pair<float, float> > &chi2CutOffOutlier = m_measurementSelectorConfig.m_chi2CutOffOutlier;
505  chi2CutOffOutlier .reserve( m_chi2CutOff.size() );
506  if (!m_chi2OutlierCutOff.empty()) {
507  if (m_chi2CutOff.size() != m_chi2OutlierCutOff.size()) {
508  ATH_MSG_ERROR("Outlier chi2 cut off provided but number of elements does not agree with"
509  " chi2 cut off for measurements which however is required: "
510  << m_chi2CutOff.size() << " != " << m_chi2OutlierCutOff.size());
511  return StatusCode::FAILURE;
512  }
513  }
514  unsigned int idx=0;
515  for (const auto &elm : m_chi2CutOff) {
516  chi2CutOffOutlier.push_back( std::make_pair(static_cast<float>(elm),
517  idx < m_chi2OutlierCutOff.size()
518  ? static_cast<float>(m_chi2OutlierCutOff[idx])
519  : std::numeric_limits<float>::max()) );
520  ++idx;
521  }
522  if (m_etaBins.size() > 2) {
523  std::vector<float> &etaBinsf = m_measurementSelectorConfig.m_etaBins;
524  etaBinsf.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
525  }
526 
527  return /*m_measurementSelector ?*/ StatusCode::SUCCESS /*: StatusCode::FAILURE*/;
528  }

◆ initStatTables()

void ActsTrk::TrackFindingBaseAlg::initStatTables ( )
protected

Definition at line 532 of file TrackFindingBaseAlg.cxx.

532  {
533  if (!m_statEtaBins.empty())
534  {
535  m_useAbsEtaForStat = (m_statEtaBins[0] > 0.);
536  float last_eta = m_statEtaBins[0];
537  for (float eta : m_statEtaBins)
538  {
539  if (eta < last_eta)
540  {
541  ATH_MSG_FATAL("Eta bins for statistics counter not in ascending order.");
542  }
543  last_eta = eta;
544  }
545  }
546  m_stat.resize(nSeedCollections() * seedCollectionStride());
547  }

◆ 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ logger()

const Acts::Logger& ActsTrk::TrackFindingBaseAlg::logger ( ) const
inlineprotected

Private access to the logger.

Definition at line 320 of file TrackFindingBaseAlg.h.

321  {
322  return *m_logger;
323  }

◆ measurementType()

xAOD::UncalibMeasType ActsTrk::TrackFindingBaseAlg::measurementType ( const detail::RecoTrackContainer::TrackStateProxy &  trackState)
staticprotected

Definition at line 262 of file TrackFindingBaseAlg.cxx.

262  {
263  if (trackState.hasReferenceSurface()) {
264  if (const auto *actsDetElem = dynamic_cast<const IDetectorElementBase *>(trackState.referenceSurface().associatedDetectorElement())) {
265  switch (actsDetElem->detectorType()) {
266  case DetectorType::Pixel:
267  return xAOD::UncalibMeasType::PixelClusterType;
268  case DetectorType::Sct:
269  return xAOD::UncalibMeasType::StripClusterType;
270  case DetectorType::Hgtd:
271  return xAOD::UncalibMeasType::HGTDClusterType;
272  default:
273  break;
274  }
275  }
276  }
277 
278  return xAOD::UncalibMeasType::Other;
279  }

◆ 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::TrackFindingBaseAlg::nSeedCollections ( ) const
inlineprotected

Definition at line 333 of file TrackFindingBaseAlg.h.

333  {
334  return m_seedLabels.size();
335  }

◆ 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::TrackFindingBaseAlg::printStatTables ( ) const
protected

Definition at line 565 of file TrackFindingBaseAlg.cxx.

565  {
566  if (msgLvl(MSG::INFO))
567  {
568  std::vector<std::string> stat_labels =
569  TableUtils::makeLabelVector(kNStat,
570  {
571  std::make_pair(kNTotalSeeds, "Input seeds"),
572  std::make_pair(kNoTrackParam, "No track parameters"),
573  std::make_pair(kNUsedSeeds, "Used seeds"),
574  std::make_pair(kNoTrack, "Cannot find track"),
575  std::make_pair(kNDuplicateSeeds, "Duplicate seeds"),
576  std::make_pair(kNNoEstimatedParams, "Initial param estimation failed"),
577  std::make_pair(kNRejectedRefinedSeeds, "Rejected refined parameters"),
578  std::make_pair(kNOutputTracks, "CKF tracks"),
579  std::make_pair(kNSelectedTracks, "selected tracks"),
580  std::make_pair(kNStoppedTracksMaxHoles, "Stopped tracks reaching max holes"),
581  std::make_pair(kMultipleBranches, "Seeds with more than one branch"),
582  std::make_pair(kNoSecond, "Tracks failing second CKF"),
583  std::make_pair(kNStoppedTracksMinPt, "Stopped tracks below pT cut"),
584  std::make_pair(kNStoppedTracksMaxEta, "Stopped tracks above max eta"),
585  std::make_pair(kNTotalSharedHits, "Total shared hits"),
586  std::make_pair(kNForcedSeedMeasurements, "Total forced measurements")
587  });
588  assert(stat_labels.size() == kNStat);
589  std::vector<std::string> categories;
590  categories.reserve(m_seedLabels.size() + 1);
591  categories.insert(categories.end(), m_seedLabels.begin(), m_seedLabels.end());
592  categories.push_back("ALL");
593 
594  std::vector<std::string> eta_labels;
595  eta_labels.reserve(m_statEtaBins.size() + 2);
596  for (std::size_t eta_bin_i = 0; eta_bin_i < m_statEtaBins.size() + 2; ++eta_bin_i)
597  {
598  eta_labels.push_back(TableUtils::makeEtaBinLabel(m_statEtaBins, eta_bin_i, m_useAbsEtaForStat));
599  }
600 
601  // vector used as 3D array stat[ eta_bin ][ stat_i ][ seed_type]
602  // stat_i = [0, kNStat)
603  // eta_bin = [0, m_statEtaBins.size()+2 ); eta_bin == m_statEtaBinsSize()+1 means sum of all etaBins
604  // seed_type = [0, nSeedCollections()+1) seed_type == nSeedCollections() means sum of all seed collections
605  std::vector<std::size_t> stat =
606  TableUtils::createCounterArrayWithProjections<std::size_t>(nSeedCollections(),
607  m_statEtaBins.size() + 1,
608  m_stat);
609 
610  // the extra columns and rows for the projections are addeded internally:
611  std::size_t stat_stride =
612  TableUtils::counterStride(nSeedCollections(),
613  m_statEtaBins.size() + 1,
614  kNStat);
615  std::size_t eta_stride =
616  TableUtils::subCategoryStride(nSeedCollections(),
617  m_statEtaBins.size() + 1,
618  kNStat);
619  std::stringstream table_out;
620 
621  if (m_dumpAllStatEtaBins.value())
622  {
623  // dump for each counter a table with one row per eta bin
624  std::size_t max_label_width = TableUtils::maxLabelWidth(stat_labels) + TableUtils::maxLabelWidth(eta_labels);
625  for (std::size_t stat_i = 0; stat_i < kNStat; ++stat_i)
626  {
627  std::size_t dest_idx_offset = stat_i * stat_stride;
628  table_out << makeTable(stat, dest_idx_offset, eta_stride,
629  eta_labels,
630  categories)
631  .columnWidth(10)
632  // only dump the footer for the last eta bin i.e. total
633  .dumpHeader(stat_i == 0)
634  .dumpFooter(stat_i + 1 == kNStat)
635  .separateLastRow(true) // separate the sum of all eta bins
636  .minLabelWidth(max_label_width)
637  .labelPrefix(stat_labels.at(stat_i));
638  }
639  }
640  else
641  {
642  // dump one table with one row per counter showing the total eta range
643  for (std::size_t eta_bin_i = (m_dumpAllStatEtaBins.value() ? 0 : m_statEtaBins.size() + 1);
644  eta_bin_i < m_statEtaBins.size() + 2;
645  ++eta_bin_i)
646  {
647  std::size_t dest_idx_offset = eta_bin_i * eta_stride;
648  table_out << makeTable(stat, dest_idx_offset, stat_stride,
649  stat_labels,
650  categories,
651  eta_labels.at(eta_bin_i))
652  .columnWidth(10)
653  // only dump the footer for the last eta bin i.e. total
654  .dumpFooter(!m_dumpAllStatEtaBins.value() || eta_bin_i == m_statEtaBins.size() + 1);
655  }
656  }
657  ATH_MSG_INFO("statistics:\n"
658  << table_out.str());
659  table_out.str("");
660 
661  // define retios first element numerator, second element denominator
662  // each element contains a vector of counter and a multiplier e.g. +- 1
663  // ratios are computed as (sum_i stat[stat_i] * multiplier_i ) / (sum_j stat[stat_j] * multiplier_j )
664  auto [ratio_labels, ratio_def] =
665  TableUtils::splitRatioDefinitionsAndLabels({TableUtils::makeRatioDefinition("failed / seeds ",
666  std::vector<TableUtils::SummandDefinition>{
667  TableUtils::defineSummand(kNTotalSeeds, 1),
668  TableUtils::defineSummand(kNUsedSeeds, -1),
669  TableUtils::defineSummand(kNDuplicateSeeds, -1),
670  // no track counted as used but want to include it as failed
671  TableUtils::defineSummand(kNoTrack, 1),
672  }, // failed seeds i.e. seeds which are not duplicates but did not produce a track
673  std::vector<TableUtils::SummandDefinition>{TableUtils::defineSummand(kNTotalSeeds, 1)}),
674  TableUtils::defineSimpleRatio("duplication / seeds", kNDuplicateSeeds, kNTotalSeeds),
675  TableUtils::defineSimpleRatio("Rejected refined params / seeds", kNRejectedRefinedSeeds, kNTotalSeeds),
676  TableUtils::defineSimpleRatio("selected / CKF tracks", kNSelectedTracks, kNOutputTracks),
677  TableUtils::defineSimpleRatio("selected tracks / used seeds", kNSelectedTracks, kNUsedSeeds),
678  TableUtils::defineSimpleRatio("branched tracks / used seeds", kMultipleBranches, kNUsedSeeds),
679  TableUtils::defineSimpleRatio("no 2nd CKF / CKF tracks", kNoSecond, kNOutputTracks),
680  TableUtils::defineSimpleRatio("shared hits / CKF tracks", kNTotalSharedHits, kNOutputTracks),
681  TableUtils::defineSimpleRatio("forced measurements / used seeds", kNForcedSeedMeasurements, kNUsedSeeds)});
682 
683  std::vector<float> ratio = TableUtils::computeRatios(ratio_def,
684  nSeedCollections() + 1,
685  m_statEtaBins.size() + 2,
686  stat);
687 
688  // the extra columns and rows for the projections are _not_ added internally
689  std::size_t ratio_stride = TableUtils::ratioStride(nSeedCollections() + 1,
690  m_statEtaBins.size() + 2,
691  ratio_def);
692  std::size_t ratio_eta_stride = TableUtils::subCategoryStride(nSeedCollections() + 1,
693  m_statEtaBins.size() + 2,
694  ratio_def);
695 
696  std::size_t max_label_width = TableUtils::maxLabelWidth(ratio_labels) + TableUtils::maxLabelWidth(eta_labels);
697  if (m_dumpAllStatEtaBins.value())
698  {
699  // show for each ratio a table with one row per eta bin
700  for (std::size_t ratio_i = 0; ratio_i < ratio_labels.size(); ++ratio_i)
701  {
702  table_out << makeTable(ratio,
703  ratio_i * ratio_stride,
704  ratio_eta_stride,
705  eta_labels,
706  categories)
707  .columnWidth(10)
708  // only dump the footer for the last eta bin i.e. total
709  .dumpHeader(ratio_i == 0)
710  .dumpFooter(ratio_i + 1 == ratio_labels.size())
711  .separateLastRow(true) // separate the sum of las
712  .minLabelWidth(max_label_width)
713  .labelPrefix(ratio_labels.at(ratio_i));
714  }
715  }
716  else
717  {
718  // dump one table with one row per ratio showing the total eta range
719  table_out << makeTable(ratio,
720  (m_statEtaBins.size() + 1) * ratio_eta_stride + 0 * ratio_stride,
721  ratio_stride,
722  ratio_labels,
723  categories)
724  .columnWidth(10)
725  // only dump the footer for the last eta bin i.e. total
726  .minLabelWidth(max_label_width)
727  .dumpFooter(false);
728 
729  // also dump a table for final tracks over seeds (ratio_i==3) showing one row per eta bin
730  eta_labels.erase(eta_labels.end() - 1); // drop last line of table which shows again all eta bins summed.
731  constexpr std::size_t ratio_i = 3;
732  table_out << makeTable(ratio,
733  ratio_i * ratio_stride,
734  ratio_eta_stride,
735  eta_labels,
736  categories)
737  .columnWidth(10)
738  .dumpHeader(false)
739  // only dump the footer for the last eta bin i.e. total
740  .dumpFooter(!m_dumpAllStatEtaBins.value() || ratio_i + 1 == ratio_labels.size())
741  .separateLastRow(false)
742  .minLabelWidth(max_label_width)
743  .labelPrefix(ratio_labels.at(ratio_i));
744  }
745 
746  ATH_MSG_INFO("Ratios:\n"
747  << table_out.str());
748  }
749  }

◆ 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::TrackFindingBaseAlg::seedCollectionStride ( ) const
inlineprotected

Definition at line 336 of file TrackFindingBaseAlg.h.

336  {
337  return m_statEtaBins.size() + 1;
338  }

◆ selectCounts()

std::array< bool, 3 > ActsTrk::TrackFindingBaseAlg::selectCounts ( const detail::RecoTrackContainer::TrackProxy &  track,
double  eta 
) const
protected

Definition at line 477 of file TrackFindingBaseAlg.cxx.

477  {
478  bool enoughMeasurements = true, tooManyHoles = false, tooManyOutliers = false;
479  const auto &trackSelectorCfg = trackFinder().trackSelector.config();
480  std::size_t etaBin = (std::abs(eta) < trackSelectorCfg.absEtaEdges.front()) ? 0
481  : (std::abs(eta) >= trackSelectorCfg.absEtaEdges.back()) ? trackSelectorCfg.absEtaEdges.size() - 1
482  : trackSelectorCfg.binIndex(eta);
483  auto cutMin = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
484  return !cutSet.empty() && (val < (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
485  };
486  auto cutMax = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
487  return !cutSet.empty() && (val > (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
488  };
489 
490  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nPixelHits(track), m_minPixelHits);
491  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nStripHits(track), m_minStripHits);
492  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nHgtdHits(track), m_minHgtdHits);
493  tooManyHoles = tooManyHoles || cutMax(s_branchState.nPixelHoles(track), m_maxPixelHoles);
494  tooManyHoles = tooManyHoles || cutMax(s_branchState.nStripHoles(track), m_maxStripHoles);
495  tooManyHoles = tooManyHoles || cutMax(s_branchState.nHgtdHoles(track), m_maxHgtdHoles);
496  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nPixelOutliers(track), m_maxPixelOutliers);
497  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nStripOutliers(track), m_maxStripOutliers);
498  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nHgtdOutliers(track), m_maxHgtdOutliers);
499 
500  return {enoughMeasurements, tooManyHoles, tooManyOutliers};
501  }

◆ selectCountsFinal()

bool ActsTrk::TrackFindingBaseAlg::selectCountsFinal ( const detail::RecoTrackContainer::TrackProxy &  track) const
protected

Definition at line 772 of file TrackFindingBaseAlg.cxx.

772  {
773  if (not m_addCounts) return true;
774  double eta = -std::log(std::tan(0.5 * track.theta()));
775  auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] = selectCounts(track, eta);
776  return enoughMeasurementsPS && !tooManyHolesPS && !tooManyOutliersPS;
777  }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ setMeasurementSelector()

std::unique_ptr< ActsTrk::IMeasurementSelector > ActsTrk::TrackFindingBaseAlg::setMeasurementSelector ( const detail::TrackFindingMeasurements &  measurements,
TrackFinderOptions &  options 
) const
protected

Setup and attach measurement selector to KF options.

Parameters
measurementsmeasurements container used in MeasurementSelector
optionsKalman filter options
Returns
unique_ptr to MeasurementSelector

Definition at line 182 of file TrackFindingBaseAlg.cxx.

184  {
185  ATH_MSG_DEBUG(name() << "::" << __FUNCTION__);
186 
187  std::unique_ptr<ActsTrk::IMeasurementSelector> measurementSelector = ActsTrk::detail::getMeasurementSelector(
188  m_pixelCalibTool.isEnabled() ? &(*m_pixelCalibTool) : nullptr,
189  measurements.measurementRanges(),
190  m_measurementSelectorConfig.m_etaBins,
191  m_measurementSelectorConfig.m_chi2CutOffOutlier,
192  m_numMeasurementsCutOff.value());
193 
194  measurementSelector->connect(&options.extensions.createTrackStates);
195 
196  return measurementSelector;
197  }

◆ stopBranch()

TrackFindingBaseAlg::BranchStopperResult ActsTrk::TrackFindingBaseAlg::stopBranch ( const detail::RecoTrackContainer::TrackProxy &  track,
const detail::RecoTrackContainer::TrackStateProxy &  trackState,
const Acts::TrackSelector::EtaBinnedConfig &  trackSelectorCfg,
const Acts::GeometryContext &  tgContext,
const detail::MeasurementIndex &  measurementIndex,
const std::size_t  typeIndex,
EventStats::value_type &  event_stat_category_i 
) const
protected

Branch stopper.

Parameters
trackTrack proxy object
trackStateTrack state proxy object
trackSelectorCfgTrack selector configuration
tgContextGeometry context
measurementIndexMeasurement index
typeIndexType index
event_stat_category_iEvent statistics for current category
Returns
BranchStopperResult

Definition at line 281 of file TrackFindingBaseAlg.cxx.

288  {
289  if (m_addCounts) {
290  updateCounts(track, trackState.typeFlags(),
291  measurementType(trackState));
292  checkCounts(track);
293  }
294 
295  if (m_trackStatePrinter.isSet()) {
296  m_trackStatePrinter->printTrackState(tgContext, trackState,
297  measurementIndex, true);
298  }
299 
300  if (!m_doBranchStopper) {
301  return BranchStopperResult::Continue;
302  }
303 
304  const auto &parameters = trackState.hasFiltered() ? trackState.filtered()
305  : trackState.predicted();
306  double eta = -std::log(std::tan(0.5 * parameters[Acts::eBoundTheta]));
307  const auto &cutSet = getCuts(eta);
308 
309  if (typeIndex < m_ptMinMeasurements.size() &&
310  !(track.nMeasurements() < m_ptMinMeasurements[typeIndex])) {
311  double pT = std::sin(parameters[Acts::eBoundTheta]) /
312  parameters[Acts::eBoundQOverP];
313  if (std::abs(pT) < cutSet.ptMin * m_branchStopperPtMinFactor) {
314  ++event_stat_category_i[kNStoppedTracksMinPt];
315  ATH_MSG_DEBUG("CkfBranchStopper: drop branch with q*pT="
316  << pT << " after " << track.nMeasurements()
317  << " measurements");
318  return BranchStopperResult::StopAndDrop;
319  }
320  }
321 
322  if (typeIndex < m_absEtaMaxMeasurements.size() &&
323  !(track.nMeasurements() < m_absEtaMaxMeasurements[typeIndex]) &&
324  !(std::abs(eta) < trackSelectorCfg.absEtaEdges.back() +
325  m_branchStopperAbsEtaMaxExtra)) {
326  ++event_stat_category_i[kNStoppedTracksMaxEta];
327  ATH_MSG_DEBUG("CkfBranchStopper: drop branch with eta="
328  << eta << " after " << track.nMeasurements()
329  << " measurements");
330  return BranchStopperResult::StopAndDrop;
331  }
332 
333 
334  // In the pixel endcap regions relax the requirement for minMeasurements before cutting the branch off
335  auto minMeasurementsBranchStop = std::abs(eta) > m_branchStopperAbsEtaMeasCut ? cutSet.minMeasurements - m_branchStopperMeasCutReduce : cutSet.minMeasurements;
336  bool enoughMeasurements = (track.nMeasurements() >= minMeasurementsBranchStop);
337  bool tooManyHoles = (track.nHoles() > cutSet.maxHoles);
338  bool tooManyOutliers = (track.nOutliers() > cutSet.maxOutliers);
339 
340  if (m_addCounts) {
341  auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] =
342  selectCounts(track, eta);
343  enoughMeasurements = enoughMeasurements && enoughMeasurementsPS;
344  tooManyHoles = tooManyHoles || tooManyHolesPS;
345  tooManyOutliers = tooManyOutliers || tooManyOutliersPS;
346  }
347 
348  if (!(tooManyHoles || tooManyOutliers)) {
349  return BranchStopperResult::Continue;
350  }
351 
352  if (!enoughMeasurements) {
353  ++event_stat_category_i[kNStoppedTracksMaxHoles];
354  }
355 
356  if (m_addCounts) {
357  ATH_MSG_DEBUG("CkfBranchStopper: stop and "
358  << (enoughMeasurements ? "keep" : "drop")
359  << " branch with nHoles=" << track.nHoles() << " ("
360  << s_branchState.nPixelHoles(track) << " pixel+"
361  << s_branchState.nStripHoles(track) << " strip+"
362  << s_branchState.nHgtdHoles(track)
363  << " hgtd), nOutliers=" << track.nOutliers() << " ("
364  << s_branchState.nPixelOutliers(track) << "+"
365  << s_branchState.nStripOutliers(track) << "+"
366  << s_branchState.nHgtdOutliers(track)
367  << "), nMeasurements=" << track.nMeasurements() << " ("
368  << s_branchState.nPixelHits(track) << "+"
369  << s_branchState.nStripHits(track) << "+"
370  << s_branchState.nHgtdHits(track) << ")");
371  } else {
372  ATH_MSG_DEBUG("CkfBranchStopper: stop and "
373  << (enoughMeasurements ? "keep" : "drop")
374  << " branch with nHoles=" << track.nHoles()
375  << ", nOutliers=" << track.nOutliers()
376  << ", nMeasurements=" << track.nMeasurements());
377  }
378 
379  return enoughMeasurements ? BranchStopperResult::StopAndKeep
380  : BranchStopperResult::StopAndDrop;
381  }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
108  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

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

TrackFindingBaseAlg::CKF_pimpl & ActsTrk::TrackFindingBaseAlg::trackFinder ( )
protected

Definition at line 19 of file TrackFindingBaseAlg.cxx.

19 { return *m_trackFinder; }

◆ trackFinder() [2/2]

const TrackFindingBaseAlg::CKF_pimpl & ActsTrk::TrackFindingBaseAlg::trackFinder ( ) const
protected

Definition at line 20 of file TrackFindingBaseAlg.cxx.

20 { return *m_trackFinder; }

◆ updateCounts()

void ActsTrk::TrackFindingBaseAlg::updateCounts ( const detail::RecoTrackContainer::TrackProxy &  track,
Acts::ConstTrackStateType  typeFlags,
xAOD::UncalibMeasType  detType 
)
staticprotected

Definition at line 410 of file TrackFindingBaseAlg.cxx.

412  {
413  if (detType == xAOD::UncalibMeasType::PixelClusterType) {
414  if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
415  s_branchState.nPixelHoles(track)++;
416  } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
417  s_branchState.nPixelOutliers(track)++;
418  } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
419  s_branchState.nPixelHits(track)++;
420  }
421  } else if (detType == xAOD::UncalibMeasType::StripClusterType) {
422  if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
423  s_branchState.nStripHoles(track)++;
424  } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
425  s_branchState.nStripOutliers(track)++;
426  } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
427  s_branchState.nStripHits(track)++;
428  }
429  } else if (detType == xAOD::UncalibMeasType::HGTDClusterType) {
430  if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
431  s_branchState.nHgtdHoles(track)++;
432  } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
433  s_branchState.nHgtdOutliers(track)++;
434  } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
435  s_branchState.nHgtdHits(track)++;
436  }
437  }
438  }

◆ 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::TrackFindingBaseAlg::ATLAS_THREAD_SAFE
mutableprotected

Definition at line 343 of file TrackFindingBaseAlg.h.

◆ ATLAS_THREAD_SAFE [2/2]

std::vector<std::array<std::size_t, kNStat> > m_stat ActsTrk::TrackFindingBaseAlg::ATLAS_THREAD_SAFE {}
mutableprotected

Definition at line 344 of file TrackFindingBaseAlg.h.

◆ m_absEtaMax

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

Definition at line 123 of file TrackFindingBaseAlg.h.

◆ m_absEtaMaxMeasurements

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

Definition at line 108 of file TrackFindingBaseAlg.h.

◆ m_absEtaMin

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

Definition at line 122 of file TrackFindingBaseAlg.h.

◆ m_addCounts

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_addCounts {this, "addCounts", true, "keep separate pixel, strip and hgtd counts and apply the following cuts"}
protected

Definition at line 137 of file TrackFindingBaseAlg.h.

◆ m_ATLASConverterTool

ToolHandle<ActsTrk::IActsToTrkConverterTool > ActsTrk::TrackFindingBaseAlg::m_ATLASConverterTool {this, "ATLASConverterTool", ""}
protected

Definition at line 91 of file TrackFindingBaseAlg.h.

◆ m_branchStopperAbsEtaMaxExtra

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

Definition at line 112 of file TrackFindingBaseAlg.h.

◆ m_branchStopperAbsEtaMeasCut

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_branchStopperAbsEtaMeasCut {this, "branchStopperAbsEtaMeasCut", 1.2, "the minimum |eta| to apply the reduction to the minMeas requirement for the branch stopper"}
protected

Definition at line 114 of file TrackFindingBaseAlg.h.

◆ m_branchStopperMeasCutReduce

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_branchStopperMeasCutReduce {this, "branchStopperMeasCutReduce", 2, "how much to reduce the minMeas requirement for the branch stopper"}
protected

Definition at line 113 of file TrackFindingBaseAlg.h.

◆ m_branchStopperPtMinFactor

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

Definition at line 111 of file TrackFindingBaseAlg.h.

◆ m_chi2CutOff

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

Definition at line 104 of file TrackFindingBaseAlg.h.

◆ m_chi2OutlierCutOff

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

Definition at line 105 of file TrackFindingBaseAlg.h.

◆ m_d0Max

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

Definition at line 127 of file TrackFindingBaseAlg.h.

◆ m_d0Min

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

Definition at line 126 of file TrackFindingBaseAlg.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::TrackFindingBaseAlg::m_doBranchStopper {this, "doBranchStopper", true, "use branch stopper"}
protected

Definition at line 109 of file TrackFindingBaseAlg.h.

◆ m_doTwoWay

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

Definition at line 110 of file TrackFindingBaseAlg.h.

◆ m_dumpAllStatEtaBins

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

Definition at line 153 of file TrackFindingBaseAlg.h.

◆ m_endOfWorldVolumeIds

Gaudi::Property<std::vector<std::uint32_t> > ActsTrk::TrackFindingBaseAlg::m_endOfWorldVolumeIds {this, "EndOfTheWorldVolumeIds", {}, ""}
protected

Definition at line 148 of file TrackFindingBaseAlg.h.

◆ m_etaBins

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

Definition at line 102 of file TrackFindingBaseAlg.h.

◆ m_etaMax

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

Definition at line 121 of file TrackFindingBaseAlg.h.

◆ m_etaMin

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

Definition at line 120 of file TrackFindingBaseAlg.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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_extrapolationTool

ToolHandle<IActsExtrapolationTool> ActsTrk::TrackFindingBaseAlg::m_extrapolationTool {this, "ExtrapolationTool", ""}
protected

Definition at line 88 of file TrackFindingBaseAlg.h.

◆ m_fitterTool

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

Definition at line 92 of file TrackFindingBaseAlg.h.

◆ m_hgtdCalibTool

ToolHandle<ActsTrk::IOnTrackCalibratorTool<detail::RecoTrackStateContainer> > ActsTrk::TrackFindingBaseAlg::m_hgtdCalibTool {this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"}
protected

Definition at line 95 of file TrackFindingBaseAlg.h.

◆ m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::TrackFindingBaseAlg::m_logger
protected

logging instance

Definition at line 326 of file TrackFindingBaseAlg.h.

◆ m_maxChi2

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

Definition at line 135 of file TrackFindingBaseAlg.h.

◆ m_maxHgtdHoles

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxHgtdHoles {this, "maxHgtdHoles", {}, "maximum number of hgtd holes"}
protected

Definition at line 143 of file TrackFindingBaseAlg.h.

◆ m_maxHgtdOutliers

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxHgtdOutliers {this, "maxHgtdOutliers", {}, "maximum number of hgtd outliers"}
protected

Definition at line 146 of file TrackFindingBaseAlg.h.

◆ m_maxHoles

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

Definition at line 132 of file TrackFindingBaseAlg.h.

◆ m_maxOutliers

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

Definition at line 133 of file TrackFindingBaseAlg.h.

◆ m_maxPixelHoles

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

Definition at line 141 of file TrackFindingBaseAlg.h.

◆ m_maxPixelOutliers

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

Definition at line 144 of file TrackFindingBaseAlg.h.

◆ m_maxPropagationStep

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

Definition at line 101 of file TrackFindingBaseAlg.h.

◆ m_maxSharedHits

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

Definition at line 134 of file TrackFindingBaseAlg.h.

◆ m_maxStripHoles

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

Definition at line 142 of file TrackFindingBaseAlg.h.

◆ m_maxStripOutliers

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

Definition at line 145 of file TrackFindingBaseAlg.h.

◆ m_measurementSelectorConfig

struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig ActsTrk::TrackFindingBaseAlg::m_measurementSelectorConfig
protected

◆ m_minHgtdHits

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_minHgtdHits {this, "minHgtdHits", {}, "minimum number of hgtd hits"}
protected

Definition at line 140 of file TrackFindingBaseAlg.h.

◆ m_minMeasurements

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

Definition at line 131 of file TrackFindingBaseAlg.h.

◆ m_minPixelHits

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

Definition at line 138 of file TrackFindingBaseAlg.h.

◆ m_minStripHits

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

Definition at line 139 of file TrackFindingBaseAlg.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> ActsTrk::TrackFindingBaseAlg::m_monTool {this, "MonTool", "", "Monitoring tool"}
protected

Definition at line 87 of file TrackFindingBaseAlg.h.

◆ m_numMeasurementsCutOff

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

Definition at line 106 of file TrackFindingBaseAlg.h.

◆ m_phiMax

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

Definition at line 119 of file TrackFindingBaseAlg.h.

◆ m_phiMin

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

Definition at line 118 of file TrackFindingBaseAlg.h.

◆ m_pixelCalibTool

ToolHandle<ActsTrk::IOnTrackCalibratorTool<detail::RecoTrackStateContainer> > ActsTrk::TrackFindingBaseAlg::m_pixelCalibTool {this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"}
protected

Definition at line 93 of file TrackFindingBaseAlg.h.

◆ m_ptMax

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

Definition at line 125 of file TrackFindingBaseAlg.h.

◆ m_ptMin

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

Definition at line 124 of file TrackFindingBaseAlg.h.

◆ m_ptMinMeasurements

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

Definition at line 107 of file TrackFindingBaseAlg.h.

◆ m_seedLabels

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

Definition at line 152 of file TrackFindingBaseAlg.h.

◆ m_statEtaBins

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

Definition at line 151 of file TrackFindingBaseAlg.h.

◆ m_stripCalibTool

ToolHandle<ActsTrk::IOnTrackCalibratorTool<detail::RecoTrackStateContainer> > ActsTrk::TrackFindingBaseAlg::m_stripCalibTool {this, "StripCalibrator", "", "Opt. strip measurement calibrator"}
protected

Definition at line 94 of file TrackFindingBaseAlg.h.

◆ m_trackContainerKey

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

Definition at line 97 of file TrackFindingBaseAlg.h.

◆ m_trackFinder

std::unique_ptr<CKF_pimpl> ActsTrk::TrackFindingBaseAlg::m_trackFinder
protected

Definition at line 81 of file TrackFindingBaseAlg.h.

◆ m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ActsTrk::TrackFindingBaseAlg::m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
protected

Definition at line 89 of file TrackFindingBaseAlg.h.

◆ m_tracksBackendHandlesHelper

ActsTrk::MutableTrackContainerHandlesHelper ActsTrk::TrackFindingBaseAlg::m_tracksBackendHandlesHelper {this}
protected

Definition at line 98 of file TrackFindingBaseAlg.h.

◆ m_trackStatePrinter

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

Definition at line 90 of file TrackFindingBaseAlg.h.

◆ m_unalibMeasSurfAcc

detail::xAODUncalibMeasSurfAcc ActsTrk::TrackFindingBaseAlg::m_unalibMeasSurfAcc {}
protected

Definition at line 83 of file TrackFindingBaseAlg.h.

◆ m_useAbsEtaForStat

bool ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat = false
protected

Definition at line 342 of file TrackFindingBaseAlg.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::TrackFindingBaseAlg::m_z0Max {this, "z0Max", {}, "TrackSelector: z0Max"}
protected

Definition at line 129 of file TrackFindingBaseAlg.h.

◆ m_z0Min

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

Definition at line 128 of file TrackFindingBaseAlg.h.

◆ s_branchState

constexpr BranchState ActsTrk::TrackFindingBaseAlg::s_branchState {}
staticconstexprprotected

Definition at line 305 of file TrackFindingBaseAlg.h.

The documentation for this class was generated from the following files:
ActsTrk::TrackFindingBaseAlg::m_trackContainerKey
SG::WriteHandleKey< ActsTrk::TrackContainer > m_trackContainerKey
Definition: TrackFindingBaseAlg.h:97
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nPixelOutliers
Definition: TrackFindingBaseAlg.h:301
ActsTrk::TrackFindingBaseAlg::m_d0Min
Gaudi::Property< std::vector< double > > m_d0Min
Definition: TrackFindingBaseAlg.h:126
ActsTrk::TrackFindingBaseAlg::m_doBranchStopper
Gaudi::Property< bool > m_doBranchStopper
Definition: TrackFindingBaseAlg.h:109
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
ActsTrk::detail::getMeasurementSelector
std::unique_ptr< ActsTrk::IMeasurementSelector > getMeasurementSelector(const ActsTrk::IOnBoundStateCalibratorTool *onTrackCalibratorTool, const ActsTrk::detail::MeasurementRangeList &measurementRanges, const std::vector< float > &etaBinsf, const std::vector< std::pair< float, float > > &chi2CutOffOutlier, const std::vector< size_t > &numMeasurementsCutOff)
Definition: AtlasMeasurementSelector.cxx:404
ActsTrk::TrackFindingBaseAlg::m_absEtaMax
Gaudi::Property< double > m_absEtaMax
Definition: TrackFindingBaseAlg.h:123
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ActsTrk::TrackFindingBaseAlg::kNStat
@ kNStat
Definition: TrackFindingBaseAlg.h:173
xAOD::UncalibMeasType::HGTDClusterType
@ HGTDClusterType
ActsTrk::TrackFindingBaseAlg::m_pixelCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_pixelCalibTool
Definition: TrackFindingBaseAlg.h:93
ActsTrk::TrackFindingBaseAlg::m_maxStripHoles
Gaudi::Property< std::vector< std::size_t > > m_maxStripHoles
Definition: TrackFindingBaseAlg.h:142
ActsTrk::IMeasurementSelector::connect
virtual void connect(std::any delegate_wrap) const =0
ActsTrk::TrackFindingBaseAlg::m_z0Max
Gaudi::Property< std::vector< double > > m_z0Max
Definition: TrackFindingBaseAlg.h:129
ActsTrk::TrackFindingBaseAlg::s_branchState
static constexpr BranchState s_branchState
Definition: TrackFindingBaseAlg.h:305
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ActsTrk::TrackFindingBaseAlg::m_unalibMeasSurfAcc
detail::xAODUncalibMeasSurfAcc m_unalibMeasSurfAcc
Definition: TrackFindingBaseAlg.h:83
ActsTrk::TrackFindingBaseAlg::TrackFinderOptions
Acts::CombinatorialKalmanFilterOptions< detail::RecoTrackContainer > TrackFinderOptions
Definition: TrackFindingBaseAlg.h:54
ActsTrk::TrackFindingBaseAlg::updateCounts
static void updateCounts(const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateType typeFlags, xAOD::UncalibMeasType detType)
Definition: TrackFindingBaseAlg.cxx:410
ActsTrk::TrackFindingBaseAlg::m_tracksBackendHandlesHelper
ActsTrk::MutableTrackContainerHandlesHelper m_tracksBackendHandlesHelper
Definition: TrackFindingBaseAlg.h:98
ActsTrk::TrackFindingBaseAlg::kNoSecond
@ kNoSecond
Definition: TrackFindingBaseAlg.h:168
ActsTrk::TrackFindingBaseAlg::m_phiMax
Gaudi::Property< std::vector< double > > m_phiMax
Definition: TrackFindingBaseAlg.h:119
ActsTrk::TrackFindingBaseAlg::m_etaMin
Gaudi::Property< std::vector< double > > m_etaMin
Definition: TrackFindingBaseAlg.h:120
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
ActsTrk::TrackFindingBaseAlg::m_addCounts
Gaudi::Property< bool > m_addCounts
Definition: TrackFindingBaseAlg.h:137
ActsTrk::detail::Navigator
Acts::Navigator Navigator
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:31
ActsTrk::TrackFindingBaseAlg::m_maxHoles
Gaudi::Property< std::vector< std::size_t > > m_maxHoles
Definition: TrackFindingBaseAlg.h:132
xAOD::UncalibMeasType::StripClusterType
@ StripClusterType
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
ActsTrk::TrackFindingBaseAlg::m_maxHgtdHoles
Gaudi::Property< std::vector< std::size_t > > m_maxHgtdHoles
Definition: TrackFindingBaseAlg.h:143
ActsTrk::TrackFindingBaseAlg::m_minHgtdHits
Gaudi::Property< std::vector< std::size_t > > m_minHgtdHits
Definition: TrackFindingBaseAlg.h:140
ActsTrk::detail::CKF_config::trackSelector
Acts::TrackSelector trackSelector
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:48
ActsTrk::detail::Extrapolator
Propagator Extrapolator
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:34
ActsTrk::TrackFindingBaseAlg::m_maxPixelHoles
Gaudi::Property< std::vector< std::size_t > > m_maxPixelHoles
Definition: TrackFindingBaseAlg.h:141
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::TrackFindingBaseAlg::m_dumpAllStatEtaBins
Gaudi::Property< bool > m_dumpAllStatEtaBins
Definition: TrackFindingBaseAlg.h:153
ActsTrk::TrackFindingBaseAlg::BranchState::nHgtdHits
static constexpr Acts::ProxyAccessor< unsigned int > nHgtdHits
Definition: TrackFindingBaseAlg.h:297
ActsTrk::TrackFindingBaseAlg::m_maxChi2
Gaudi::Property< std::vector< double > > m_maxChi2
Definition: TrackFindingBaseAlg.h:135
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
ActsTrk::TrackFindingBaseAlg::m_absEtaMaxMeasurements
Gaudi::Property< std::vector< std::size_t > > m_absEtaMaxMeasurements
Definition: TrackFindingBaseAlg.h:108
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
ActsTrk::TrackFindingBaseAlg::m_hgtdCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_hgtdCalibTool
Definition: TrackFindingBaseAlg.h:95
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
ActsTrk::TrackFindingBaseAlg::printStatTables
void printStatTables() const
Definition: TrackFindingBaseAlg.cxx:565
TableUtils::defineSimpleRatio
RatioDefinition defineSimpleRatio(T numerator, T denominator)
Definition: TableUtils.h:384
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:20
ActsTrk::TrackFindingBaseAlg::kNUsedSeeds
@ kNUsedSeeds
Definition: TrackFindingBaseAlg.h:159
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelHits
static constexpr Acts::ProxyAccessor< unsigned int > nPixelHits
Definition: TrackFindingBaseAlg.h:295
ActsTrk::DetectorType::Sct
@ Sct
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
ActsTrk::TrackFindingBaseAlg::m_branchStopperAbsEtaMaxExtra
Gaudi::Property< double > m_branchStopperAbsEtaMaxExtra
Definition: TrackFindingBaseAlg.h:112
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
ActsTrk::TrackFindingBaseAlg::m_chi2OutlierCutOff
Gaudi::Property< std::vector< double > > m_chi2OutlierCutOff
Definition: TrackFindingBaseAlg.h:105
ActsTrk::TrackFindingBaseAlg::m_ATLASConverterTool
ToolHandle< ActsTrk::IActsToTrkConverterTool > m_ATLASConverterTool
Definition: TrackFindingBaseAlg.h:91
ActsTrk::TrackFindingBaseAlg::m_maxOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxOutliers
Definition: TrackFindingBaseAlg.h:133
ActsTrk::TrackFindingBaseAlg::BranchState::nStripHoles
static constexpr Acts::ProxyAccessor< unsigned int > nStripHoles
Definition: TrackFindingBaseAlg.h:299
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
ActsTrk::TrackFindingBaseAlg::initStatTables
void initStatTables()
Definition: TrackFindingBaseAlg.cxx:532
ActsTrk::TrackFindingBaseAlg::trackFinder
CKF_pimpl & trackFinder()
Definition: TrackFindingBaseAlg.cxx:19
config
Definition: PhysicsAnalysis/AnalysisCommon/AssociationUtils/python/config.py:1
ActsTrk::TrackFindingBaseAlg::kMultipleBranches
@ kMultipleBranches
Definition: TrackFindingBaseAlg.h:167
ActsTrk::MutableTrackContainerHandlesHelper::initialize
StatusCode initialize(const std::string &prefix)
Sets up the handles.
Definition: TrackContainerHandlesHelper.cxx:47
ActsTrk::TrackFindingBaseAlg::kNoTrackParam
@ kNoTrackParam
Definition: TrackFindingBaseAlg.h:158
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
ActsTrk::TrackFindingBaseAlg::m_etaMax
Gaudi::Property< std::vector< double > > m_etaMax
Definition: TrackFindingBaseAlg.h:121
ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig::m_chi2CutOffOutlier
std::vector< std::pair< float, float > > m_chi2CutOffOutlier
Definition: TrackFindingBaseAlg.h:57
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
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:304
ActsTrk::TrackFindingBaseAlg::m_endOfWorldVolumeIds
Gaudi::Property< std::vector< std::uint32_t > > m_endOfWorldVolumeIds
Definition: TrackFindingBaseAlg.h:148
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMinPt
@ kNStoppedTracksMinPt
Definition: TrackFindingBaseAlg.h:169
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
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::TrackFindingBaseAlg::checkCounts
void checkCounts(const detail::RecoTrackContainer::TrackProxy &track) const
Definition: TrackFindingBaseAlg.cxx:454
ActsTrk::TrackFindingBaseAlg::m_maxSharedHits
Gaudi::Property< std::vector< std::size_t > > m_maxSharedHits
Definition: TrackFindingBaseAlg.h:134
ActsTrk::TrackFindingBaseAlg::m_branchStopperPtMinFactor
Gaudi::Property< double > m_branchStopperPtMinFactor
Definition: TrackFindingBaseAlg.h:111
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
ActsTrk::TrackFindingBaseAlg::setMeasurementSelector
std::unique_ptr< ActsTrk::IMeasurementSelector > setMeasurementSelector(const detail::TrackFindingMeasurements &measurements, TrackFinderOptions &options) const
Setup and attach measurement selector to KF options.
Definition: TrackFindingBaseAlg.cxx:182
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
ActsTrk::TrackFindingBaseAlg::m_phiMin
Gaudi::Property< std::vector< double > > m_phiMin
Definition: TrackFindingBaseAlg.h:118
ActsTrk::TrackFindingBaseAlg::m_minMeasurements
Gaudi::Property< std::vector< std::size_t > > m_minMeasurements
Definition: TrackFindingBaseAlg.h:131
mergePhysValFiles.categories
categories
Definition: PhysicsAnalysis/JetTagging/JetTagValidation/JetTagDQA/scripts/mergePhysValFiles.py:17
xAOD::etaBin
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap etaBin
Definition: L2StandAloneMuon_v1.cxx:149
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
ActsTrk::TrackFindingBaseAlg::m_chi2CutOff
Gaudi::Property< std::vector< double > > m_chi2CutOff
Definition: TrackFindingBaseAlg.h:104
AthCommonDataStore
Definition: AthCommonDataStore.h:52
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:309
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ActsTrk::DetectorType::Pixel
@ Pixel
Inner detector legacy.
makeTable
TableUtils::StatTable< T > makeTable(const std::array< T, N > &counter, const std::array< std::string, N > &label)
Definition: TableUtils.h:523
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
ActsTrk::detail::RecoConstTrackStateContainerProxy
RecoTrackStateContainer::ConstTrackStateProxy RecoConstTrackStateContainerProxy
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:26
TableUtils::maxLabelWidth
std::size_t maxLabelWidth(const T_Collection &col)
Definition: TableUtils.h:290
lumiFormat.i
int i
Definition: lumiFormat.py:85
ActsTrk::TrackFindingBaseAlg::kNOutputTracks
@ kNOutputTracks
Definition: TrackFindingBaseAlg.h:163
ActsTrk::TrackFindingBaseAlg::m_branchStopperMeasCutReduce
Gaudi::Property< double > m_branchStopperMeasCutReduce
Definition: TrackFindingBaseAlg.h:113
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
ActsTrk::TrackFindingBaseAlg::seedCollectionStride
std::size_t seedCollectionStride() const
Definition: TrackFindingBaseAlg.h:336
ActsTrk::TrackFindingBaseAlg::m_seedLabels
Gaudi::Property< std::vector< std::string > > m_seedLabels
Definition: TrackFindingBaseAlg.h:152
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
ActsTrk::TrackFindingBaseAlg::m_maxPixelOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxPixelOutliers
Definition: TrackFindingBaseAlg.h:144
ActsTrk::TrackFindingBaseAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrackFindingBaseAlg.h:87
ActsTrk::TrackFindingBaseAlg::m_d0Max
Gaudi::Property< std::vector< double > > m_d0Max
Definition: TrackFindingBaseAlg.h:127
ActsTrk::TrackFindingBaseAlg::BranchState::nStripOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nStripOutliers
Definition: TrackFindingBaseAlg.h:302
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:92
ActsTrk::TrackFindingBaseAlg::measurementType
static xAOD::UncalibMeasType measurementType(const detail::RecoTrackContainer::TrackStateProxy &trackState)
Definition: TrackFindingBaseAlg.cxx:262
xAOD::Other
@ Other
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsTrk::TrackFindingBaseAlg::m_branchStopperAbsEtaMeasCut
Gaudi::Property< double > m_branchStopperAbsEtaMeasCut
Definition: TrackFindingBaseAlg.h:114
python.AtlRunQueryLib.options
options
Definition: AtlRunQueryLib.py:378
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
detail::ul
unsigned long ul
Definition: PrimitiveHelpers.h:46
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::TrackFindingBaseAlg::selectCounts
std::array< bool, 3 > selectCounts(const detail::RecoTrackContainer::TrackProxy &track, double eta) const
Definition: TrackFindingBaseAlg.cxx:477
ActsTrk::TrackFindingBaseAlg::m_maxPropagationStep
Gaudi::Property< unsigned int > m_maxPropagationStep
Definition: TrackFindingBaseAlg.h:101
beamspotman.stat
stat
Definition: beamspotman.py:262
ActsTrk::TrackFindingBaseAlg::m_numMeasurementsCutOff
Gaudi::Property< std::vector< size_t > > m_numMeasurementsCutOff
Definition: TrackFindingBaseAlg.h:106
ActsTrk::TrackFindingBaseAlg::m_stripCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_stripCalibTool
Definition: TrackFindingBaseAlg.h:94
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::TrackFindingBaseAlg::m_minStripHits
Gaudi::Property< std::vector< std::size_t > > m_minStripHits
Definition: TrackFindingBaseAlg.h:139
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMaxHoles
@ kNStoppedTracksMaxHoles
Definition: TrackFindingBaseAlg.h:166
ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat
bool m_useAbsEtaForStat
Definition: TrackFindingBaseAlg.h:342
ActsTrk::TrackFindingBaseAlg::m_etaBins
Gaudi::Property< std::vector< double > > m_etaBins
Definition: TrackFindingBaseAlg.h:102
ActsTrk::TrackFindingBaseAlg::kNNoEstimatedParams
@ kNNoEstimatedParams
Definition: TrackFindingBaseAlg.h:162
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:275
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::TrackFindingBaseAlg::kNTotalSeeds
@ kNTotalSeeds
Definition: TrackFindingBaseAlg.h:157
ActsTrk::TrackFindingBaseAlg::m_extrapolationTool
ToolHandle< IActsExtrapolationTool > m_extrapolationTool
Definition: TrackFindingBaseAlg.h:88
ActsTrk::DetectorType::Hgtd
@ Hgtd
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMaxEta
@ kNStoppedTracksMaxEta
Definition: TrackFindingBaseAlg.h:170
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:448
ActsTrk::TrackFindingBaseAlg::getCuts
const Acts::TrackSelector::Config & getCuts(double eta) const
Retrieves track selector configuration for given eta value.
Definition: TrackFindingBaseAlg.cxx:226
ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector
StatusCode initializeMeasurementSelector()
Definition: TrackFindingBaseAlg.cxx:503
ActsTrk::detail::Stepper
Acts::SympyStepper Stepper
Adapted from Acts Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithmFunction....
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:30
ActsTrk::TrackFindingBaseAlg::kNForcedSeedMeasurements
@ kNForcedSeedMeasurements
Definition: TrackFindingBaseAlg.h:172
ActsTrk::TrackFindingBaseAlg::m_minPixelHits
Gaudi::Property< std::vector< std::size_t > > m_minPixelHits
Definition: TrackFindingBaseAlg.h:138
TableUtils::makeEtaBinLabel
std::string makeEtaBinLabel(const std::vector< float > &eta_bins, std::size_t eta_bin_i, bool abs_eta=false)
Definition: TableUtils.h:514
ActsTrk::TrackFindingBaseAlg::BranchState::nStripHits
static constexpr Acts::ProxyAccessor< unsigned int > nStripHits
Definition: TrackFindingBaseAlg.h:296
ActsTrk::TrackFindingBaseAlg::m_trackingGeometryTool
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool
Definition: TrackFindingBaseAlg.h:89
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelHoles
static constexpr Acts::ProxyAccessor< unsigned int > nPixelHoles
Definition: TrackFindingBaseAlg.h:298
ActsTrk::TrackFindingBaseAlg::nSeedCollections
std::size_t nSeedCollections() const
Definition: TrackFindingBaseAlg.h:333
a
TList * a
Definition: liststreamerinfos.cxx:10
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
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:294
ActsTrk::TrackFindingBaseAlg::m_ptMin
Gaudi::Property< std::vector< double > > m_ptMin
Definition: TrackFindingBaseAlg.h:124
ActsTrk::TrackFindingBaseAlg::m_ptMax
Gaudi::Property< std::vector< double > > m_ptMax
Definition: TrackFindingBaseAlg.h:125
ActsTrk::TrackFindingBaseAlg::kNDuplicateSeeds
@ kNDuplicateSeeds
Definition: TrackFindingBaseAlg.h:161
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
ActsTrk::TrackFindingBaseAlg::m_absEtaMin
Gaudi::Property< double > m_absEtaMin
Definition: TrackFindingBaseAlg.h:122
ActsTrk::TrackFindingBaseAlg::kNTotalSharedHits
@ kNTotalSharedHits
Definition: TrackFindingBaseAlg.h:171
ActsTrk::TrackFindingBaseAlg::m_logger
std::unique_ptr< const Acts::Logger > m_logger
logging instance
Definition: TrackFindingBaseAlg.h:326
ActsTrk::TrackFindingBaseAlg::m_ptMinMeasurements
Gaudi::Property< std::vector< std::size_t > > m_ptMinMeasurements
Definition: TrackFindingBaseAlg.h:107
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
ActsTrk::TrackFindingBaseAlg::m_trackStatePrinter
ToolHandle< ActsTrk::TrackStatePrinterTool > m_trackStatePrinter
Definition: TrackFindingBaseAlg.h:90
ActsTrk::TrackFindingBaseAlg::BranchState::nHgtdHoles
static constexpr Acts::ProxyAccessor< unsigned int > nHgtdHoles
Definition: TrackFindingBaseAlg.h:300
ActsTrk::TrackFindingBaseAlg::m_measurementSelectorConfig
struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig m_measurementSelectorConfig
ActsTrk::TrackFindingBaseAlg::BranchState::nHgtdOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nHgtdOutliers
Definition: TrackFindingBaseAlg.h:303
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig::m_etaBins
std::vector< float > m_etaBins
Definition: TrackFindingBaseAlg.h:58
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
ActsTrk::TrackFindingBaseAlg::m_statEtaBins
Gaudi::Property< std::vector< float > > m_statEtaBins
Definition: TrackFindingBaseAlg.h:151
ActsTrk::TrackFindingBaseAlg::m_maxStripOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxStripOutliers
Definition: TrackFindingBaseAlg.h:145
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
ActsTrk::TrackFindingBaseAlg::m_fitterTool
ToolHandle< ActsTrk::IFitterTool > m_fitterTool
Definition: TrackFindingBaseAlg.h:92
ActsTrk::TrackFindingBaseAlg::m_maxHgtdOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxHgtdOutliers
Definition: TrackFindingBaseAlg.h:146
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
ActsTrk::TrackFindingBaseAlg::kNSelectedTracks
@ kNSelectedTracks
Definition: TrackFindingBaseAlg.h:165
ActsTrk::TrackFindingBaseAlg::kNoTrack
@ kNoTrack
Definition: TrackFindingBaseAlg.h:160
ActsTrk::TrackFindingBaseAlg::m_trackFinder
std::unique_ptr< CKF_pimpl > m_trackFinder
Definition: TrackFindingBaseAlg.h:81
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
ActsTrk::detail::CKF
Acts::CombinatorialKalmanFilter< Propagator, RecoTrackContainer > CKF
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:33
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
TableUtils::makeRatioDefinition
std::tuple< std::string, RatioDefinition > makeRatioDefinition(std::string &&name, std::vector< SummandDefinition > &&numerator, std::vector< SummandDefinition > &&denominator)
Definition: TableUtils.h:438
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
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:473
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
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:402
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
ActsTrk::TrackFindingBaseAlg::m_z0Min
Gaudi::Property< std::vector< double > > m_z0Min
Definition: TrackFindingBaseAlg.h:128
ActsTrk::TrackFindingBaseAlg::logger
const Acts::Logger & logger() const
Private access to the logger.
Definition: TrackFindingBaseAlg.h:320
ActsTrk::detail::CKF_config::ckfExtensions
Acts::CombinatorialKalmanFilterExtensions< RecoTrackContainer > ckfExtensions
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:46
ActsTrk::TrackFindingBaseAlg::copyCounts
static void copyCounts(const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackProxy &other)
Definition: TrackFindingBaseAlg.cxx:440
xAOD::UncalibMeasType::PixelClusterType
@ PixelClusterType
ActsTrk::TrackFindingBaseAlg::m_doTwoWay
Gaudi::Property< bool > m_doTwoWay
Definition: TrackFindingBaseAlg.h:110
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
ActsTrk::TrackFindingBaseAlg::kNRejectedRefinedSeeds
@ kNRejectedRefinedSeeds
Definition: TrackFindingBaseAlg.h:164
Generated on Mon Sep 29 2025 21:59:08 for ATLAS Offline Software by   doxygen 1.8.18