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, 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 checkPixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track) const
 
std::array< bool, 3 > selectPixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track, double eta) const
 
bool selectPixelStripCountsFinal (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 addPixelStripCounts (detail::RecoTrackContainer &tracksContainer)
 
static void initPixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track)
 
static void updatePixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateType typeFlags, xAOD::UncalibMeasType detType)
 
static void copyPixelStripCounts (const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackProxy &other)
 

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_addPixelStripCounts {this, "addPixelStripCounts", true, "keep separate pixel and strip counts and apply the following cuts"}
 
Gaudi::Property< std::vector< std::size_t > > m_minPixelHits {this, "minPixelHits", {}, "minimum number of pixel hits"}
 
Gaudi::Property< std::vector< std::size_t > > m_minStripHits {this, "minStripHits", {}, "minimum number of strip hits"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxPixelHoles {this, "maxPixelHoles", {}, "maximum number of pixel holes"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxStripHoles {this, "maxStripHoles", {}, "maximum number of strip holes"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxPixelOutliers {this, "maxPixelOutliers", {}, "maximum number of pixel outliers"}
 
Gaudi::Property< std::vector< std::size_t > > m_maxStripOutliers {this, "maxStripOutliers", {}, "maximum number of strip outliers"}
 
Gaudi::Property< std::vector< 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< 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 267 of file TrackFindingBaseAlg.h.

◆ EventStats

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

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

Member Enumeration Documentation

◆ DestinyType

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

Definition at line 189 of file TrackFindingAlg.h.

189 : 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 
kNStat 

Definition at line 152 of file TrackFindingBaseAlg.h.

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

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

◆ addPixelStripCounts()

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

Definition at line 379 of file TrackFindingBaseAlg.cxx.

380  {
381  tracksContainer.addColumn<unsigned int>("nPixelHits");
382  tracksContainer.addColumn<unsigned int>("nStripHits");
383  tracksContainer.addColumn<unsigned int>("nPixelHoles");
384  tracksContainer.addColumn<unsigned int>("nStripHoles");
385  tracksContainer.addColumn<unsigned int>("nPixelOutliers");
386  tracksContainer.addColumn<unsigned int>("nStripOutliers");
387  }

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

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

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

◆ checkPixelStripCounts()

void ActsTrk::TrackFindingBaseAlg::checkPixelStripCounts ( const detail::RecoTrackContainer::TrackProxy &  track) const
protectedinherited

Definition at line 432 of file TrackFindingBaseAlg.cxx.

432  {
433  // This check will fail if there are other types (HGTD, MS?) of hits, holes, or outliers.
434  // The check can be removed when it is no longer appropriate.
435  if (track.nMeasurements() != s_branchState.nPixelHits(track) + s_branchState.nStripHits(track))
436  ATH_MSG_WARNING("mismatched hit count: total (" << track.nMeasurements()
437  << ") != pixel (" << s_branchState.nPixelHits(track)
438  << ") + strip (" << s_branchState.nStripHits(track) << ")");
439  if (track.nHoles() < s_branchState.nPixelHoles(track) + s_branchState.nStripHoles(track)) // allow extra HGTD holes
440  ATH_MSG_WARNING("mismatched hole count: total (" << track.nHoles()
441  << ") < pixel (" << s_branchState.nPixelHoles(track)
442  << ") + strip (" << s_branchState.nStripHoles(track) << ")");
443  if (track.nOutliers() != s_branchState.nPixelOutliers(track) + s_branchState.nStripOutliers(track))
444  ATH_MSG_WARNING("mismatched outlier count: total (" << track.nOutliers()
445  << ") != pixel (" << s_branchState.nPixelOutliers(track)
446  << ") + strip (" << s_branchState.nStripOutliers(track) << ")");
447  };

◆ computeStatSum()

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

Definition at line 727 of file TrackFindingBaseAlg.cxx.

727  {
728  std::size_t out = 0u;
729  for (std::size_t category_i = seed_collection * seedCollectionStride();
730  category_i < (seed_collection + 1) * seedCollectionStride();
731  ++category_i)
732  {
733  assert(category_i < stat.size());
734  out += stat[category_i][counter_i];
735  }
736  return out;
737  }

◆ copyPixelStripCounts()

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

Definition at line 421 of file TrackFindingBaseAlg.cxx.

423  {
424  s_branchState.nPixelHits(track) = s_branchState.nPixelHits(other);
425  s_branchState.nStripHits(track) = s_branchState.nStripHits(other);
426  s_branchState.nPixelHoles(track) = s_branchState.nPixelHoles(other);
427  s_branchState.nStripHoles(track) = s_branchState.nStripHoles(other);
428  s_branchState.nPixelOutliers(track) = s_branchState.nPixelOutliers(other);
429  s_branchState.nStripOutliers(track) = s_branchState.nStripOutliers(other);
430  }

◆ copyStats()

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

Definition at line 519 of file TrackFindingBaseAlg.cxx.

519  {
520  std::lock_guard<std::mutex> lock(m_mutex);
521  std::size_t category_i = 0;
522  for (const std::array<unsigned int, kNStat> &src_stat : event_stat)
523  {
524  std::array<std::size_t, kNStat> &dest_stat = m_stat[category_i++];
525  for (std::size_t i = 0; i < src_stat.size(); ++i)
526  {
527  assert(i < dest_stat.size());
528  dest_stat[i] += src_stat[i];
529  }
530  }
531  }

◆ 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.copyFrom(trackProxy, false); // #3534
249  if (m_addPixelStripCounts) {
250  copyPixelStripCounts(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 151 of file TrackFindingAlg.cxx.

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

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & 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 851 of file TrackFindingAlg.cxx.

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

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

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

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

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

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

799  {
800  const xAOD::SpacePoint* sp = useTopSp ? seed.sp().back() : seed.sp().front();
801  const xAOD::SpacePoint::ConstVectorMap pos = sp->globalPosition();
802  double etaSeed = std::atanh(pos[2] / pos.norm());
803  return getStatCategory(typeIndex, etaSeed);
804  }

◆ getStatCategory()

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

Definition at line 718 of file TrackFindingBaseAlg.cxx.

718  {
719  std::vector<float>::const_iterator bin_iter = std::upper_bound(m_statEtaBins.begin(),
720  m_statEtaBins.end(),
721  m_useAbsEtaForStat ? std::abs(eta) : eta);
722  std::size_t category_i = seed_collection * seedCollectionStride() + static_cast<std::size_t>(bin_iter - m_statEtaBins.begin());
723  assert(category_i < m_stat.size());
724  return category_i;
725  }

◆ 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 
94  ATH_CHECK(m_paramEstimationTool.retrieve());
95  ATH_CHECK(m_seedContainerKeys.initialize());
96  ATH_CHECK(m_detEleCollKeys.initialize());
97  ATH_CHECK(m_uncalibratedMeasurementContainerKeys.initialize());
98  ATH_CHECK(m_volumeIdToDetectorElementCollMapKey.initialize());
99  ATH_CHECK(m_detElStatus.initialize());
100  ATH_CHECK(m_beamSpotKey.initialize());
101 
102  m_storeDestinies = not m_seedDestiny.empty();
103  ATH_CHECK(m_seedDestiny.initialize(m_storeDestinies));
104 
105  if (m_seedContainerKeys.size() != m_detEleCollKeys.size())
106  {
107  ATH_MSG_FATAL("There are " << m_detEleCollKeys.size() << " DetectorElementsKeys, but " << m_seedContainerKeys.size() << " SeedContainerKeys");
108  return StatusCode::FAILURE;
109  }
110 
111  if (m_detEleCollKeys.size() != m_seedLabels.size())
112  {
113  ATH_MSG_FATAL("There are " << m_seedLabels.size() << " SeedLabels, but " << m_detEleCollKeys.size() << " DetectorElementsKeys");
114  return StatusCode::FAILURE;
115  }
116 
117  if (m_useTopSpRZboundary.size() != 2)
118  {
119  ATH_MSG_FATAL("useTopSpRZboundary must have 2 elements, but has " << m_useTopSpRZboundary.size());
120  return StatusCode::FAILURE;
121  }
122 
123  if (m_ambiStrategy == 1 /* END_OF_TF */) {
124  Acts::GreedyAmbiguityResolution::Config cfg;
125  cfg.maximumSharedHits = m_maximumSharedHits;
126  cfg.maximumIterations = m_maximumIterations;
127  cfg.nMeasurementsMin = m_nMeasurementsMin;
128 
129  m_ambi.emplace(std::move(cfg), makeActsAthenaLogger(this, "Acts"));
130  }
131 
132  if (m_storeDestinies) {
133  if (m_seedDestiny.size() != m_seedContainerKeys.size()) {
134  ATH_MSG_ERROR("There are " << m_seedDestiny.size() << " seed destiny collections, but " << m_seedContainerKeys.size() << " seed collections");
135  return StatusCode::FAILURE;
136  }
137  }
138 
139  return StatusCode::SUCCESS;
140  }

◆ initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector ( )
protectedinherited

Definition at line 472 of file TrackFindingBaseAlg.cxx.

472  {
473  std::vector<std::pair<float, float> > &chi2CutOffOutlier = m_measurementSelectorConfig.m_chi2CutOffOutlier;
474  chi2CutOffOutlier .reserve( m_chi2CutOff.size() );
475  if (!m_chi2OutlierCutOff.empty()) {
476  if (m_chi2CutOff.size() != m_chi2OutlierCutOff.size()) {
477  ATH_MSG_ERROR("Outlier chi2 cut off provided but number of elements does not agree with"
478  " chi2 cut off for measurements which however is required: "
479  << m_chi2CutOff.size() << " != " << m_chi2OutlierCutOff.size());
480  return StatusCode::FAILURE;
481  }
482  }
483  unsigned int idx=0;
484  for (const auto &elm : m_chi2CutOff) {
485  chi2CutOffOutlier.push_back( std::make_pair(static_cast<float>(elm),
486  idx < m_chi2OutlierCutOff.size()
487  ? static_cast<float>(m_chi2OutlierCutOff[idx])
488  : std::numeric_limits<float>::max()) );
489  ++idx;
490  }
491  if (m_etaBins.size() > 2) {
492  std::vector<float> &etaBinsf = m_measurementSelectorConfig.m_etaBins;
493  etaBinsf.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
494  }
495 
496  return /*m_measurementSelector ?*/ StatusCode::SUCCESS /*: StatusCode::FAILURE*/;
497  }

◆ initPixelStripCounts()

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

Definition at line 389 of file TrackFindingBaseAlg.cxx.

390  {
391  s_branchState.nPixelHits(track) = 0;
392  s_branchState.nStripHits(track) = 0;
393  s_branchState.nPixelHoles(track) = 0;
394  s_branchState.nStripHoles(track) = 0;
395  s_branchState.nPixelOutliers(track) = 0;
396  s_branchState.nStripOutliers(track) = 0;
397  }

◆ initStatTables()

void ActsTrk::TrackFindingBaseAlg::initStatTables ( )
protectedinherited

Definition at line 501 of file TrackFindingBaseAlg.cxx.

501  {
502  if (!m_statEtaBins.empty())
503  {
504  m_useAbsEtaForStat = (m_statEtaBins[0] > 0.);
505  float last_eta = m_statEtaBins[0];
506  for (float eta : m_statEtaBins)
507  {
508  if (eta < last_eta)
509  {
510  ATH_MSG_FATAL("Eta bins for statistics counter not in ascending order.");
511  }
512  last_eta = eta;
513  }
514  }
515  m_stat.resize(nSeedCollections() * seedCollectionStride());
516  }

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

314  {
315  return *m_logger;
316  }

◆ 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  default:
271  break;
272  }
273  }
274  }
275 
276  return xAOD::UncalibMeasType::Other;
277  }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ nSeedCollections()

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

Definition at line 326 of file TrackFindingBaseAlg.h.

326  {
327  return m_seedLabels.size();
328  }

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

814  {
815  if (not m_trackStatePrinter.isSet()) return;
816 
817  if (nPrinted == 0) {
818  ATH_MSG_INFO("CKF results for " << seeds.size() << ' ' << seedType << " seeds:");
819  }
820  ++nPrinted;
821  m_trackStatePrinter->printSeed(detContext.geometry, *seeds[iseed], seedParameters, measurementIndex, iseed, isKF);
822  }

◆ printStatTables()

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

Definition at line 534 of file TrackFindingBaseAlg.cxx.

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

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

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

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

329  {
330  return m_statEtaBins.size() + 1;
331  }

◆ selectPixelStripCounts()

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

Definition at line 449 of file TrackFindingBaseAlg.cxx.

449  {
450  bool enoughMeasurements = true, tooManyHoles = false, tooManyOutliers = false;
451  const auto &trackSelectorCfg = trackFinder().trackSelector.config();
452  std::size_t etaBin = (std::abs(eta) < trackSelectorCfg.absEtaEdges.front()) ? 0
453  : (std::abs(eta) >= trackSelectorCfg.absEtaEdges.back()) ? trackSelectorCfg.absEtaEdges.size() - 1
454  : trackSelectorCfg.binIndex(eta);
455  auto cutMin = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
456  return !cutSet.empty() && (val < (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
457  };
458  auto cutMax = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
459  return !cutSet.empty() && (val > (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
460  };
461 
462  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nPixelHits(track), m_minPixelHits);
463  enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nStripHits(track), m_minStripHits);
464  tooManyHoles = tooManyHoles || cutMax(s_branchState.nPixelHoles(track), m_maxPixelHoles);
465  tooManyHoles = tooManyHoles || cutMax(s_branchState.nStripHoles(track), m_maxStripHoles);
466  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nPixelOutliers(track), m_maxPixelOutliers);
467  tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nStripOutliers(track), m_maxStripOutliers);
468 
469  return {enoughMeasurements, tooManyHoles, tooManyOutliers};
470  }

◆ selectPixelStripCountsFinal()

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

Definition at line 739 of file TrackFindingBaseAlg.cxx.

739  {
740  if (not m_addPixelStripCounts) return true;
741  double eta = -std::log(std::tan(0.5 * track.theta()));
742  auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] = selectPixelStripCounts(track, eta);
743  return enoughMeasurementsPS && !tooManyHolesPS && !tooManyOutliersPS;
744  }

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

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

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

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

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

720  {
721 
722  const auto lastMeasurementIndex = track.tipIndex();
723  duplicateSeedDetector.newTrajectory();
724 
725  tracksContainer.trackStateContainer().visitBackwards(
726  lastMeasurementIndex,
727  [&duplicateSeedDetector,&measurementIndex](const detail::RecoTrackStateContainer::ConstTrackStateProxy &state) -> void
728  {
729  // Check there is a source link
730  if (not state.hasUncalibratedSourceLink())
731  return;
732 
733  // Fill the duplicate selector
734  auto sl = state.getUncalibratedSourceLink().template get<ATLASUncalibSourceLink>();
735  duplicateSeedDetector.addMeasurement(sl, measurementIndex);
736  }); // end visitBackwards
737  }

◆ storeTrackCollectionToStoreGate()

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

Definition at line 391 of file TrackFindingAlg.cxx.

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

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

◆ updatePixelStripCounts()

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

Definition at line 399 of file TrackFindingBaseAlg.cxx.

401  {
402  if (detType == xAOD::UncalibMeasType::PixelClusterType) {
403  if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
404  s_branchState.nPixelHoles(track)++;
405  } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
406  s_branchState.nPixelOutliers(track)++;
407  } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
408  s_branchState.nPixelHits(track)++;
409  }
410  } else if (detType == xAOD::UncalibMeasType::StripClusterType) {
411  if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
412  s_branchState.nStripHoles(track)++;
413  } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
414  s_branchState.nStripOutliers(track)++;
415  } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
416  s_branchState.nStripHits(track)++;
417  }
418  }
419  }

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

◆ ATLAS_THREAD_SAFE [2/3]

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

Definition at line 193 of file TrackFindingAlg.h.

◆ ATLAS_THREAD_SAFE [3/3]

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

Definition at line 194 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_addPixelStripCounts

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_addPixelStripCounts {this, "addPixelStripCounts", true, "keep separate pixel and strip 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 140 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 131 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 150 of file TrackFindingBaseAlg.h.

◆ m_endOfWorldVolumeIds

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

Definition at line 145 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_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 319 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_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 127 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 125 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 140 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 142 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 141 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 143 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 191 of file TrackFindingAlg.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 129 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 149 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 148 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 335 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 298 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:126
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelOutliers
static constexpr Acts::ProxyAccessor< unsigned int > nPixelOutliers
Definition: TrackFindingBaseAlg.h:295
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:674
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:131
ActsTrk::TrackFindingBaseAlg::m_doBranchStopper
Gaudi::Property< bool > m_doBranchStopper
Definition: TrackFindingBaseAlg.h:109
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
test_pyathena.eta
eta
Definition: test_pyathena.py:10
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:851
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:385
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ActsTrk::TrackFindingBaseAlg::kNStat
@ kNStat
Definition: TrackFindingBaseAlg.h:169
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
ActsTrk::TrackFindingBaseAlg::selectPixelStripCountsFinal
bool selectPixelStripCountsFinal(const detail::RecoTrackContainer::TrackProxy &track) const
Definition: TrackFindingBaseAlg.cxx:739
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:141
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:806
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:242
ActsTrk::TrackFindingBaseAlg::s_branchState
static constexpr BranchState s_branchState
Definition: TrackFindingBaseAlg.h:298
ActsTrk::TrackFindingBaseAlg::updatePixelStripCounts
static void updatePixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateType typeFlags, xAOD::UncalibMeasType detType)
Definition: TrackFindingBaseAlg.cxx:399
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:796
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::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:165
make_unique
std::unique_ptr< T > make_unique(Args &&... args)
Definition: SkimmingToolEXOT5.cxx:23
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::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:172
ActsTrk::TrackFindingBaseAlg::m_maxPixelHoles
Gaudi::Property< std::vector< std::size_t > > m_maxPixelHoles
Definition: TrackFindingBaseAlg.h:140
ActsTrk::TrackFindingAlg::FAILURE
@ FAILURE
Definition: TrackFindingAlg.h:189
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:150
xAOD::SpacePoint_v1::globalPosition
ConstVectorMap globalPosition() const
Returns the global position of the pixel cluster.
Definition: SpacePoint_v1.cxx:25
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
ActsTrk::TrackFindingAlg::SUCCEED
@ SUCCEED
Definition: TrackFindingAlg.h:189
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:267
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:727
ActsTrk::TrackFindingBaseAlg::kNUsedSeeds
@ kNUsedSeeds
Definition: TrackFindingBaseAlg.h:156
ActsTrk::TrackFindingBaseAlg::BranchState::nPixelHits
static constexpr Acts::ProxyAccessor< unsigned int > nPixelHits
Definition: TrackFindingBaseAlg.h:291
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:739
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
ActsTrk::TrackFindingBaseAlg::m_branchStopperAbsEtaMaxExtra
Gaudi::Property< double > m_branchStopperAbsEtaMaxExtra
Definition: TrackFindingBaseAlg.h:112
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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:189
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:422
ActsTrk::TrackFindingBaseAlg::BranchState::nStripHoles
static constexpr Acts::ProxyAccessor< unsigned int > nStripHoles
Definition: TrackFindingBaseAlg.h:294
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:189
ActsTrk::TrackFindingBaseAlg::kMultipleBranches
@ kMultipleBranches
Definition: TrackFindingBaseAlg.h:164
ActsTrk::TrackFindingBaseAlg::kNoTrackParam
@ kNoTrackParam
Definition: TrackFindingBaseAlg.h:155
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:145
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMinPt
@ kNStoppedTracksMinPt
Definition: TrackFindingBaseAlg.h:166
ActsTrk::TrackFindingBaseAlg::getStatCategory
std::size_t getStatCategory(std::size_t seed_collection, float eta) const
Definition: TrackFindingBaseAlg.cxx:718
ActsTrk::TrackFindingAlg::m_nMeasurementsMin
Gaudi::Property< unsigned int > m_nMeasurementsMin
Definition: TrackFindingAlg.h:130
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::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
ActsTrk::TrackFindingBaseAlg::m_addPixelStripCounts
Gaudi::Property< bool > m_addPixelStripCounts
Definition: TrackFindingBaseAlg.h:137
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:18
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:160
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:407
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:329
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:149
ActsTrk::TrackFindingAlg::storeSeedInfo
void storeSeedInfo(const detail::RecoTrackContainer &tracksContainer, const detail::RecoTrackContainerProxy &track, detail::DuplicateSeedDetector &duplicateSeedDetector, const detail::MeasurementIndex &measurementIndex) const
Definition: TrackFindingAlg.cxx:717
ActsTrk::TrackFindingAlg::m_paramEstimationTool
ToolHandle< ActsTrk::ITrackParamsEstimationTool > m_paramEstimationTool
Definition: TrackFindingAlg.h:96
MuonR4::State
CalibratedSpacePoint::State State
Definition: SpacePointCalibrator.cxx:33
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:142
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:296
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::m_maxPropagationStep
Gaudi::Property< unsigned int > m_maxPropagationStep
Definition: TrackFindingBaseAlg.h:101
beamspotman.stat
stat
Definition: beamspotman.py:264
DataVector::clear
void clear()
Erase all the elements in the collection.
ActsTrk::TrackFindingBaseAlg::addPixelStripCounts
static void addPixelStripCounts(detail::RecoTrackContainer &tracksContainer)
Definition: TrackFindingBaseAlg.cxx:379
ActsTrk::TrackFindingBaseAlg::m_numMeasurementsCutOff
Gaudi::Property< std::vector< size_t > > m_numMeasurementsCutOff
Definition: TrackFindingBaseAlg.h:106
ActsTrk::TrackFindingBaseAlg::copyPixelStripCounts
static void copyPixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackProxy &other)
Definition: TrackFindingBaseAlg.cxx:421
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:163
ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat
bool m_useAbsEtaForStat
Definition: TrackFindingBaseAlg.h:335
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:159
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:154
checkNSWValTree.Options
Options
Definition: checkNSWValTree.py:14
ActsTrk::TrackFindingBaseAlg::m_extrapolationTool
ToolHandle< IActsExtrapolationTool > m_extrapolationTool
Definition: TrackFindingBaseAlg.h:88
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:279
ActsTrk::TrackFindingBaseAlg::kNStoppedTracksMaxEta
@ kNStoppedTracksMaxEta
Definition: TrackFindingBaseAlg.h:167
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::TrackFindingBaseAlg::checkPixelStripCounts
void checkPixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track) const
Definition: TrackFindingBaseAlg.cxx:432
ActsTrk::ActsSeed
Definition: Seed.h:18
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:128
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:292
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:293
ActsTrk::TrackFindingBaseAlg::nSeedCollections
std::size_t nSeedCollections() const
Definition: TrackFindingBaseAlg.h:326
ActsTrk::TrackFindingBaseAlg::selectPixelStripCounts
std::array< bool, 3 > selectPixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track, double eta) const
Definition: TrackFindingBaseAlg.cxx:449
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:158
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:168
ActsTrk::TrackFindingBaseAlg::m_logger
std::unique_ptr< const Acts::Logger > m_logger
logging instance
Definition: TrackFindingBaseAlg.h:319
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:519
ActsTrk::detail::ExpectedLayerPatternHelper::add
static void add(track_container_t &trackContainer)
Definition: ExpectedHitUtils.h:35
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:191
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:148
ActsTrk::TrackFindingBaseAlg::m_maxStripOutliers
Gaudi::Property< std::vector< std::size_t > > m_maxStripOutliers
Definition: TrackFindingBaseAlg.h:143
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
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:162
ActsTrk::TrackFindingBaseAlg::kNoTrack
@ kNoTrack
Definition: TrackFindingBaseAlg.h:157
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:391
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
ActsTrk::TrackFindingBaseAlg::initPixelStripCounts
static void initPixelStripCounts(const detail::RecoTrackContainer::TrackProxy &track)
Definition: TrackFindingBaseAlg.cxx:389
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:915
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:313
ActsTrk::TrackFindingAlg::m_ambi
std::optional< Acts::GreedyAmbiguityResolution > m_ambi
Definition: TrackFindingAlg.h:140
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
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:161
ActsTrk::detail::addToExpectedLayerPattern
void addToExpectedLayerPattern(std::array< unsigned int, 4 > &pattern, const ActsDetectorElement &detElement)
Definition: ExpectedHitUtils.cxx:40
Generated on Mon Sep 1 2025 21:56:14 for ATLAS Offline Software by   doxygen 1.8.18