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)
 

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< ActsTrk::IExtrapolationTool > 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< bool > m_checkCounts {this, "checkCounts", false, "check consistency among track state counts"}
 
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 272 of file TrackFindingBaseAlg.h.

◆ EventStats

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

Definition at line 177 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 247 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 156 of file TrackFindingBaseAlg.h.

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

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 440 of file TrackFindingBaseAlg.cxx.

440  {
441  // This check will fail if there are other types (HGTD, MS?) of hits, holes, or outliers.
442  // The check can be removed when it is no longer appropriate.
443  if (track.nMeasurements() != s_branchState.nPixelHits(track) + s_branchState.nStripHits(track) + s_branchState.nHgtdHits(track))
444  ATH_MSG_WARNING("mismatched hit count: total (" << track.nMeasurements()
445  << ") != pixel (" << s_branchState.nPixelHits(track)
446  << ") + strip (" << s_branchState.nStripHits(track)
447  << ") + hgtd (" << s_branchState.nHgtdHits(track)
448  << ")");
449  if (track.nHoles() != s_branchState.nPixelHoles(track) + s_branchState.nStripHoles(track) + s_branchState.nHgtdHoles(track))
450  ATH_MSG_WARNING("mismatched hole count: total (" << track.nHoles()
451  << ") < pixel (" << s_branchState.nPixelHoles(track)
452  << ") + strip (" << s_branchState.nStripHoles(track)
453  << ") + hgtd (" << s_branchState.nHgtdHoles(track)
454  << ")");
455  if (track.nOutliers() != s_branchState.nPixelOutliers(track) + s_branchState.nStripOutliers(track) + s_branchState.nHgtdOutliers(track))
456  ATH_MSG_WARNING("mismatched outlier count: total (" << track.nOutliers()
457  << ") != pixel (" << s_branchState.nPixelOutliers(track)
458  << ") + strip (" << s_branchState.nStripOutliers(track)
459  << ") + hgtd (" << s_branchState.nHgtdOutliers(track)
460  << ")");
461  };

◆ computeStatSum()

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

Definition at line 746 of file TrackFindingBaseAlg.cxx.

746  {
747  std::size_t out = 0u;
748  for (std::size_t category_i = seed_collection * seedCollectionStride();
749  category_i < (seed_collection + 1) * seedCollectionStride();
750  ++category_i)
751  {
752  assert(category_i < stat.size());
753  out += stat[category_i][counter_i];
754  }
755  return out;
756  }

◆ copyStats()

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

Definition at line 536 of file TrackFindingBaseAlg.cxx.

536  {
537  std::lock_guard<std::mutex> lock(m_mutex);
538  std::size_t category_i = 0;
539  for (const std::array<unsigned int, kNStat> &src_stat : event_stat)
540  {
541  std::array<std::size_t, kNStat> &dest_stat = m_stat[category_i++];
542  for (std::size_t i = 0; i < src_stat.size(); ++i)
543  {
544  assert(i < dest_stat.size());
545  dest_stat[i] += src_stat[i];
546  }
547  }
548  }

◆ 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 237 of file TrackFindingBaseAlg.cxx.

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

◆ 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 171 of file TrackFindingBaseAlg.cxx.

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

◆ 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 177 of file TrackFindingBaseAlg.cxx.

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

◆ 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 228 of file TrackFindingBaseAlg.cxx.

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

◆ 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 201 of file TrackFindingBaseAlg.cxx.

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

◆ getStatCategory()

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

Definition at line 737 of file TrackFindingBaseAlg.cxx.

737  {
738  std::vector<float>::const_iterator bin_iter = std::upper_bound(m_statEtaBins.begin(),
739  m_statEtaBins.end(),
740  m_useAbsEtaForStat ? std::abs(eta) : eta);
741  std::size_t category_i = seed_collection * seedCollectionStride() + static_cast<std::size_t>(bin_iter - m_statEtaBins.begin());
742  assert(category_i < m_stat.size());
743  return category_i;
744  }

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

◆ initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector ( )
protected

Definition at line 489 of file TrackFindingBaseAlg.cxx.

489  {
490  std::vector<std::pair<float, float> > &chi2CutOffOutlier = m_measurementSelectorConfig.m_chi2CutOffOutlier;
491  chi2CutOffOutlier .reserve( m_chi2CutOff.size() );
492  if (!m_chi2OutlierCutOff.empty()) {
493  if (m_chi2CutOff.size() != m_chi2OutlierCutOff.size()) {
494  ATH_MSG_ERROR("Outlier chi2 cut off provided but number of elements does not agree with"
495  " chi2 cut off for measurements which however is required: "
496  << m_chi2CutOff.size() << " != " << m_chi2OutlierCutOff.size());
497  return StatusCode::FAILURE;
498  }
499  }
500  unsigned int idx=0;
501  for (const auto &elm : m_chi2CutOff) {
502  chi2CutOffOutlier.push_back( std::make_pair(static_cast<float>(elm),
503  idx < m_chi2OutlierCutOff.size()
504  ? static_cast<float>(m_chi2OutlierCutOff[idx])
505  : std::numeric_limits<float>::max()) );
506  ++idx;
507  }
508  if (m_etaBins.size() > 2) {
509  std::vector<float> &etaBinsf = m_measurementSelectorConfig.m_etaBins;
510  etaBinsf.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
511  }
512 
513  return /*m_measurementSelector ?*/ StatusCode::SUCCESS /*: StatusCode::FAILURE*/;
514  }

◆ initStatTables()

void ActsTrk::TrackFindingBaseAlg::initStatTables ( )
protected

Definition at line 518 of file TrackFindingBaseAlg.cxx.

518  {
519  if (!m_statEtaBins.empty())
520  {
521  m_useAbsEtaForStat = (m_statEtaBins[0] > 0.);
522  float last_eta = m_statEtaBins[0];
523  for (float eta : m_statEtaBins)
524  {
525  if (eta < last_eta)
526  {
527  ATH_MSG_FATAL("Eta bins for statistics counter not in ascending order.");
528  }
529  last_eta = eta;
530  }
531  }
532  m_stat.resize(nSeedCollections() * seedCollectionStride());
533  }

◆ 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 319 of file TrackFindingBaseAlg.h.

320  {
321  return *m_logger;
322  }

◆ measurementType()

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

Definition at line 261 of file TrackFindingBaseAlg.cxx.

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

◆ 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 332 of file TrackFindingBaseAlg.h.

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

◆ 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 551 of file TrackFindingBaseAlg.cxx.

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

◆ 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 335 of file TrackFindingBaseAlg.h.

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

◆ selectCounts()

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

Definition at line 463 of file TrackFindingBaseAlg.cxx.

463  {
464  bool enoughMeasurements = true, tooManyHoles = false, tooManyOutliers = false;
465  const auto &trackSelectorCfg = trackFinder().trackSelector.config();
466  std::size_t etaBin = (std::abs(eta) < trackSelectorCfg.absEtaEdges.front()) ? 0
467  : (std::abs(eta) >= trackSelectorCfg.absEtaEdges.back()) ? trackSelectorCfg.absEtaEdges.size() - 1
468  : trackSelectorCfg.binIndex(eta);
469  auto cutMin = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
470  return !cutSet.empty() && (val < (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
471  };
472  auto cutMax = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
473  return !cutSet.empty() && (val > (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
474  };
475 
476  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nPixelHits(track), m_minPixelHits);
477  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nStripHits(track), m_minStripHits);
478  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nHgtdHits(track), m_minHgtdHits);
479  tooManyHoles = tooManyHoles || cutMax(s_branchState.nPixelHoles(track), m_maxPixelHoles);
480  tooManyHoles = tooManyHoles || cutMax(s_branchState.nStripHoles(track), m_maxStripHoles);
481  tooManyHoles = tooManyHoles || cutMax(s_branchState.nHgtdHoles(track), m_maxHgtdHoles);
482  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nPixelOutliers(track), m_maxPixelOutliers);
483  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nStripOutliers(track), m_maxStripOutliers);
484  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nHgtdOutliers(track), m_maxHgtdOutliers);
485 
486  return {enoughMeasurements, tooManyHoles, tooManyOutliers};
487  }

◆ selectCountsFinal()

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

Definition at line 758 of file TrackFindingBaseAlg.cxx.

758  {
759  if (not m_addCounts) return true;
760  double eta = -std::log(std::tan(0.5 * track.theta()));
761  auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] = selectCounts(track, eta);
762  return enoughMeasurementsPS && !tooManyHolesPS && !tooManyOutliersPS;
763  }

◆ 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 183 of file TrackFindingBaseAlg.cxx.

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

◆ 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 279 of file TrackFindingBaseAlg.cxx.

286  {
287  if (m_addCounts) {
288  updateCounts(track, trackState.typeFlags(),
289  measurementType(trackState));
290  if (m_checkCounts) {
291  checkCounts(track);
292  }
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 342 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 343 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_checkCounts

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_checkCounts {this, "checkCounts", false, "check consistency among track state counts"}
protected

Definition at line 138 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 154 of file TrackFindingBaseAlg.h.

◆ m_endOfWorldVolumeIds

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

Definition at line 149 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<ActsTrk::IExtrapolationTool> 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 325 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 144 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 147 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 142 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 145 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 143 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 146 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 141 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 139 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 140 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 153 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 152 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 341 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 306 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:302
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::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:174
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:143
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:306
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:169
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:144
ActsTrk::TrackFindingBaseAlg::m_minHgtdHits
Gaudi::Property< std::vector< std::size_t > > m_minHgtdHits
Definition: TrackFindingBaseAlg.h:141
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:142
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:154
ActsTrk::TrackFindingBaseAlg::BranchState::nHgtdHits
static constexpr Acts::ProxyAccessor< unsigned int > nHgtdHits
Definition: TrackFindingBaseAlg.h:298
ActsTrk::TrackFindingBaseAlg::m_maxChi2
Gaudi::Property< std::vector< double > > m_maxChi2
Definition: TrackFindingBaseAlg.h:135
ActsTrk::TrackFindingBaseAlg::m_extrapolationTool
ToolHandle< ActsTrk::IExtrapolationTool > m_extrapolationTool
Definition: TrackFindingBaseAlg.h:88
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:551
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:160
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelHits
static constexpr Acts::ProxyAccessor< unsigned int > nPixelHits
Definition: TrackFindingBaseAlg.h:296
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:300
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
ActsTrk::TrackFindingBaseAlg::initStatTables
void initStatTables()
Definition: TrackFindingBaseAlg.cxx:518
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:168
ActsTrk::MutableTrackContainerHandlesHelper::initialize
StatusCode initialize(const std::string &prefix)
Sets up the handles.
Definition: TrackContainerHandlesHelper.cxx:47
ActsTrk::TrackFindingBaseAlg::kNoTrackParam
@ kNoTrackParam
Definition: TrackFindingBaseAlg.h:159
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:149
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMinPt
@ kNStoppedTracksMinPt
Definition: TrackFindingBaseAlg.h:170
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:440
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:183
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:164
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:335
ActsTrk::TrackFindingBaseAlg::m_seedLabels
Gaudi::Property< std::vector< std::string > > m_seedLabels
Definition: TrackFindingBaseAlg.h:153
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:145
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:303
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:92
ActsTrk::TrackFindingBaseAlg::measurementType
static xAOD::UncalibMeasType measurementType(const detail::RecoTrackContainer::TrackStateProxy &trackState)
Definition: TrackFindingBaseAlg.cxx:261
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:463
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:140
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMaxHoles
@ kNStoppedTracksMaxHoles
Definition: TrackFindingBaseAlg.h:167
ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat
bool m_useAbsEtaForStat
Definition: TrackFindingBaseAlg.h:341
ActsTrk::TrackFindingBaseAlg::m_etaBins
Gaudi::Property< std::vector< double > > m_etaBins
Definition: TrackFindingBaseAlg.h:102
ActsTrk::TrackFindingBaseAlg::kNNoEstimatedParams
@ kNNoEstimatedParams
Definition: TrackFindingBaseAlg.h:163
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
ActsTrk::detail::getMeasurementSelector
std::unique_ptr< ActsTrk::IMeasurementSelector > getMeasurementSelector(const ActsTrk::IOnBoundStateCalibratorTool *pixelOnTrackCalibratorTool, const ActsTrk::IOnBoundStateCalibratorTool *stripOnTrackCalibratorTool, const ActsTrk::IOnBoundStateCalibratorTool *hgtdOnTrackCalibratorTool, 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
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::TrackFindingBaseAlg::kNTotalSeeds
@ kNTotalSeeds
Definition: TrackFindingBaseAlg.h:158
ActsTrk::DetectorType::Hgtd
@ Hgtd
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMaxEta
@ kNStoppedTracksMaxEta
Definition: TrackFindingBaseAlg.h:171
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:228
ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector
StatusCode initializeMeasurementSelector()
Definition: TrackFindingBaseAlg.cxx:489
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:173
ActsTrk::TrackFindingBaseAlg::m_minPixelHits
Gaudi::Property< std::vector< std::size_t > > m_minPixelHits
Definition: TrackFindingBaseAlg.h:139
ActsTrk::TrackFindingBaseAlg::m_checkCounts
Gaudi::Property< bool > m_checkCounts
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:297
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:299
ActsTrk::TrackFindingBaseAlg::nSeedCollections
std::size_t nSeedCollections() const
Definition: TrackFindingBaseAlg.h:332
a
TList * a
Definition: liststreamerinfos.cxx:10
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:162
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:172
ActsTrk::TrackFindingBaseAlg::m_logger
std::unique_ptr< const Acts::Logger > m_logger
logging instance
Definition: TrackFindingBaseAlg.h:325
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:301
ActsTrk::TrackFindingBaseAlg::m_measurementSelectorConfig
struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig m_measurementSelectorConfig
ActsTrk::TrackFindingBaseAlg::BranchState::nHgtdOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nHgtdOutliers
Definition: TrackFindingBaseAlg.h:304
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:152
ActsTrk::TrackFindingBaseAlg::m_maxStripOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxStripOutliers
Definition: TrackFindingBaseAlg.h:146
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:147
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:166
ActsTrk::TrackFindingBaseAlg::kNoTrack
@ kNoTrack
Definition: TrackFindingBaseAlg.h:161
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:319
ActsTrk::detail::CKF_config::ckfExtensions
Acts::CombinatorialKalmanFilterExtensions< RecoTrackContainer > ckfExtensions
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:46
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:165
Generated on Sun Oct 26 2025 21:52:02 for ATLAS Offline Software by   doxygen 1.8.18