ATLAS Offline Software
Public Types | 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::TrackFindingAlg Class Reference

#include <TrackFindingAlg.h>

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

Public Types

using ExpectedLayerPattern = std::array< unsigned int, 4 >
 

Public Member Functions

 TrackFindingAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TrackFindingAlg ()=default
 
virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual StatusCode execute (const EventContext &ctx) const override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Types

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

Protected Member Functions

CKF_pimpl & trackFinder ()
 
const CKF_pimpl & trackFinder () const
 
StatusCode initializeMeasurementSelector ()
 
std::unique_ptr< ActsTrk::IMeasurementSelector > setMeasurementSelector (const detail::TrackFindingMeasurements &measurements, TrackFinderOptions &options) const
 Setup and attach measurement selector to KF options. More...
 
TrackFindingDefaultOptions getDefaultOptions (const DetectorContextHolder &detContext, const detail::TrackFindingMeasurements &measurements, const Acts::PerigeeSurface *pSurface) const
 Get CKF options for first and second pass + pointer to MeasurementSelector. More...
 
template<class HandleArrayKeyType , class ContainerType >
StatusCode getContainersFromKeys (const EventContext &ctx, HandleArrayKeyType &handleKeyArray, std::vector< const ContainerType * > &outputContainers, std::size_t &sum) const
 Take the array of handle keys and for each key retrieve containers, then append them to the output vector. More...
 
const Acts::TrackSelector::Config & getCuts (double eta) const
 Retrieves track selector configuration for given eta value. More...
 
template<class MeasurementSource >
std::unique_ptr< Acts::BoundTrackParameters > doRefit (const MeasurementSource &measurement, const Acts::BoundTrackParameters &initialParameters, const DetectorContextHolder &detContext, const bool paramsAtOutermostSurface) const
 Perform Kalman Filter fit and update given initialParameters. More...
 
std::vector< typename detail::RecoTrackContainer::TrackProxy > doTwoWayTrackFinding (const detail::RecoTrackStateContainerProxy &firstMeasurement, const TrkProxy &trackProxy, detail::RecoTrackContainer &tracksContainerTemp, const TrackFinderOptions &options) const
 Perform two-way track finding. More...
 
BranchStopperResult stopBranch (const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackStateProxy &trackState, const Acts::TrackSelector::EtaBinnedConfig &trackSelectorCfg, const Acts::GeometryContext &tgContext, const detail::MeasurementIndex &measurementIndex, const std::size_t typeIndex, EventStats::value_type &event_stat_category_i) const
 Branch stopper. More...
 
void checkCounts (const detail::RecoTrackContainer::TrackProxy &track) const
 
std::array< bool, 3 > selectCounts (const detail::RecoTrackContainer::TrackProxy &track, double eta) const
 
bool selectCountsFinal (const detail::RecoTrackContainer::TrackProxy &track) const
 
const Acts::Logger & logger () const
 Private access to the logger. More...
 
void initStatTables ()
 
void copyStats (const EventStats &event_stat) const
 
void printStatTables () const
 
std::size_t nSeedCollections () const
 
std::size_t seedCollectionStride () const
 
std::size_t getStatCategory (std::size_t seed_collection, float eta) const
 
std::size_t computeStatSum (std::size_t seed_collection, EStat counter_i, const EventStats &stat) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Static Protected Member Functions

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

Protected Attributes

struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig m_measurementSelectorConfig
 
std::unique_ptr< CKF_pimpl > m_trackFinder
 
detail::xAODUncalibMeasSurfAcc m_unalibMeasSurfAcc {}
 
ToolHandle< GenericMonitoringTool > m_monTool {this, "MonTool", "", "Monitoring tool"}
 
ToolHandle< IActsExtrapolationTool > m_extrapolationTool {this, "ExtrapolationTool", ""}
 
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
 
ToolHandle< ActsTrk::TrackStatePrinterTool > m_trackStatePrinter {this, "TrackStatePrinter", "", "optional track state printer"}
 
ToolHandle< ActsTrk::IActsToTrkConverterTool > m_ATLASConverterTool {this, "ATLASConverterTool", ""}
 
ToolHandle< ActsTrk::IFitterTool > m_fitterTool {this, "FitterTool", "", "Fitter Tool for Seeds"}
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_pixelCalibTool {this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"}
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_stripCalibTool {this, "StripCalibrator", "", "Opt. strip measurement calibrator"}
 
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_hgtdCalibTool {this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"}
 
SG::WriteHandleKey< ActsTrk::TrackContainer > m_trackContainerKey {this, "ACTSTracksLocation", "", "Output track collection (ActsTrk variant)"}
 
ActsTrk::MutableTrackContainerHandlesHelper m_tracksBackendHandlesHelper {this}
 
Gaudi::Property< unsigned int > m_maxPropagationStep {this, "maxPropagationStep", 1000, "Maximum number of steps for one propagate call"}
 
Gaudi::Property< std::vector< double > > m_etaBins {this, "etaBins", {}, "bins in |eta| to specify variable selections"}
 
Gaudi::Property< std::vector< double > > m_chi2CutOff {this, "chi2CutOff", {}, "MeasurementSelector: maximum local chi2 contribution"}
 
Gaudi::Property< std::vector< double > > m_chi2OutlierCutOff {this, "chi2OutlierCutOff", {}, "MeasurementSelector: maximum local chi2 contribution for outlier"}
 
Gaudi::Property< std::vector< size_t > > m_numMeasurementsCutOff {this, "numMeasurementsCutOff", {}, "MeasurementSelector: maximum number of associated measurements on a single surface"}
 
Gaudi::Property< std::vector< std::size_t > > m_ptMinMeasurements {this, "ptMinMeasurements", {}, "if specified for the given seed collection, applies ptMin cut in branch stopper once ptMinMinMeasurements have been encountered"}
 
Gaudi::Property< std::vector< std::size_t > > m_absEtaMaxMeasurements {this, "absEtaMaxMeasurements", {}, "if specified for the given seed collection, applies absEtaMax cut in branch stopper once absEtaMaxMeasurements have been encountered"}
 
Gaudi::Property< bool > m_doBranchStopper {this, "doBranchStopper", true, "use branch stopper"}
 
Gaudi::Property< bool > m_doTwoWay {this, "doTwoWay", true, "run CKF twice, first with forward propagation with smoothing, then with backward propagation"}
 
Gaudi::Property< double > m_branchStopperPtMinFactor {this, "branchStopperPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the branch stopper"}
 
Gaudi::Property< double > m_branchStopperAbsEtaMaxExtra {this, "branchStopperAbsEtaMaxExtra", 0.0, "increase absEtaMax cut when used in the branch stopper"}
 
Gaudi::Property< double > m_branchStopperMeasCutReduce {this, "branchStopperMeasCutReduce", 2, "how much to reduce the minMeas requirement for the branch stopper"}
 
Gaudi::Property< double > m_branchStopperAbsEtaMeasCut {this, "branchStopperAbsEtaMeasCut", 1.2, "the minimum |eta| to apply the reduction to the minMeas requirement for the branch stopper"}
 
Gaudi::Property< std::vector< double > > m_phiMin {this, "phiMin", {}, "TrackSelector: phiMin"}
 
Gaudi::Property< std::vector< double > > m_phiMax {this, "phiMax", {}, "TrackSelector: phiMax"}
 
Gaudi::Property< std::vector< double > > m_etaMin {this, "etaMin", {}, "TrackSelector: etaMin"}
 
Gaudi::Property< std::vector< double > > m_etaMax {this, "etaMax", {}, "TrackSelector: etaMax"}
 
Gaudi::Property< double > m_absEtaMin {this, "absEtaMin", 0.0, "TrackSelector: absEtaMin"}
 
Gaudi::Property< double > m_absEtaMax {this, "absEtaMax", std::numeric_limits<double>::max(), "TrackSelector: absEtaMax"}
 
Gaudi::Property< std::vector< double > > m_ptMin {this, "ptMin", {}, "TrackSelector: ptMin"}
 
Gaudi::Property< std::vector< double > > m_ptMax {this, "ptMax", {}, "TrackSelector: ptMax"}
 
Gaudi::Property< std::vector< double > > m_d0Min {this, "d0Min", {}, "TrackSelector: d0Min"}
 
Gaudi::Property< std::vector< double > > m_d0Max {this, "d0Max", {}, "TrackSelector: d0Max"}
 
Gaudi::Property< std::vector< double > > m_z0Min {this, "z0Min", {}, "TrackSelector: z0Min"}
 
Gaudi::Property< std::vector< double > > m_z0Max {this, "z0Max", {}, "TrackSelector: z0Max"}
 
Gaudi::Property< std::vector< std::size_t > > m_minMeasurements {this, "minMeasurements", {}, "TrackSelector: minMeasurements"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxHoles {this, "maxHoles", {}, "TrackSelector: maxHoles"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxOutliers {this, "maxOutliers", {}, "TrackSelector: maxOutliers"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxSharedHits {this, "maxSharedHits", {}, "TrackSelector: maxSharedHits"}
 
Gaudi::Property< std::vector< double > > m_maxChi2 {this, "maxChi2", {}, "TrackSelector: maxChi2"}
 
Gaudi::Property< bool > m_addCounts {this, "addCounts", true, "keep separate pixel, strip and hgtd counts and apply the following cuts"}
 
Gaudi::Property< std::vector< std::size_t > > m_minPixelHits {this, "minPixelHits", {}, "minimum number of pixel hits"}
 
Gaudi::Property< std::vector< std::size_t > > m_minStripHits {this, "minStripHits", {}, "minimum number of strip hits"}
 
Gaudi::Property< std::vector< std::size_t > > m_minHgtdHits {this, "minHgtdHits", {}, "minimum number of hgtd hits"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxPixelHoles {this, "maxPixelHoles", {}, "maximum number of pixel holes"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxStripHoles {this, "maxStripHoles", {}, "maximum number of strip holes"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxHgtdHoles {this, "maxHgtdHoles", {}, "maximum number of hgtd holes"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxPixelOutliers {this, "maxPixelOutliers", {}, "maximum number of pixel outliers"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxStripOutliers {this, "maxStripOutliers", {}, "maximum number of strip outliers"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxHgtdOutliers {this, "maxHgtdOutliers", {}, "maximum number of hgtd outliers"}
 
Gaudi::Property< std::vector< std::uint32_t > > m_endOfWorldVolumeIds {this, "EndOfTheWorldVolumeIds", {}, ""}
 
Gaudi::Property< std::vector< float > > m_statEtaBins {this, "StatisticEtaBins", {-4, -2.6, -2, 0, 2., 2.6, 4}, "Gather statistics separately for these bins."}
 
Gaudi::Property< std::vector< std::string > > m_seedLabels {this, "SeedLabels", {}, "One label per seed key used in outputs"}
 
Gaudi::Property< bool > m_dumpAllStatEtaBins {this, "DumpEtaBinsForAll", false, "Dump eta bins of all statistics counter."}
 
std::unique_ptr< const Acts::Logger > m_logger
 logging instance More...
 
bool m_useAbsEtaForStat = false
 

Static Protected Attributes

static constexpr BranchState s_branchState {}
 

Private Types

enum  DestinyType : int { UNKNOWN =0, SUCCEED, DUPLICATE, FAILURE }
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

std::size_t getSeedCategory (std::size_t typeIndex, const ActsTrk::Seed &seed, bool useTopSp) const
 
void printSeed (unsigned int iseed, const DetectorContextHolder &detContext, const ActsTrk::SeedContainer &seeds, const Acts::BoundTrackParameters &seedParameters, const detail::MeasurementIndex &measurementIndex, std::size_t &nPrinted, const char *seedType, bool isKF=false) const
 
StatusCode addTrack (const DetectorContextHolder &detContext, detail::RecoTrackContainerProxy &track, const Acts::Surface &pSurface, const Acts::TrackExtrapolationStrategy &extrapolationStrategy, detail::SharedHitCounter &sharedHits, detail::RecoTrackContainer &actsTracksContainer, const detail::MeasurementIndex &measurementIndex, const detail::RecoTrackContainer &tracksContainerTemp, detail::DuplicateSeedDetector &duplicateSeedDetector, std::vector< int > *destiny, EventStats &event_stat, std::size_t &ntracks, std::size_t iseed, std::size_t category_i, const char *seedType) const
 
StatusCode storeTrackCollectionToStoreGate (const EventContext &ctx, Acts::VectorTrackContainer &&originalTrackBackend, Acts::VectorMultiTrajectory &&originalTrackStateBackend) const
 
StatusCode propagateDetectorElementStatusToMeasurements (const ActsTrk::ActsVolumeIdToDetectorElementCollectionMap &volume_id_to_det_el_coll, const std::vector< const InDet::SiDetectorElementStatus * > &det_el_status_arr, detail::TrackFindingMeasurements &measurements) const
 
bool shouldReverseSearch (const ActsTrk::Seed &seed) const
 
Acts::Result< void > extrapolateTrackToReferenceSurface (const DetectorContextHolder &detContext, detail::RecoTrackContainerProxy &track, const Acts::Surface &referenceSurface, const detail::Extrapolator &propagator, Acts::TrackExtrapolationStrategy strategy, ExpectedLayerPattern &expectedLayerPattern) const
 
StatusCode findTracks (const DetectorContextHolder &detContext, const detail::TrackFindingMeasurements &measurements, const detail::MeasurementIndex &measurementIndex, detail::SharedHitCounter &sharedHits, detail::DuplicateSeedDetector &duplicateSeedDetector, const ActsTrk::SeedContainer &seeds, const InDetDD::SiDetectorElementCollection &detElements, detail::RecoTrackContainer &actsTracksContainer, std::size_t seedCollectionIndex, const char *seedType, EventStats &event_stat, std::vector< int > *destiny, const Acts::PerigeeSurface &pSurface) const
 invoke track finding procedure More...
 
void storeSeedInfo (const detail::RecoTrackContainer &tracksContainer, const detail::RecoTrackContainerProxy &track, detail::DuplicateSeedDetector &duplicateSeedDetector, const detail::MeasurementIndex &measurementIndex) const
 
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

ToolHandle< ActsTrk::ITrackParamsEstimationTool > m_paramEstimationTool {this, "TrackParamsEstimationTool", "", "Track Param Estimation from Seeds"}
 
SG::ReadHandleKeyArray< ActsTrk::SeedContainer > m_seedContainerKeys {this, "SeedContainerKeys", {}, "Seed containers"}
 
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollection > m_detEleCollKeys {this, "DetectorElementsKeys", {}, "Keys of input SiDetectorElementCollection"}
 
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainer > m_uncalibratedMeasurementContainerKeys {this, "UncalibratedMeasurementContainerKeys", {}, "input cluster collections"}
 
SG::ReadCondHandleKey< ActsTrk::ActsVolumeIdToDetectorElementCollectionMap > m_volumeIdToDetectorElementCollMapKey
 
SG::ReadHandleKeyArray< InDet::SiDetectorElementStatus > m_detElStatus {this, "DetElStatus", {}, "Keys for detector element status conditions data."}
 
bool m_storeDestinies {false}
 
SG::WriteHandleKeyArray< std::vector< int > > m_seedDestiny {this, "SeedDestiny", {}}
 
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
 
Gaudi::Property< bool > m_skipDuplicateSeeds {this, "skipDuplicateSeeds", true, "skip duplicate seeds before calling CKF"}
 
Gaudi::Property< unsigned int > m_seedMeasOffset {this,"seedMeasOffset", 0, "Reduce the requirement on the space points on seed to mark a seed as duplicate, e.g seedMeasOffset=1, only N-1 measurements on seed are sufficient deduplicate the seed"}
 
Gaudi::Property< std::vector< bool > > m_refitSeeds {this, "refitSeeds", {}, "Run KalmanFitter on seeds before passing to CKF, specified separately for each seed collection"}
 
Gaudi::Property< std::vector< double > > m_useTopSpRZboundary {this, "useTopSpRZboundary", {350. * Acts::UnitConstants::mm, 1060. * Acts::UnitConstants::mm}, "R/Z boundary for using the top space point in the track parameter estimation"}
 
Gaudi::Property< bool > m_autoReverseSearch {this, "autoReverseSearch", false, "Whether to run the finding in seed parameter direction (false or not specified) or reverse direction (true), automatically determined by the param estimation tool"}
 
Gaudi::Property< bool > m_countSharedHits {this, "countSharedHits", true, "add shared hit flags to tracks"}
 
Gaudi::Property< bool > m_forceTrackOnSeed {this, "forceTrackOnSeed", true, "force track to use measurements from the seed"}
 
Gaudi::Property< unsigned int > m_maximumSharedHits {this, "MaximumSharedHits", 3u, "Maximum number of shared hits per track."}
 
Gaudi::Property< unsigned int > m_maximumIterations {this, "MaximumIterations", 10000u, "Maximum number of iterations to resolve ambiguities among all tracks."}
 
Gaudi::Property< unsigned int > m_nMeasurementsMin {this, "NMeasurementsMin", 7u, "Minimum number of measurements per track."}
 
Gaudi::Property< std::size_t > m_ambiStrategy {this, "ambiStrategy", 0, "0 - Do ambiguity resolution outside track finding; 1 - Do ambiguity in track finding using GreedyAmbiguitySolver tool; 2 - Do shared hit cut during track candidate selection"}
 
std::optional< Acts::GreedyAmbiguityResolution > m_ambi
 
Gaudi::Property< float > m_memorySafetyMargin {this, "MemorySafetyMargin", 1.2}
 
std::size_t m_nTrackReserve ATLAS_THREAD_SAFE {0ul}
 
std::size_t m_nTrackStateReserve ATLAS_THREAD_SAFE {0ul}
 
std::mutex m_mutex ATLAS_THREAD_SAFE {}
 
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 46 of file TrackFindingAlg.h.

Member Typedef Documentation

◆ BranchStopperResult

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

Definition at line 271 of file TrackFindingBaseAlg.h.

◆ EventStats

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

Definition at line 176 of file TrackFindingBaseAlg.h.

◆ ExpectedLayerPattern

using ActsTrk::TrackFindingAlg::ExpectedLayerPattern = std::array<unsigned int, 4>

Definition at line 58 of file TrackFindingAlg.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>
protectedinherited

Definition at line 54 of file TrackFindingBaseAlg.h.

◆ TrkProxy

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

Definition at line 246 of file TrackFindingBaseAlg.h.

Member Enumeration Documentation

◆ DestinyType

enum ActsTrk::TrackFindingAlg::DestinyType : int
private
Enumerator
UNKNOWN 
SUCCEED 
DUPLICATE 
FAILURE 

Definition at line 190 of file TrackFindingAlg.h.

190 : int {UNKNOWN=0, SUCCEED, DUPLICATE, FAILURE};

◆ EStat

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

Definition at line 155 of file TrackFindingBaseAlg.h.

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

Constructor & Destructor Documentation

◆ TrackFindingAlg()

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

Definition at line 73 of file TrackFindingAlg.cxx.

74  : TrackFindingBaseAlg(name, pSvcLocator) {}

◆ ~TrackFindingAlg()

virtual ActsTrk::TrackFindingAlg::~TrackFindingAlg ( )
virtualdefault

Member Function Documentation

◆ addCounts()

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

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  }

◆ addTrack()

StatusCode ActsTrk::TrackFindingAlg::addTrack ( const DetectorContextHolder &  detContext,
detail::RecoTrackContainerProxy &  track,
const Acts::Surface &  pSurface,
const Acts::TrackExtrapolationStrategy &  extrapolationStrategy,
detail::SharedHitCounter &  sharedHits,
detail::RecoTrackContainer &  actsTracksContainer,
const detail::MeasurementIndex &  measurementIndex,
const detail::RecoTrackContainer &  tracksContainerTemp,
detail::DuplicateSeedDetector &  duplicateSeedDetector,
std::vector< int > *  destiny,
EventStats &  event_stat,
std::size_t &  ntracks,
std::size_t  iseed,
std::size_t  category_i,
const char *  seedType 
) const
private

Definition at line 925 of file TrackFindingAlg.cxx.

940  {
941 
942  std::array<unsigned int, 4> expectedLayerPattern;
943 
944  // if the the perigeeSurface was not hit (in particular the case for the inside-out pass,
945  // the track has no reference surface and the extrapolation to the perigee has not been done
946  // yet.
947  if (not track.hasReferenceSurface()) {
948  auto extrapolationResult =
949  extrapolateTrackToReferenceSurface(detContext, track,
950  pSurface,
951  trackFinder().extrapolator,
952  extrapolationStrategy,
953  expectedLayerPattern);
954 
955  if (not extrapolationResult.ok()) {
956  ATH_MSG_WARNING("Extrapolation for seed "
957  << iseed << " and " << track.index()
958  << " failed with error " << extrapolationResult.error()
959  << " dropping track candidate.");
960  if (m_storeDestinies) destiny->at(iseed) = DestinyType::FAILURE;
961  return StatusCode::SUCCESS;
962  }
963  }
964 
965  // Before trimming, inspect encountered surfaces from all track states
966  for(const auto ts : track.trackStatesReversed()) {
967  const auto& surface = ts.referenceSurface();
968  if(surface.associatedDetectorElement() != nullptr) {
969  const auto* detElem = dynamic_cast<const ActsDetectorElement*>(surface.associatedDetectorElement());
970  if(detElem != nullptr) {
971  detail::addToExpectedLayerPattern(expectedLayerPattern, *detElem);
972  }
973  }
974  }
975 
976  // Trim tracks
977  // - trimHoles
978  // - trimOutliers
979  // - trimMaterial
980  // - trimOtherNoneMeasurement
981  Acts::trimTrack(track, true, true, true, true);
982  Acts::calculateTrackQuantities(track);
983  if (m_addCounts) {
984  initCounts(track);
985  for (const auto trackState : track.trackStatesReversed()) {
986  updateCounts(track, trackState.typeFlags(), measurementType(trackState));
987  }
988  checkCounts(track);
989  }
990 
991  ++ntracks;
992  ++event_stat[category_i][kNOutputTracks];
993 
994  if ( not trackFinder().trackSelector.isValidTrack(track) or
995  not selectCountsFinal(track)) {
996  ATH_MSG_DEBUG("Track " << ntracks << " from " << seedType << " seed " << iseed << " failed track selection");
997  if ( m_trackStatePrinter.isSet() ) {
998  m_trackStatePrinter->printTrack(detContext.geometry, tracksContainerTemp, track, measurementIndex, true);
999  }
1000  return StatusCode::SUCCESS;
1001  }
1002 
1003  // Fill the track infos into the duplicate seed detector
1004  if (m_skipDuplicateSeeds) {
1005  storeSeedInfo(tracksContainerTemp, track, duplicateSeedDetector, measurementIndex);
1006  }
1007 
1008  auto actsDestProxy = actsTracksContainer.makeTrack();
1009  actsDestProxy.copyFrom(track); // make sure we copy track states!
1010 
1011  detail::ExpectedLayerPatternHelper::set(actsDestProxy, expectedLayerPattern);
1012 
1013  if (not m_countSharedHits) {
1014  return StatusCode::SUCCESS;
1015  }
1016 
1017  auto [nShared, nBadTrackMeasurements] = sharedHits.computeSharedHits(actsDestProxy, actsTracksContainer, measurementIndex);
1018 
1019  if (nBadTrackMeasurements > 0) {
1020  ATH_MSG_ERROR("computeSharedHits: " << nBadTrackMeasurements << " track measurements not found in input for " << seedType << " seed " << iseed << " track");
1021  }
1022 
1023  ATH_MSG_DEBUG("found " << actsDestProxy.nSharedHits() << " shared hits in " << seedType << " seed " << iseed << " track");
1024 
1025  event_stat[category_i][kNTotalSharedHits] += nShared;
1026 
1027  if (m_ambiStrategy == 2u) { // run the ambiguity during track selection
1028 
1029  if (actsDestProxy.nSharedHits() <= m_maximumSharedHits) {
1030  ++event_stat[category_i][kNSelectedTracks];
1031  }
1032  else { // track fails the shared hit selection
1033 
1034  ATH_MSG_DEBUG("found " << actsDestProxy.nSharedHits() << " shared hits in " << seedType << " seed " << iseed << " track");
1035  // Reset the original track shared hits by running coumputeSharedHits
1036  // with removeSharedHits flag to true
1037  // nSharedRemoved contains the total shared hits that will be removed
1038  auto [nSharedRemoved, nRemoveBadTrackMeasurements] = sharedHits.computeSharedHits(actsDestProxy, actsTracksContainer, measurementIndex, true);
1039 
1040  ATH_MSG_DEBUG("Removed " << nSharedRemoved << " shared hits in " << seedType << " seed " << iseed << " track and the matching track");
1041 
1042  if (nRemoveBadTrackMeasurements > 0) {
1043  ATH_MSG_ERROR("computeSharedHits with remove flag ON: " << nRemoveBadTrackMeasurements <<
1044  " track measurements not found in input for " << seedType << " seed " << iseed << " track");
1045  }
1046 
1047  if (actsDestProxy.nSharedHits() != 0) {
1048  ATH_MSG_ERROR("computeSharedHits with remove flag ON returned " <<
1049  actsDestProxy.nSharedHits()<< " while expecting 0 for" <<
1050  seedType << " seed " << iseed << " track");
1051  }
1052 
1053  // Remove the track from the container
1054  actsTracksContainer.removeTrack(actsDestProxy.index());
1055  ATH_MSG_DEBUG("Track " << ntracks << " from " << seedType << " seed " << iseed << " failed shared hit selection");
1056  }
1057  }
1058  else { // use ambi during selection
1059  ++event_stat[category_i][kNSelectedTracks];
1060 
1061  if (m_trackStatePrinter.isSet()) {
1062  m_trackStatePrinter->printTrack(detContext.geometry, actsTracksContainer, actsDestProxy, measurementIndex);
1063  }
1064  }
1065 
1066  return StatusCode::SUCCESS;
1067  }

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

Definition at line 454 of file TrackFindingBaseAlg.cxx.

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

◆ computeStatSum()

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

Definition at line 760 of file TrackFindingBaseAlg.cxx.

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

◆ copyCounts()

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

Definition at line 440 of file TrackFindingBaseAlg.cxx.

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

◆ copyStats()

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

Definition at line 550 of file TrackFindingBaseAlg.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ doRefit()

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

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
protectedinherited

Perform two-way track finding.

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

Definition at line 235 of file TrackFindingBaseAlg.cxx.

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

◆ evtStore() [1/2]

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

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode ActsTrk::TrackFindingAlg::execute ( const EventContext &  ctx) const
overridevirtual

Reimplemented from ActsTrk::TrackFindingBaseAlg.

Definition at line 152 of file TrackFindingAlg.cxx.

153  {
154  ATH_MSG_DEBUG("Executing " << name() << " ... ");
155 
156  auto timer = Monitored::Timer<std::chrono::milliseconds>("TIME_execute");
157  auto mon_nTracks = Monitored::Scalar<int>("nTracks");
158  auto mon = Monitored::Group(m_monTool, timer, mon_nTracks);
159 
160  // ================================================== //
161  // ===================== INPUTS ===================== //
162  // ================================================== //
163 
164  // SEED TRIPLETS
165  std::vector<const ActsTrk::SeedContainer *> seedContainers;
166  std::size_t total_seeds = 0;
167  ATH_CHECK(getContainersFromKeys(ctx, m_seedContainerKeys, seedContainers, total_seeds));
168 
169  // DESTINIES
170  std::vector< std::unique_ptr< std::vector<int> > > destinies {};
171  if (m_storeDestinies) {
172  destinies.reserve( seedContainers.size() );
173  for (std::size_t i(0); i<seedContainers.size(); ++i) {
174  destinies.push_back( std::make_unique< std::vector<int> >( seedContainers.at(i)->size(), DestinyType::UNKNOWN) );
175  }
176  }
177 
178  // MEASUREMENTS
179  std::vector<const xAOD::UncalibratedMeasurementContainer *> uncalibratedMeasurementContainers;
180  std::size_t total_measurements = 0;
181  ATH_CHECK(getContainersFromKeys(ctx, m_uncalibratedMeasurementContainerKeys, uncalibratedMeasurementContainers, total_measurements));
182 
183  // map detector element status to volume ids
184  SG::ReadCondHandle<ActsTrk::ActsVolumeIdToDetectorElementCollectionMap>
185  volumeIdToDetectorElementCollMap(m_volumeIdToDetectorElementCollMapKey,ctx);
186  ATH_CHECK(volumeIdToDetectorElementCollMap.isValid());
187  std::vector< const InDet::SiDetectorElementStatus *> det_el_status_arr;
188  const std::vector<const InDetDD::SiDetectorElementCollection*> &det_el_collections =volumeIdToDetectorElementCollMap->collections();
189  det_el_status_arr.resize( det_el_collections.size(), nullptr);
190  for (const SG::ReadHandleKey<InDet::SiDetectorElementStatus> &det_el_status_key : m_detElStatus) {
191  SG::ReadHandle<InDet::SiDetectorElementStatus> det_el_status(det_el_status_key,ctx);
192  ATH_CHECK( det_el_status.isValid());
193  const std::vector<const InDetDD::SiDetectorElementCollection*>::const_iterator
194  det_el_col_iter = std::find(det_el_collections.begin(),
195  det_el_collections.end(),
196  &det_el_status->getDetectorElements());
197  det_el_status_arr.at(det_el_col_iter - det_el_collections.begin()) = det_el_status.cptr();
198  }
199 
200  detail::MeasurementIndex measurementIndex(uncalibratedMeasurementContainers.size());
201  for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer) {
202  measurementIndex.addMeasurements(*uncalibratedMeasurementContainers[icontainer]);
203  }
204 
205  detail::TrackFindingMeasurements measurements(uncalibratedMeasurementContainers.size());
206  for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer) {
207  ATH_MSG_DEBUG("Create " << uncalibratedMeasurementContainers[icontainer]->size() << " source links from measurements in " << m_uncalibratedMeasurementContainerKeys[icontainer].key());
208  measurements.addMeasurements(icontainer,
209  *uncalibratedMeasurementContainers[icontainer],
210  *m_trackingGeometryTool->surfaceIdMap(),
211  m_forceTrackOnSeed ? &measurementIndex : nullptr);
212  }
213 
214  ATH_MSG_DEBUG("measurement index size = " << measurementIndex.size());
215 
216  ATH_CHECK( propagateDetectorElementStatusToMeasurements(*(volumeIdToDetectorElementCollMap.cptr()), det_el_status_arr, measurements) );
217 
218  if (m_trackStatePrinter.isSet()) {
219  m_trackStatePrinter->printMeasurements(ctx, uncalibratedMeasurementContainers, measurements.measurementOffsets());
220  }
221 
222  detail::DuplicateSeedDetector duplicateSeedDetector(total_seeds,
223  m_seedMeasOffset.value(),
224  m_skipDuplicateSeeds);
225  for (std::size_t icontainer = 0; icontainer < seedContainers.size(); ++icontainer)
226  {
227  duplicateSeedDetector.addSeeds(icontainer, *seedContainers[icontainer], measurementIndex,
228  m_paramEstimationTool->spacePointIndicesFun(),
229  [this,icontainer](const ActsTrk::Seed& seed) -> bool {
230  const bool reverseSearch = m_autoReverseSearch && shouldReverseSearch(seed);
231  const bool refitSeeds = icontainer < m_refitSeeds.size() && m_refitSeeds[icontainer];
232  const bool useTopSp = reverseSearch && !refitSeeds;
233  return useTopSp;
234  });
235  }
236 
237  // Get Beam pos and make pSurface
238  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle = SG::makeHandle( m_beamSpotKey, ctx );
239  ATH_CHECK( beamSpotHandle.isValid() );
240  const InDet::BeamSpotData* beamSpotData = beamSpotHandle.cptr();
241 
242  // Beam Spot Position
243  Acts::Vector3 beamPos( beamSpotData->beamPos().x() * Acts::UnitConstants::mm,
244  beamSpotData->beamPos().y() * Acts::UnitConstants::mm,
245  0 );
246 
247  // Construct a perigee surface as the target surface
248  std::shared_ptr<Acts::PerigeeSurface> pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(beamPos);
249 
250  // ================================================== //
251  // ===================== CONDS ====================== //
252  // ================================================== //
253 
254  std::vector<const InDetDD::SiDetectorElementCollection*> detElementsCollections;
255  std::size_t total_detElems = 0;
256  ATH_CHECK(getContainersFromKeys(ctx, m_detEleCollKeys, detElementsCollections, total_detElems));
257 
258  // ================================================== //
259  // ===================== COMPUTATION ================ //
260  // ================================================== //
261  Acts::VectorTrackContainer actsTrackBackend;
262  Acts::VectorMultiTrajectory actsTrackStateBackend;
263  {
264  std::lock_guard<std::mutex> lock( m_mutex );
265  actsTrackBackend.reserve(m_nTrackReserve);
266  actsTrackStateBackend.reserve(m_nTrackStateReserve);
267  }
268  detail::RecoTrackContainer actsTracksContainer(actsTrackBackend,
269  actsTrackStateBackend);
270 
271  if (m_addCounts) {
272  addCounts(actsTracksContainer);
273  }
274 
275  detail::ExpectedLayerPatternHelper::add(actsTracksContainer);
276 
277  EventStats event_stat;
278  event_stat.resize(m_stat.size());
279 
280  DetectorContextHolder detContext {
281  .geometry = m_trackingGeometryTool->getGeometryContext(ctx).context(),
282  .magField = m_extrapolationTool->getMagneticFieldContext(ctx),
283  // CalibrationContext converter not implemented yet.
284  .calib = getCalibrationContext(ctx)
285  };
286 
287  detail::SharedHitCounter sharedHits;
288 
289  // Perform the track finding for all initial parameters.
290  for (std::size_t icontainer = 0; icontainer < seedContainers.size(); ++icontainer)
291  {
292  ATH_CHECK(findTracks(detContext,
293  measurements,
294  measurementIndex,
295  sharedHits,
296  duplicateSeedDetector,
297  *seedContainers.at(icontainer),
298  *detElementsCollections.at(icontainer),
299  actsTracksContainer,
300  icontainer,
301  icontainer < m_seedLabels.size() ? m_seedLabels[icontainer].c_str() : m_seedContainerKeys[icontainer].key().c_str(),
302  event_stat,
303  m_storeDestinies ? destinies.at(icontainer).get() : nullptr,
304  *pSurface.get()));
305  }
306 
307  ATH_MSG_DEBUG(" \\__ Created " << actsTracksContainer.size() << " tracks");
308 
309  mon_nTracks = actsTracksContainer.size();
310  copyStats(event_stat);
311 
312 
313  // ================================================== //
314  // ===================== OUTPUTS ==================== //
315  // ================================================== //
316 
317  // Save the seed destinies
318  if (m_storeDestinies) {
319  for (std::size_t i(0); i<destinies.size(); ++i) {
320  const SG::WriteHandleKey< std::vector<int> >& writeKey = m_seedDestiny.at(i);
321  // make the handle and record
322  SG::WriteHandle< std::vector<int> > destinyHandle = SG::makeHandle( writeKey, ctx );
323  ATH_CHECK( destinyHandle.record( std::move( destinies.at(i) ) ) );
324  }
325  }
326 
327  {
328  std::lock_guard<std::mutex> lock( m_mutex );
329  // update the reserve space
330  if (actsTrackBackend.size() > m_nTrackReserve) {
331  m_nTrackReserve = static_cast<std::size_t>( std::ceil(m_memorySafetyMargin * actsTrackBackend.size()) );
332  }
333  if (actsTrackStateBackend.size() > m_nTrackStateReserve) {
334  m_nTrackStateReserve = static_cast<std::size_t>( std::ceil(m_memorySafetyMargin * actsTrackStateBackend.size()) );
335  }
336  }
337 
338  // handle the ambiguity
339  // we potentially need to short list the track candidates and make some copies
340  if (not m_ambi) {
341  // no need to shortlist anything. just use the actsTracksContainer
342  ATH_MSG_DEBUG(" \\__ Created " << actsTracksContainer.size() << " resolved tracks");
343  ATH_CHECK( storeTrackCollectionToStoreGate( ctx,
344  std::move(actsTrackBackend),
345  std::move(actsTrackStateBackend) ) );
346  return StatusCode::SUCCESS;
347  }
348 
349  // we have asked for the ambi
350  // we start by shortlisting the container
351  Acts::VectorTrackContainer resolvedTrackBackend;
352  Acts::VectorMultiTrajectory resolvedTrackStateBackend;
353  resolvedTrackBackend.reserve( actsTrackBackend.size() );
354  resolvedTrackStateBackend.reserve( actsTrackStateBackend.size() );
355  detail::RecoTrackContainer resolvedTracksContainer(resolvedTrackBackend, resolvedTrackStateBackend);
356  detail::ExpectedLayerPatternHelper::add(resolvedTracksContainer);
357 
358  if (m_addCounts) {
359  addCounts(resolvedTracksContainer);
360  }
361 
362  // Start ambiguity resolution
363  Acts::GreedyAmbiguityResolution::State state;
364  m_ambi->computeInitialState(actsTracksContainer, state, &sourceLinkHash,
365  &sourceLinkEquality);
366  m_ambi->resolve(state);
367 
368  // Copy the resolved tracks into the output container
369  // We need a different sharedHits counter here because it saves the track index
370  // and since I ran the resolving the track indices changed.
371  detail::SharedHitCounter sharedHits_forFinalAmbi;
372 
373  // shotlist
374  for (auto iTrack : state.selectedTracks) {
375  auto destProxy = resolvedTracksContainer.makeTrack();
376  destProxy.copyFrom(actsTracksContainer.getTrack(state.trackTips.at(iTrack)));
377 
378  if (m_countSharedHits) {
379  auto [nShared, nBadTrackMeasurements] = sharedHits_forFinalAmbi.computeSharedHits(destProxy, resolvedTracksContainer, measurementIndex);
380  if (nBadTrackMeasurements > 0)
381  ATH_MSG_ERROR("computeSharedHits: " << nBadTrackMeasurements << " track measurements not found in input track");
382  }
383  } // loop on tracks
384 
385  ATH_MSG_DEBUG(" \\__ Created " << resolvedTracksContainer.size() << " resolved tracks");
386 
387  ATH_CHECK( storeTrackCollectionToStoreGate( ctx,
388  std::move(resolvedTrackBackend),
389  std::move(resolvedTrackStateBackend)) );
390 
391  return StatusCode::SUCCESS;
392  }

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

◆ extrapolateTrackToReferenceSurface()

Acts::Result< void > ActsTrk::TrackFindingAlg::extrapolateTrackToReferenceSurface ( const DetectorContextHolder &  detContext,
detail::RecoTrackContainerProxy &  track,
const Acts::Surface &  referenceSurface,
const detail::Extrapolator &  propagator,
Acts::TrackExtrapolationStrategy  strategy,
ExpectedLayerPattern &  expectedLayerPattern 
) const
private

Definition at line 861 of file TrackFindingAlg.cxx.

867  {
868 
869  Acts::PropagatorOptions<detail::Stepper::Options, detail::Navigator::Options,
870  Acts::ActorList<Acts::MaterialInteractor, Collector>>
871  options(detContext.geometry, detContext.magField);
872 
873  auto findResult = findTrackStateForExtrapolation(
874  options.geoContext, track, referenceSurface, strategy, logger());
875 
876  if (!findResult.ok()) {
877  ACTS_ERROR("failed to find track state for extrapolation");
878  return findResult.error();
879  }
880 
881  auto &[trackState, distance] = *findResult;
882 
883  options.direction = Acts::Direction::fromScalarZeroAsPositive(distance);
884 
885  Acts::BoundTrackParameters parameters = track.createParametersFromState(trackState);
886  ACTS_VERBOSE("extrapolating track to reference surface at distance "
887  << distance << " with direction " << options.direction
888  << " with starting parameters " << parameters);
889 
890  auto state = propagator.makeState<decltype(options), Acts::ForcedSurfaceReached>(referenceSurface, options);
891  ExpectedLayerPattern*& collectorResult = state.get<TrackFindingAlg::ExpectedLayerPattern*>();
892  collectorResult = &expectedLayerPattern;
893 
894  auto initRes = propagator.initialize(state, parameters);
895  if(!initRes.ok()) {
896  ACTS_ERROR("Failed to initialize propgation state: " << initRes.error().message());
897  return initRes.error();
898  }
899 
900 
901  auto propagateOnlyResult =
902  propagator.propagate(state);
903 
904  if (!propagateOnlyResult.ok()) {
905  ACTS_ERROR("failed to extrapolate track: " << propagateOnlyResult.error().message());
906  return propagateOnlyResult.error();
907  }
908 
909  auto propagateResult = propagator.makeResult(
910  std::move(state), propagateOnlyResult, referenceSurface, options);
911 
912  if (!propagateResult.ok()) {
913  ACTS_ERROR("failed to extrapolate track: " << propagateResult.error().message());
914  return propagateResult.error();
915  }
916 
917  track.setReferenceSurface(referenceSurface.getSharedPtr());
918  track.parameters() = propagateResult->endParameters.value().parameters();
919  track.covariance() =
920  propagateResult->endParameters.value().covariance().value();
921 
922  return Acts::Result<void>::success();
923  }

◆ 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::TrackFindingAlg::finalize ( )
overridevirtual

Reimplemented from ActsTrk::TrackFindingBaseAlg.

Definition at line 145 of file TrackFindingAlg.cxx.

145  {
146  ATH_CHECK(TrackFindingBaseAlg::finalize());
147  return StatusCode::SUCCESS;
148  }

◆ findTracks()

StatusCode ActsTrk::TrackFindingAlg::findTracks ( const DetectorContextHolder &  detContext,
const detail::TrackFindingMeasurements &  measurements,
const detail::MeasurementIndex &  measurementIndex,
detail::SharedHitCounter &  sharedHits,
detail::DuplicateSeedDetector &  duplicateSeedDetector,
const ActsTrk::SeedContainer &  seeds,
const InDetDD::SiDetectorElementCollection &  detElements,
detail::RecoTrackContainer &  actsTracksContainer,
std::size_t  seedCollectionIndex,
const char *  seedType,
EventStats &  event_stat,
std::vector< int > *  destiny,
const Acts::PerigeeSurface &  pSurface 
) const
private

invoke track finding procedure

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

Definition at line 425 of file TrackFindingAlg.cxx.

438  {
439  ATH_MSG_DEBUG(name() << "::" << __FUNCTION__);
440 
441  auto [options, secondOptions, measurementSelector] = getDefaultOptions(detContext, measurements, &pSurface);
442 
443  // ActsTrk::MutableTrackContainer tracksContainerTemp;
444  Acts::VectorTrackContainer trackBackend;
445  Acts::VectorMultiTrajectory trackStateBackend;
446  detail::RecoTrackContainer tracksContainerTemp(trackBackend, trackStateBackend);
447 
448  if (m_addCounts) {
449  addCounts(tracksContainerTemp);
450  }
451 
452  detail::ExpectedLayerPatternHelper::add(tracksContainerTemp);
453 
454  std::size_t category_i = 0;
455  const auto &trackSelectorCfg = trackFinder().trackSelector.config();
456  auto stopBranchProxy = [&](const detail::RecoTrackContainer::TrackProxy &track,
457  const detail::RecoTrackContainer::TrackStateProxy &trackState) -> BranchStopperResult {
458  return stopBranch(track, trackState, trackSelectorCfg, detContext.geometry, measurementIndex, typeIndex, event_stat[category_i]);
459  };
460  options.extensions.branchStopper.connect(stopBranchProxy);
461 
462  Acts::PropagatorOptions<detail::Stepper::Options, detail::Navigator::Options,
463  Acts::ActorList<Acts::MaterialInteractor>>
464  extrapolationOptions(detContext.geometry, detContext.magField);
465 
466  Acts::TrackExtrapolationStrategy extrapolationStrategy =
467  Acts::TrackExtrapolationStrategy::first;
468 
469  // Perform the track finding for all initial parameters
470  ATH_MSG_DEBUG("Invoke track finding with " << seeds.size() << ' ' << seedType << " seeds.");
471 
472 
473  std::size_t nPrinted = 0;
474 
475  // Function for Estimate Track Parameters
476  auto retrieveSurfaceFunction =
477  [this, &detElements] (const ActsTrk::Seed& seed, bool useTopSp) -> const Acts::Surface& {
478  const xAOD::SpacePoint* sp = useTopSp ? seed.sp().back() : seed.sp().front();
479  const InDetDD::SiDetectorElement* element = detElements.getDetectorElement(useTopSp ? sp->elementIdList().back()
480  : sp->elementIdList().front());
481  const Trk::Surface& atlas_surface = element->surface();
482  return m_ATLASConverterTool->trkSurfaceToActsSurface(atlas_surface);
483  };
484 
485 
486 
487  // Loop over the track finding results for all initial parameters
488  for (unsigned int iseed = 0; iseed < seeds.size(); ++iseed)
489  {
490  // Get the seed
491  const ActsTrk::Seed& seed = *seeds[iseed];
492 
493  category_i = typeIndex * (m_statEtaBins.size() + 1);
494  tracksContainerTemp.clear();
495 
496  const bool reverseSearch = m_autoReverseSearch && shouldReverseSearch(seed);
497  const bool refitSeeds = typeIndex < m_refitSeeds.size() && m_refitSeeds[typeIndex];
498  const bool useTopSp = reverseSearch && !refitSeeds;
499 
500  // Check if the seed is a duplicate seed
501  const bool isDupSeed = duplicateSeedDetector.isDuplicate(typeIndex, iseed);
502 
503  if (isDupSeed) {
504  ATH_MSG_DEBUG("skip " << seedType << " seed " << iseed << " - already found");
505  category_i = getSeedCategory(typeIndex, seed, useTopSp);
506  ++event_stat[category_i][kNTotalSeeds];
507  ++event_stat[category_i][kNDuplicateSeeds];
508  if (m_storeDestinies) destiny->at(iseed) = DestinyType::DUPLICATE;
509  if (!m_trackStatePrinter.isSet()) continue; // delay continue to estimate track parms for TrackStatePrinter?
510  }
511 
512  // Set the option accordingly - we change the direction and the target surface accordingly
513  options.propagatorPlainOptions.direction = reverseSearch ? Acts::Direction::Backward() : Acts::Direction::Forward();
514  secondOptions.propagatorPlainOptions.direction = options.propagatorPlainOptions.direction.invert();
515  options.targetSurface = reverseSearch ? &pSurface : nullptr;
516  secondOptions.targetSurface = reverseSearch ? nullptr : &pSurface;
517  // TODO since the second pass is strictly an extension we should have a separate branch stopper which never drops and always extrapolates to the target surface
518 
519  // Get first estimate of parameters from the seed
520  std::optional<Acts::BoundTrackParameters> optTrackParams =
521  m_paramEstimationTool->estimateTrackParameters(seed,
522  useTopSp,
523  detContext.geometry,
524  detContext.magField,
525  retrieveSurfaceFunction);
526 
527  if (!optTrackParams) {
528  ATH_MSG_DEBUG("Failed to estimate track parameters for seed " << iseed);
529  if (!isDupSeed) {
530  category_i = getSeedCategory(typeIndex, seed, useTopSp);
531  ++event_stat[category_i][kNTotalSeeds];
532  ++event_stat[category_i][kNNoEstimatedParams];
533  if (m_storeDestinies) destiny->at(iseed) = DestinyType::FAILURE;
534  }
535  continue;
536  }
537 
538  Acts::BoundTrackParameters *initialParameters = &(*optTrackParams);
539  printSeed(iseed, detContext, seeds, *initialParameters, measurementIndex, nPrinted, seedType);
540  if (isDupSeed) continue; // skip now if not done before
541 
542  double etaInitial = -std::log(std::tan(0.5 * initialParameters->theta()));
543  category_i = getStatCategory(typeIndex, etaInitial);
544  ++event_stat[category_i][kNTotalSeeds]; // also updated for duplicate seeds
545  ++event_stat[category_i][kNUsedSeeds];
546 
547  // Optional refit track parameters to get more refined value
548  std::unique_ptr<Acts::BoundTrackParameters> refitSeedParameters;
549  if (refitSeeds) {
550  refitSeedParameters = doRefit(seed, *initialParameters, detContext, reverseSearch);
551  if (refitSeedParameters.get() == nullptr) {
552  ++event_stat[category_i][kNRejectedRefinedSeeds];
553  if (m_storeDestinies) destiny->at(iseed) = DestinyType::FAILURE;
554  continue;
555  }
556  if (refitSeedParameters.get() != initialParameters) {
557  initialParameters = refitSeedParameters.get();
558  printSeed(iseed, detContext, seeds, *initialParameters, measurementIndex, nPrinted, seedType, true);
559  }
560  }
561 
562  auto measurementRangesForced =
563  m_forceTrackOnSeed ? std::make_unique<ActsTrk::detail::MeasurementRangeListFlat>(measurements.setMeasurementRangesForced(seed, measurementIndex))
564  : nullptr;
565  measurementSelector->setMeasurementRangesForced(measurementRangesForced.get());
566  if (measurementRangesForced)
567  event_stat[category_i][kNForcedSeedMeasurements] += measurementRangesForced->size();
568 
569  // Get the Acts tracks, given this seed
570  // Result here contains a vector of TrackProxy objects
571  auto result = trackFinder().ckf.findTracks(*initialParameters, options, tracksContainerTemp);
572 
573  // The result for this seed
574  if (not result.ok()) {
575  ATH_MSG_WARNING("Track finding failed for " << seedType << " seed " << iseed << " with error" << result.error());
576  if (m_storeDestinies) destiny->at(iseed) = DestinyType::FAILURE;
577  continue;
578  }
579  auto &tracksForSeed = result.value();
580 
581 
582 
583  std::size_t ntracks = 0ul;
584 
585  // loop on the tracks we have just found from the seed
586  std::size_t nfirst = 0;
587  for (TrkProxy &firstTrack : tracksForSeed) {
588  // smoothing
589  auto smoothingResult = Acts::smoothTrack(detContext.geometry, firstTrack, logger(), Acts::MbfSmoother());
590  if (!smoothingResult.ok()) {
591  ATH_MSG_DEBUG("Smoothing for seed "
592  << iseed << " and first track " << firstTrack.index()
593  << " failed with error " << smoothingResult.error());
594  continue;
595  }
596 
597  // if no two way, just add the track and move on
598  if (not m_doTwoWay) {
599  // add the track to the collection
600  ATH_CHECK( addTrack(detContext,
601  firstTrack,
602  pSurface,
603  extrapolationStrategy,
604  sharedHits,
605  actsTracksContainer,
606  measurementIndex,
607  tracksContainerTemp,
608  duplicateSeedDetector,
609  destiny,
610  event_stat,
611  ntracks,
612  iseed,
613  category_i,
614  seedType) );
615  ++nfirst;
616  continue;
617  }
618 
619  // TWO WAY STARTS HERE
620  // We need the first measurement of the track
621  std::optional<detail::RecoTrackStateContainerProxy> firstMeas = getFirstMeasurementFromTrack(firstTrack);
622  // we are supposed to find a measurement
623  if (not firstMeas.has_value()) {
624  ATH_MSG_ERROR("Could not retrieve first measurement from track proxy. Is it ill-formed?");
625  return StatusCode::FAILURE;
626  }
627  detail::RecoTrackStateContainerProxy& firstMeasurement = firstMeas.value();
628 
629  // Get the tracks from the second track finding
630  std::vector<typename detail::RecoTrackContainer::TrackProxy> secondTracksForSeed =
631  doTwoWayTrackFinding(firstMeasurement,
632  firstTrack,
633  tracksContainerTemp,
634  secondOptions);
635 
636  if ( secondTracksForSeed.empty() ) {
637  ATH_MSG_DEBUG("No viable result from second track finding for " << seedType << " seed " << iseed << " track " << nfirst);
638  ++event_stat[category_i][kNoSecond];
639  ATH_CHECK( addTrack(detContext,
640  firstTrack,
641  pSurface,
642  extrapolationStrategy,
643  sharedHits,
644  actsTracksContainer,
645  measurementIndex,
646  tracksContainerTemp,
647  duplicateSeedDetector,
648  destiny,
649  event_stat,
650  ntracks,
651  iseed,
652  category_i,
653  seedType) );
654  }
655 
656  // need to add tracks here
657  // do the stiching
658  // store the original previous state to restore it later
659  auto originalFirstMeasurementPrevious = firstMeasurement.previous();
660  for (auto &secondTrack : secondTracksForSeed) {
661  secondTrack.reverseTrackStates(true);
662 
663  firstMeasurement.previous() = secondTrack.outermostTrackState().index();
664  secondTrack.tipIndex() = firstTrack.tipIndex();
665 
666  if (reverseSearch) {
667  // smooth the full track
668  auto secondSmoothingResult = Acts::smoothTrack(detContext.geometry,
669  secondTrack,
670  logger());
671  if ( not secondSmoothingResult.ok() ) {
672  continue;
673  }
674  secondTrack.reverseTrackStates(true);
675  }
676 
677  // Add track to collection
678  ATH_CHECK( addTrack(detContext,
679  secondTrack,
680  pSurface,
681  extrapolationStrategy,
682  sharedHits,
683  actsTracksContainer,
684  measurementIndex,
685  tracksContainerTemp,
686  duplicateSeedDetector,
687  destiny,
688  event_stat,
689  ntracks,
690  iseed,
691  category_i,
692  seedType) );
693  } // loop on tracks
694 
695  // finish the stiching
696  // restore the original previous state for the first track
697  firstMeasurement.previous() = originalFirstMeasurementPrevious;
698 
699  nfirst++;
700  } // loop on tracks from seed
701 
702  if (m_storeDestinies) {
703  if (ntracks == 0) {
704  destiny->at(iseed) = DestinyType::FAILURE;
705  } else {
706  destiny->at(iseed) = DestinyType::SUCCEED;
707  }
708  }
709 
710  if (ntracks == 0) {
711  ATH_MSG_DEBUG("Track finding found no track candidates for " << seedType << " seed " << iseed);
712  ++event_stat[category_i][kNoTrack];
713  } else if (ntracks >= 2) {
714  ++event_stat[category_i][kMultipleBranches];
715  }
716 
717  if (m_trackStatePrinter.isSet())
718  std::cout << std::flush;
719  } // loop on seeds
720 
721  ATH_MSG_DEBUG("Completed " << seedType << " track finding with " << computeStatSum(typeIndex, kNOutputTracks, event_stat) << " track candidates.");
722 
723  return StatusCode::SUCCESS;
724  }

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

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
protectedinherited

Retrieves track selector configuration for given eta value.

Parameters
etatrack candidate eta value

Definition at line 226 of file TrackFindingBaseAlg.cxx.

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

◆ getDefaultOptions()

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

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

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

Definition at line 199 of file TrackFindingBaseAlg.cxx.

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

◆ getSeedCategory()

std::size_t ActsTrk::TrackFindingAlg::getSeedCategory ( std::size_t  typeIndex,
const ActsTrk::Seed &  seed,
bool  useTopSp 
) const
private

Definition at line 806 of file TrackFindingAlg.cxx.

809  {
810  const xAOD::SpacePoint* sp = useTopSp ? seed.sp().back() : seed.sp().front();
811  const xAOD::SpacePoint::ConstVectorMap pos = sp->globalPosition();
812  double etaSeed = std::atanh(pos[2] / pos.norm());
813  return getStatCategory(typeIndex, etaSeed);
814  }

◆ getStatCategory()

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

Definition at line 751 of file TrackFindingBaseAlg.cxx.

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

◆ initCounts()

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

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::TrackFindingAlg::initialize ( )
overridevirtual

Reimplemented from ActsTrk::TrackFindingBaseAlg.

Definition at line 78 of file TrackFindingAlg.cxx.

79  {
80  ATH_MSG_INFO("Initializing " << name() << " ... ");
81 
82  ATH_CHECK(TrackFindingBaseAlg::initialize());
83  ATH_MSG_DEBUG(" " << m_skipDuplicateSeeds);
84  ATH_MSG_DEBUG(" " << m_refitSeeds);
85  ATH_MSG_DEBUG(" " << m_statEtaBins);
86  ATH_MSG_DEBUG(" " << m_seedLabels);
87  ATH_MSG_DEBUG(" " << m_dumpAllStatEtaBins);
88  ATH_MSG_DEBUG(" " << m_useTopSpRZboundary);
89  ATH_MSG_DEBUG(" " << m_seedMeasOffset);
90  ATH_MSG_DEBUG(" " << m_ambiStrategy);
91  ATH_MSG_DEBUG(" " << m_autoReverseSearch);
92  ATH_MSG_DEBUG(" " << m_countSharedHits);
93  ATH_MSG_DEBUG(" " << m_forceTrackOnSeed);
94 
95  ATH_CHECK(m_paramEstimationTool.retrieve());
96  ATH_CHECK(m_seedContainerKeys.initialize());
97  ATH_CHECK(m_detEleCollKeys.initialize());
98  ATH_CHECK(m_uncalibratedMeasurementContainerKeys.initialize());
99  ATH_CHECK(m_volumeIdToDetectorElementCollMapKey.initialize());
100  ATH_CHECK(m_detElStatus.initialize());
101  ATH_CHECK(m_beamSpotKey.initialize());
102 
103  m_storeDestinies = not m_seedDestiny.empty();
104  ATH_CHECK(m_seedDestiny.initialize(m_storeDestinies));
105 
106  if (m_seedContainerKeys.size() != m_detEleCollKeys.size())
107  {
108  ATH_MSG_FATAL("There are " << m_detEleCollKeys.size() << " DetectorElementsKeys, but " << m_seedContainerKeys.size() << " SeedContainerKeys");
109  return StatusCode::FAILURE;
110  }
111 
112  if (m_detEleCollKeys.size() != m_seedLabels.size())
113  {
114  ATH_MSG_FATAL("There are " << m_seedLabels.size() << " SeedLabels, but " << m_detEleCollKeys.size() << " DetectorElementsKeys");
115  return StatusCode::FAILURE;
116  }
117 
118  if (m_useTopSpRZboundary.size() != 2)
119  {
120  ATH_MSG_FATAL("useTopSpRZboundary must have 2 elements, but has " << m_useTopSpRZboundary.size());
121  return StatusCode::FAILURE;
122  }
123 
124  if (m_ambiStrategy == 1u /* END_OF_TF */) {
125  Acts::GreedyAmbiguityResolution::Config cfg;
126  cfg.maximumSharedHits = m_maximumSharedHits;
127  cfg.maximumIterations = m_maximumIterations;
128  cfg.nMeasurementsMin = m_nMeasurementsMin;
129 
130  m_ambi.emplace(std::move(cfg), makeActsAthenaLogger(this, "Acts"));
131  }
132 
133  if (m_storeDestinies) {
134  if (m_seedDestiny.size() != m_seedContainerKeys.size()) {
135  ATH_MSG_ERROR("There are " << m_seedDestiny.size() << " seed destiny collections, but " << m_seedContainerKeys.size() << " seed collections");
136  return StatusCode::FAILURE;
137  }
138  }
139 
140  return StatusCode::SUCCESS;
141  }

◆ initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector ( )
protectedinherited

Definition at line 503 of file TrackFindingBaseAlg.cxx.

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

◆ initStatTables()

void ActsTrk::TrackFindingBaseAlg::initStatTables ( )
protectedinherited

Definition at line 532 of file TrackFindingBaseAlg.cxx.

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

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

◆ logger()

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

Private access to the logger.

Definition at line 320 of file TrackFindingBaseAlg.h.

321  {
322  return *m_logger;
323  }

◆ measurementType()

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

Definition at line 262 of file TrackFindingBaseAlg.cxx.

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

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ nSeedCollections()

std::size_t ActsTrk::TrackFindingBaseAlg::nSeedCollections ( ) const
inlineprotectedinherited

Definition at line 333 of file TrackFindingBaseAlg.h.

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

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ printSeed()

void ActsTrk::TrackFindingAlg::printSeed ( unsigned int  iseed,
const DetectorContextHolder &  detContext,
const ActsTrk::SeedContainer &  seeds,
const Acts::BoundTrackParameters &  seedParameters,
const detail::MeasurementIndex &  measurementIndex,
std::size_t &  nPrinted,
const char *  seedType,
bool  isKF = false 
) const
private

Definition at line 816 of file TrackFindingAlg.cxx.

824  {
825  if (not m_trackStatePrinter.isSet()) return;
826 
827  if (nPrinted == 0) {
828  ATH_MSG_INFO("CKF results for " << seeds.size() << ' ' << seedType << " seeds:");
829  }
830  ++nPrinted;
831  m_trackStatePrinter->printSeed(detContext.geometry, *seeds[iseed], seedParameters, measurementIndex, iseed, isKF);
832  }

◆ printStatTables()

void ActsTrk::TrackFindingBaseAlg::printStatTables ( ) const
protectedinherited

Definition at line 565 of file TrackFindingBaseAlg.cxx.

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

◆ propagateDetectorElementStatusToMeasurements()

StatusCode ActsTrk::TrackFindingAlg::propagateDetectorElementStatusToMeasurements ( const ActsTrk::ActsVolumeIdToDetectorElementCollectionMap &  volume_id_to_det_el_coll,
const std::vector< const InDet::SiDetectorElementStatus * > &  det_el_status_arr,
detail::TrackFindingMeasurements &  measurements 
) const
private

Definition at line 749 of file TrackFindingAlg.cxx.

751  {
752  const Acts::TrackingGeometry *
753  acts_tracking_geometry = m_trackingGeometryTool->trackingGeometry().get();
754  ATH_CHECK(acts_tracking_geometry != nullptr);
755 
756  using Counter = struct { unsigned int n_volumes, n_volumes_with_status, n_missing_detector_elements, n_detector_elements, n_disabled_detector_elements;};
757  Counter counter {0u,0u,0u,0u,0u};
758  acts_tracking_geometry->visitVolumes([&counter,
759  &volume_id_to_det_el_coll,
760  &det_el_status_arr,
761  &measurements,
762  this](const Acts::TrackingVolume *volume_ptr) {
763  ++counter.n_volumes;
764  if (!volume_ptr) return;
765 
766  const InDet::SiDetectorElementStatus*
767  det_el_status = det_el_status_arr.at(volume_id_to_det_el_coll.collecionMap().at(volume_ptr->geometryId().volume()));
768  if (det_el_status) {
769  ++counter.n_volumes_with_status;
770  volume_ptr->visitSurfaces([&counter, det_el_status, &measurements,this](const Acts::Surface *surface_ptr) {
771  if (!surface_ptr) return;
772  const Acts::Surface &surface = *surface_ptr;
773  const Acts::DetectorElementBase*detector_element = surface.associatedDetectorElement();
774  if (detector_element) {
775  ++counter.n_detector_elements;
776  const ActsDetectorElement *acts_detector_element = static_cast<const ActsDetectorElement*>(detector_element);
777  if (!det_el_status->isGood( acts_detector_element->identifyHash() )) {
778  ActsTrk::detail::MeasurementRange old_range = measurements.markSurfaceInsensitive(surface_ptr->geometryId());
779  if (!old_range.empty()) {
780  auto geoid_to_string = [](const Acts::GeometryIdentifier &id) -> std::string {
781  std::stringstream amsg;
782  amsg << id;
783  return amsg.str();
784  };
785  std::string a_msg ( geoid_to_string(surface_ptr->geometryId()));
786  ATH_MSG_WARNING("Reject " << (old_range.elementEndIndex() - old_range.elementBeginIndex())
787  << " measurements because surface " << a_msg);
788  }
789  ++counter.n_disabled_detector_elements;
790  }
791  }
792  }, true /*only sensitive surfaces*/);
793  }
794  else {
795  ++counter.n_missing_detector_elements;
796  }
797  });
798  ATH_MSG_DEBUG("Volumes with detector element status " << counter.n_volumes_with_status << " / " << counter.n_volumes
799  << " disabled detector elements " << counter.n_disabled_detector_elements
800  << " / " << counter.n_detector_elements
801  << " missing detector elements "
802  << counter.n_missing_detector_elements);
803  return StatusCode::SUCCESS;
804  }

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

Definition at line 336 of file TrackFindingBaseAlg.h.

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

◆ selectCounts()

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

Definition at line 477 of file TrackFindingBaseAlg.cxx.

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

◆ selectCountsFinal()

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

Definition at line 772 of file TrackFindingBaseAlg.cxx.

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

◆ setFilterPassed()

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

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ setMeasurementSelector()

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

Setup and attach measurement selector to KF options.

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

Definition at line 182 of file TrackFindingBaseAlg.cxx.

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

◆ shouldReverseSearch()

bool ActsTrk::TrackFindingAlg::shouldReverseSearch ( const ActsTrk::Seed &  seed) const
private

Definition at line 410 of file TrackFindingAlg.cxx.

410  {
411  const auto& bottom_sp = seed.sp().front();
412 
413  const double r = bottom_sp->radius();
414  const double z = std::abs(bottom_sp->z());
415 
416  const double rBoundary = m_useTopSpRZboundary.value()[0];
417  const double zBoundary = m_useTopSpRZboundary.value()[1];
418 
419  return r > rBoundary || z > zBoundary;
420  }

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

Branch stopper.

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

Definition at line 281 of file TrackFindingBaseAlg.cxx.

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

◆ storeSeedInfo()

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

Definition at line 727 of file TrackFindingAlg.cxx.

730  {
731 
732  const auto lastMeasurementIndex = track.tipIndex();
733  duplicateSeedDetector.newTrajectory();
734 
735  tracksContainer.trackStateContainer().visitBackwards(
736  lastMeasurementIndex,
737  [&duplicateSeedDetector,&measurementIndex](const detail::RecoTrackStateContainer::ConstTrackStateProxy &state) -> void
738  {
739  // Check there is a source link
740  if (not state.hasUncalibratedSourceLink())
741  return;
742 
743  // Fill the duplicate selector
744  auto sl = state.getUncalibratedSourceLink().template get<ATLASUncalibSourceLink>();
745  duplicateSeedDetector.addMeasurement(sl, measurementIndex);
746  }); // end visitBackwards
747  }

◆ storeTrackCollectionToStoreGate()

StatusCode ActsTrk::TrackFindingAlg::storeTrackCollectionToStoreGate ( const EventContext &  ctx,
Acts::VectorTrackContainer &&  originalTrackBackend,
Acts::VectorMultiTrajectory &&  originalTrackStateBackend 
) const
private

Definition at line 394 of file TrackFindingAlg.cxx.

397  {
398  // convert to const
399  Acts::ConstVectorTrackContainer constTrackBackend( std::move(originalTrackBackend) );
400  Acts::ConstVectorMultiTrajectory constTrackStateBackend( std::move(originalTrackStateBackend) );
401  std::unique_ptr< ActsTrk::TrackContainer> constTracksContainer = std::make_unique< ActsTrk::TrackContainer >( std::move(constTrackBackend),
402  std::move(constTrackStateBackend) );
403 
404  SG::WriteHandle<ActsTrk::TrackContainer> trackContainerHandle = SG::makeHandle(m_trackContainerKey, ctx);
405  ATH_MSG_DEBUG(" \\__ Tracks Container `" << m_trackContainerKey.key() << "` created ...");
406  ATH_CHECK(trackContainerHandle.record(std::move(constTracksContainer)));
407  return StatusCode::SUCCESS;
408  }

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

Definition at line 19 of file TrackFindingBaseAlg.cxx.

19 { return *m_trackFinder; }

◆ trackFinder() [2/2]

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

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 
)
staticprotectedinherited

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/3]

std::size_t m_nTrackReserve ActsTrk::TrackFindingAlg::ATLAS_THREAD_SAFE {0ul}
mutableprivate

Definition at line 193 of file TrackFindingAlg.h.

◆ ATLAS_THREAD_SAFE [2/3]

std::size_t m_nTrackStateReserve ActsTrk::TrackFindingAlg::ATLAS_THREAD_SAFE {0ul}
mutableprivate

Definition at line 194 of file TrackFindingAlg.h.

◆ ATLAS_THREAD_SAFE [3/3]

std::mutex m_mutex ActsTrk::TrackFindingAlg::ATLAS_THREAD_SAFE {}
mutableprivate

Definition at line 195 of file TrackFindingAlg.h.

◆ m_absEtaMax

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

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"}
protectedinherited

Definition at line 108 of file TrackFindingBaseAlg.h.

◆ m_absEtaMin

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

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"}
protectedinherited

Definition at line 137 of file TrackFindingBaseAlg.h.

◆ m_ambi

std::optional<Acts::GreedyAmbiguityResolution> ActsTrk::TrackFindingAlg::m_ambi
private

Definition at line 141 of file TrackFindingAlg.h.

◆ m_ambiStrategy

Gaudi::Property<std::size_t> ActsTrk::TrackFindingAlg::m_ambiStrategy {this, "ambiStrategy", 0, "0 - Do ambiguity resolution outside track finding; 1 - Do ambiguity in track finding using GreedyAmbiguitySolver tool; 2 - Do shared hit cut during track candidate selection"}
private

Definition at line 132 of file TrackFindingAlg.h.

◆ m_ATLASConverterTool

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

Definition at line 91 of file TrackFindingBaseAlg.h.

◆ m_autoReverseSearch

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_autoReverseSearch {this, "autoReverseSearch", false, "Whether to run the finding in seed parameter direction (false or not specified) or reverse direction (true), automatically determined by the param estimation tool"}
private

Definition at line 120 of file TrackFindingAlg.h.

◆ m_beamSpotKey

SG::ReadCondHandleKey< InDet::BeamSpotData > ActsTrk::TrackFindingAlg::m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
private

Definition at line 113 of file TrackFindingAlg.h.

◆ m_branchStopperAbsEtaMaxExtra

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

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"}
protectedinherited

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"}
protectedinherited

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"}
protectedinherited

Definition at line 111 of file TrackFindingBaseAlg.h.

◆ m_chi2CutOff

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

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"}
protectedinherited

Definition at line 105 of file TrackFindingBaseAlg.h.

◆ m_countSharedHits

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

Definition at line 121 of file TrackFindingAlg.h.

◆ m_d0Max

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

Definition at line 127 of file TrackFindingBaseAlg.h.

◆ m_d0Min

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

Definition at line 126 of file TrackFindingBaseAlg.h.

◆ m_detEleCollKeys

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

Definition at line 101 of file TrackFindingAlg.h.

◆ m_detElStatus

SG::ReadHandleKeyArray<InDet::SiDetectorElementStatus> ActsTrk::TrackFindingAlg::m_detElStatus {this, "DetElStatus", {}, "Keys for detector element status conditions data."}
private

Definition at line 108 of file TrackFindingAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doBranchStopper

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

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"}
protectedinherited

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."}
protectedinherited

Definition at line 153 of file TrackFindingBaseAlg.h.

◆ m_endOfWorldVolumeIds

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

Definition at line 148 of file TrackFindingBaseAlg.h.

◆ m_etaBins

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

Definition at line 102 of file TrackFindingBaseAlg.h.

◆ m_etaMax

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

Definition at line 121 of file TrackFindingBaseAlg.h.

◆ m_etaMin

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

Definition at line 120 of file TrackFindingBaseAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_extrapolationTool

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

Definition at line 88 of file TrackFindingBaseAlg.h.

◆ m_fitterTool

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

Definition at line 92 of file TrackFindingBaseAlg.h.

◆ m_forceTrackOnSeed

Gaudi::Property<bool> ActsTrk::TrackFindingAlg::m_forceTrackOnSeed {this, "forceTrackOnSeed", true, "force track to use measurements from the seed"}
private

Definition at line 122 of file TrackFindingAlg.h.

◆ m_hgtdCalibTool

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

Definition at line 95 of file TrackFindingBaseAlg.h.

◆ m_logger

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

logging instance

Definition at line 326 of file TrackFindingBaseAlg.h.

◆ m_maxChi2

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

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"}
protectedinherited

Definition at line 143 of file TrackFindingBaseAlg.h.

◆ m_maxHgtdOutliers

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

Definition at line 146 of file TrackFindingBaseAlg.h.

◆ m_maxHoles

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

Definition at line 132 of file TrackFindingBaseAlg.h.

◆ m_maximumIterations

Gaudi::Property<unsigned int> ActsTrk::TrackFindingAlg::m_maximumIterations {this, "MaximumIterations", 10000u, "Maximum number of iterations to resolve ambiguities among all tracks."}
private

Definition at line 128 of file TrackFindingAlg.h.

◆ m_maximumSharedHits

Gaudi::Property<unsigned int> ActsTrk::TrackFindingAlg::m_maximumSharedHits {this, "MaximumSharedHits", 3u, "Maximum number of shared hits per track."}
private

Definition at line 126 of file TrackFindingAlg.h.

◆ m_maxOutliers

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

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"}
protectedinherited

Definition at line 141 of file TrackFindingBaseAlg.h.

◆ m_maxPixelOutliers

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

Definition at line 144 of file TrackFindingBaseAlg.h.

◆ m_maxPropagationStep

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

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"}
protectedinherited

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"}
protectedinherited

Definition at line 142 of file TrackFindingBaseAlg.h.

◆ m_maxStripOutliers

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

Definition at line 145 of file TrackFindingBaseAlg.h.

◆ m_measurementSelectorConfig

struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig ActsTrk::TrackFindingBaseAlg::m_measurementSelectorConfig
protectedinherited

◆ m_memorySafetyMargin

Gaudi::Property< float > ActsTrk::TrackFindingAlg::m_memorySafetyMargin {this, "MemorySafetyMargin", 1.2}
private

Definition at line 192 of file TrackFindingAlg.h.

◆ m_minHgtdHits

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

Definition at line 140 of file TrackFindingBaseAlg.h.

◆ m_minMeasurements

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

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"}
protectedinherited

Definition at line 138 of file TrackFindingBaseAlg.h.

◆ m_minStripHits

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

Definition at line 139 of file TrackFindingBaseAlg.h.

◆ m_monTool

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

Definition at line 87 of file TrackFindingBaseAlg.h.

◆ m_nMeasurementsMin

Gaudi::Property<unsigned int> ActsTrk::TrackFindingAlg::m_nMeasurementsMin {this, "NMeasurementsMin", 7u, "Minimum number of measurements per track."}
private

Definition at line 130 of file TrackFindingAlg.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"}
protectedinherited

Definition at line 106 of file TrackFindingBaseAlg.h.

◆ m_paramEstimationTool

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

Definition at line 96 of file TrackFindingAlg.h.

◆ m_phiMax

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

Definition at line 119 of file TrackFindingBaseAlg.h.

◆ m_phiMin

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

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"}
protectedinherited

Definition at line 93 of file TrackFindingBaseAlg.h.

◆ m_ptMax

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

Definition at line 125 of file TrackFindingBaseAlg.h.

◆ m_ptMin

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

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"}
protectedinherited

Definition at line 107 of file TrackFindingBaseAlg.h.

◆ m_refitSeeds

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

Definition at line 118 of file TrackFindingAlg.h.

◆ m_seedContainerKeys

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

Definition at line 100 of file TrackFindingAlg.h.

◆ m_seedDestiny

SG::WriteHandleKeyArray< std::vector<int> > ActsTrk::TrackFindingAlg::m_seedDestiny {this, "SeedDestiny", {}}
private

Definition at line 112 of file TrackFindingAlg.h.

◆ m_seedLabels

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

Definition at line 152 of file TrackFindingBaseAlg.h.

◆ m_seedMeasOffset

Gaudi::Property<unsigned int> ActsTrk::TrackFindingAlg::m_seedMeasOffset {this,"seedMeasOffset", 0, "Reduce the requirement on the space points on seed to mark a seed as duplicate, e.g seedMeasOffset=1, only N-1 measurements on seed are sufficient deduplicate the seed"}
private

Definition at line 117 of file TrackFindingAlg.h.

◆ m_skipDuplicateSeeds

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

Definition at line 116 of file TrackFindingAlg.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."}
protectedinherited

Definition at line 151 of file TrackFindingBaseAlg.h.

◆ m_storeDestinies

bool ActsTrk::TrackFindingAlg::m_storeDestinies {false}
private

Definition at line 111 of file TrackFindingAlg.h.

◆ m_stripCalibTool

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

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)"}
protectedinherited

Definition at line 97 of file TrackFindingBaseAlg.h.

◆ m_trackFinder

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

Definition at line 81 of file TrackFindingBaseAlg.h.

◆ m_trackingGeometryTool

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

Definition at line 89 of file TrackFindingBaseAlg.h.

◆ m_tracksBackendHandlesHelper

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

Definition at line 98 of file TrackFindingBaseAlg.h.

◆ m_trackStatePrinter

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

Definition at line 90 of file TrackFindingBaseAlg.h.

◆ m_unalibMeasSurfAcc

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

Definition at line 83 of file TrackFindingBaseAlg.h.

◆ m_uncalibratedMeasurementContainerKeys

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

Definition at line 103 of file TrackFindingAlg.h.

◆ m_useAbsEtaForStat

bool ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat = false
protectedinherited

Definition at line 342 of file TrackFindingBaseAlg.h.

◆ m_useTopSpRZboundary

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingAlg::m_useTopSpRZboundary {this, "useTopSpRZboundary", {350. * Acts::UnitConstants::mm, 1060. * Acts::UnitConstants::mm}, "R/Z boundary for using the top space point in the track parameter estimation"}
private

Definition at line 119 of file TrackFindingAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_volumeIdToDetectorElementCollMapKey

SG::ReadCondHandleKey<ActsTrk::ActsVolumeIdToDetectorElementCollectionMap> ActsTrk::TrackFindingAlg::m_volumeIdToDetectorElementCollMapKey
private
Initial value:
{this, "ActsVolumeIdToDetectorElementCollectionMapKey", "ActsVolumeIdToDetectorElementCollectionMap",
"Map which associates Acts geometry volume IDs to detector element collections."}

Definition at line 104 of file TrackFindingAlg.h.

◆ m_z0Max

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

Definition at line 129 of file TrackFindingBaseAlg.h.

◆ m_z0Min

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

Definition at line 128 of file TrackFindingBaseAlg.h.

◆ s_branchState

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

Definition at line 305 of file TrackFindingBaseAlg.h.

The documentation for this class was generated from the following files:
xAOD::strategy
strategy
Definition: L2CombinedMuon_v1.cxx:108
ActsTrk::detail::RecoTrackStateContainerProxy
RecoTrackStateContainer::TrackStateProxy RecoTrackStateContainerProxy
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:25
ActsTrk::TrackFindingBaseAlg::m_trackContainerKey
SG::WriteHandleKey< ActsTrk::TrackContainer > m_trackContainerKey
Definition: TrackFindingBaseAlg.h:97
python.StoreID.UNKNOWN
int UNKNOWN
Definition: StoreID.py:16
ActsTrk::TrackFindingAlg::m_maximumSharedHits
Gaudi::Property< unsigned int > m_maximumSharedHits
Definition: TrackFindingAlg.h:127
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nPixelOutliers
Definition: TrackFindingBaseAlg.h:301
ActsTrk::TrackFindingBaseAlg::doTwoWayTrackFinding
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.
Definition: TrackFindingBaseAlg.cxx:235
beamspotman.r
def r
Definition: beamspotman.py:672
ActsTrk::getCalibrationContext
Acts::CalibrationContext getCalibrationContext(const EventContext &ctx)
The Acts::Calibration context is piped through the Acts fitters to (re)calibrate the Acts::SourceLink...
Definition: CalibrationContext.h:15
ActsTrk::TrackFindingAlg::m_ambiStrategy
Gaudi::Property< std::size_t > m_ambiStrategy
Definition: TrackFindingAlg.h:132
ActsTrk::TrackFindingBaseAlg::m_doBranchStopper
Gaudi::Property< bool > m_doBranchStopper
Definition: TrackFindingBaseAlg.h:109
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
ActsTrk::TrackFindingAlg::extrapolateTrackToReferenceSurface
Acts::Result< void > extrapolateTrackToReferenceSurface(const DetectorContextHolder &detContext, detail::RecoTrackContainerProxy &track, const Acts::Surface &referenceSurface, const detail::Extrapolator &propagator, Acts::TrackExtrapolationStrategy strategy, ExpectedLayerPattern &expectedLayerPattern) const
Definition: TrackFindingAlg.cxx:861
ActsTrk::detail::getMeasurementSelector
std::unique_ptr< ActsTrk::IMeasurementSelector > getMeasurementSelector(const ActsTrk::IOnBoundStateCalibratorTool *onTrackCalibratorTool, const ActsTrk::detail::MeasurementRangeList &measurementRanges, const std::vector< float > &etaBinsf, const std::vector< std::pair< float, float > > &chi2CutOffOutlier, const std::vector< size_t > &numMeasurementsCutOff)
Definition: AtlasMeasurementSelector.cxx:404
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ActsTrk::TrackFindingBaseAlg::kNStat
@ kNStat
Definition: TrackFindingBaseAlg.h:173
xAOD::UncalibMeasType::HGTDClusterType
@ HGTDClusterType
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
ActsTrk::TrackFindingBaseAlg::m_pixelCalibTool
ToolHandle< ActsTrk::IOnTrackCalibratorTool< detail::RecoTrackStateContainer > > m_pixelCalibTool
Definition: TrackFindingBaseAlg.h:93
get_generator_info.result
result
Definition: get_generator_info.py:21
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
ActsTrk::TrackFindingBaseAlg::m_maxStripHoles
Gaudi::Property< std::vector< std::size_t > > m_maxStripHoles
Definition: TrackFindingBaseAlg.h:142
ActsTrk::TrackFindingAlg::printSeed
void printSeed(unsigned int iseed, const DetectorContextHolder &detContext, const ActsTrk::SeedContainer &seeds, const Acts::BoundTrackParameters &seedParameters, const detail::MeasurementIndex &measurementIndex, std::size_t &nPrinted, const char *seedType, bool isKF=false) const
Definition: TrackFindingAlg.cxx:816
ActsTrk::IMeasurementSelector::connect
virtual void connect(std::any delegate_wrap) const =0
ActsTrk::TrackFindingBaseAlg::TrkProxy
Acts::TrackProxy< Acts::VectorTrackContainer, Acts::VectorMultiTrajectory, Acts::detail::RefHolder, false > TrkProxy
Definition: TrackFindingBaseAlg.h:246
ActsTrk::TrackFindingBaseAlg::s_branchState
static constexpr BranchState s_branchState
Definition: TrackFindingBaseAlg.h:305
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
FullCPAlgorithmsTest_eljob.flush
flush
Definition: FullCPAlgorithmsTest_eljob.py:194
ActsTrk::TrackFindingAlg::getSeedCategory
std::size_t getSeedCategory(std::size_t typeIndex, const ActsTrk::Seed &seed, bool useTopSp) const
Definition: TrackFindingAlg.cxx:806
ActsTrk::TrackFindingBaseAlg::TrackFinderOptions
Acts::CombinatorialKalmanFilterOptions< detail::RecoTrackContainer > TrackFinderOptions
Definition: TrackFindingBaseAlg.h:54
xAOD::SpacePoint_v1::elementIdList
const std::vector< DetectorIDHashType > & elementIdList() const
Returns the IdentifierHash of the spacepoint (corresponds to the detector element IdentifierHash)
Definition: SpacePoint_v1.cxx:14
ActsTrk::ActsVolumeIdToDetectorElementCollectionMap::collecionMap
const std::array< unsigned char, 256 > & collecionMap() const
Definition: ActsVolumeIdToDetectorElementCollectionMap.h:36
ActsTrk::TrackFindingBaseAlg::updateCounts
static void updateCounts(const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateType typeFlags, xAOD::UncalibMeasType detType)
Definition: TrackFindingBaseAlg.cxx:410
ActsTrk::TrackFindingAlg::m_seedMeasOffset
Gaudi::Property< unsigned int > m_seedMeasOffset
Definition: TrackFindingAlg.h:117
ActsTrk::TrackFindingAlg::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrackFindingAlg.h:113
ActsTrk::TrackFindingBaseAlg::kNoSecond
@ kNoSecond
Definition: TrackFindingBaseAlg.h:168
make_unique
std::unique_ptr< T > make_unique(Args &&... args)
Definition: SkimmingToolEXOT5.cxx:23
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
ActsTrk::TrackFindingBaseAlg::m_addCounts
Gaudi::Property< bool > m_addCounts
Definition: TrackFindingBaseAlg.h:137
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
xAOD::UncalibMeasType::StripClusterType
@ StripClusterType
ActsTrk::TrackFindingBaseAlg::initialize
virtual StatusCode initialize() override
Definition: TrackFindingBaseAlg.cxx:26
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
ActsTrk::TrackFindingBaseAlg::finalize
virtual StatusCode finalize() override
Definition: TrackFindingBaseAlg.cxx:176
ActsTrk::detail::ExpectedLayerPatternHelper::set
static void set(track_proxy_t &track, std::array< unsigned int, 4 > values)
Definition: ExpectedHitUtils.h:51
ActsTrk::TrackFindingBaseAlg::m_maxHgtdHoles
Gaudi::Property< std::vector< std::size_t > > m_maxHgtdHoles
Definition: TrackFindingBaseAlg.h:143
ActsTrk::TrackFindingBaseAlg::m_minHgtdHits
Gaudi::Property< std::vector< std::size_t > > m_minHgtdHits
Definition: TrackFindingBaseAlg.h:140
ActsTrk::detail::CKF_config::trackSelector
Acts::TrackSelector trackSelector
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:48
ActsTrk::TrackFindingBaseAlg::EventStats
std::vector< std::array< unsigned int, kNStat > > EventStats
Definition: TrackFindingBaseAlg.h:176
ActsTrk::TrackFindingBaseAlg::m_maxPixelHoles
Gaudi::Property< std::vector< std::size_t > > m_maxPixelHoles
Definition: TrackFindingBaseAlg.h:141
ActsTrk::TrackFindingBaseAlg::addCounts
static void addCounts(detail::RecoTrackContainer &tracksContainer)
Definition: TrackFindingBaseAlg.cxx:384
ActsTrk::TrackFindingAlg::FAILURE
@ FAILURE
Definition: TrackFindingAlg.h:190
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::getDefaultOptions
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.
Definition: TrackFindingBaseAlg.cxx:199
ActsTrk::TrackFindingBaseAlg::m_dumpAllStatEtaBins
Gaudi::Property< bool > m_dumpAllStatEtaBins
Definition: TrackFindingBaseAlg.h:153
xAOD::SpacePoint_v1::globalPosition
ConstVectorMap globalPosition() const
Returns the global position of the pixel cluster.
Definition: SpacePoint_v1.cxx:25
ActsTrk::TrackFindingBaseAlg::BranchState::nHgtdHits
static constexpr Acts::ProxyAccessor< unsigned int > nHgtdHits
Definition: TrackFindingBaseAlg.h:297
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
ActsTrk::TrackFindingAlg::SUCCEED
@ SUCCEED
Definition: TrackFindingAlg.h:190
ActsTrk::TrackFindingBaseAlg::m_absEtaMaxMeasurements
Gaudi::Property< std::vector< std::size_t > > m_absEtaMaxMeasurements
Definition: TrackFindingBaseAlg.h:108
InDetDD::SolidStateDetectorElementBase::surface
Trk::Surface & surface()
Element Surface.
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:210
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::BranchStopperResult
Acts::CombinatorialKalmanFilterBranchStopperResult BranchStopperResult
Definition: TrackFindingBaseAlg.h:271
xAOD::SpacePoint_v1::ConstVectorMap
Eigen::Map< const Eigen::Matrix< float, 3, 1 > > ConstVectorMap
Definition: SpacePoint_v1.h:31
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
ActsTrk::TrackFindingAlg::m_autoReverseSearch
Gaudi::Property< bool > m_autoReverseSearch
Definition: TrackFindingAlg.h:120
TableUtils::defineSimpleRatio
RatioDefinition defineSimpleRatio(T numerator, T denominator)
Definition: TableUtils.h:384
ActsTrk::TrackFindingAlg::m_refitSeeds
Gaudi::Property< std::vector< bool > > m_refitSeeds
Definition: TrackFindingAlg.h:118
xAOD::SpacePoint_v1
Definition: SpacePoint_v1.h:29
ActsTrk::TrackFindingBaseAlg::computeStatSum
std::size_t computeStatSum(std::size_t seed_collection, EStat counter_i, const EventStats &stat) const
Definition: TrackFindingBaseAlg.cxx:760
ActsTrk::TrackFindingBaseAlg::kNUsedSeeds
@ kNUsedSeeds
Definition: TrackFindingBaseAlg.h:159
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelHits
static constexpr Acts::ProxyAccessor< unsigned int > nPixelHits
Definition: TrackFindingBaseAlg.h:295
ActsTrk::DetectorType::Sct
@ Sct
ActsTrk::TrackFindingAlg::propagateDetectorElementStatusToMeasurements
StatusCode propagateDetectorElementStatusToMeasurements(const ActsTrk::ActsVolumeIdToDetectorElementCollectionMap &volume_id_to_det_el_coll, const std::vector< const InDet::SiDetectorElementStatus * > &det_el_status_arr, detail::TrackFindingMeasurements &measurements) const
Definition: TrackFindingAlg.cxx:749
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
ActsTrk::TrackFindingAlg::m_forceTrackOnSeed
Gaudi::Property< bool > m_forceTrackOnSeed
Definition: TrackFindingAlg.h:122
ActsTrk::TrackFindingBaseAlg::m_branchStopperAbsEtaMaxExtra
Gaudi::Property< double > m_branchStopperAbsEtaMaxExtra
Definition: TrackFindingBaseAlg.h:112
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ActsTrk::TrackFindingAlg::m_seedContainerKeys
SG::ReadHandleKeyArray< ActsTrk::SeedContainer > m_seedContainerKeys
Definition: TrackFindingAlg.h:100
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::TrackFindingAlg::UNKNOWN
@ UNKNOWN
Definition: TrackFindingAlg.h:190
SG::ReadHandleKey< InDet::SiDetectorElementStatus >
ActsTrk::TrackFindingBaseAlg::m_ATLASConverterTool
ToolHandle< ActsTrk::IActsToTrkConverterTool > m_ATLASConverterTool
Definition: TrackFindingBaseAlg.h:91
ActsTrk::detail::RecoTrackContainer
Acts::TrackContainer< Acts::VectorTrackContainer, Acts::VectorMultiTrajectory > RecoTrackContainer
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:22
ActsTrk::TrackFindingAlg::findTracks
StatusCode findTracks(const DetectorContextHolder &detContext, const detail::TrackFindingMeasurements &measurements, const detail::MeasurementIndex &measurementIndex, detail::SharedHitCounter &sharedHits, detail::DuplicateSeedDetector &duplicateSeedDetector, const ActsTrk::SeedContainer &seeds, const InDetDD::SiDetectorElementCollection &detElements, detail::RecoTrackContainer &actsTracksContainer, std::size_t seedCollectionIndex, const char *seedType, EventStats &event_stat, std::vector< int > *destiny, const Acts::PerigeeSurface &pSurface) const
invoke track finding procedure
Definition: TrackFindingAlg.cxx:425
ActsTrk::TrackFindingBaseAlg::BranchState::nStripHoles
static constexpr Acts::ProxyAccessor< unsigned int > nStripHoles
Definition: TrackFindingBaseAlg.h:299
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
ActsTrk::TrackFindingBaseAlg::trackFinder
CKF_pimpl & trackFinder()
Definition: TrackFindingBaseAlg.cxx:19
ActsTrk::TrackFindingAlg::DUPLICATE
@ DUPLICATE
Definition: TrackFindingAlg.h:190
ActsTrk::TrackFindingBaseAlg::kMultipleBranches
@ kMultipleBranches
Definition: TrackFindingBaseAlg.h:167
ActsTrk::TrackFindingBaseAlg::kNoTrackParam
@ kNoTrackParam
Definition: TrackFindingBaseAlg.h:158
python.utils.AtlRunQueryTimer.timer
def timer(name, disabled=False)
Definition: AtlRunQueryTimer.py:85
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
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
TableUtils::subCategoryStride
constexpr std::size_t subCategoryStride([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::size_t n_counter)
Definition: TableUtils.h:304
ActsTrk::TrackFindingBaseAlg::m_endOfWorldVolumeIds
Gaudi::Property< std::vector< std::uint32_t > > m_endOfWorldVolumeIds
Definition: TrackFindingBaseAlg.h:148
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMinPt
@ kNStoppedTracksMinPt
Definition: TrackFindingBaseAlg.h:169
ActsTrk::TrackFindingBaseAlg::getStatCategory
std::size_t getStatCategory(std::size_t seed_collection, float eta) const
Definition: TrackFindingBaseAlg.cxx:751
ActsTrk::TrackFindingAlg::m_nMeasurementsMin
Gaudi::Property< unsigned int > m_nMeasurementsMin
Definition: TrackFindingAlg.h:131
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
ActsTrk::TrackFindingAlg::m_uncalibratedMeasurementContainerKeys
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainer > m_uncalibratedMeasurementContainerKeys
Definition: TrackFindingAlg.h:103
makeActsAthenaLogger
std::unique_ptr< const Acts::Logger > makeActsAthenaLogger(IMessageSvc *svc, const std::string &name, int level, std::optional< std::string > parent_name)
Definition: Tracking/Acts/ActsInterop/src/Logger.cxx:64
ActsTrk::TrackFindingBaseAlg::checkCounts
void checkCounts(const detail::RecoTrackContainer::TrackProxy &track) const
Definition: TrackFindingBaseAlg.cxx:454
ActsTrk::TrackFindingAlg::m_storeDestinies
bool m_storeDestinies
Definition: TrackFindingAlg.h:111
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
ActsTrk::TrackFindingBaseAlg::m_branchStopperPtMinFactor
Gaudi::Property< double > m_branchStopperPtMinFactor
Definition: TrackFindingBaseAlg.h:111
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
ActsTrk::TrackFindingBaseAlg::setMeasurementSelector
std::unique_ptr< ActsTrk::IMeasurementSelector > setMeasurementSelector(const detail::TrackFindingMeasurements &measurements, TrackFinderOptions &options) const
Setup and attach measurement selector to KF options.
Definition: TrackFindingBaseAlg.cxx:182
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
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
ActsTrk::TrackFindingAlg::m_countSharedHits
Gaudi::Property< bool > m_countSharedHits
Definition: TrackFindingAlg.h:121
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
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
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.
ActsTrk::TrackFindingBaseAlg::getContainersFromKeys
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 ve...
SG::WriteHandleKey
Property holding a SG store/key/clid from which a WriteHandle is made.
Definition: StoreGate/StoreGate/WriteHandleKey.h:40
ActsTrk::TrackFindingAlg::m_seedDestiny
SG::WriteHandleKeyArray< std::vector< int > > m_seedDestiny
Definition: TrackFindingAlg.h:112
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
Acts
Definition: MuonSpectrometer/MuonPhaseII/Event/xAOD/xAODMuonPrepData/xAODMuonPrepData/UtilFunctions.h:17
lumiFormat.i
int i
Definition: lumiFormat.py:85
ActsTrk::TrackFindingBaseAlg::kNOutputTracks
@ kNOutputTracks
Definition: TrackFindingBaseAlg.h:163
z
#define z
InDet::SiDetectorElementStatus
Definition: SiDetectorElementStatus.h:62
LVL1::MuCTPIBits::SubsysID::Forward
@ Forward
ActsTrk::TrackFindingAlg::shouldReverseSearch
bool shouldReverseSearch(const ActsTrk::Seed &seed) const
Definition: TrackFindingAlg.cxx:410
ActsTrk::TrackFindingBaseAlg::m_branchStopperMeasCutReduce
Gaudi::Property< double > m_branchStopperMeasCutReduce
Definition: TrackFindingBaseAlg.h:113
ActsTrk::TrackFindingBaseAlg::doRefit
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.
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
ActsTrk::TrackFindingBaseAlg::seedCollectionStride
std::size_t seedCollectionStride() const
Definition: TrackFindingBaseAlg.h:336
ActsTrk::TrackFindingAlg::m_useTopSpRZboundary
Gaudi::Property< std::vector< double > > m_useTopSpRZboundary
Definition: TrackFindingAlg.h:119
ActsTrk::TrackFindingBaseAlg::m_seedLabels
Gaudi::Property< std::vector< std::string > > m_seedLabels
Definition: TrackFindingBaseAlg.h:152
ActsTrk::TrackFindingAlg::storeSeedInfo
void storeSeedInfo(const detail::RecoTrackContainer &tracksContainer, const detail::RecoTrackContainerProxy &track, detail::DuplicateSeedDetector &duplicateSeedDetector, const detail::MeasurementIndex &measurementIndex) const
Definition: TrackFindingAlg.cxx:727
ActsTrk::TrackFindingAlg::m_paramEstimationTool
ToolHandle< ActsTrk::ITrackParamsEstimationTool > m_paramEstimationTool
Definition: TrackFindingAlg.h:96
MuonR4::State
CalibratedSpacePoint::State State
Definition: SpacePointCalibrator.cxx:40
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
ActsTrk::TrackFindingBaseAlg::m_maxPixelOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxPixelOutliers
Definition: TrackFindingBaseAlg.h:144
ActsTrk::TrackFindingAlg::m_detEleCollKeys
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollection > m_detEleCollKeys
Definition: TrackFindingAlg.h:101
ActsTrk::TrackFindingBaseAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrackFindingBaseAlg.h:87
ActsTrk::TrackFindingBaseAlg::BranchState::nStripOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nStripOutliers
Definition: TrackFindingBaseAlg.h:302
ActsTrk::TrackFindingBaseAlg::measurementType
static xAOD::UncalibMeasType measurementType(const detail::RecoTrackContainer::TrackStateProxy &trackState)
Definition: TrackFindingBaseAlg.cxx:262
xAOD::Other
@ Other
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsTrk::TrackFindingBaseAlg::m_branchStopperAbsEtaMeasCut
Gaudi::Property< double > m_branchStopperAbsEtaMeasCut
Definition: TrackFindingBaseAlg.h:114
python.AtlRunQueryLib.options
options
Definition: AtlRunQueryLib.py:378
ActsDetectorElement
Definition: ActsDetectorElement.h:44
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
ActsTrk::TrackFindingBaseAlg::selectCounts
std::array< bool, 3 > selectCounts(const detail::RecoTrackContainer::TrackProxy &track, double eta) const
Definition: TrackFindingBaseAlg.cxx:477
ActsTrk::TrackFindingBaseAlg::m_maxPropagationStep
Gaudi::Property< unsigned int > m_maxPropagationStep
Definition: TrackFindingBaseAlg.h:101
beamspotman.stat
stat
Definition: beamspotman.py:262
DataVector::clear
void clear()
Erase all the elements in the collection.
ActsTrk::TrackFindingBaseAlg::m_numMeasurementsCutOff
Gaudi::Property< std::vector< size_t > > m_numMeasurementsCutOff
Definition: TrackFindingBaseAlg.h:106
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
ActsTrk::TrackFindingBaseAlg::m_minStripHits
Gaudi::Property< std::vector< std::size_t > > m_minStripHits
Definition: TrackFindingBaseAlg.h:139
InDet::BeamSpotData::beamPos
const Amg::Vector3D & beamPos() const noexcept
Definition: BeamSpotData.h:68
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMaxHoles
@ kNStoppedTracksMaxHoles
Definition: TrackFindingBaseAlg.h:166
ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat
bool m_useAbsEtaForStat
Definition: TrackFindingBaseAlg.h:342
ActsTrk::TrackFindingBaseAlg::m_etaBins
Gaudi::Property< std::vector< double > > m_etaBins
Definition: TrackFindingBaseAlg.h:102
InDet::SiDetectorElementStatus::isGood
bool isGood(IdentifierHash hash) const
Definition: SiDetectorElementStatus.h:97
ActsTrk::TrackFindingBaseAlg::kNNoEstimatedParams
@ kNNoEstimatedParams
Definition: TrackFindingBaseAlg.h:162
TableUtils::makeLabelVector
std::vector< std::string > makeLabelVector(T_index n_entries, std::initializer_list< std::pair< T_index, T_string > > a_list)
Definition: TableUtils.h:275
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::TrackFindingBaseAlg::kNTotalSeeds
@ kNTotalSeeds
Definition: TrackFindingBaseAlg.h:157
checkNSWValTree.Options
Options
Definition: checkNSWValTree.py:14
ActsTrk::TrackFindingBaseAlg::m_extrapolationTool
ToolHandle< IActsExtrapolationTool > m_extrapolationTool
Definition: TrackFindingBaseAlg.h:88
ActsTrk::TrackFindingBaseAlg::selectCountsFinal
bool selectCountsFinal(const detail::RecoTrackContainer::TrackProxy &track) const
Definition: TrackFindingBaseAlg.cxx:772
ActsTrk::DetectorType::Hgtd
@ Hgtd
ActsTrk::TrackFindingBaseAlg::TrackFindingBaseAlg
TrackFindingBaseAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TrackFindingBaseAlg.cxx:22
ActsTrk::TrackFindingBaseAlg::stopBranch
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.
Definition: TrackFindingBaseAlg.cxx:281
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMaxEta
@ kNStoppedTracksMaxEta
Definition: TrackFindingBaseAlg.h:170
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
WriteCaloSwCorrections.cfg
cfg
Definition: WriteCaloSwCorrections.py:23
TableUtils::splitRatioDefinitionsAndLabels
std::tuple< std::vector< std::string >, std::vector< RatioDefinition > > splitRatioDefinitionsAndLabels(std::initializer_list< std::tuple< std::string, RatioDefinition > > a_ratio_list)
Definition: TableUtils.h:448
ActsTrk::TrackFindingBaseAlg::getCuts
const Acts::TrackSelector::Config & getCuts(double eta) const
Retrieves track selector configuration for given eta value.
Definition: TrackFindingBaseAlg.cxx:226
ActsDetectorElement::identifyHash
IdentifierHash identifyHash() const
Identifier hash.
Definition: ActsDetectorElement.h:75
ActsTrk::ActsSeed
Definition: Seed.h:18
ActsTrk::TrackFindingBaseAlg::kNForcedSeedMeasurements
@ kNForcedSeedMeasurements
Definition: TrackFindingBaseAlg.h:172
ActsTrk::TrackFindingBaseAlg::m_minPixelHits
Gaudi::Property< std::vector< std::size_t > > m_minPixelHits
Definition: TrackFindingBaseAlg.h:138
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
ActsTrk::TrackFindingAlg::m_maximumIterations
Gaudi::Property< unsigned int > m_maximumIterations
Definition: TrackFindingAlg.h:129
ActsTrk::TrackFindingAlg::m_volumeIdToDetectorElementCollMapKey
SG::ReadCondHandleKey< ActsTrk::ActsVolumeIdToDetectorElementCollectionMap > m_volumeIdToDetectorElementCollMapKey
Definition: TrackFindingAlg.h:105
TableUtils::makeEtaBinLabel
std::string makeEtaBinLabel(const std::vector< float > &eta_bins, std::size_t eta_bin_i, bool abs_eta=false)
Definition: TableUtils.h:514
ActsTrk::TrackFindingBaseAlg::BranchState::nStripHits
static constexpr Acts::ProxyAccessor< unsigned int > nStripHits
Definition: TrackFindingBaseAlg.h:296
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
ActsTrk::TrackFindingBaseAlg::m_trackingGeometryTool
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool
Definition: TrackFindingBaseAlg.h:89
ActsTrk::TrackFindingAlg::m_skipDuplicateSeeds
Gaudi::Property< bool > m_skipDuplicateSeeds
Definition: TrackFindingAlg.h:116
InDet::BeamSpotData
Definition: BeamSpotData.h:21
ActsTrk::detail::expectedLayerPattern
std::array< unsigned int, 4 > expectedLayerPattern(const EventContext &ctx, const IActsExtrapolationTool &extrapolator, const Acts::BoundTrackParameters &perigee_parameters, double pathLimit)
Extrapolate from the perigee outwards and gather information which detector layers should have hits.
Definition: ExpectedHitUtils.cxx:14
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelHoles
static constexpr Acts::ProxyAccessor< unsigned int > nPixelHoles
Definition: TrackFindingBaseAlg.h:298
ActsTrk::TrackFindingBaseAlg::nSeedCollections
std::size_t nSeedCollections() const
Definition: TrackFindingBaseAlg.h:333
a
TList * a
Definition: liststreamerinfos.cxx:10
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
h
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:294
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
ActsTrk::TrackFindingBaseAlg::kNDuplicateSeeds
@ kNDuplicateSeeds
Definition: TrackFindingBaseAlg.h:161
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
ActsTrk::TrackFindingBaseAlg::kNTotalSharedHits
@ kNTotalSharedHits
Definition: TrackFindingBaseAlg.h:171
ActsTrk::TrackFindingBaseAlg::m_logger
std::unique_ptr< const Acts::Logger > m_logger
logging instance
Definition: TrackFindingBaseAlg.h:326
ActsTrk::TrackFindingBaseAlg::m_ptMinMeasurements
Gaudi::Property< std::vector< std::size_t > > m_ptMinMeasurements
Definition: TrackFindingBaseAlg.h:107
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
ActsTrk::TrackFindingBaseAlg::m_trackStatePrinter
ToolHandle< ActsTrk::TrackStatePrinterTool > m_trackStatePrinter
Definition: TrackFindingBaseAlg.h:90
ActsTrk::TrackFindingBaseAlg::copyStats
void copyStats(const EventStats &event_stat) const
Definition: TrackFindingBaseAlg.cxx:550
ActsTrk::detail::ExpectedLayerPatternHelper::add
static void add(track_container_t &trackContainer)
Definition: ExpectedHitUtils.h:35
ActsTrk::TrackFindingBaseAlg::BranchState::nHgtdHoles
static constexpr Acts::ProxyAccessor< unsigned int > nHgtdHoles
Definition: TrackFindingBaseAlg.h:300
DeMoScan.first
bool first
Definition: DeMoScan.py:534
plotBeamSpotMon.mon
mon
Definition: plotBeamSpotMon.py:66
ActsTrk::TrackFindingBaseAlg::m_measurementSelectorConfig
struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig m_measurementSelectorConfig
ActsTrk::TrackFindingAlg::m_memorySafetyMargin
Gaudi::Property< float > m_memorySafetyMargin
Definition: TrackFindingAlg.h:192
ActsTrk::TrackFindingBaseAlg::BranchState::nHgtdOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nHgtdOutliers
Definition: TrackFindingBaseAlg.h:303
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig::m_etaBins
std::vector< float > m_etaBins
Definition: TrackFindingBaseAlg.h:58
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
ActsTrk::TrackFindingBaseAlg::m_statEtaBins
Gaudi::Property< std::vector< float > > m_statEtaBins
Definition: TrackFindingBaseAlg.h:151
ActsTrk::TrackFindingBaseAlg::m_maxStripOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxStripOutliers
Definition: TrackFindingBaseAlg.h:145
ActsTrk::TrackFindingBaseAlg::initCounts
static void initCounts(const detail::RecoTrackContainer::TrackProxy &track)
Definition: TrackFindingBaseAlg.cxx:397
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
ActsTrk::TrackFindingBaseAlg::m_maxHgtdOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxHgtdOutliers
Definition: TrackFindingBaseAlg.h:146
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
ActsTrk::TrackFindingBaseAlg::kNSelectedTracks
@ kNSelectedTracks
Definition: TrackFindingBaseAlg.h:165
ActsTrk::TrackFindingBaseAlg::kNoTrack
@ kNoTrack
Definition: TrackFindingBaseAlg.h:160
ActsTrk::TrackFindingBaseAlg::m_trackFinder
std::unique_ptr< CKF_pimpl > m_trackFinder
Definition: TrackFindingBaseAlg.h:81
ActsTrk::TrackFindingAlg::storeTrackCollectionToStoreGate
StatusCode storeTrackCollectionToStoreGate(const EventContext &ctx, Acts::VectorTrackContainer &&originalTrackBackend, Acts::VectorMultiTrajectory &&originalTrackStateBackend) const
Definition: TrackFindingAlg.cxx:394
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
ActsTrk::TrackFindingAlg::m_detElStatus
SG::ReadHandleKeyArray< InDet::SiDetectorElementStatus > m_detElStatus
Definition: TrackFindingAlg.h:109
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
ActsTrk::TrackFindingAlg::addTrack
StatusCode addTrack(const DetectorContextHolder &detContext, detail::RecoTrackContainerProxy &track, const Acts::Surface &pSurface, const Acts::TrackExtrapolationStrategy &extrapolationStrategy, detail::SharedHitCounter &sharedHits, detail::RecoTrackContainer &actsTracksContainer, const detail::MeasurementIndex &measurementIndex, const detail::RecoTrackContainer &tracksContainerTemp, detail::DuplicateSeedDetector &duplicateSeedDetector, std::vector< int > *destiny, EventStats &event_stat, std::size_t &ntracks, std::size_t iseed, std::size_t category_i, const char *seedType) const
Definition: TrackFindingAlg.cxx:925
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
TableUtils::computeRatios
std::vector< float > computeRatios(const std::vector< RatioDefinition > &ratio_def, const std::size_t categories, const std::size_t sub_categories, const std::vector< std::size_t > &counter)
Definition: TableUtils.cxx:21
TableUtils::defineSummand
SummandDefinition defineSummand(T counter_idx, int multiplier)
Definition: TableUtils.h:402
python.CaloScaleNoiseConfig.ts
ts
Definition: CaloScaleNoiseConfig.py:87
test_pyathena.counter
counter
Definition: test_pyathena.py:15
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:79
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
ActsTrk::TrackFindingBaseAlg::logger
const Acts::Logger & logger() const
Private access to the logger.
Definition: TrackFindingBaseAlg.h:320
ActsTrk::TrackFindingAlg::m_ambi
std::optional< Acts::GreedyAmbiguityResolution > m_ambi
Definition: TrackFindingAlg.h:141
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
ActsTrk::TrackFindingAlg::ExpectedLayerPattern
std::array< unsigned int, 4 > ExpectedLayerPattern
Definition: TrackFindingAlg.h:58
InDetDD::SiDetectorElementCollection::getDetectorElement
const SiDetectorElement * getDetectorElement(const IdentifierHash &hash) const
Definition: SiDetectorElementCollection.cxx:9
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
ActsTrk::TrackFindingBaseAlg::copyCounts
static void copyCounts(const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackProxy &other)
Definition: TrackFindingBaseAlg.cxx:440
xAOD::UncalibMeasType::PixelClusterType
@ PixelClusterType
ActsTrk::TrackFindingBaseAlg::m_doTwoWay
Gaudi::Property< bool > m_doTwoWay
Definition: TrackFindingBaseAlg.h:110
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition: ReadCondHandle.h:71
ActsTrk::TrackFindingBaseAlg::kNRejectedRefinedSeeds
@ kNRejectedRefinedSeeds
Definition: TrackFindingBaseAlg.h:164
ActsTrk::detail::addToExpectedLayerPattern
void addToExpectedLayerPattern(std::array< unsigned int, 4 > &pattern, const ActsDetectorElement &detElement)
Definition: ExpectedHitUtils.cxx:40
Generated on Mon Sep 29 2025 21:59:08 for ATLAS Offline Software by   doxygen 1.8.18