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.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

Protected Member Functions
CKF_pimpl &	trackFinder ()
const CKF_pimpl &	trackFinder () const
StatusCode	initializeMeasurementSelector ()
std::unique_ptr< ActsTrk::IMeasurementSelector >	setMeasurementSelector (const detail::TrackFindingMeasurements &measurements, TrackFinderOptions &options) const
	Setup and attach measurement selector to KF options.
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.
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.
const Acts::TrackSelector::Config &	getCuts (double eta) const
	Retrieves track selector configuration for given eta value.
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.
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.
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.
void	checkCounts (const detail::RecoTrackContainer::TrackProxy &track) const
std::array< bool, 3 >	selectCounts (const detail::RecoTrackContainer::TrackProxy &track, double eta) const
bool	selectCountsFinal (const detail::RecoTrackContainer::TrackProxy &track) const
const Acts::Logger &	logger () const
	Private access to the logger.
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
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.

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

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

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

Detailed Description

Definition at line 45 of file TrackFindingAlg.h.

Member Typedef Documentation

BranchStopperResult

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

protectedinherited

Definition at line 272 of file TrackFindingBaseAlg.h.

EventStats

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

protectedinherited

Definition at line 177 of file TrackFindingBaseAlg.h.

ExpectedLayerPattern

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

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

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

EStat

enum ActsTrk::TrackFindingBaseAlg::EStat : std::size_t

protectedinherited

Enumerator
kNTotalSeeds
kNoTrackParam
kNUsedSeeds
kNoTrack
kNDuplicateSeeds
kNNoEstimatedParams
kNOutputTracks
kNRejectedRefinedSeeds
kNSelectedTracks
kNStoppedTracksMaxHoles
kMultipleBranches
kNoSecond
kNStoppedTracksMinPt
kNStoppedTracksMaxEta
kNTotalSharedHits
kNForcedSeedMeasurements
kNStat

Definition at line 156 of file TrackFindingBaseAlg.h.

    {
      kNTotalSeeds,
      kNoTrackParam,
      kNUsedSeeds,
      kNoTrack,
      kNDuplicateSeeds,
      kNNoEstimatedParams,
      kNOutputTracks,
      kNRejectedRefinedSeeds,
      kNSelectedTracks,
      kNStoppedTracksMaxHoles,
      kMultipleBranches,
      kNoSecond,
      kNStoppedTracksMinPt,
      kNStoppedTracksMaxEta,
      kNTotalSharedHits,
      kNForcedSeedMeasurements,
      kNStat
    };

Constructor & Destructor Documentation

TrackFindingAlg()

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

Definition at line 73 of file TrackFindingAlg.cxx.

    : TrackFindingBaseAlg(name, pSvcLocator) {}

~TrackFindingAlg()

virtual ActsTrk::TrackFindingAlg::~TrackFindingAlg ( )

virtualdefault

Member Function Documentation

addCounts()

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

staticprotectedinherited

Definition at line 384 of file TrackFindingBaseAlg.cxx.

  {
    tracksContainer.addColumn<unsigned int>("nPixelHits");
    tracksContainer.addColumn<unsigned int>("nStripHits");
    tracksContainer.addColumn<unsigned int>("nHgtdHits");
    tracksContainer.addColumn<unsigned int>("nPixelHoles");
    tracksContainer.addColumn<unsigned int>("nStripHoles");
    tracksContainer.addColumn<unsigned int>("nHgtdHoles");
    tracksContainer.addColumn<unsigned int>("nPixelOutliers");
    tracksContainer.addColumn<unsigned int>("nStripOutliers");
    tracksContainer.addColumn<unsigned int>("nHgtdOutliers");
  }

addTrack()

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

private

Definition at line 925 of file TrackFindingAlg.cxx.

  {
 
    std::array<unsigned int, 4> expectedLayerPattern{};
 
    // if the the perigeeSurface was not hit (in particular the case for the inside-out pass,
    // the track has no reference surface and the extrapolation to the perigee has not been done
    // yet.
    if (not track.hasReferenceSurface()) {
      auto extrapolationResult =
        extrapolateTrackToReferenceSurface(detContext, track,
                                          pSurface,
                                          trackFinder().extrapolator,
                                          extrapolationStrategy,
                                          expectedLayerPattern);
 
      if (not extrapolationResult.ok()) {
        ATH_MSG_WARNING("Extrapolation for seed "
                        << iseed << " and " << track.index()
                        << " failed with error " << extrapolationResult.error()
                        << " dropping track candidate.");
        if (m_storeDestinies) destiny->at(iseed) = DestinyType::FAILURE;
        return StatusCode::SUCCESS;
      }
    }
 
    // Before trimming, inspect encountered surfaces from all track states
    for(const auto ts : track.trackStatesReversed()) {
      const auto& surface = ts.referenceSurface();
      if(surface.associatedDetectorElement() != nullptr) {
        const auto* detElem = dynamic_cast<const ActsDetectorElement*>(surface.associatedDetectorElement());
        if(detElem != nullptr) {
          detail::addToExpectedLayerPattern(expectedLayerPattern, *detElem);
        }
      }
    }
 
    // Trim tracks
    // - trimHoles
    // - trimOutliers
    // - trimMaterial
    // - trimOtherNoneMeasurement
    Acts::trimTrack(track, true, true, true, true);
    Acts::calculateTrackQuantities(track);
    if (m_addCounts) {
      initCounts(track);
      for (const auto trackState : track.trackStatesReversed()) {
        updateCounts(track, trackState.typeFlags(), measurementType(trackState));
      }
      if (m_checkCounts) {
        checkCounts(track);
      }
    }
 
    ++ntracks;
    ++event_stat[category_i][kNOutputTracks];
 
    if ( not trackFinder().trackSelector.isValidTrack(track) or
         not selectCountsFinal(track)) {
      ATH_MSG_DEBUG("Track " << ntracks << " from " << seedType << " seed " << iseed << " failed track selection");
      if ( m_trackStatePrinter.isSet() ) {
        m_trackStatePrinter->printTrack(detContext.geometry, tracksContainerTemp, track, measurementIndex, true);
      }
      return StatusCode::SUCCESS;
    }
 
    // Fill the track infos into the duplicate seed detector
    if (m_skipDuplicateSeeds) {
      storeSeedInfo(tracksContainerTemp, track, duplicateSeedDetector, measurementIndex);
    }
 
    auto actsDestProxy   = actsTracksContainer.makeTrack();
    actsDestProxy.copyFrom(track);  // make sure we copy track states!
 
    detail::ExpectedLayerPatternHelper::set(actsDestProxy, expectedLayerPattern);
 
    if (not m_countSharedHits) {
      return StatusCode::SUCCESS;
    }
 
    auto [nShared, nBadTrackMeasurements] = sharedHits.computeSharedHits(actsDestProxy, actsTracksContainer, measurementIndex);
 
    if (nBadTrackMeasurements > 0) {
      ATH_MSG_ERROR("computeSharedHits: " << nBadTrackMeasurements << " track measurements not found in input for " << seedType << " seed " << iseed << " track");
    }
 
    ATH_MSG_DEBUG("found " << actsDestProxy.nSharedHits() << " shared hits in " << seedType << " seed " << iseed << " track");
 
    event_stat[category_i][kNTotalSharedHits] += nShared;
 
    if (m_ambiStrategy == 2u) { // run the ambiguity during track selection
 
      if (actsDestProxy.nSharedHits() <= m_maximumSharedHits) {
        ++event_stat[category_i][kNSelectedTracks];
      }
      else { // track fails the shared hit selection
 
        ATH_MSG_DEBUG("found " << actsDestProxy.nSharedHits() << " shared hits in " << seedType << " seed " << iseed << " track");
        // Reset the original track shared hits by running coumputeSharedHits
        // with removeSharedHits flag to true
        // nSharedRemoved contains the total shared hits that will be removed
        auto [nSharedRemoved, nRemoveBadTrackMeasurements] = sharedHits.computeSharedHits(actsDestProxy, actsTracksContainer, measurementIndex, true);
 
        ATH_MSG_DEBUG("Removed " << nSharedRemoved << " shared hits in " << seedType << " seed " << iseed << " track and the matching track");
 
        if (nRemoveBadTrackMeasurements > 0) {
          ATH_MSG_ERROR("computeSharedHits with remove flag ON: " << nRemoveBadTrackMeasurements <<
                        " track measurements not found in input for " << seedType << " seed " << iseed << " track");
        }
 
        if (actsDestProxy.nSharedHits() != 0) {
          ATH_MSG_ERROR("computeSharedHits with remove flag ON returned " <<
                        actsDestProxy.nSharedHits()<< " while expecting 0 for" <<
                        seedType << " seed " << iseed << " track");
        }
 
        // Remove the track from the container
        actsTracksContainer.removeTrack(actsDestProxy.index());
        ATH_MSG_DEBUG("Track " << ntracks << " from " << seedType << " seed " << iseed << " failed shared hit selection");
      }
    }
    else { // use ambi during selection
      ++event_stat[category_i][kNSelectedTracks];
 
      if (m_trackStatePrinter.isSet()) {
        m_trackStatePrinter->printTrack(detContext.geometry, actsTracksContainer, actsDestProxy, measurementIndex);
      }
    }
 
    return StatusCode::SUCCESS;
  }

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

checkCounts()

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

protectedinherited

Definition at line 440 of file TrackFindingBaseAlg.cxx.

                                                                                             {
    // This check will fail if there are other types (HGTD, MS?) of hits, holes, or outliers.
    // The check can be removed when it is no longer appropriate.
    if (track.nMeasurements() != s_branchState.nPixelHits(track) + s_branchState.nStripHits(track) + s_branchState.nHgtdHits(track))
      ATH_MSG_WARNING("mismatched hit count: total (" << track.nMeasurements()
                      << ") != pixel (" << s_branchState.nPixelHits(track)
                      << ") + strip (" << s_branchState.nStripHits(track)
                      << ") + hgtd (" << s_branchState.nHgtdHits(track)
                      << ")");
    if (track.nHoles() != s_branchState.nPixelHoles(track) + s_branchState.nStripHoles(track) + s_branchState.nHgtdHoles(track))
      ATH_MSG_WARNING("mismatched hole count: total (" << track.nHoles()
                      << ") < pixel (" << s_branchState.nPixelHoles(track)
                      << ") + strip (" << s_branchState.nStripHoles(track)
                      << ") + hgtd (" << s_branchState.nHgtdHoles(track)
                      << ")");
    if (track.nOutliers() != s_branchState.nPixelOutliers(track) + s_branchState.nStripOutliers(track) + s_branchState.nHgtdOutliers(track))
      ATH_MSG_WARNING("mismatched outlier count: total (" << track.nOutliers()
                      << ") != pixel (" << s_branchState.nPixelOutliers(track)
                      << ") + strip (" << s_branchState.nStripOutliers(track)
                      << ") + hgtd (" << s_branchState.nHgtdOutliers(track)
                      << ")");
  };

computeStatSum()

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

protectedinherited

Definition at line 746 of file TrackFindingBaseAlg.cxx.

                                                                                                                        {
    std::size_t out = 0u;
    for (std::size_t category_i = seed_collection * seedCollectionStride();
         category_i < (seed_collection + 1) * seedCollectionStride();
         ++category_i)
    {
      assert(category_i < stat.size());
      out += stat[category_i][counter_i];
    }
    return out;
  }

copyStats()

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

protectedinherited

Definition at line 536 of file TrackFindingBaseAlg.cxx.

                                                                        {
    std::lock_guard<std::mutex> lock(m_mutex);
    std::size_t category_i = 0;
    for (const std::array<unsigned int, kNStat> &src_stat : event_stat)
    {
      std::array<std::size_t, kNStat> &dest_stat = m_stat[category_i++];
      for (std::size_t i = 0; i < src_stat.size(); ++i)
      {
        assert(i < dest_stat.size());
        dest_stat[i] += src_stat[i];
      }
    }
  }

declareGaudiProperty()

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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.

{ 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

MeasurementSource

Type of measurement source: ActsTrk::Seed or (in future) ActsTrk::ProtoTrack

Parameters

measurement	Measurement source for KF
initialParameters	Parameters to use in KF
detContext	Struct holding geometry, magnetic field and calibration contexts
paramsAtOutermostSurface	Flag 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

addTrack	Function or lambda which adds newly found track to container
trackProxy	Track proxy object
tracksContainerTemp	Track proxy container
options	Fit options
tgContext	Geometry context
reverseSearch	Flag for searching in reverse direction
seedType	Seed type (only used for warnings/debug printouts)
iseed	Seed number (only used for warnings/debug printouts)
itrack	Track number (only used for warnings/debug printouts)

Returns

Number of found tracks

Definition at line 237 of file TrackFindingBaseAlg.cxx.

                                                                                     {
    if (not m_doTwoWay) return {};
 
    // Create initial parameters for the propagation
    Acts::BoundTrackParameters secondInitialParameters = trackProxy.createParametersFromState(detail::RecoConstTrackStateContainerProxy{firstMeasurement});
    if (!secondInitialParameters.referenceSurface().insideBounds(secondInitialParameters.localPosition())) {  // #3751
      return {};
    }
 
    auto rootBranch = tracksContainerTemp.makeTrack();
    rootBranch.copyFromWithoutStates(trackProxy);  // #3534
 
    // perform track finding
    auto secondResult =
      trackFinder().ckf.findTracks(secondInitialParameters, options, tracksContainerTemp, rootBranch);
    if (not secondResult.ok()) {
      return {};
    }
    return secondResult.value();
  }

evtStore()

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.

{ return m_evtStore; }

execute()

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

overridevirtual

Reimplemented from ActsTrk::TrackFindingBaseAlg.

Definition at line 152 of file TrackFindingAlg.cxx.

  {
    ATH_MSG_DEBUG("Executing " << name() << " ... ");
 
    auto timer = Monitored::Timer<std::chrono::milliseconds>("TIME_execute");
    auto mon_nTracks = Monitored::Scalar<int>("nTracks");
    auto mon = Monitored::Group(m_monTool, timer, mon_nTracks);
 
    // ================================================== //
    // ===================== INPUTS ===================== //
    // ================================================== //
 
    // SEED TRIPLETS
    std::vector<const ActsTrk::SeedContainer *> seedContainers;
    std::size_t total_seeds = 0;
    ATH_CHECK(getContainersFromKeys(ctx, m_seedContainerKeys, seedContainers, total_seeds));
 
    // DESTINIES
    std::vector< std::unique_ptr< std::vector<int> > > destinies {};
    if (m_storeDestinies) {
      destinies.reserve( seedContainers.size() );
      for (std::size_t i(0); i<seedContainers.size(); ++i) {
        destinies.push_back( std::make_unique< std::vector<int> >( seedContainers.at(i)->size(), DestinyType::UNKNOWN) );
      }
    }
 
    // MEASUREMENTS
    std::vector<const xAOD::UncalibratedMeasurementContainer *> uncalibratedMeasurementContainers;
    std::size_t total_measurements = 0;
    ATH_CHECK(getContainersFromKeys(ctx, m_uncalibratedMeasurementContainerKeys, uncalibratedMeasurementContainers, total_measurements));
 
    // map detector element status to volume ids
    SG::ReadCondHandle<ActsTrk::ActsVolumeIdToDetectorElementCollectionMap>
      volumeIdToDetectorElementCollMap(m_volumeIdToDetectorElementCollMapKey,ctx);
    ATH_CHECK(volumeIdToDetectorElementCollMap.isValid());
    std::vector< const InDet::SiDetectorElementStatus *> det_el_status_arr;
    const std::vector<const InDetDD::SiDetectorElementCollection*> &det_el_collections =volumeIdToDetectorElementCollMap->collections();
    det_el_status_arr.resize( det_el_collections.size(), nullptr);
    for (const SG::ReadHandleKey<InDet::SiDetectorElementStatus> &det_el_status_key : m_detElStatus) {
      SG::ReadHandle<InDet::SiDetectorElementStatus> det_el_status(det_el_status_key,ctx);
      ATH_CHECK( det_el_status.isValid());
      const std::vector<const InDetDD::SiDetectorElementCollection*>::const_iterator
        det_el_col_iter = std::find(det_el_collections.begin(),
                                    det_el_collections.end(),
                                    &det_el_status->getDetectorElements());
      det_el_status_arr.at(det_el_col_iter - det_el_collections.begin()) = det_el_status.cptr();
    }
 
    detail::MeasurementIndex measurementIndex(uncalibratedMeasurementContainers.size());
    for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer) {
      measurementIndex.addMeasurements(*uncalibratedMeasurementContainers[icontainer]);
    }
 
    detail::TrackFindingMeasurements measurements(uncalibratedMeasurementContainers.size());
    for (std::size_t icontainer = 0; icontainer < uncalibratedMeasurementContainers.size(); ++icontainer) {
      ATH_MSG_DEBUG("Create " << uncalibratedMeasurementContainers[icontainer]->size() << " source links from measurements in " << m_uncalibratedMeasurementContainerKeys[icontainer].key());
      measurements.addMeasurements(icontainer,
                                   *uncalibratedMeasurementContainers[icontainer],
                                   *m_trackingGeometryTool->surfaceIdMap(),
                                   m_forceTrackOnSeed ? &measurementIndex : nullptr);
    }
 
    ATH_MSG_DEBUG("measurement index size = " << measurementIndex.size());
 
    ATH_CHECK( propagateDetectorElementStatusToMeasurements(*(volumeIdToDetectorElementCollMap.cptr()), det_el_status_arr, measurements) );
 
    if (m_trackStatePrinter.isSet()) {
      m_trackStatePrinter->printMeasurements(ctx, uncalibratedMeasurementContainers, measurements.measurementOffsets());
    }
 
    detail::DuplicateSeedDetector duplicateSeedDetector(total_seeds,
                                                        m_seedMeasOffset.value(),
                                                        m_skipDuplicateSeeds);
    for (std::size_t icontainer = 0; icontainer < seedContainers.size(); ++icontainer)
      {
        duplicateSeedDetector.addSeeds(icontainer, *seedContainers[icontainer], measurementIndex,
                                       m_paramEstimationTool->spacePointIndicesFun(),
                                       [this,icontainer](const ActsTrk::Seed& seed) -> bool {
                                         const bool reverseSearch = m_autoReverseSearch && shouldReverseSearch(seed);
                                         const bool refitSeeds = icontainer < m_refitSeeds.size() && m_refitSeeds[icontainer];
                                         const bool useTopSp = reverseSearch && !refitSeeds;
                                         return useTopSp;
                                       });
      }
 
    // Get Beam pos and make pSurface
    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle = SG::makeHandle( m_beamSpotKey, ctx );
    ATH_CHECK( beamSpotHandle.isValid() );
    const InDet::BeamSpotData* beamSpotData = beamSpotHandle.cptr();
 
    // Beam Spot Position
    Acts::Vector3 beamPos( beamSpotData->beamPos().x() * Acts::UnitConstants::mm,
                           beamSpotData->beamPos().y() * Acts::UnitConstants::mm,
                           0 );
 
    // Construct a perigee surface as the target surface
    std::shared_ptr<Acts::PerigeeSurface> pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(beamPos);
 
    // ================================================== //
    // ===================== CONDS ====================== //
    // ================================================== //
 
    std::vector<const InDetDD::SiDetectorElementCollection*> detElementsCollections;
    std::size_t total_detElems = 0;
    ATH_CHECK(getContainersFromKeys(ctx, m_detEleCollKeys, detElementsCollections, total_detElems));
 
    // ================================================== //
    // ===================== COMPUTATION ================ //
    // ================================================== //
    Acts::VectorTrackContainer actsTrackBackend;
    Acts::VectorMultiTrajectory actsTrackStateBackend;
    {
      std::lock_guard<std::mutex> lock( m_mutex );      
      actsTrackBackend.reserve(m_nTrackReserve);
      actsTrackStateBackend.reserve(m_nTrackStateReserve);
    }
    detail::RecoTrackContainer actsTracksContainer(actsTrackBackend,
                                                   actsTrackStateBackend);
 
    if (m_addCounts) {
      addCounts(actsTracksContainer);
    }
 
    detail::ExpectedLayerPatternHelper::add(actsTracksContainer);
 
    EventStats event_stat;
    event_stat.resize(m_stat.size());
 
    DetectorContextHolder detContext {
      .geometry = m_trackingGeometryTool->getGeometryContext(ctx).context(),
      .magField = m_extrapolationTool->getMagneticFieldContext(ctx),
      // CalibrationContext converter not implemented yet.
      .calib = getCalibrationContext(ctx)
    };
 
    detail::SharedHitCounter sharedHits;
 
    // Perform the track finding for all initial parameters.
    for (std::size_t icontainer = 0; icontainer < seedContainers.size(); ++icontainer)
      {
        ATH_CHECK(findTracks(detContext,
                             measurements,
                             measurementIndex,
                             sharedHits,
                             duplicateSeedDetector,
                             *seedContainers.at(icontainer),
                             *detElementsCollections.at(icontainer),
                             actsTracksContainer,
                             icontainer,
                             icontainer < m_seedLabels.size() ? m_seedLabels[icontainer].c_str() : m_seedContainerKeys[icontainer].key().c_str(),
                             event_stat,
                             m_storeDestinies ? destinies.at(icontainer).get() : nullptr,
                             *pSurface.get()));
      }
 
    ATH_MSG_DEBUG("    \\__ Created " << actsTracksContainer.size() << " tracks");
 
    mon_nTracks = actsTracksContainer.size();
    copyStats(event_stat);
 
 
    // ================================================== //
    // ===================== OUTPUTS ==================== //
    // ================================================== //
 
    // Save the seed destinies
    if (m_storeDestinies) {
      for (std::size_t i(0); i<destinies.size(); ++i) {
        const SG::WriteHandleKey< std::vector<int> >& writeKey = m_seedDestiny.at(i);
        // make the handle and record
        SG::WriteHandle< std::vector<int> > destinyHandle = SG::makeHandle( writeKey, ctx );
        ATH_CHECK( destinyHandle.record( std::move(  destinies.at(i) )  ) );
      }
    }
 
    {
      std::lock_guard<std::mutex> lock( m_mutex );
      // update the reserve space
      if (actsTrackBackend.size() > m_nTrackReserve) {
        m_nTrackReserve = static_cast<std::size_t>( std::ceil(m_memorySafetyMargin * actsTrackBackend.size()) );
      }
      if (actsTrackStateBackend.size() > m_nTrackStateReserve) {
        m_nTrackStateReserve = static_cast<std::size_t>( std::ceil(m_memorySafetyMargin * actsTrackStateBackend.size()) );
      }
    }
    
    // handle the ambiguity    
    // we potentially need to short list the track candidates and make some copies
    if (not m_ambi) {
      // no need to shortlist anything. just use the actsTracksContainer
      ATH_MSG_DEBUG("    \\__ Created " << actsTracksContainer.size() << " resolved tracks");
      ATH_CHECK( storeTrackCollectionToStoreGate( ctx,
                                                  std::move(actsTrackBackend),
                                                  std::move(actsTrackStateBackend) ) );
      return StatusCode::SUCCESS;
    }
 
    // we have asked for the ambi
    // we start by shortlisting the container
    Acts::VectorTrackContainer resolvedTrackBackend;
    Acts::VectorMultiTrajectory resolvedTrackStateBackend;
    resolvedTrackBackend.reserve( actsTrackBackend.size() );
    resolvedTrackStateBackend.reserve( actsTrackStateBackend.size() );
    detail::RecoTrackContainer resolvedTracksContainer(resolvedTrackBackend, resolvedTrackStateBackend);
    detail::ExpectedLayerPatternHelper::add(resolvedTracksContainer);
 
    if (m_addCounts) {
      addCounts(resolvedTracksContainer);
    }
 
    // Start ambiguity resolution
    Acts::GreedyAmbiguityResolution::State state;
    m_ambi->computeInitialState(actsTracksContainer, state, &sourceLinkHash,
                                &sourceLinkEquality);
    m_ambi->resolve(state);
 
    // Copy the resolved tracks into the output container
    // We need a different sharedHits counter here because it saves the track index
    // and since I ran the resolving the track indices changed.
    detail::SharedHitCounter sharedHits_forFinalAmbi;
 
    // shotlist
    for (auto iTrack : state.selectedTracks) {
      auto destProxy = resolvedTracksContainer.makeTrack();
      destProxy.copyFrom(actsTracksContainer.getTrack(state.trackTips.at(iTrack)));
 
      if (m_countSharedHits) {
        auto [nShared, nBadTrackMeasurements] = sharedHits_forFinalAmbi.computeSharedHits(destProxy, resolvedTracksContainer, measurementIndex);
        if (nBadTrackMeasurements > 0)
          ATH_MSG_ERROR("computeSharedHits: " << nBadTrackMeasurements << " track measurements not found in input track");
      }
    } // loop on tracks
 
    ATH_MSG_DEBUG("    \\__ Created " << resolvedTracksContainer.size() << " resolved tracks");
 
    ATH_CHECK( storeTrackCollectionToStoreGate( ctx,
                                                std::move(resolvedTrackBackend),
                                                std::move(resolvedTrackStateBackend)) );
 
    return StatusCode::SUCCESS;
  }

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 ( ) const

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.

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

extrapolateTrackToReferenceSurface()

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

private

Definition at line 861 of file TrackFindingAlg.cxx.

                                                    {
 
    Acts::PropagatorOptions<detail::Stepper::Options, detail::Navigator::Options,
                            Acts::ActorList<Acts::MaterialInteractor, Collector>>
    options(detContext.geometry, detContext.magField);
 
    auto findResult = findTrackStateForExtrapolation(
        options.geoContext, track, referenceSurface, strategy, logger());
 
    if (!findResult.ok()) {
      ATH_MSG_WARNING("Failed to find track state for extrapolation");
      return findResult.error();
    }
 
    auto &[trackState, distance] = *findResult;
 
    options.direction = Acts::Direction::fromScalarZeroAsPositive(distance);
 
    Acts::BoundTrackParameters parameters = track.createParametersFromState(trackState);
    ATH_MSG_VERBOSE("Extrapolating track to reference surface at distance "
                << distance << " with direction " << options.direction
                << " with starting parameters " << parameters);
 
    auto state = propagator.makeState<decltype(options), Acts::ForcedSurfaceReached>(referenceSurface, options);
    ExpectedLayerPattern*& collectorResult = state.get<TrackFindingAlg::ExpectedLayerPattern*>();
    collectorResult = &expectedLayerPattern;
 
    auto initRes = propagator.initialize(state, parameters);
    if(!initRes.ok()) {
      ATH_MSG_WARNING("Failed to initialize propagation state: " << initRes.error().message());
      return initRes.error();
    }
 
 
    auto propagateOnlyResult =
        propagator.propagate(state);
 
    if (!propagateOnlyResult.ok()) {
      ATH_MSG_WARNING("Failed to extrapolate track: " << propagateOnlyResult.error().message());
      return propagateOnlyResult.error();
    }
 
    auto propagateResult = propagator.makeResult(
        std::move(state), propagateOnlyResult, referenceSurface, options);
 
    if (!propagateResult.ok()) {
      ATH_MSG_WARNING("Failed to extrapolate track: " << propagateResult.error().message());
      return propagateResult.error();
    }
 
    track.setReferenceSurface(referenceSurface.getSharedPtr());
    track.parameters() = propagateResult->endParameters.value().parameters();
    track.covariance() =
        propagateResult->endParameters.value().covariance().value();
 
    return Acts::Result<void>::success();
 }

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode ActsTrk::TrackFindingAlg::finalize ( )

overridevirtual

Reimplemented from ActsTrk::TrackFindingBaseAlg.

Definition at line 145 of file TrackFindingAlg.cxx.

                                       {
    ATH_CHECK(TrackFindingBaseAlg::finalize());
    return StatusCode::SUCCESS;
  }

findTracks()

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

private

invoke track finding procedure

Parameters

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

Definition at line 425 of file TrackFindingAlg.cxx.

  {
    ATH_MSG_DEBUG(name() << "::" << __FUNCTION__);
 
    auto [options, secondOptions, measurementSelector] = getDefaultOptions(detContext, measurements, &pSurface);
 
    // ActsTrk::MutableTrackContainer tracksContainerTemp;
    Acts::VectorTrackContainer trackBackend;
    Acts::VectorMultiTrajectory trackStateBackend;
    detail::RecoTrackContainer tracksContainerTemp(trackBackend, trackStateBackend);
 
    if (m_addCounts) {
      addCounts(tracksContainerTemp);
    }
 
    detail::ExpectedLayerPatternHelper::add(tracksContainerTemp);
 
    std::size_t category_i = 0;
    const auto &trackSelectorCfg = trackFinder().trackSelector.config();
    auto stopBranchProxy = [&](const detail::RecoTrackContainer::TrackProxy &track,
                               const detail::RecoTrackContainer::TrackStateProxy &trackState) -> BranchStopperResult {
      return stopBranch(track, trackState, trackSelectorCfg, detContext.geometry, measurementIndex, typeIndex, event_stat[category_i]);
    };
    options.extensions.branchStopper.connect(stopBranchProxy);
 
    Acts::PropagatorOptions<detail::Stepper::Options, detail::Navigator::Options,
                            Acts::ActorList<Acts::MaterialInteractor>>
      extrapolationOptions(detContext.geometry, detContext.magField);
 
    Acts::TrackExtrapolationStrategy extrapolationStrategy =
      Acts::TrackExtrapolationStrategy::first;
 
    // Perform the track finding for all initial parameters
    ATH_MSG_DEBUG("Invoke track finding with " << seeds.size() << ' ' << seedType << " seeds.");
 
 
    std::size_t nPrinted = 0;
 
    // Function for Estimate Track Parameters
    auto retrieveSurfaceFunction =
      [this, &detElements] (const ActsTrk::Seed& seed, bool useTopSp) -> const Acts::Surface& {
        const xAOD::SpacePoint* sp = useTopSp ? seed.sp().back() : seed.sp().front();
        const InDetDD::SiDetectorElement* element = detElements.getDetectorElement(useTopSp ? sp->elementIdList().back()
                                                                                   : sp->elementIdList().front());
        const Trk::Surface& atlas_surface = element->surface();
        return m_ATLASConverterTool->trkSurfaceToActsSurface(atlas_surface);
      };
 
 
 
    // Loop over the track finding results for all initial parameters
    for (unsigned int iseed = 0; iseed < seeds.size(); ++iseed)
      {
        // Get the seed
        const ActsTrk::Seed seed = seeds[iseed];
 
        category_i = typeIndex * (m_statEtaBins.size() + 1);
        tracksContainerTemp.clear();
 
        const bool reverseSearch = m_autoReverseSearch && shouldReverseSearch(seed);
        const bool refitSeeds = typeIndex < m_refitSeeds.size() && m_refitSeeds[typeIndex];
        const bool useTopSp = reverseSearch && !refitSeeds;
 
        // Check if the seed is a duplicate seed
        const bool isDupSeed = duplicateSeedDetector.isDuplicate(typeIndex, iseed);
 
        if (isDupSeed) {
          ATH_MSG_DEBUG("skip " << seedType << " seed " << iseed << " - already found");
          category_i = getSeedCategory(typeIndex, seed, useTopSp);
          ++event_stat[category_i][kNTotalSeeds];
          ++event_stat[category_i][kNDuplicateSeeds];
          if (m_storeDestinies) destiny->at(iseed) = DestinyType::DUPLICATE;
          if (!m_trackStatePrinter.isSet()) continue;  // delay continue to estimate track parms for TrackStatePrinter?
        }
 
        // Set the option accordingly - we change the direction and the target surface accordingly
        options.propagatorPlainOptions.direction = reverseSearch ? Acts::Direction::Backward() : Acts::Direction::Forward();
        secondOptions.propagatorPlainOptions.direction = options.propagatorPlainOptions.direction.invert();
        options.targetSurface = reverseSearch ? &pSurface : nullptr;
        secondOptions.targetSurface = reverseSearch ? nullptr : &pSurface;
        // 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
 
        // Get first estimate of parameters from the seed
        std::optional<Acts::BoundTrackParameters> optTrackParams =
          m_paramEstimationTool->estimateTrackParameters(seed,
                                                         useTopSp,
                                                         detContext.geometry,
                                                         detContext.magField,
                                                         retrieveSurfaceFunction);
 
        if (!optTrackParams) {
          ATH_MSG_DEBUG("Failed to estimate track parameters for seed " << iseed);
          if (!isDupSeed) {
            category_i = getSeedCategory(typeIndex, seed, useTopSp);
            ++event_stat[category_i][kNTotalSeeds];
            ++event_stat[category_i][kNNoEstimatedParams];
            if (m_storeDestinies) destiny->at(iseed) = DestinyType::FAILURE;
          }
          continue;
        }
 
        Acts::BoundTrackParameters *initialParameters = &(*optTrackParams);
        printSeed(iseed, detContext, seeds, *initialParameters, measurementIndex, nPrinted, seedType);
        if (isDupSeed) continue;  // skip now if not done before
 
        double etaInitial = -std::log(std::tan(0.5 * initialParameters->theta()));
        category_i = getStatCategory(typeIndex, etaInitial);
        ++event_stat[category_i][kNTotalSeeds];  // also updated for duplicate seeds
        ++event_stat[category_i][kNUsedSeeds];
 
        // Optional refit track parameters to get more refined value
        std::unique_ptr<Acts::BoundTrackParameters> refitSeedParameters;
        if (refitSeeds) {
          refitSeedParameters = doRefit(seed, *initialParameters, detContext, reverseSearch);
          if (refitSeedParameters.get() == nullptr) {
            ++event_stat[category_i][kNRejectedRefinedSeeds];
            if (m_storeDestinies) destiny->at(iseed) = DestinyType::FAILURE;
            continue;
          }
          if (refitSeedParameters.get() != initialParameters) {
            initialParameters = refitSeedParameters.get();
            printSeed(iseed, detContext, seeds, *initialParameters, measurementIndex, nPrinted, seedType, true);
          }
        }
 
        auto measurementRangesForced =
            m_forceTrackOnSeed ? std::make_unique<ActsTrk::detail::MeasurementRangeListFlat>(measurements.setMeasurementRangesForced(seed, measurementIndex))
                               : nullptr;
        measurementSelector->setMeasurementRangesForced(measurementRangesForced.get());
        if (measurementRangesForced)
          event_stat[category_i][kNForcedSeedMeasurements] += measurementRangesForced->size();
 
        // Get the Acts tracks, given this seed
        // Result here contains a vector of TrackProxy objects
        auto result = trackFinder().ckf.findTracks(*initialParameters, options, tracksContainerTemp);
 
        // The result for this seed
        if (not result.ok()) {
          ATH_MSG_WARNING("Track finding failed for " << seedType << " seed " << iseed << " with error" << result.error());
          if (m_storeDestinies) destiny->at(iseed) = DestinyType::FAILURE;
          continue;
        }
        auto &tracksForSeed = result.value();
 
 
 
        std::size_t ntracks = 0ul;
 
        // loop on the tracks we have just found from the seed
        std::size_t nfirst = 0;
        for (TrkProxy &firstTrack : tracksForSeed) {
          // smoothing
          auto smoothingResult = Acts::smoothTrack(detContext.geometry, firstTrack, logger(), Acts::MbfSmoother());
          if (!smoothingResult.ok()) {
            ATH_MSG_DEBUG("Smoothing for seed "
                          << iseed << " and first track " << firstTrack.index()
                          << " failed with error " << smoothingResult.error());
            continue;
          }
 
          // if no two way, just add the track and move on
          if (not m_doTwoWay) {
            // add the track to the collection
            ATH_CHECK( addTrack(detContext,
                                firstTrack,
                                pSurface,
                                extrapolationStrategy,
                                sharedHits,
                                actsTracksContainer,
                                measurementIndex,
                                tracksContainerTemp,
                                duplicateSeedDetector,
                                destiny,
                                event_stat,
                                ntracks,
                                iseed,
                                category_i,
                                seedType) );
            ++nfirst;
            continue;
          }
 
          // TWO WAY STARTS HERE
          // We need the first measurement of the track
          std::optional<detail::RecoTrackStateContainerProxy> firstMeas = getFirstMeasurementFromTrack(firstTrack);
          // we are supposed to find a measurement
          if (not firstMeas.has_value()) {
            ATH_MSG_ERROR("Could not retrieve first measurement from track proxy. Is it ill-formed?");
            return StatusCode::FAILURE;
          }
          detail::RecoTrackStateContainerProxy& firstMeasurement = firstMeas.value();
 
          // Get the tracks from the second track finding
          std::vector<typename detail::RecoTrackContainer::TrackProxy> secondTracksForSeed =
            doTwoWayTrackFinding(firstMeasurement,
                                 firstTrack,
                                 tracksContainerTemp,
                                 secondOptions);
 
          if ( secondTracksForSeed.empty() ) {
            ATH_MSG_DEBUG("No viable result from second track finding for " << seedType << " seed " << iseed << " track " << nfirst);
            ++event_stat[category_i][kNoSecond];
            ATH_CHECK( addTrack(detContext,
                                firstTrack,
                                pSurface,
                                extrapolationStrategy,
                                sharedHits,
                                actsTracksContainer,
                                measurementIndex,
                                tracksContainerTemp,
                                duplicateSeedDetector,
                                destiny,
                                event_stat,
                                ntracks,
                                iseed,
                                category_i,
                                seedType) );
          }
 
          // need to add tracks here
          // do the stiching
          // store the original previous state to restore it later
          auto originalFirstMeasurementPrevious = firstMeasurement.previous();
          for (auto &secondTrack : secondTracksForSeed) {
            secondTrack.reverseTrackStates(true);
 
            firstMeasurement.previous() = secondTrack.outermostTrackState().index();
            secondTrack.tipIndex() = firstTrack.tipIndex();
 
            if (reverseSearch) {
              // smooth the full track
              auto secondSmoothingResult = Acts::smoothTrack(detContext.geometry,
                                                             secondTrack,
                                                             logger());
              if ( not secondSmoothingResult.ok() ) {
                continue;
              }
              secondTrack.reverseTrackStates(true);
            }
 
            // Add track to collection
            ATH_CHECK( addTrack(detContext,
                                secondTrack,
                                pSurface,
                                extrapolationStrategy,
                                sharedHits,
                                actsTracksContainer,
                                measurementIndex,
                                tracksContainerTemp,
                                duplicateSeedDetector,
                                destiny,
                                event_stat,
                                ntracks,
                                iseed,
                                category_i,
                                seedType) );
          } // loop on tracks
 
          // finish the stiching
          // restore the original previous state for the first track
          firstMeasurement.previous() = originalFirstMeasurementPrevious;
 
          nfirst++;
        } // loop on tracks from seed
 
        if (m_storeDestinies) {
          if (ntracks == 0) {
            destiny->at(iseed) = DestinyType::FAILURE;
          } else {
            destiny->at(iseed) = DestinyType::SUCCEED;
          }
        }
 
        if (ntracks == 0) {
          ATH_MSG_DEBUG("Track finding found no track candidates for " << seedType << " seed " << iseed);
          ++event_stat[category_i][kNoTrack];
        } else if (ntracks >= 2) {
          ++event_stat[category_i][kMultipleBranches];
        }
 
        if (m_trackStatePrinter.isSet())
          std::cout << std::flush;
      } // loop on seeds
 
    ATH_MSG_DEBUG("Completed " << seedType << " track finding with " << computeStatSum(typeIndex, kNOutputTracks, event_stat) << " track candidates.");
 
    return StatusCode::SUCCESS;
  }

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

HandleArrayKeyType	Type of the list of handle keys
ContainerType	Type of the output container

Parameters

ctx	Event context
handleKeyArray	List of handle keys
outputContainers	Vector of output containers
sum	Number 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

eta	track candidate eta value

Definition at line 228 of file TrackFindingBaseAlg.cxx.

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

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

detContext	Object holding detector-related context
measurements	<easurements container used in MeasurementSelector
pSurface	Raw pointer to perigee surface

Definition at line 201 of file TrackFindingBaseAlg.cxx.

                                                {
    Acts::PropagatorPlainOptions plainOptions{detContext.geometry, detContext.magField};
    plainOptions.maxSteps = m_maxPropagationStep;
    plainOptions.direction = Acts::Direction::Forward();
    plainOptions.endOfWorldVolumeIds = m_endOfWorldVolumeIds;
 
    // Set the CombinatorialKalmanFilter options
    TrackFinderOptions options(detContext.geometry, detContext.magField, detContext.calib,
                               trackFinder().ckfExtensions, plainOptions, pSurface);
 
    std::unique_ptr<ActsTrk::IMeasurementSelector> measurementSelector = setMeasurementSelector(measurements, options);
 
    Acts::PropagatorPlainOptions plainSecondOptions{detContext.geometry, detContext.magField};
    plainSecondOptions.maxSteps = m_maxPropagationStep;
    plainSecondOptions.direction = plainOptions.direction.invert();
 
    TrackFinderOptions secondOptions(detContext.geometry, detContext.magField, detContext.calib,
                                     options.extensions, plainSecondOptions, pSurface);
    secondOptions.targetSurface = pSurface;
    secondOptions.skipPrePropagationUpdate = true;
 
    return {std::move(options), std::move(secondOptions), std::move(measurementSelector)};
  };

getSeedCategory()

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

private

Definition at line 806 of file TrackFindingAlg.cxx.

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

getStatCategory()

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

protectedinherited

Definition at line 737 of file TrackFindingBaseAlg.cxx.

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

initCounts()

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

staticprotectedinherited

Definition at line 397 of file TrackFindingBaseAlg.cxx.

  {
    s_branchState.nPixelHits(track) = 0;
    s_branchState.nStripHits(track) = 0;
    s_branchState.nHgtdHits(track) = 0;
    s_branchState.nPixelHoles(track) = 0;
    s_branchState.nStripHoles(track) = 0;
    s_branchState.nHgtdHoles(track) = 0;
    s_branchState.nPixelOutliers(track) = 0;
    s_branchState.nStripOutliers(track) = 0;
    s_branchState.nHgtdOutliers(track) = 0;
  }

initialize()

StatusCode ActsTrk::TrackFindingAlg::initialize ( )

overridevirtual

Reimplemented from ActsTrk::TrackFindingBaseAlg.

Definition at line 78 of file TrackFindingAlg.cxx.

  {
    ATH_MSG_INFO("Initializing " << name() << " ... ");
 
    ATH_CHECK(TrackFindingBaseAlg::initialize());
    ATH_MSG_DEBUG("   " << m_skipDuplicateSeeds);
    ATH_MSG_DEBUG("   " << m_refitSeeds);
    ATH_MSG_DEBUG("   " << m_statEtaBins);
    ATH_MSG_DEBUG("   " << m_seedLabels);
    ATH_MSG_DEBUG("   " << m_dumpAllStatEtaBins);
    ATH_MSG_DEBUG("   " << m_useTopSpRZboundary);
    ATH_MSG_DEBUG("   " << m_seedMeasOffset);
    ATH_MSG_DEBUG("   " << m_ambiStrategy);
    ATH_MSG_DEBUG("   " << m_autoReverseSearch);
    ATH_MSG_DEBUG("   " << m_countSharedHits);
    ATH_MSG_DEBUG("   " << m_forceTrackOnSeed);
 
    ATH_CHECK(m_paramEstimationTool.retrieve());
    ATH_CHECK(m_seedContainerKeys.initialize());
    ATH_CHECK(m_detEleCollKeys.initialize());
    ATH_CHECK(m_uncalibratedMeasurementContainerKeys.initialize());
    ATH_CHECK(m_volumeIdToDetectorElementCollMapKey.initialize());
    ATH_CHECK(m_detElStatus.initialize());
    ATH_CHECK(m_beamSpotKey.initialize());
 
    m_storeDestinies = not m_seedDestiny.empty();
    ATH_CHECK(m_seedDestiny.initialize(m_storeDestinies));
 
    if (m_seedContainerKeys.size() != m_detEleCollKeys.size())
      {
        ATH_MSG_FATAL("There are " << m_detEleCollKeys.size() << " DetectorElementsKeys, but " << m_seedContainerKeys.size() << " SeedContainerKeys");
        return StatusCode::FAILURE;
      }
 
    if (m_detEleCollKeys.size() != m_seedLabels.size())
      {
        ATH_MSG_FATAL("There are " << m_seedLabels.size() << " SeedLabels, but " << m_detEleCollKeys.size() << " DetectorElementsKeys");
        return StatusCode::FAILURE;
      }
 
    if (m_useTopSpRZboundary.size() != 2)
      {
        ATH_MSG_FATAL("useTopSpRZboundary must have 2 elements, but has " << m_useTopSpRZboundary.size());
        return StatusCode::FAILURE;
      }
 
    if (m_ambiStrategy == 1u /* END_OF_TF */) {
      Acts::GreedyAmbiguityResolution::Config cfg;
      cfg.maximumSharedHits = m_maximumSharedHits;
      cfg.maximumIterations = m_maximumIterations;
      cfg.nMeasurementsMin = m_nMeasurementsMin;
 
      m_ambi.emplace(std::move(cfg), makeActsAthenaLogger(this, "Acts"));
    }
 
    if (m_storeDestinies) {
      if (m_seedDestiny.size() != m_seedContainerKeys.size()) {
        ATH_MSG_ERROR("There are " << m_seedDestiny.size() << " seed destiny collections, but " << m_seedContainerKeys.size() << " seed collections");
        return StatusCode::FAILURE;
      }
    }
 
    return StatusCode::SUCCESS;
  }

initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector ( )

protectedinherited

Definition at line 489 of file TrackFindingBaseAlg.cxx.

                                                                {
    std::vector<std::pair<float, float> > &chi2CutOffOutlier = m_measurementSelectorConfig.m_chi2CutOffOutlier;
    chi2CutOffOutlier .reserve( m_chi2CutOff.size() );
    if (!m_chi2OutlierCutOff.empty()) {
       if (m_chi2CutOff.size() !=  m_chi2OutlierCutOff.size()) {
          ATH_MSG_ERROR("Outlier chi2 cut off provided but number of elements does not agree with"
                        " chi2 cut off for measurements which however is required: "
                        << m_chi2CutOff.size() << " != " <<  m_chi2OutlierCutOff.size());
          return StatusCode::FAILURE;
       }
    }
    unsigned int idx=0;
    for (const auto &elm : m_chi2CutOff) {
       chi2CutOffOutlier.push_back( std::make_pair(static_cast<float>(elm),
                                                   idx < m_chi2OutlierCutOff.size()
                                                   ? static_cast<float>(m_chi2OutlierCutOff[idx])
                                                   : std::numeric_limits<float>::max()) );
       ++idx;
    }
    if (m_etaBins.size() > 2) {
      std::vector<float> &etaBinsf = m_measurementSelectorConfig.m_etaBins;
      etaBinsf.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
    }
 
    return /*m_measurementSelector ?*/ StatusCode::SUCCESS /*: StatusCode::FAILURE*/;
  }

initStatTables()

void ActsTrk::TrackFindingBaseAlg::initStatTables ( )

protectedinherited

Definition at line 518 of file TrackFindingBaseAlg.cxx.

                                           {
    if (!m_statEtaBins.empty())
    {
      m_useAbsEtaForStat = (m_statEtaBins[0] > 0.);
      float last_eta = m_statEtaBins[0];
      for (float eta : m_statEtaBins)
      {
        if (eta < last_eta)
        {
          ATH_MSG_FATAL("Eta bins for statistics counter not in ascending order.");
        }
        last_eta = eta;
      }
    }
    m_stat.resize(nSeedCollections() * seedCollectionStride());
  }

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 ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

logger()

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

inlineprotectedinherited

Private access to the logger.

Definition at line 319 of file TrackFindingBaseAlg.h.

    {
      return *m_logger;
    }

measurementType()

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

staticprotectedinherited

Definition at line 261 of file TrackFindingBaseAlg.cxx.

                                                                                                                     {
    if (trackState.hasReferenceSurface()) {
      if (const auto *actsDetElem = dynamic_cast<const IDetectorElementBase *>(trackState.referenceSurface().associatedDetectorElement())) {
        switch (actsDetElem->detectorType()) {
        case DetectorType::Pixel:
          return xAOD::UncalibMeasType::PixelClusterType;
        case DetectorType::Sct:
          return xAOD::UncalibMeasType::StripClusterType;
        case DetectorType::Hgtd:
          return xAOD::UncalibMeasType::HGTDClusterType;
        default:
          break;
        }
      }
    }
    return xAOD::UncalibMeasType::Other;
  }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

nSeedCollections()

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

inlineprotectedinherited

Definition at line 332 of file TrackFindingBaseAlg.h.

                                       {
      return m_seedLabels.size();
    }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

printSeed()

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

private

Definition at line 816 of file TrackFindingAlg.cxx.

  {
    if (not m_trackStatePrinter.isSet()) return;
 
    if (nPrinted == 0) {
      ATH_MSG_INFO("CKF results for " << seeds.size() << ' ' << seedType << " seeds:");
    }
    ++nPrinted;
    m_trackStatePrinter->printSeed(detContext.geometry, seeds[iseed], seedParameters, measurementIndex, iseed, isKF);
  }

printStatTables()

void ActsTrk::TrackFindingBaseAlg::printStatTables ( ) const

protectedinherited

Definition at line 551 of file TrackFindingBaseAlg.cxx.

                                                  {
    if (msgLvl(MSG::INFO))
    {
      std::vector<std::string> stat_labels =
          TableUtils::makeLabelVector(kNStat,
                                      {
                                          std::make_pair(kNTotalSeeds, "Input seeds"),
                                          std::make_pair(kNoTrackParam, "No track parameters"),
                                          std::make_pair(kNUsedSeeds, "Used   seeds"),
                                          std::make_pair(kNoTrack, "Cannot find track"),
                                          std::make_pair(kNDuplicateSeeds, "Duplicate seeds"),
                                          std::make_pair(kNNoEstimatedParams, "Initial param estimation failed"),
                                          std::make_pair(kNRejectedRefinedSeeds, "Rejected refined parameters"),
                                          std::make_pair(kNOutputTracks, "CKF tracks"),
                                          std::make_pair(kNSelectedTracks, "selected tracks"),
                                          std::make_pair(kNStoppedTracksMaxHoles, "Stopped tracks reaching max holes"),
                                          std::make_pair(kMultipleBranches, "Seeds with more than one branch"),
                                          std::make_pair(kNoSecond, "Tracks failing second CKF"),
                                          std::make_pair(kNStoppedTracksMinPt, "Stopped tracks below pT cut"),
                                          std::make_pair(kNStoppedTracksMaxEta, "Stopped tracks above max eta"),
                                          std::make_pair(kNTotalSharedHits, "Total shared hits"),
                                          std::make_pair(kNForcedSeedMeasurements, "Total forced measurements")
                                      });
      assert(stat_labels.size() == kNStat);
      std::vector<std::string> categories;
      categories.reserve(m_seedLabels.size() + 1);
      categories.insert(categories.end(), m_seedLabels.begin(), m_seedLabels.end());
      categories.push_back("ALL");
 
      std::vector<std::string> eta_labels;
      eta_labels.reserve(m_statEtaBins.size() + 2);
      for (std::size_t eta_bin_i = 0; eta_bin_i < m_statEtaBins.size() + 2; ++eta_bin_i)
      {
        eta_labels.push_back(TableUtils::makeEtaBinLabel(m_statEtaBins, eta_bin_i, m_useAbsEtaForStat));
      }
 
      // vector used as 3D array stat[ eta_bin ][ stat_i ][ seed_type]
      // stat_i = [0, kNStat)
      // eta_bin = [0, m_statEtaBins.size()+2 ); eta_bin == m_statEtaBinsSize()+1 means sum of all etaBins
      // seed_type = [0, nSeedCollections()+1)  seed_type == nSeedCollections() means sum of all seed collections
      std::vector<std::size_t> stat =
          TableUtils::createCounterArrayWithProjections<std::size_t>(nSeedCollections(),
                                                                     m_statEtaBins.size() + 1,
                                                                     m_stat);
 
      // the extra columns and rows for the projections are addeded internally:
      std::size_t stat_stride =
          TableUtils::counterStride(nSeedCollections(),
                                    m_statEtaBins.size() + 1,
                                    kNStat);
      std::size_t eta_stride =
          TableUtils::subCategoryStride(nSeedCollections(),
                                        m_statEtaBins.size() + 1,
                                        kNStat);
      std::stringstream table_out;
 
      if (m_dumpAllStatEtaBins.value())
      {
        // dump for each counter a table with one row per eta bin
        std::size_t max_label_width = TableUtils::maxLabelWidth(stat_labels) + TableUtils::maxLabelWidth(eta_labels);
        for (std::size_t stat_i = 0; stat_i < kNStat; ++stat_i)
        {
          std::size_t dest_idx_offset = stat_i * stat_stride;
          table_out << makeTable(stat, dest_idx_offset, eta_stride,
                                 eta_labels,
                                 categories)
                           .columnWidth(10)
                           // only dump the footer for the last eta bin i.e. total
                           .dumpHeader(stat_i == 0)
                           .dumpFooter(stat_i + 1 == kNStat)
                           .separateLastRow(true) // separate the sum of all eta bins
                           .minLabelWidth(max_label_width)
                           .labelPrefix(stat_labels.at(stat_i));
        }
      }
      else
      {
        // dump one table with one row per counter showing the total eta range
        for (std::size_t eta_bin_i = (m_dumpAllStatEtaBins.value() ? 0 : m_statEtaBins.size() + 1);
             eta_bin_i < m_statEtaBins.size() + 2;
             ++eta_bin_i)
        {
          std::size_t dest_idx_offset = eta_bin_i * eta_stride;
          table_out << makeTable(stat, dest_idx_offset, stat_stride,
                                 stat_labels,
                                 categories,
                                 eta_labels.at(eta_bin_i))
                           .columnWidth(10)
                           // only dump the footer for the last eta bin i.e. total
                           .dumpFooter(!m_dumpAllStatEtaBins.value() || eta_bin_i == m_statEtaBins.size() + 1);
        }
      }
      ATH_MSG_INFO("statistics:\n"
                   << table_out.str());
      table_out.str("");
 
      // define retios first element numerator, second element denominator
      // each element contains a vector of counter and a multiplier e.g. +- 1
      // ratios are computed as  (sum_i stat[stat_i] *  multiplier_i ) / (sum_j stat[stat_j] *  multiplier_j )
      auto [ratio_labels, ratio_def] =
          TableUtils::splitRatioDefinitionsAndLabels({TableUtils::makeRatioDefinition("failed / seeds ",
                                                                                      std::vector<TableUtils::SummandDefinition>{
                                                                                          TableUtils::defineSummand(kNTotalSeeds, 1),
                                                                                          TableUtils::defineSummand(kNUsedSeeds, -1),
                                                                                          TableUtils::defineSummand(kNDuplicateSeeds, -1),
                                                                                          // no track counted  as used but want to include it as failed
                                                                                          TableUtils::defineSummand(kNoTrack, 1),
                                                                                      }, // failed seeds i.e. seeds which are not duplicates but did not produce a track
                                                                                      std::vector<TableUtils::SummandDefinition>{TableUtils::defineSummand(kNTotalSeeds, 1)}),
                                                      TableUtils::defineSimpleRatio("duplication / seeds", kNDuplicateSeeds, kNTotalSeeds),
                                                      TableUtils::defineSimpleRatio("Rejected refined params / seeds", kNRejectedRefinedSeeds, kNTotalSeeds),
                                                      TableUtils::defineSimpleRatio("selected / CKF tracks", kNSelectedTracks, kNOutputTracks),
                                                      TableUtils::defineSimpleRatio("selected tracks / used seeds", kNSelectedTracks, kNUsedSeeds),
                                                      TableUtils::defineSimpleRatio("branched tracks / used seeds", kMultipleBranches, kNUsedSeeds),
                                                      TableUtils::defineSimpleRatio("no 2nd CKF / CKF tracks", kNoSecond, kNOutputTracks),
                                                      TableUtils::defineSimpleRatio("shared hits / CKF tracks", kNTotalSharedHits, kNOutputTracks),
                                                      TableUtils::defineSimpleRatio("forced measurements / used seeds", kNForcedSeedMeasurements, kNUsedSeeds)});
 
      std::vector<float> ratio = TableUtils::computeRatios(ratio_def,
                                                           nSeedCollections() + 1,
                                                           m_statEtaBins.size() + 2,
                                                           stat);
 
      // the extra columns and rows for the projections are _not_ added internally
      std::size_t ratio_stride = TableUtils::ratioStride(nSeedCollections() + 1,
                                                         m_statEtaBins.size() + 2,
                                                         ratio_def);
      std::size_t ratio_eta_stride = TableUtils::subCategoryStride(nSeedCollections() + 1,
                                                                   m_statEtaBins.size() + 2,
                                                                   ratio_def);
 
      std::size_t max_label_width = TableUtils::maxLabelWidth(ratio_labels) + TableUtils::maxLabelWidth(eta_labels);
      if (m_dumpAllStatEtaBins.value())
      {
        // show for each ratio a table with one row per eta bin
        for (std::size_t ratio_i = 0; ratio_i < ratio_labels.size(); ++ratio_i)
        {
          table_out << makeTable(ratio,
                                 ratio_i * ratio_stride,
                                 ratio_eta_stride,
                                 eta_labels,
                                 categories)
                           .columnWidth(10)
                           // only dump the footer for the last eta bin i.e. total
                           .dumpHeader(ratio_i == 0)
                           .dumpFooter(ratio_i + 1 == ratio_labels.size())
                           .separateLastRow(true) // separate the sum of las
                           .minLabelWidth(max_label_width)
                           .labelPrefix(ratio_labels.at(ratio_i));
        }
      }
      else
      {
        // dump one table with one row per ratio showing  the total eta range
        table_out << makeTable(ratio,
                               (m_statEtaBins.size() + 1) * ratio_eta_stride + 0 * ratio_stride,
                               ratio_stride,
                               ratio_labels,
                               categories)
                         .columnWidth(10)
                         // only dump the footer for the last eta bin i.e. total
                         .minLabelWidth(max_label_width)
                         .dumpFooter(false);
 
        // also dump a table for final tracks over seeds (ratio_i==3) showing one row per eta bin
        eta_labels.erase(eta_labels.end() - 1); // drop last line of table which shows again all eta bins summed.
        constexpr std::size_t ratio_i = 3;
        table_out << makeTable(ratio,
                               ratio_i * ratio_stride,
                               ratio_eta_stride,
                               eta_labels,
                               categories)
                         .columnWidth(10)
                         .dumpHeader(false)
                         // only dump the footer for the last eta bin i.e. total
                         .dumpFooter(!m_dumpAllStatEtaBins.value() || ratio_i + 1 == ratio_labels.size())
                         .separateLastRow(false)
                         .minLabelWidth(max_label_width)
                         .labelPrefix(ratio_labels.at(ratio_i));
      }
 
      ATH_MSG_INFO("Ratios:\n"
                   << table_out.str());
    }
  }

propagateDetectorElementStatusToMeasurements()

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

private

Definition at line 749 of file TrackFindingAlg.cxx.

                                                                                                                               {
    const Acts::TrackingGeometry *
      acts_tracking_geometry = m_trackingGeometryTool->trackingGeometry().get();
    ATH_CHECK(acts_tracking_geometry != nullptr);
 
    using Counter = struct { unsigned int n_volumes, n_volumes_with_status, n_missing_detector_elements, n_detector_elements, n_disabled_detector_elements;};
    Counter counter {0u,0u,0u,0u,0u};
    acts_tracking_geometry->visitVolumes([&counter,
                                          &volume_id_to_det_el_coll,
                                          &det_el_status_arr,
                                          &measurements,
                                          this](const Acts::TrackingVolume *volume_ptr) {
      ++counter.n_volumes;
      if (!volume_ptr) return;
 
      const InDet::SiDetectorElementStatus*
        det_el_status = det_el_status_arr.at(volume_id_to_det_el_coll.collecionMap().at(volume_ptr->geometryId().volume()));
      if (det_el_status) {
        ++counter.n_volumes_with_status;
        volume_ptr->visitSurfaces([&counter, det_el_status, &measurements,this](const Acts::Surface *surface_ptr) {
          if (!surface_ptr) return;
          const Acts::Surface &surface = *surface_ptr;
          const Acts::DetectorElementBase*detector_element = surface.associatedDetectorElement();
          if (detector_element) {
            ++counter.n_detector_elements;
            const ActsDetectorElement *acts_detector_element = static_cast<const ActsDetectorElement*>(detector_element);
            if (!det_el_status->isGood( acts_detector_element->identifyHash() )) {
              ActsTrk::detail::MeasurementRange old_range = measurements.markSurfaceInsensitive(surface_ptr->geometryId());
              if (!old_range.empty()) {
                auto geoid_to_string = [](const Acts::GeometryIdentifier &id) -> std::string  {
                  std::stringstream amsg;
                  amsg << id;
                  return amsg.str();
                };
                std::string a_msg ( geoid_to_string(surface_ptr->geometryId()));
                ATH_MSG_WARNING("Reject " << (old_range.elementEndIndex() - old_range.elementBeginIndex())
                                << " measurements because surface " << a_msg);
              }
              ++counter.n_disabled_detector_elements;
            }
          }
        }, true /*only sensitive surfaces*/);
      }
      else {
        ++counter.n_missing_detector_elements;
      }
    });
    ATH_MSG_DEBUG("Volumes with detector element status " << counter.n_volumes_with_status << " / " << counter.n_volumes
                  << " disabled detector elements " << counter.n_disabled_detector_elements
                  << " / " << counter.n_detector_elements
                  << " missing detector elements "
                  << counter.n_missing_detector_elements);
    return StatusCode::SUCCESS;
  }

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

seedCollectionStride()

std::size_t ActsTrk::TrackFindingBaseAlg::seedCollectionStride ( ) const

inlineprotectedinherited

Definition at line 335 of file TrackFindingBaseAlg.h.

                                           {
      return m_statEtaBins.size() + 1;
    }

selectCounts()

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

protectedinherited

Definition at line 463 of file TrackFindingBaseAlg.cxx.

                                                                                                                       {
    bool enoughMeasurements = true, tooManyHoles = false, tooManyOutliers = false;
    const auto &trackSelectorCfg = trackFinder().trackSelector.config();
    std::size_t etaBin = (std::abs(eta) < trackSelectorCfg.absEtaEdges.front())   ? 0
                         : (std::abs(eta) >= trackSelectorCfg.absEtaEdges.back()) ? trackSelectorCfg.absEtaEdges.size() - 1
                                                                                  : trackSelectorCfg.binIndex(eta);
    auto cutMin = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
      return !cutSet.empty() && (val < (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
    };
    auto cutMax = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
      return !cutSet.empty() && (val > (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
    };
 
    enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nPixelHits(track), m_minPixelHits);
    enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nStripHits(track), m_minStripHits);
    enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nHgtdHits(track), m_minHgtdHits);
    tooManyHoles = tooManyHoles || cutMax(s_branchState.nPixelHoles(track), m_maxPixelHoles);
    tooManyHoles = tooManyHoles || cutMax(s_branchState.nStripHoles(track), m_maxStripHoles);
    tooManyHoles = tooManyHoles || cutMax(s_branchState.nHgtdHoles(track), m_maxHgtdHoles);
    tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nPixelOutliers(track), m_maxPixelOutliers);
    tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nStripOutliers(track), m_maxStripOutliers);
    tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nHgtdOutliers(track), m_maxHgtdOutliers);
 
    return {enoughMeasurements, tooManyHoles, tooManyOutliers};
  }

selectCountsFinal()

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

protectedinherited

Definition at line 758 of file TrackFindingBaseAlg.cxx.

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

setFilterPassed()

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

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

setMeasurementSelector()

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

nodiscardprotectedinherited

Setup and attach measurement selector to KF options.

Parameters

measurements	measurements container used in MeasurementSelector
options	Kalman filter options

Returns

unique_ptr to MeasurementSelector

Definition at line 183 of file TrackFindingBaseAlg.cxx.

                                         {
 
    std::unique_ptr<ActsTrk::IMeasurementSelector> measurementSelector = ActsTrk::detail::getMeasurementSelector(
        m_pixelCalibTool.isEnabled() ? &(*m_pixelCalibTool) : nullptr,
        m_stripCalibTool.isEnabled() ? &(*m_stripCalibTool) : nullptr,
        m_hgtdCalibTool.isEnabled() ? &(*m_hgtdCalibTool) : nullptr,
        measurements.measurementRanges(),
        m_measurementSelectorConfig.m_etaBins,
        m_measurementSelectorConfig.m_chi2CutOffOutlier,
        m_numMeasurementsCutOff.value());
 
    measurementSelector->connect(&options.extensions.createTrackStates);
 
    return measurementSelector;
  }

shouldReverseSearch()

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

private

Definition at line 410 of file TrackFindingAlg.cxx.

                                                                         {
    const auto& bottom_sp = seed.sp().front();
 
    const double r = bottom_sp->radius();
    const double z = std::abs(bottom_sp->z());
 
    const double rBoundary = m_useTopSpRZboundary.value()[0];
    const double zBoundary = m_useTopSpRZboundary.value()[1];
 
    return r > rBoundary || z > zBoundary;
  }

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

track	Track proxy object
trackState	Track state proxy object
trackSelectorCfg	Track selector configuration
tgContext	Geometry context
measurementIndex	Measurement index
typeIndex	Type index
event_stat_category_i	Event statistics for current category

Returns

BranchStopperResult

Definition at line 279 of file TrackFindingBaseAlg.cxx.

                                                         {
    if (m_addCounts) {
      updateCounts(track, trackState.typeFlags(),
                   measurementType(trackState));
      if (m_checkCounts) {
        checkCounts(track);
      }
    }
 
    if (m_trackStatePrinter.isSet()) {
      m_trackStatePrinter->printTrackState(tgContext, trackState,
                                           measurementIndex, true);
    }
 
    if (!m_doBranchStopper) {
      return BranchStopperResult::Continue;
    }
 
    const auto &parameters = trackState.hasFiltered() ? trackState.filtered()
                                                      : trackState.predicted();
    double eta = -std::log(std::tan(0.5 * parameters[Acts::eBoundTheta]));
    const auto &cutSet = getCuts(eta);
 
    if (typeIndex < m_ptMinMeasurements.size() &&
        !(track.nMeasurements() < m_ptMinMeasurements[typeIndex])) {
      double pT = std::sin(parameters[Acts::eBoundTheta]) /
                  parameters[Acts::eBoundQOverP];
      if (std::abs(pT) < cutSet.ptMin * m_branchStopperPtMinFactor) {
        ++event_stat_category_i[kNStoppedTracksMinPt];
        ATH_MSG_DEBUG("CkfBranchStopper: drop branch with q*pT="
                      << pT << " after " << track.nMeasurements()
                      << " measurements");
        return BranchStopperResult::StopAndDrop;
      }
    }
 
    if (typeIndex < m_absEtaMaxMeasurements.size() &&
        !(track.nMeasurements() < m_absEtaMaxMeasurements[typeIndex]) &&
        !(std::abs(eta) < trackSelectorCfg.absEtaEdges.back() +
                              m_branchStopperAbsEtaMaxExtra)) {
      ++event_stat_category_i[kNStoppedTracksMaxEta];
      ATH_MSG_DEBUG("CkfBranchStopper: drop branch with eta="
                    << eta << " after " << track.nMeasurements()
                    << " measurements");
      return BranchStopperResult::StopAndDrop;
    }
 
 
    // In the pixel endcap regions relax the requirement for minMeasurements before cutting the branch off
    auto minMeasurementsBranchStop = std::abs(eta) > m_branchStopperAbsEtaMeasCut ? cutSet.minMeasurements - m_branchStopperMeasCutReduce : cutSet.minMeasurements;
    bool enoughMeasurements = (track.nMeasurements() >= minMeasurementsBranchStop);
    bool tooManyHoles = (track.nHoles() > cutSet.maxHoles);
    bool tooManyOutliers = (track.nOutliers() > cutSet.maxOutliers);
 
    if (m_addCounts) {
      auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] =
          selectCounts(track, eta);
      enoughMeasurements = enoughMeasurements && enoughMeasurementsPS;
      tooManyHoles = tooManyHoles || tooManyHolesPS;
      tooManyOutliers = tooManyOutliers || tooManyOutliersPS;
    }
 
    if (!(tooManyHoles || tooManyOutliers)) {
      return BranchStopperResult::Continue;
    }
 
    if (!enoughMeasurements) {
      ++event_stat_category_i[kNStoppedTracksMaxHoles];
    }
 
    if (m_addCounts) {
      ATH_MSG_DEBUG("CkfBranchStopper: stop and "
                    << (enoughMeasurements ? "keep" : "drop")
                    << " branch with nHoles=" << track.nHoles() << " ("
                    << s_branchState.nPixelHoles(track) << " pixel+"
                    << s_branchState.nStripHoles(track) << " strip+"
                    << s_branchState.nHgtdHoles(track)
                    << " hgtd), nOutliers=" << track.nOutliers() << " ("
                    << s_branchState.nPixelOutliers(track) << "+"
                    << s_branchState.nStripOutliers(track) << "+"
                    << s_branchState.nHgtdOutliers(track)
                    << "), nMeasurements=" << track.nMeasurements() << " ("
                    << s_branchState.nPixelHits(track) << "+"
                    << s_branchState.nStripHits(track) << "+"
                    << s_branchState.nHgtdHits(track) << ")");
    } else {
      ATH_MSG_DEBUG("CkfBranchStopper: stop and "
                    << (enoughMeasurements ? "keep" : "drop")
                    << " branch with nHoles=" << track.nHoles()
                    << ", nOutliers=" << track.nOutliers()
                    << ", nMeasurements=" << track.nMeasurements());
    }
 
    return enoughMeasurements ? BranchStopperResult::StopAndKeep
                              : BranchStopperResult::StopAndDrop;
  }

storeSeedInfo()

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

private

Definition at line 727 of file TrackFindingAlg.cxx.

                                                                                       {
 
    const auto lastMeasurementIndex = track.tipIndex();
    duplicateSeedDetector.newTrajectory();
 
    tracksContainer.trackStateContainer().visitBackwards(
                                                         lastMeasurementIndex,
                                                         [&duplicateSeedDetector,&measurementIndex](const detail::RecoTrackStateContainer::ConstTrackStateProxy &state) -> void
                                                         {
                                                           // Check there is a source link
                                                           if (not state.hasUncalibratedSourceLink())
                                                             return;
 
                                                           // Fill the duplicate selector
                                                           auto sl = state.getUncalibratedSourceLink().template get<ATLASUncalibSourceLink>();
                                                           duplicateSeedDetector.addMeasurement(sl, measurementIndex);
                                                         }); // end visitBackwards
  }

storeTrackCollectionToStoreGate()

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

private

Definition at line 394 of file TrackFindingAlg.cxx.

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

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.

{
  return BaseAlg::sysExecute (ctx);
}

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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

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.

{ return *m_trackFinder; }

trackFinder() [2/2]

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

protectedinherited

Definition at line 20 of file TrackFindingBaseAlg.cxx.

{ return *m_trackFinder; }

updateCounts()

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

staticprotectedinherited

Definition at line 410 of file TrackFindingBaseAlg.cxx.

                                                                      {
    if (detType == xAOD::UncalibMeasType::PixelClusterType) {
      if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
        s_branchState.nPixelHoles(track)++;
      } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
        s_branchState.nPixelOutliers(track)++;
      } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
        s_branchState.nPixelHits(track)++;
      }
    } else if (detType == xAOD::UncalibMeasType::StripClusterType) {
      if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
        s_branchState.nStripHoles(track)++;
      } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
        s_branchState.nStripOutliers(track)++;
      } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
        s_branchState.nStripHits(track)++;
      }
    } else if (detType == xAOD::UncalibMeasType::HGTDClusterType) {
      if (typeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
        s_branchState.nHgtdHoles(track)++;
      } else if (typeFlags.test(Acts::TrackStateFlag::OutlierFlag)) {
        s_branchState.nHgtdOutliers(track)++;
      } else if (typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) {
        s_branchState.nHgtdHits(track)++;
      }
    }
  }

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

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.

{0ul};

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.

{0ul};

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.

{this, "absEtaMax", std::numeric_limits<double>::max(), "TrackSelector: absEtaMax"};

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.

{this, "absEtaMaxMeasurements", {}, "if specified for the given seed collection, applies absEtaMax cut in branch stopper once absEtaMaxMeasurements have been encountered"};

m_absEtaMin

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

protectedinherited

Definition at line 122 of file TrackFindingBaseAlg.h.

{this, "absEtaMin", 0.0, "TrackSelector: absEtaMin"};

m_addCounts

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

protectedinherited

Definition at line 137 of file TrackFindingBaseAlg.h.

{this, "addCounts", true, "keep separate pixel, strip and hgtd counts and apply the following cuts"};

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.

{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"};

m_ATLASConverterTool

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

protectedinherited

Definition at line 91 of file TrackFindingBaseAlg.h.

{this, "ATLASConverterTool", ""};

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

{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"};

m_beamSpotKey

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

private

Definition at line 112 of file TrackFindingAlg.h.

{this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"};

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.

{this, "branchStopperAbsEtaMaxExtra", 0.0, "increase absEtaMax cut when used in the branch stopper"};

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.

{this, "branchStopperAbsEtaMeasCut", 1.2, "the minimum |eta| to apply the reduction to the minMeas requirement for the branch stopper"};

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.

{this, "branchStopperMeasCutReduce", 2, "how much to reduce the minMeas requirement for the branch stopper"};

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.

{this, "branchStopperPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the branch stopper"};

m_checkCounts

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

protectedinherited

Definition at line 138 of file TrackFindingBaseAlg.h.

{this, "checkCounts", false, "check consistency among track state counts"};

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.

{this, "chi2CutOff", {}, "MeasurementSelector: maximum local chi2 contribution"};

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.

{this, "chi2OutlierCutOff", {}, "MeasurementSelector: maximum local chi2 contribution for outlier"};

m_countSharedHits

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

private

Definition at line 120 of file TrackFindingAlg.h.

{this, "countSharedHits", true, "add shared hit flags to tracks"};

m_d0Max

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

protectedinherited

Definition at line 127 of file TrackFindingBaseAlg.h.

{this, "d0Max", {}, "TrackSelector: d0Max"};

m_d0Min

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

protectedinherited

Definition at line 126 of file TrackFindingBaseAlg.h.

{this, "d0Min", {}, "TrackSelector: d0Min"};

m_detEleCollKeys

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

private

Definition at line 100 of file TrackFindingAlg.h.

{this, "DetectorElementsKeys", {}, "Keys of input SiDetectorElementCollection"};

m_detElStatus

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

private

Definition at line 107 of file TrackFindingAlg.h.

{this, "DetElStatus", {}, "Keys for detector element status conditions data."};

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.

{this, "doBranchStopper", true, "use branch stopper"};

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.

{this, "doTwoWay", true, "run CKF twice, first with forward propagation with smoothing, then with backward propagation"};

m_dumpAllStatEtaBins

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

protectedinherited

Definition at line 154 of file TrackFindingBaseAlg.h.

{this, "DumpEtaBinsForAll", false, "Dump eta bins of all statistics counter."};

m_endOfWorldVolumeIds

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

protectedinherited

Definition at line 149 of file TrackFindingBaseAlg.h.

{this, "EndOfTheWorldVolumeIds", {}, ""};

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.

{this, "etaBins", {}, "bins in |eta| to specify variable selections"};

m_etaMax

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

protectedinherited

Definition at line 121 of file TrackFindingBaseAlg.h.

{this, "etaMax", {}, "TrackSelector: etaMax"};

m_etaMin

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

protectedinherited

Definition at line 120 of file TrackFindingBaseAlg.h.

{this, "etaMin", {}, "TrackSelector: etaMin"};

m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_extrapolationTool

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

protectedinherited

Definition at line 88 of file TrackFindingBaseAlg.h.

{this, "ExtrapolationTool", ""};

m_fitterTool

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

protectedinherited

Definition at line 92 of file TrackFindingBaseAlg.h.

{this, "FitterTool", "", "Fitter Tool for Seeds"};

m_forceTrackOnSeed

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

private

Definition at line 121 of file TrackFindingAlg.h.

{this, "forceTrackOnSeed", true, "force track to use measurements from the seed"};

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.

{this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"};

m_logger

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

protectedinherited

logging instance

Definition at line 325 of file TrackFindingBaseAlg.h.

m_maxChi2

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

protectedinherited

Definition at line 135 of file TrackFindingBaseAlg.h.

{this, "maxChi2", {}, "TrackSelector: maxChi2"};

m_maxHgtdHoles

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

protectedinherited

Definition at line 144 of file TrackFindingBaseAlg.h.

{this, "maxHgtdHoles", {}, "maximum number of hgtd holes"};

m_maxHgtdOutliers

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

protectedinherited

Definition at line 147 of file TrackFindingBaseAlg.h.

{this, "maxHgtdOutliers", {}, "maximum number of hgtd outliers"};

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.

{this, "maxHoles", {}, "TrackSelector: maxHoles"};

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.

{this, "MaximumIterations", 10000u, "Maximum number of iterations to resolve ambiguities among all tracks."};

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.

{this, "MaximumSharedHits", 3u, "Maximum number of shared hits per track."};

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.

{this, "maxOutliers", {}, "TrackSelector: maxOutliers"};

m_maxPixelHoles

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

protectedinherited

Definition at line 142 of file TrackFindingBaseAlg.h.

{this, "maxPixelHoles", {}, "maximum number of pixel holes"};

m_maxPixelOutliers

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

protectedinherited

Definition at line 145 of file TrackFindingBaseAlg.h.

{this, "maxPixelOutliers", {}, "maximum number of pixel outliers"};

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.

{this, "maxPropagationStep", 1000, "Maximum number of steps for one propagate call"};

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.

{this, "maxSharedHits", {}, "TrackSelector: maxSharedHits"};

m_maxStripHoles

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

protectedinherited

Definition at line 143 of file TrackFindingBaseAlg.h.

{this, "maxStripHoles", {}, "maximum number of strip holes"};

m_maxStripOutliers

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

protectedinherited

Definition at line 146 of file TrackFindingBaseAlg.h.

{this, "maxStripOutliers", {}, "maximum number of strip outliers"};

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.

{this, "MemorySafetyMargin", 1.2};

m_minHgtdHits

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

protectedinherited

Definition at line 141 of file TrackFindingBaseAlg.h.

{this, "minHgtdHits", {}, "minimum number of hgtd hits"};

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.

{this, "minMeasurements", {}, "TrackSelector: minMeasurements"};

m_minPixelHits

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

protectedinherited

Definition at line 139 of file TrackFindingBaseAlg.h.

{this, "minPixelHits", {}, "minimum number of pixel hits"};

m_minStripHits

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

protectedinherited

Definition at line 140 of file TrackFindingBaseAlg.h.

{this, "minStripHits", {}, "minimum number of strip hits"};

m_monTool

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

protectedinherited

Definition at line 87 of file TrackFindingBaseAlg.h.

{this, "MonTool", "", "Monitoring tool"};

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.

{this, "NMeasurementsMin", 7u, "Minimum number of measurements per track."};

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.

{this, "numMeasurementsCutOff", {}, "MeasurementSelector: maximum number of associated measurements on a single surface"};

m_paramEstimationTool

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

private

Definition at line 95 of file TrackFindingAlg.h.

{this, "TrackParamsEstimationTool", "", "Track Param Estimation from Seeds"};

m_phiMax

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

protectedinherited

Definition at line 119 of file TrackFindingBaseAlg.h.

{this, "phiMax", {}, "TrackSelector: phiMax"};

m_phiMin

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

protectedinherited

Definition at line 118 of file TrackFindingBaseAlg.h.

{this, "phiMin", {}, "TrackSelector: phiMin"};

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.

{this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"};

m_ptMax

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

protectedinherited

Definition at line 125 of file TrackFindingBaseAlg.h.

{this, "ptMax", {}, "TrackSelector: ptMax"};

m_ptMin

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

protectedinherited

Definition at line 124 of file TrackFindingBaseAlg.h.

{this, "ptMin", {}, "TrackSelector: ptMin"};

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.

{this, "ptMinMeasurements", {}, "if specified for the given seed collection, applies ptMin cut in branch stopper once ptMinMinMeasurements have been encountered"};

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

{this, "refitSeeds", {}, "Run KalmanFitter on seeds before passing to CKF, specified separately for each seed collection"};

m_seedContainerKeys

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

private

Definition at line 99 of file TrackFindingAlg.h.

{this, "SeedContainerKeys", {}, "Seed containers"};

m_seedDestiny

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

private

Definition at line 111 of file TrackFindingAlg.h.

{this, "SeedDestiny", {}};

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

{this, "SeedLabels", {}, "One label per seed key used in outputs"};

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

{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"};

m_skipDuplicateSeeds

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

private

Definition at line 115 of file TrackFindingAlg.h.

{this, "skipDuplicateSeeds", true, "skip duplicate seeds before calling CKF"};

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

{this, "StatisticEtaBins", {-4, -2.6, -2, 0, 2., 2.6, 4}, "Gather statistics separately for these bins."};

m_storeDestinies

bool ActsTrk::TrackFindingAlg::m_storeDestinies {false}

private

Definition at line 110 of file TrackFindingAlg.h.

{false};

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.

{this, "StripCalibrator", "", "Opt. strip measurement calibrator"};

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.

{this, "ACTSTracksLocation", "", "Output track collection (ActsTrk variant)"};

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.

{this, "TrackingGeometryTool", ""};

m_tracksBackendHandlesHelper

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

protectedinherited

Definition at line 98 of file TrackFindingBaseAlg.h.

{this};

m_trackStatePrinter

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

protectedinherited

Definition at line 90 of file TrackFindingBaseAlg.h.

{this, "TrackStatePrinter", "", "optional track state printer"};

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

{this, "UncalibratedMeasurementContainerKeys", {}, "input cluster collections"};

m_useAbsEtaForStat

bool ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat = false

protectedinherited

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

{this, "useTopSpRZboundary", {350. * Acts::UnitConstants::mm, 1060. * Acts::UnitConstants::mm}, "R/Z boundary for using the top space point in the track parameter estimation"};

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

      {this, "ActsVolumeIdToDetectorElementCollectionMapKey", "ActsVolumeIdToDetectorElementCollectionMap",
       "Map which associates Acts geometry volume IDs to detector element collections."};

m_z0Max

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

protectedinherited

Definition at line 129 of file TrackFindingBaseAlg.h.

{this, "z0Max", {}, "TrackSelector: z0Max"};

m_z0Min

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

protectedinherited

Definition at line 128 of file TrackFindingBaseAlg.h.

{this, "z0Min", {}, "TrackSelector: z0Min"};

s_branchState

BranchState ActsTrk::TrackFindingBaseAlg::s_branchState {}

staticconstexprprotectedinherited

Definition at line 306 of file TrackFindingBaseAlg.h.

{};

---

The documentation for this class was generated from the following files:

• TrackFindingAlg.h
• TrackFindingAlg.cxx