ActsTrk::HGTDTrackExtensionAlg Class Reference

#include <HGTDTrackExtensionAlg.h>

Inheritance diagram for ActsTrk::HGTDTrackExtensionAlg:

Collaboration diagram for ActsTrk::HGTDTrackExtensionAlg:

Classes
struct	TrackExtensionData
	Data structure to hold HGTD track extension results Contains information about hits, timing, and extrapolation for each HGTD layer. More...

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

Public Member Functions
virtual	~HGTDTrackExtensionAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
	TrackFindingBaseAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
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
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
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 , kNSeedRefitFailure ,   kNRejectedRefinedSeeds , kNSelectedTracks , kNStoppedTracksMaxHoles , kMultipleBranches ,   kNoSecond , kNStoppedTracksMinPt , kNStoppedTracksMaxEta , kNTotalSharedHits ,   kNForcedSeedMeasurements , kNResolvedTracks , kNStat }
using	TrackFinderOptions = Acts::CombinatorialKalmanFilterOptions<detail::RecoTrackContainer>
using	EventStats = std::vector<std::array<unsigned int, kNStat>>
using	TrkProxy = detail::RecoTrackContainer::TrackProxy
using	BranchStopperResult = Acts::CombinatorialKalmanFilterBranchStopperResult

Protected Member Functions
CKF_pimpl &	trackFinder ()
const CKF_pimpl &	trackFinder () const
StatusCode	initializeMeasurementSelector ()
std::unique_ptr< ActsTrk::IMeasurementSelector >	setMeasurementSelector (const EventContext &ctx, const detail::TrackFindingMeasurements &measurements, TrackFinderOptions &options) const
	Setup and attach measurement selector to KF options.
TrackFindingDefaultOptions	getDefaultOptions (const EventContext &ctx, 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::variant< std::unique_ptr< Acts::BoundTrackParameters >, TrackFindingBaseAlg::EStat >	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	addCountsAndProperties (detail::RecoTrackContainer &tracksContainer, bool add_counts)
static void	initCounts (const detail::RecoTrackContainer::TrackProxy &track)
static void	updateCounts (const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateTypeMap 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"}
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
ToolHandle< ActsTrk::TrackStatePrinterTool >	m_trackStatePrinter {this, "TrackStatePrinter", "", "optional track state printer"}
ToolHandle< ActsTrk::IFitterTool >	m_fitterTool {this, "FitterTool", "", "Fitter Tool for Seeds"}
ToolHandle< ActsTrk::IPixelOnTrackCalibratorTool< detail::RecoTrackStateContainer > >	m_pixelCalibTool {this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"}
ToolHandle< ActsTrk::IStripOnTrackCalibratorTool< detail::RecoTrackStateContainer > >	m_stripCalibTool {this, "StripCalibrator", "", "Opt. strip measurement calibrator"}
ToolHandle< ActsTrk::IHGTDOnTrackCalibratorTool< 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}
ContextUtility	m_ctxProvider {this}
	Utility to fetch the geometry, magnetic field and calibration context in the event.
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< double >	m_edgeHoleBorderWidth {this,"EdgeHoleBorderWidth", 0. ,"Width of the border of surfaces (mm) within which holes are not counted as holes."}
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< bool >	m_inflateCovarianceTwoWay {this, "inflateCovarianceTwoWay", false, "inflate covariance matrix at the beginning of two-way track finding"}
Gaudi::Property< double >	m_twoWayinflateCovarianceFactor {this, "twoWayinflateCovarianceFactor", 1.0, "factor to multiply the initial covariance matrix at the beginning of two-way track finding"}
Gaudi::Property< double >	m_branchStopperPtMinFactor {this, "branchStopperPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the branch stopper"}
Gaudi::Property< double >	m_seedRefitPtMinFactor {this, "seedRefitPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the seed refit"}
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
bool	m_showResolvedStats = false

Static Protected Attributes
static constexpr BranchState	s_branchState {}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	findExtension (const EventContext &ctx, const DetectorContextHolder &detContext, const detail::TrackFindingMeasurements &measurements, const detail::MeasurementIndex &measurementIndex, const Acts::BoundTrackParameters lastMeasurementStateParameters, detail::RecoTrackContainer &tracksContainerTemp, detail::RecoTrackContainer &actsTracksContainer, EventStats &event_stat, const Acts::Surface &refSurface, int &extension_index) const
	invoke track finding procedure to extend ITk tracks to HGTD layers using CKF.
bool	addTrack (const DetectorContextHolder &detContext, detail::RecoTrackContainerProxy &track, const Acts::Surface &refSurface, const Acts::TrackExtrapolationStrategy &extrapolationStrategy, detail::RecoTrackContainer &actsTracksContainer, const detail::MeasurementIndex &measurementIndex, const detail::RecoTrackContainer &tracksContainerTemp) const
	add extension to track container if it passes the track selector criteria
Acts::Result< void >	extrapolateTrackToReferenceSurface (const DetectorContextHolder &detContext, detail::RecoTrackContainerProxy &track, const Acts::Surface &referenceSurface, const detail::Extrapolator &propagator, Acts::TrackExtrapolationStrategy strategy, ExpectedLayerPattern &expectedLayerPattern) const
	it can happen that the last hit of an extension doesn't have a surface associated with it, this function then extrapolates the track to the next valid surface
StatusCode	collectMeasurements (const EventContext &context, detail::TrackFindingMeasurements &measurements) const
	Create and fills the TrackExtensionData with HGTD hits at the extension.
TrackExtensionData	processTrackExtension (const EventContext &ctx, const xAOD::TrackParticle *trackParticle, const detail::RecoTrackContainer::TrackProxy &trackProxy, const xAOD::HGTDClusterContainer *hgtdClusters) const
	Create and fills the TrackExtensionData with HGTD hits at the extension.
std::pair< float, float >	correctTOF (const xAOD::TrackParticle *trackParticle, const xAOD::HGTDCluster *cluster, float measuredTime, float measuredTimeErr, const Acts::TrackingGeometry *trackingGeometry, const Acts::GeometryContext &geoContext) const
	subtracts the time of flight (TOF) from a measured hit time.
const xAOD::HGTDCluster *	getHGTDClusterFromState (const EventContext &ctx, const ActsTrk::detail::RecoConstTrackStateContainerProxy &state, const xAOD::HGTDClusterContainer *hgtdClusters) const
	Get xAOD::HGTDCluster from track state, so it is possible to retrieve its raw time and position for extension decoration.
std::size_t	getHGTDLayerIndex (const Acts::GeometryIdentifier &geoID) const
	returns the index of HGTD layer where surfaces lies.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trackParticleContainerName {this, "TrackParticleContainerName", "InDetTrackParticles", "Name of the TrackParticle container"}
SG::ReadHandleKey< xAOD::HGTDClusterContainer >	m_HGTDClusterContainerName {this, "HGTDClusterContainerName", "HGTD_Clusters", "Name of the HGTD_Cluster container"}
SG::ReadHandleKeyArray< xAOD::UncalibratedMeasurementContainer >	m_uncalibratedMeasurementContainerKeys {this, "UncalibratedMeasurementContainerKeys", {}, "input cluster collections"}
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer >	m_actsTrackLinkKey {this, "ActsTrackLink", m_trackParticleContainerName, "actsTrack", "Link to Acts track"}
Gaudi::Property< float >	m_minEtaAcceptance {this, "MinEtaAcceptance", 2.38, "Minimum eta to consider a track for extension"}
Gaudi::Property< float >	m_maxEtaAcceptance {this, "MaxEtaAcceptance", 4.00, "Maximum eta to consider a track for extension"}
ActsTrk::detail::xAODUncalibMeasSurfAcc	m_surfAcc {}
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_numHGTDHitsKey {this, "numHGTDHits", m_trackParticleContainerName, "numHGTDHits", "Number of HGTD hits on the track extension"}
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_layerHasExtensionKey { this, "HGTD_has_extension", m_trackParticleContainerName, "HGTD_has_extension", "Decoration for layer extension" }
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_layerExtensionChi2Key { this, "HGTD_extension_chi2", m_trackParticleContainerName, "HGTD_extension_chi2", "Decoration for chi2 of extension" }
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_layerClusterRawTimeKey { this, "HGTD_cluster_raw_time", m_trackParticleContainerName, "HGTD_cluster_raw_time", "Decoration for raw time of cluster" }
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_layerClusterTimeKey { this, "HGTD_cluster_time", m_trackParticleContainerName, "HGTD_cluster_time", "Decoration for cluster time" }
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_extrapXKey { this, "HGTD_extrap_x", m_trackParticleContainerName, "HGTD_extrap_x", "Decoration for extrapolated X coordinate" }
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_extrapYKey { this, "HGTD_extrap_y", m_trackParticleContainerName, "HGTD_extrap_y", "Decoration for extrapolated Y coordinate" }
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_hgtdTrackLinkKey {this, "hgtdTrackLink", m_trackParticleContainerName, "hgtdTrackLink", "Link to Hgtd track"}
Gaudi::Property< float >	m_memorySafetyMargin {this, "MemorySafetyMargin", 1.2}
std::atomic< std::size_t > m_nTrackReserve	ATLAS_THREAD_SAFE {0ul}
std::atomic< std::size_t > m_nTrackStateReserve	ATLAS_THREAD_SAFE {0ul}
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 67 of file HGTDTrackExtensionAlg.h.

Member Typedef Documentation

BranchStopperResult

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

protectedinherited

Definition at line 281 of file TrackFindingBaseAlg.h.

EventStats

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

protectedinherited

Definition at line 183 of file TrackFindingBaseAlg.h.

ExpectedLayerPattern

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

Definition at line 75 of file HGTDTrackExtensionAlg.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 = detail::RecoTrackContainer::TrackProxy

protectedinherited

Definition at line 256 of file TrackFindingBaseAlg.h.

Member Enumeration Documentation

EStat

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

protectedinherited

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

Definition at line 160 of file TrackFindingBaseAlg.h.

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

Constructor & Destructor Documentation

~HGTDTrackExtensionAlg()

virtual ActsTrk::HGTDTrackExtensionAlg::~HGTDTrackExtensionAlg ( )

virtualdefault

Member Function Documentation

addCountsAndProperties()

void ActsTrk::TrackFindingBaseAlg::addCountsAndProperties ( detail::RecoTrackContainer & tracksContainer, bool add_counts )

staticprotectedinherited

Definition at line 411 of file TrackFindingBaseAlg.cxx.

  {
    if (addCounts) {
       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");
    }
    ActsTrk::TrackContainerUtils::addFitterTypeProperty(tracksContainer);
  }

addTrack()

bool ActsTrk::HGTDTrackExtensionAlg::addTrack ( const DetectorContextHolder & detContext, detail::RecoTrackContainerProxy & track, const Acts::Surface & refSurface, const Acts::TrackExtrapolationStrategy & extrapolationStrategy, detail::RecoTrackContainer & actsTracksContainer, const detail::MeasurementIndex & measurementIndex, const detail::RecoTrackContainer & tracksContainerTemp ) const

private

add extension to track container if it passes the track selector criteria

Parameters

detContext	- detector context
track	- track to be added
refSurface	- reference surface from ITk track, used by extrapolator
extrapolationStrategy	- extrapolation direction
actsTracksContainer	- output extensions container (after selection and aggregated of all event)
measurementIndex	- helper with measurement indices
tracksContainerTemp	- extensions found by CKF (before track selection)

Returns

true if track was accepted and added to container, false otherwise

Definition at line 840 of file HGTDTrackExtensionAlg.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,
                                      refSurface,
                                      trackFinder().extrapolator,
                                      extrapolationStrategy,
                                      expectedLayerPattern);
    if (not extrapolationResult.ok()) {
      ATH_MSG_WARNING("Extrapolation for "
                      << track.index()
                      << " failed with error " << extrapolationResult.error()
                      << " dropping track candidate.");
      return false;
    }
  }
 
  // Before trimming, inspect encountered surfaces from all track states
  for(const auto ts : track.trackStatesReversed()) {
    const auto* detElem = getActsDetectorElement(ts.referenceSurface());
    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);
    }
  }
 
  if ( not trackFinder().trackSelector.isValidTrack(track)) {
    ATH_MSG_WARNING("Track " << track.index() << " failed track selection");
    if ( m_trackStatePrinter.isSet() ) {
      m_trackStatePrinter->printTrack(detContext.geometry, tracksContainerTemp, track, measurementIndex, true);
    }
    return false;
  }
 
  auto actsDestProxy   = actsTracksContainer.makeTrack();
  actsDestProxy.copyFrom(track);  // make sure we copy track states!
  detail::ExpectedLayerPatternHelper::set(actsDestProxy, expectedLayerPattern);
 
  ATH_MSG_DEBUG("Added Track " << track.index() << " into container");
  return true;                                                                               
}

checkCounts()

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

protectedinherited

Definition at line 470 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)
                      << ")");
  };

collectMeasurements()

StatusCode ActsTrk::HGTDTrackExtensionAlg::collectMeasurements ( const EventContext & context, detail::TrackFindingMeasurements & measurements ) const

private

Create and fills the TrackExtensionData with HGTD hits at the extension.

The TrackExtensionData object will later be used to fill the TrackParticle decorations

Parameters

trackParticle	- trackParticle associated with this hit
measurements	- measurements to be used at the extension finding

computeStatSum()

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

protectedinherited

Definition at line 780 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 566 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];
      }
    }
  }

correctTOF()

std::pair< float, float > ActsTrk::HGTDTrackExtensionAlg::correctTOF ( const xAOD::TrackParticle * trackParticle, const xAOD::HGTDCluster * cluster, float measuredTime, float measuredTimeErr, const Acts::TrackingGeometry * trackingGeometry, const Acts::GeometryContext & geoContext ) const

private

subtracts the time of flight (TOF) from a measured hit time.

It uses an estimate of track particle vertex to calculate the lenght of the track up to this hit. The corrected measurement will be the one to be assigned as the time of the track

Parameters

trackParticle	- trackParticle associated with this hit
cluster	- HGTD cluster of the hit, used to access its surface and position
measuredTime	- time measured (ns)
measuredTimeErr	- resolution of time measured (ns)
trackingGeometry	- detector geometry
geoContext	- geometry context

Definition at line 672 of file HGTDTrackExtensionAlg.cxx.

                                               {
 
  ATH_MSG_DEBUG("Correcting input time: " << measuredTime);
 
  if (!trackParticle || !cluster) {
    ATH_MSG_WARNING("Null pointer provided to correctTOF");
    return {measuredTime, measuredTimeErr}; // Return uncorrected values
  }
 
  // Get the surface for this HGTD cluster
  const Acts::Surface* surface = nullptr;
  try {
    surface = m_surfAcc.get(cluster);
  } catch (const std::exception& e) {
    ATH_MSG_WARNING("Exception getting surface: " << e.what());
    return {measuredTime, measuredTimeErr}; // Return uncorrected values
  }
  
  if (!surface) {
    ATH_MSG_WARNING("Could not determine surface for HGTD cluster with id " 
                    << cluster->identifier());
    return {measuredTime, measuredTimeErr}; // Return uncorrected values
  }
 
  // Get the global position of the hit
  Acts::Vector3 globalHitPos;
  try {
    // Try to get the cluster's local position
    auto localPos = cluster->localPosition<3>();
    // Transform to global coordinates
    globalHitPos = surface->localToGlobal(
        geoContext,
        Acts::Vector2(localPos[0], localPos[1]),
        Acts::Vector3::Zero());
  } catch (const std::exception& e) {
    ATH_MSG_WARNING("Failed to transform position: " << e.what());
    // Fall back to surface center
    globalHitPos = surface->center(geoContext);
  }
  
  // Get track origin (vertex position)
  //option 1 - use beamspot
  //Amg::Vector3D trackOrigin(trackParticle->vx(), trackParticle->vy(), trackParticle->vz());
  
  //option 2 - use perigee - this is what is done in legacy code: 
  // https://gitlab.cern.ch/atlas/athena/-/blob/main/HighGranularityTimingDetector/HGTD_Reconstruction/HGTD_RecTools/src/StraightLineTOFcorrectionTool.cxx
  // Get track origin from perigee parameters instead of vertex
  // In ACTS, this is the d0 and z0 parameter with reference to the beamline
  
  // Get the perigee position (the point of closest approach to the beamline)
  double d0 = trackParticle->d0();
  double z0 = trackParticle->z0();
  double phi0 = trackParticle->phi0();
  
  Amg::Vector3D trackOrigin(-d0 * std::sin(phi0), d0 * std::cos(phi0), z0);
  ATH_MSG_DEBUG("Track perigee: d0=" << d0 << ", z0=" << z0 << ", phi0=" << phi0);
  ATH_MSG_DEBUG("Track origin (perigee): (" << trackOrigin.x() << ", " 
                << trackOrigin.y() << ", " << trackOrigin.z() << ")");
  
  // Calculate distance components
  float dx = globalHitPos.x() - trackOrigin.x();
  float dy = globalHitPos.y() - trackOrigin.y();
  float dz = globalHitPos.z() - trackOrigin.z();
  
  // Calculate distance and time of flight
  float distance = std::sqrt(dx*dx + dy*dy + dz*dz);
  float tof = distance / Gaudi::Units::c_light;
  
  // Apply TOF correction
  float correctedTime = measuredTime - tof;
  
  ATH_MSG_DEBUG("Track origin: (" << trackOrigin.x() << ", " 
                << trackOrigin.y() << ", " << trackOrigin.z() << ")");
  ATH_MSG_DEBUG("Hit position: (" << globalHitPos.x() << ", " 
                << globalHitPos.y() << ", " << globalHitPos.z() << ")");
  ATH_MSG_DEBUG("Distance = " << distance << " mm, TOF = " << tof 
                << " ns, Corrected time = " << correctedTime);
  
  return {correctedTime, measuredTimeErr};
}

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::variant< std::unique_ptr< Acts::BoundTrackParameters >, TrackFindingBaseAlg::EStat > 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 243 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 {};
    }
 
    // First, inflate the covariance matrix if configured
    if (m_inflateCovarianceTwoWay) {
      ATH_MSG_DEBUG("Inflating covariance matrix for second track finding with factor = " << m_twoWayinflateCovarianceFactor.value());
      ATH_MSG_VERBOSE("Original parameters before inflation: \n" << secondInitialParameters);
 
      auto inflatedCovariance = secondInitialParameters.covariance().value();
      inflatedCovariance *= m_twoWayinflateCovarianceFactor;
 
      const auto& origSurface = secondInitialParameters.referenceSurface();
      auto surfacePtr = const_cast<Acts::Surface&>(origSurface).shared_from_this();
 
      Acts::BoundTrackParameters newParams(
          std::static_pointer_cast<const Acts::Surface>(std::move(surfacePtr)),
          secondInitialParameters.parameters(), 
          std::make_optional(inflatedCovariance),
          secondInitialParameters.particleHypothesis());
      secondInitialParameters = std::move(newParams);
      
      ATH_MSG_VERBOSE("Inflated covariance matrix : \n" << secondInitialParameters.covariance().value());
    }
 
    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::HGTDTrackExtensionAlg::execute ( const EventContext & ctx ) const

overridevirtual

Reimplemented from ActsTrk::TrackFindingBaseAlg.

Definition at line 125 of file HGTDTrackExtensionAlg.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);
 
  // ================================================== //
  // ========= RETRIEVE TRACK PARTICLES =============== //
  // ================================================== //
 
  const xAOD::TrackParticleContainer* trackParticles{nullptr};
  ATH_CHECK(SG::get(trackParticles, m_trackParticleContainerName, ctx));
 
  ATH_MSG_DEBUG("Size of trackParticles collection " << trackParticles->size());
  
  // Create WriteDecorHandles for all decorations
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<char>> layerHasExtensionHandle(m_layerHasExtensionKey, ctx);
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> layerExtensionChi2Handle(m_layerExtensionChi2Key, ctx);
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> layerClusterRawTimeHandle(m_layerClusterRawTimeKey, ctx);
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> layerClusterTimeHandle(m_layerClusterTimeKey, ctx);
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, float> extrapXHandle(m_extrapXKey, ctx);
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, float> extrapYHandle(m_extrapYKey, ctx);
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, int> numHGTDHitsHandle(m_numHGTDHitsKey, ctx);
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, ElementLink<ActsTrk::TrackContainer>> hgtdTrackLink(m_hgtdTrackLinkKey, ctx);
  
  // ================================================== //
  // ============ RETRIEVE MEASUREMENTS =============== //
  // ================================================== //
  const xAOD::HGTDClusterContainer* hgtdClusters{nullptr};
  ATH_CHECK(SG::get(hgtdClusters, m_HGTDClusterContainerName, ctx));
 
 
  std::vector<const xAOD::UncalibratedMeasurementContainer *> uncalibratedMeasurementContainers;
  std::size_t total_measurements = 0;
  ATH_CHECK(getContainersFromKeys(ctx, m_uncalibratedMeasurementContainerKeys, uncalibratedMeasurementContainers, total_measurements));
 
 
  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_trackingGeometrySvc->surfaceIdMap(),
                                  &measurementIndex);
  }
 
  ATH_MSG_DEBUG("measurement index size = " << measurementIndex.size());
 
 
  if (m_trackStatePrinter.isSet()) {
    m_trackStatePrinter->printMeasurements(ctx, uncalibratedMeasurementContainers, measurements.measurementOffsets());
  }
 
  // ================================================== //
  // ===================== COMPUTATION ================ //
  // ================================================== //
 
  EventStats event_stat;
  event_stat.resize(m_stat.size());
 
  DetectorContextHolder detContext {
    .geometry = m_ctxProvider.getGeometryContext(ctx),
    .magField = m_ctxProvider.getMagneticFieldContext(ctx),
    // CalibrationContext converter not implemented yet.
    .calib = m_ctxProvider.getCalibrationContext(ctx)
  };
  
  Acts::VectorTrackContainer actsTrackBackend;
  Acts::VectorMultiTrajectory actsTrackStateBackend;
 
  auto atomicMax=[](std::size_t new_val, std::atomic<std::size_t> &dest) -> void {
    std::size_t is_value;
    do {
       is_value = dest;
       if (is_value>=new_val) return;
    } while (!dest.compare_exchange_weak(is_value, new_val));
  };
  atomicMax(actsTrackBackend.size(), m_nTrackReserve); 
  atomicMax(actsTrackStateBackend.size(), m_nTrackStateReserve);
 
  detail::RecoTrackContainer actsTracksContainer(actsTrackBackend,
                                                  actsTrackStateBackend);
 
  
  addCountsAndProperties(actsTracksContainer, m_addCounts.value());
 
  detail::ExpectedLayerPatternHelper::add(actsTracksContainer);
 
  int extension_index{0};
  // Loop over each track particle and decorate it with various information
  std::unordered_map<uint32_t, uint32_t> extensions;
  for (const xAOD::TrackParticle* trackParticle : *trackParticles) {
    // Default to empty track data
    TrackExtensionData trackData;
 
    std::optional<ActsTrk::TrackContainer::ConstTrackProxy> optional_track = getActsTrack(*trackParticle);
    if (!optional_track.has_value()) {
      ATH_MSG_ERROR("No valid ACTS track associated with TrackParticle " << trackParticle->index());
      return StatusCode::FAILURE;
    }
 
    const ActsTrk::TrackContainer::ConstTrackProxy& track = optional_track.value();
 
    // Retrieve quantities for ACTS track
    float trackEta = Acts::VectorHelpers::eta(track.momentum());
 
    // Check eta coverage first
    if (std::abs(trackEta) < m_minEtaAcceptance or std::abs(trackEta) > m_maxEtaAcceptance) {
      ATH_MSG_DEBUG("!!!!! ------  Track eta " << trackEta
            << " outside eta range [" << m_minEtaAcceptance.value() << ", " << m_maxEtaAcceptance.value()
            << "], skipping extension  ------ !!!!!");
 
      // set default values
      trackData.hasClusterVec = {false, false, false, false};
      trackData.numHGTDHits = 0;
      layerHasExtensionHandle(*trackParticle) = trackData.hasClusterVec;
      layerExtensionChi2Handle(*trackParticle) = trackData.chi2Vec;
      layerClusterRawTimeHandle(*trackParticle) = trackData.rawTimeVec;
      layerClusterTimeHandle(*trackParticle) = trackData.timeVec;
      extrapXHandle(*trackParticle) = trackData.extrapX;
      extrapYHandle(*trackParticle) = trackData.extrapY;
      numHGTDHitsHandle(*trackParticle) = trackData.numHGTDHits;
 
      continue;
    }
 
    float trackpT = track.transverseMomentum();
    float trackPhi = track.phi();
    float trackNmeasurements = track.nMeasurements();
    
    ATH_MSG_DEBUG("TrackParticle " << trackParticle->index() << 
                  " has ACTS track with eta: " << trackEta << 
                  ", phi: " << trackPhi << 
                  ", pT: " << trackpT << 
                  " and nMeasurements: " << trackNmeasurements);
 
    // Parameters at last measurement state
    const auto lastMeasurementState = Acts::findLastMeasurementState(track);
    if (not lastMeasurementState.ok()) {
      ATH_MSG_ERROR("Problem finding last measurement state for acts track");
      return StatusCode::FAILURE;
    }
    const Acts::BoundTrackParameters lastMeasurementStateParameters = track.createParametersFromState(*lastMeasurementState);
    
    // Parameters at reference state of track - not necessarily a measurement state!!!                        
    const Acts::Surface& refSurface = track.referenceSurface();
    const Acts::BoundTrackParameters parametersAtRefSurface(refSurface.getSharedPtr(), 
                                track.parameters(), 
                                track.covariance(),
                                track.particleHypothesis());
 
    ATH_MSG_DEBUG("Initial track parameters for extension - lastMeasurementStateParameters:");
    ATH_MSG_DEBUG(" - eta: " << -1 * log(tan(lastMeasurementStateParameters.theta() * 0.5)));
    ATH_MSG_DEBUG(" - phi: " << lastMeasurementStateParameters.phi());
    ATH_MSG_DEBUG(" - pT: " << std::abs(1./lastMeasurementStateParameters.qOverP() * std::sin(lastMeasurementStateParameters.theta())));
    ATH_MSG_DEBUG(" - theta: " << lastMeasurementStateParameters.theta());
    ATH_MSG_DEBUG(" - qOverP: " << lastMeasurementStateParameters.qOverP());
    ATH_MSG_DEBUG(" - covariance exists: " << (lastMeasurementStateParameters.covariance().has_value() ? "yes" : "no"));
 
 
    // ActsTrk::MutableTrackContainer tracksContainerTemp;
    Acts::VectorTrackContainer trackBackend;
    Acts::VectorMultiTrajectory trackStateBackend;
    detail::RecoTrackContainer tracksContainerTemp(trackBackend, trackStateBackend);
 
    addCountsAndProperties(tracksContainerTemp, m_addCounts.value());
  
    detail::ExpectedLayerPatternHelper::add(tracksContainerTemp);
 
    // Now use the *last measurement parameters* parameters for the CKF
    if(findExtension(ctx,
                      detContext,
                      measurements,
                      measurementIndex,
                      lastMeasurementStateParameters,
                      tracksContainerTemp,
                      actsTracksContainer,
                      event_stat,
                      refSurface,
                      extension_index))
    {
      const detail::RecoTrackContainer::TrackProxy&  trackProxy = tracksContainerTemp.at(extension_index);
      trackData = processTrackExtension(ctx, trackParticle, trackProxy, hgtdClusters);     
      extensions.insert(std::make_pair(trackParticle->index(), actsTracksContainer.size() - 1));
 
    }
    else{
      trackData.hasClusterVec = {false, false, false, false};
      trackData.numHGTDHits = 0;
    }
      // Apply decorations from the track data
      layerHasExtensionHandle(*trackParticle) = trackData.hasClusterVec;
      layerExtensionChi2Handle(*trackParticle) = trackData.chi2Vec;
      layerClusterRawTimeHandle(*trackParticle) = trackData.rawTimeVec;
      layerClusterTimeHandle(*trackParticle) = trackData.timeVec;
      extrapXHandle(*trackParticle) = trackData.extrapX;
      extrapYHandle(*trackParticle) = trackData.extrapY;
      numHGTDHitsHandle(*trackParticle) = trackData.numHGTDHits;
  } // loop on tracks
 
  // ================================================== //
  // ===================== OUTPUTS ==================== //
  // ================================================== //
 
  ATH_MSG_DEBUG("    \\__ Found " << actsTracksContainer.size() << " extensions");
 
  // 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()) );
  }
 
  // convert to const
  Acts::ConstVectorTrackContainer constTrackBackend( std::move(actsTrackBackend) );
  Acts::ConstVectorMultiTrajectory constTrackStateBackend( std::move(actsTrackStateBackend) );
  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)));
 
  const  ActsTrk::TrackContainer *const_track_container_ptr = trackContainerHandle.cptr();
  
  for ( const std::pair< const uint32_t,uint32_t> &ext : extensions) {
 
    hgtdTrackLink(*trackParticles->at(ext.first))
         = ElementLink<ActsTrk::TrackContainer>( *const_track_container_ptr,
                                                    ext.second );
 
}
 
  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 & AthCommonAlgorithm< 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 89 of file AthCommonAlgorithm.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::HGTDTrackExtensionAlg::extrapolateTrackToReferenceSurface ( const DetectorContextHolder & detContext, detail::RecoTrackContainerProxy & track, const Acts::Surface & referenceSurface, const detail::Extrapolator & propagator, Acts::TrackExtrapolationStrategy strategy, ExpectedLayerPattern & expectedLayerPattern ) const

private

it can happen that the last hit of an extension doesn't have a surface associated with it, this function then extrapolates the track to the next valid surface

Parameters

detContext	- detector context
track	- track to be extrapolated
referenceSurface	- perigee surface (beamspot)
propagator	- propagator to be used for the extrapolation
strategy	- extrapolation strategy (can define if it is outwards or inwards for example)
expectedLayerPattern	- output of expected layer pattern

Definition at line 909 of file HGTDTrackExtensionAlg.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<HGTDTrackExtensionAlg::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, options, true, &referenceSurface);
 
  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 AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

finalize()

StatusCode ActsTrk::TrackFindingBaseAlg::finalize ( )

overridevirtualinherited

Reimplemented in ActsTrk::TrackFindingAlg.

Definition at line 179 of file TrackFindingBaseAlg.cxx.

                                           {
    printStatTables();
 
    return StatusCode::SUCCESS;
  }

findExtension()

bool ActsTrk::HGTDTrackExtensionAlg::findExtension ( const EventContext & ctx, const DetectorContextHolder & detContext, const detail::TrackFindingMeasurements & measurements, const detail::MeasurementIndex & measurementIndex, const Acts::BoundTrackParameters lastMeasurementStateParameters, detail::RecoTrackContainer & tracksContainerTemp, detail::RecoTrackContainer & actsTracksContainer, EventStats & event_stat, const Acts::Surface & refSurface, int & extension_index ) const

private

invoke track finding procedure to extend ITk tracks to HGTD layers using CKF.

Extrapolation start with the last hit of ITk track.

Parameters

ctx	- event context
detContext	- detector context
measurements	- measurements to be used at the extension finding
measurementIndex	- helper with measurement indices
lastMeasurementStateParameters	- State parameters of ITk track last Hit
tracksContainerTemp	- extensions found by CKF (before track selection)
actsTracksContainer	- output extensions container (after selection and aggregated of all event)
event_stat	- stats, just for this event
refSurface	- - reference surface from ITk track, used by extrapolator
extension_index	- index of the found extension at the tracksContainerTemp

Returns

true if a valid extension was found, false otherwise

Definition at line 371 of file HGTDTrackExtensionAlg.cxx.

                             {
 
  //Setting pSurface to nullptr
  auto [options, secondOptions, measurementSelector] = getDefaultOptions(ctx, detContext, measurements, nullptr);
 
 
  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, 0, 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;
 
  // Get the Acts tracks, given the initial parameters from last hit of itk track
  Acts::Result<std::vector<TrkProxy> > result =
    trackFinder().ckf.findTracks(initialParameters, options, tracksContainerTemp);
 
  // Track finding result
  if (not result.ok()) {
    ATH_MSG_WARNING("Track finding failed with error" << result.error());
    return false;
  }
 
  ATH_MSG_DEBUG("Built " << tracksContainerTemp.size() << " extensions from it");
  auto &foundTracks = result.value();
 
  // loop on the tracks we have just found
  int best_track_index = -1;
  float best_track_chi2 = 1000;
  TrkProxy &best_track_proxy = foundTracks.at(0);
 
  for (TrkProxy &firstTrack : foundTracks) {
    if((firstTrack.chi2() > 0) and (firstTrack.chi2() < best_track_chi2)){
      best_track_index = firstTrack.index();
      best_track_chi2  = firstTrack.chi2();
      best_track_proxy = firstTrack;
    }
  }
 
  if(best_track_index == -1) return false;
 
  ATH_MSG_DEBUG("Best extension index " << best_track_proxy.index() <<
                " nMeas " << best_track_proxy.nMeasurements() <<
                " chi2 " << best_track_proxy.chi2());
 
  if(addTrack(detContext,
      best_track_proxy,
      refSurface,
      extrapolationStrategy,
      actsTracksContainer,
      measurementIndex,
      tracksContainerTemp)){
 
      extension_index = best_track_index;
      return true;
    }
  else { 
    ATH_MSG_DEBUG("Track failed selection, not adding it");
    return false; 
  }
  
}

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 234 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 EventContext & ctx, 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 206 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(ctx, 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)};
  };

getHGTDClusterFromState()

const xAOD::HGTDCluster * ActsTrk::HGTDTrackExtensionAlg::getHGTDClusterFromState ( const EventContext & ctx, const ActsTrk::detail::RecoConstTrackStateContainerProxy & state, const xAOD::HGTDClusterContainer * hgtdClusters ) const

private

Get xAOD::HGTDCluster from track state, so it is possible to retrieve its raw time and position for extension decoration.

Parameters

ctx	- event context
state	- track state of HGTD hit

Definition at line 759 of file HGTDTrackExtensionAlg.cxx.

                                                      {
 
  if (state.hasUncalibratedSourceLink()) {
    auto uncalib_cluster = detail::xAODUncalibMeasCalibrator::unpack(state.getUncalibratedSourceLink());
    assert( uncalib_cluster != nullptr);   
    xAOD::UncalibMeasType clusterType = uncalib_cluster->type();
 
    if (clusterType == xAOD::UncalibMeasType::HGTDClusterType) {
      ATH_MSG_DEBUG("Found HGTD cluster in source link");
      auto hgtdCluster = static_cast<const xAOD::HGTDCluster *>(uncalib_cluster);
      return hgtdCluster;
    } 
    else {
      ATH_MSG_DEBUG("Source link contains non-HGTD measurement type: " << static_cast<int>(clusterType));
    }
 
    // If we have a reference surface, try to match by position
    if (state.hasReferenceSurface()) {
      const auto& surface = state.referenceSurface();
      Acts::GeometryIdentifier geoID = surface.geometryId();
 
      const auto *acts_detector_element = getActsDetectorElement(surface);
      
      // Check if this is an HGTD surface
      if (acts_detector_element->detectorType() == DetectorType::Hgtd) {
        ATH_MSG_DEBUG("This is an HGTD surface with ID: " << geoID.volume() << ":" << geoID.layer());
        
        // Modern approach uses surface accessor instead of detector element map
        
        // Get global position of the state surface
        const Acts::GeometryContext& geoContext = m_ctxProvider.getGeometryContext(ctx);
        Acts::Vector3 statePos = surface.center(geoContext);
        
        // Find the closest cluster to this state position
        const xAOD::HGTDCluster* closestCluster = nullptr;
        double minDistance = 100.0; // Use a reasonable threshold (in mm)
        
        for (const xAOD::HGTDCluster* cluster : *hgtdClusters) {
          // Get the cluster's surface
          const Acts::Surface* clusterSurface = m_surfAcc.get(cluster);
              
          if (!clusterSurface) continue;
          
          // Check if it's on the same surface by comparing geometry IDs
          Acts::GeometryIdentifier clusterGeoID = clusterSurface->geometryId();
          if (clusterGeoID.volume() == geoID.volume() && clusterGeoID.layer() == geoID.layer()) {
            // Get cluster position
            Acts::Vector3 clusterPos = clusterSurface->center(geoContext);
            
            // Calculate 2D distance (x,y only, since z is fixed for a layer)
            double dx = clusterPos.x() - statePos.x();
            double dy = clusterPos.y() - statePos.y();
            double distance = std::sqrt(dx*dx + dy*dy);
            
            // Update closest if this is better
            if (distance < minDistance) {
              minDistance = distance;
              closestCluster = cluster;
              ATH_MSG_DEBUG("Found possible cluster match at distance " << distance << " mm");
            }
          }
        }
        
        if (closestCluster) {
          ATH_MSG_DEBUG("Found closest cluster at distance " << minDistance << " mm");
          return closestCluster;
        } else {
          ATH_MSG_DEBUG("No matching cluster found on this surface");
        }
      }
    }
  } 
  else {
    ATH_MSG_DEBUG("State doesn't have uncalibrated source link");
  }
  return nullptr;
}

getHGTDLayerIndex()

std::size_t ActsTrk::HGTDTrackExtensionAlg::getHGTDLayerIndex ( const Acts::GeometryIdentifier & geoID ) const

private

returns the index of HGTD layer where surfaces lies.

This index is used at to locate where in the vectors of TrackExtensionData the hit information should be written Returns 99 if surface is outiside of HGTD.

Parameters

geoID

- surface geometry id

Definition at line 639 of file HGTDTrackExtensionAlg.cxx.

                                                                                            {
  // Get volume and layer ID
  std::uint32_t volume = geoID.volume();
  std::uint32_t layer = geoID.layer();
  
  // Check if we're in the positive or negative endcap 
  bool isPositiveEndcap = (volume == 25); 
  bool isNegativeEndcap = (volume == 2); 
  
  // Different mapping for different sides to maintain consistent physical ordering
  if (isPositiveEndcap) {
    // Mapping for positive endcap
    switch(layer) {
      case 2: return 0;  // First HGTD layer (closest to IP)
      case 4: return 1;  // Second HGTD layer
      case 6: return 2;  // Third HGTD layer
      case 8: return 3;  // Fourth HGTD layer (farthest from IP)
      default: return 99; // Invalid layer
    }
  } else if (isNegativeEndcap) {
    // Mapping for negative endcap - potentially different ordering
    switch(layer) {
      case 2: return 3; 
      case 4: return 2;  
      case 6: return 1;
      case 8: return 0;
      default: return 99; // Invalid layer
    }
  } else {
    return 99; // Not an HGTD volume
  }
}

getStatCategory()

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

protectedinherited

Definition at line 771 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 427 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::HGTDTrackExtensionAlg::initialize ( )

overridevirtual

Reimplemented from ActsTrk::TrackFindingBaseAlg.

Definition at line 93 of file HGTDTrackExtensionAlg.cxx.

{
  ATH_MSG_DEBUG("Initializing " << name() << "...");
 
  ATH_CHECK(TrackFindingBaseAlg::initialize());
  ATH_MSG_DEBUG("     " << m_absEtaMin);
  ATH_MSG_DEBUG("     " << m_absEtaMax);
 
  ATH_CHECK(m_trackParticleContainerName.initialize());
  ATH_CHECK(m_HGTDClusterContainerName.initialize());
  ATH_CHECK(m_actsTrackLinkKey.initialize());
 
  ATH_CHECK(m_uncalibratedMeasurementContainerKeys.initialize());
 
  // Initialize all WriteDecorHandleKeys
  ATH_CHECK(m_layerHasExtensionKey.initialize());
  ATH_CHECK(m_layerExtensionChi2Key.initialize());
  ATH_CHECK(m_layerClusterRawTimeKey.initialize());
  ATH_CHECK(m_layerClusterTimeKey.initialize());
  ATH_CHECK(m_extrapXKey.initialize());
  ATH_CHECK(m_extrapYKey.initialize());
  ATH_CHECK(m_numHGTDHitsKey.initialize());
  ATH_CHECK(m_hgtdTrackLinkKey.initialize());
 
  // Initialize surface accessor
  m_surfAcc = ActsTrk::detail::xAODUncalibMeasSurfAcc{m_trackingGeometrySvc.get()};
 
  return StatusCode::SUCCESS;
}

initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector ( )

protectedinherited

Definition at line 519 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 548 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()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, 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, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

logger()

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

inlineprotectedinherited

Private access to the logger.

Definition at line 328 of file TrackFindingBaseAlg.h.

    {
      return *m_logger;
    }

measurementType()

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

staticprotectedinherited

Definition at line 288 of file TrackFindingBaseAlg.cxx.

                                                                                                                     {
    if (trackState.hasReferenceSurface()) {
      if (const auto *actsDetElem = dynamic_cast<const ISurfacePlacement*>(trackState.referenceSurface().surfacePlacement())) {
        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 341 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.

printStatTables()

void ActsTrk::TrackFindingBaseAlg::printStatTables ( ) const

protectedinherited

Definition at line 581 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(kNSeedRefitFailure, "Seed refit Kalman fit failure"),
                                          std::make_pair(kNOutputTracks, "CKF tracks"),
                                          std::make_pair(kNSelectedTracks, "selected tracks"),
                                          std::make_pair(kNResolvedTracks, "resolved 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("resolved / selected tracks", kNResolvedTracks, kNSelectedTracks),
                                                      TableUtils::defineSimpleRatio("resolved tracks / used seeds", kNResolvedTracks, 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 used seeds (ratio_i==6 or 4) 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.
        std::size_t ratio_i = m_showResolvedStats ? 6 : 4;
        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());
    }
  }

processTrackExtension()

HGTDTrackExtensionAlg::TrackExtensionData ActsTrk::HGTDTrackExtensionAlg::processTrackExtension ( const EventContext & ctx, const xAOD::TrackParticle * trackParticle, const detail::RecoTrackContainer::TrackProxy & trackProxy, const xAOD::HGTDClusterContainer * hgtdClusters ) const

private

Create and fills the TrackExtensionData with HGTD hits at the extension.

The TrackExtensionData object will later be used to fill the TrackParticle decorations

Parameters

trackParticle	- trackParticle associated with this hit
cluster	- HGTD cluster of the hit, used to access its surface and position
measuredTime	- time measured (ns)
measuredTimeErr	- resolution of time measured (ns)
trackingGeometry	- detector geometry
geoContext	- geometry context

Definition at line 452 of file HGTDTrackExtensionAlg.cxx.

                                                      {
 
  TrackExtensionData data;
 
  // Modern approach uses surface accessor instead of detector element map
  
  // Apply track smoothing before trying to access chi2 values
  Acts::GeometryContext geoContext = m_ctxProvider.getGeometryContext(ctx);
  const Acts::TrackingGeometry* acts_tracking_geometry = m_trackingGeometrySvc->trackingGeometry().get();
 
  
  // Count measurements, holes, and HGTD hits specifically
  std::size_t nMeasurements = 0;
  std::size_t nHoles = 0;
  std::size_t nOutliers = 0;
  std::size_t nHGTDHits = 0;
  
  std::vector<char> hasHitInLayer = {false, false, false, false};
  std::vector<float> chi2PerLayer = {-1.0, -1.0, -1.0, -1.0};
  std::vector<float> timePerLayer = {-1.0, -1.0, -1.0, -1.0};
  std::vector<float> rawTimePerLayer = {-1.0, -1.0, -1.0, -1.0};
 
  // Extrapolated position - get the position at the first HGTD surface encountered
  float extrapX = 0.0;
  float extrapY = 0.0;
  float extrapZ = 0.0;
  bool foundExtrapolation = false;
 
  for (auto state : trackProxy.trackStatesReversed()) {
    auto flags = state.typeFlags();
    if (flags.isHole()) {
        nHoles++;
    } else if (flags.isOutlier()) {
        nOutliers++;
    } else if (flags.isMeasurement()) {
        nMeasurements++;
        
        // Check if this is an HGTD hit                
        const auto& surface = state.referenceSurface();
        Acts::GeometryIdentifier geoID = surface.geometryId();
        std::size_t layerIndex = getHGTDLayerIndex(geoID);
 
        // Check if measurement is at a valid HGTD layer
        if (layerIndex != 99) {
 
          const auto& calibrated = state.template calibrated<3>(); //x,y,time
          const auto& predicted = state.predicted(); //6D
          const auto& calibCov = state.template calibratedCovariance<3>(); // Full 3D covariance
 
          Eigen::Vector2d residual2d;
          residual2d(0) = calibrated(0) - predicted(Acts::eBoundLoc0);
          residual2d(1) = calibrated(1) - predicted(Acts::eBoundLoc1);
 
          // Extract the top-left 2x2 from the 3x3 measurement covariance
          AmgSymMatrix(2) cov_2d{calibCov.template block<2,2>(0,0)};
 
          // Get the predicted covariance for residual calculation
          const auto& predictedCov = state.predictedCovariance();
          AmgSymMatrix(2) predicted_cov_2d{predictedCov.template block<2,2>(0,0)};
          
          // Total residual covariance is measurement + predicted covariances
          AmgSymMatrix(2) residual_cov = cov_2d + predicted_cov_2d;
                                    
          double chi2=0.0;
          double ndf = 2.0;
          if (residual_cov.determinant() != 0) {
            chi2 = residual2d.transpose() * residual_cov.inverse() * residual2d;
          }
          else{
            chi2=-99.9;
          }
 
          if (layerIndex < 4) { 
            nHGTDHits++;
            hasHitInLayer[layerIndex] = true;
            chi2PerLayer[layerIndex] =chi2/ndf; //state.chi2();
                  
            // Get the measured time from the calibrated 3D measurement (local x, y, time)
            float rawTime = 0.0f;
            float calibratedTime = 0.0f;
 
            if (state.hasCalibrated()) {
            // Extract time from calibrated data
              try {
                const auto& calibrated = state.template calibrated<3>();
                calibratedTime = ActsTrk::timeToAthena(calibrated(2));
                ATH_MSG_DEBUG("Got time from calibrated<3>: " << calibratedTime);
              } catch (const std::exception& e) {
                ATH_MSG_WARNING("Failed to extract time from calibrated<3>: " << e.what());                    
              }
            }
        
            // Extract raw time from HGTD clusters
            const xAOD::HGTDCluster* cluster = getHGTDClusterFromState(ctx, state, hgtdClusters);
 
            if (cluster) {
              rawTime = cluster->time();
              ATH_MSG_DEBUG("Got raw time from cluster: " << rawTime);
            } else {
              ATH_MSG_WARNING("Could not get cluster from state");
            }
 
            // Store the raw time
            rawTimePerLayer[layerIndex] = calibratedTime;
            if (cluster) {
              auto [correctedTime, timeErr] = correctTOF(
                  trackParticle,
                  cluster,
                  calibratedTime,
                  0.0, // time error set to zero for now!
                  acts_tracking_geometry,
                  geoContext);
              timePerLayer[layerIndex] = correctedTime;
              ATH_MSG_DEBUG("Applied TOF correction: " << calibratedTime << " -> " << correctedTime);
            } else {
              // No cluster or time, use raw time
              timePerLayer[layerIndex] = calibratedTime;
              ATH_MSG_DEBUG("No cluster found for TOF correction, using calibrated time: " << calibratedTime);
            }
          } 
          else {
            ATH_MSG_DEBUG("State does not have calibrated data");
          }
 
      // For extrapolation: use the first HGTD hit's surface position.
      if (!foundExtrapolation) {
        foundExtrapolation = true;
        if (state.hasPredicted()) {
          // Get the local predicted position
          const auto& predicted = state.predicted();
          Acts::Vector2 localPos(predicted[Acts::eBoundLoc0], predicted[Acts::eBoundLoc1]);
            
          // Transform to global coordinates
          Acts::Vector3 globalPos = surface.localToGlobal(
              geoContext,
              localPos,
              Acts::Vector3::Zero());
                
          extrapX = globalPos.x();
          extrapY = globalPos.y();
          extrapZ = globalPos.z();
            
          ATH_MSG_DEBUG("Extrapolated position (predicted) at HGTD: x=" << extrapX 
                      << ", y=" << extrapY << ", z=" << extrapZ);
        } else {
            // Fallback to surface center
            Acts::Vector3 globalPos = surface.center(geoContext);
            extrapX = globalPos.x();
            extrapY = globalPos.y();
            extrapZ = globalPos.z();
            
            ATH_MSG_DEBUG("Extrapolated position (surface center) at HGTD: x=" << extrapX 
                        << ", y=" << extrapY << ", z=" << extrapZ);
        }
      }
      ATH_MSG_DEBUG("Found HGTD hit on layer " << layerIndex 
                << ", chi2=" << chi2PerLayer[layerIndex]
                << ", time=" << timePerLayer[layerIndex]);                                    
      }
    }
  }
  
  ATH_MSG_DEBUG("Extension Statistics: "
              << " nMeasurements=" << nMeasurements
              << " nHGTDHits=" << nHGTDHits
              << " nHoles=" << nHoles 
              << " nOutliers=" << nOutliers
              << " extrapolation found: " << (foundExtrapolation ? "yes" : "no")); 
  
 
  // Fill the data structure with results
  data.hasClusterVec = std::move(hasHitInLayer);
  data.chi2Vec    = std::move(chi2PerLayer);
  data.timeVec    = std::move(timePerLayer);
  data.rawTimeVec = std::move(rawTimePerLayer);
  data.extrapX = extrapX;
  data.extrapY = extrapY;
  data.extrapZ = extrapZ;
  data.numHGTDHits = nHGTDHits;
 
  return data;
}

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 344 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 493 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 792 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 AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

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

setMeasurementSelector()

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

nodiscardprotectedinherited

Setup and attach measurement selector to KF options.

Parameters

ctx	the current event context
measurements	measurements container used in MeasurementSelector
options	Kalman filter options

Returns

unique_ptr to MeasurementSelector

Definition at line 185 of file TrackFindingBaseAlg.cxx.

                                         {
 
    std::unique_ptr<ActsTrk::IMeasurementSelector> measurementSelector = ActsTrk::detail::getMeasurementSelector(
        ctx,
        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(),
        m_edgeHoleBorderWidth.value());
 
    measurementSelector->connect(&options.extensions.createTrackStates);
 
    return measurementSelector;
  }

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

sysExecute()

StatusCode AthCommonAlgorithm< 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.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< 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 AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.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 21 of file TrackFindingBaseAlg.cxx.

{ return *m_trackFinder; }

trackFinder() [2/2]

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

protectedinherited

Definition at line 22 of file TrackFindingBaseAlg.cxx.

{ return *m_trackFinder; }

TrackFindingBaseAlg()

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

Definition at line 46 of file TrackFindingBaseAlg.cxx.

: AthReentrantAlgorithm(name, pSvcLocator) {}

updateCounts()

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

staticprotectedinherited

Definition at line 440 of file TrackFindingBaseAlg.cxx.

                                                                         {
    if (detType == xAOD::UncalibMeasType::PixelClusterType) {
      if (typeFlags.isHole()) {
        s_branchState.nPixelHoles(track)++;
      } else if (typeFlags.isOutlier()) {
        s_branchState.nPixelOutliers(track)++;
      } else if (typeFlags.isMeasurement()) {
        s_branchState.nPixelHits(track)++;
      }
    } else if (detType == xAOD::UncalibMeasType::StripClusterType) {
      if (typeFlags.isHole()) {
        s_branchState.nStripHoles(track)++;
      } else if (typeFlags.isOutlier()) {
        s_branchState.nStripOutliers(track)++;
      } else if (typeFlags.isMeasurement()) {
        s_branchState.nStripHits(track)++;
      }
    } else if (detType == xAOD::UncalibMeasType::HGTDClusterType) {
      if (typeFlags.isHole()) {
        s_branchState.nHgtdHoles(track)++;
      } else if (typeFlags.isOutlier()) {
        s_branchState.nHgtdOutliers(track)++;
      } else if (typeFlags.isMeasurement()) {
        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/2]

std::atomic<std::size_t> m_nTrackStateReserve ActsTrk::HGTDTrackExtensionAlg::ATLAS_THREAD_SAFE {0ul}

mutableprivate

Definition at line 123 of file HGTDTrackExtensionAlg.h.

{0ul};

ATLAS_THREAD_SAFE [2/2]

std::atomic<std::size_t> m_nTrackReserve ActsTrk::HGTDTrackExtensionAlg::ATLAS_THREAD_SAFE {0ul}

mutableprivate

Definition at line 122 of file HGTDTrackExtensionAlg.h.

{0ul};

m_absEtaMax

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

protectedinherited

Definition at line 127 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 109 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 126 of file TrackFindingBaseAlg.h.

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

m_actsTrackLinkKey

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_actsTrackLinkKey {this, "ActsTrackLink", m_trackParticleContainerName, "actsTrack", "Link to Acts track"}

private

Definition at line 85 of file HGTDTrackExtensionAlg.h.

{this, "ActsTrackLink", m_trackParticleContainerName, "actsTrack", "Link to Acts track"};

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

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

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 116 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 118 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 117 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 114 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 142 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_ctxProvider

ContextUtility ActsTrk::TrackFindingBaseAlg::m_ctxProvider {this}

protectedinherited

Utility to fetch the geometry, magnetic field and calibration context in the event.

Definition at line 99 of file TrackFindingBaseAlg.h.

{this};

m_d0Max

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

protectedinherited

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

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

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 110 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 111 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 158 of file TrackFindingBaseAlg.h.

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

m_edgeHoleBorderWidth

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_edgeHoleBorderWidth {this,"EdgeHoleBorderWidth", 0. ,"Width of the border of surfaces (mm) within which holes are not counted as holes."}

protectedinherited

Definition at line 107 of file TrackFindingBaseAlg.h.

{this,"EdgeHoleBorderWidth", 0. ,"Width of the border of surfaces (mm) within which holes are not counted as holes."};

m_endOfWorldVolumeIds

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

protectedinherited

Definition at line 153 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 125 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 124 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 AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_extrapXKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_extrapXKey { this, "HGTD_extrap_x", m_trackParticleContainerName, "HGTD_extrap_x", "Decoration for extrapolated X coordinate" }

private

Definition at line 101 of file HGTDTrackExtensionAlg.h.

{ this, "HGTD_extrap_x", m_trackParticleContainerName, "HGTD_extrap_x", "Decoration for extrapolated X coordinate" };

m_extrapYKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_extrapYKey { this, "HGTD_extrap_y", m_trackParticleContainerName, "HGTD_extrap_y", "Decoration for extrapolated Y coordinate" }

private

Definition at line 102 of file HGTDTrackExtensionAlg.h.

{ this, "HGTD_extrap_y", m_trackParticleContainerName, "HGTD_extrap_y", "Decoration for extrapolated Y coordinate" };

m_fitterTool

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

protectedinherited

Definition at line 90 of file TrackFindingBaseAlg.h.

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

m_hgtdCalibTool

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

protectedinherited

Definition at line 93 of file TrackFindingBaseAlg.h.

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

m_HGTDClusterContainerName

SG::ReadHandleKey<xAOD::HGTDClusterContainer> ActsTrk::HGTDTrackExtensionAlg::m_HGTDClusterContainerName {this, "HGTDClusterContainerName", "HGTD_Clusters", "Name of the HGTD_Cluster container"}

private

Definition at line 80 of file HGTDTrackExtensionAlg.h.

{this, "HGTDClusterContainerName", "HGTD_Clusters", "Name of the HGTD_Cluster container"};

m_hgtdTrackLinkKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_hgtdTrackLinkKey {this, "hgtdTrackLink", m_trackParticleContainerName, "hgtdTrackLink", "Link to Hgtd track"}

private

Definition at line 103 of file HGTDTrackExtensionAlg.h.

{this, "hgtdTrackLink", m_trackParticleContainerName, "hgtdTrackLink", "Link to Hgtd track"};

m_inflateCovarianceTwoWay

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_inflateCovarianceTwoWay {this, "inflateCovarianceTwoWay", false, "inflate covariance matrix at the beginning of two-way track finding"}

protectedinherited

Definition at line 112 of file TrackFindingBaseAlg.h.

{this, "inflateCovarianceTwoWay", false, "inflate covariance matrix at the beginning of two-way track finding"};

m_layerClusterRawTimeKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_layerClusterRawTimeKey { this, "HGTD_cluster_raw_time", m_trackParticleContainerName, "HGTD_cluster_raw_time", "Decoration for raw time of cluster" }

private

Definition at line 99 of file HGTDTrackExtensionAlg.h.

{ this, "HGTD_cluster_raw_time", m_trackParticleContainerName, "HGTD_cluster_raw_time", "Decoration for raw time of cluster" };

m_layerClusterTimeKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_layerClusterTimeKey { this, "HGTD_cluster_time", m_trackParticleContainerName, "HGTD_cluster_time", "Decoration for cluster time" }

private

Definition at line 100 of file HGTDTrackExtensionAlg.h.

{ this, "HGTD_cluster_time", m_trackParticleContainerName, "HGTD_cluster_time", "Decoration for cluster time" };

m_layerExtensionChi2Key

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_layerExtensionChi2Key { this, "HGTD_extension_chi2", m_trackParticleContainerName, "HGTD_extension_chi2", "Decoration for chi2 of extension" }

private

Definition at line 98 of file HGTDTrackExtensionAlg.h.

{ this, "HGTD_extension_chi2", m_trackParticleContainerName, "HGTD_extension_chi2", "Decoration for chi2 of extension" };

m_layerHasExtensionKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_layerHasExtensionKey { this, "HGTD_has_extension", m_trackParticleContainerName, "HGTD_has_extension", "Decoration for layer extension" }

private

Definition at line 97 of file HGTDTrackExtensionAlg.h.

{ this, "HGTD_has_extension", m_trackParticleContainerName, "HGTD_has_extension", "Decoration for layer extension" };

m_logger

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

protectedinherited

logging instance

Definition at line 334 of file TrackFindingBaseAlg.h.

m_maxChi2

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

protectedinherited

Definition at line 139 of file TrackFindingBaseAlg.h.

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

m_maxEtaAcceptance

Gaudi::Property<float> ActsTrk::HGTDTrackExtensionAlg::m_maxEtaAcceptance {this, "MaxEtaAcceptance", 4.00, "Maximum eta to consider a track for extension"}

private

Definition at line 89 of file HGTDTrackExtensionAlg.h.

{this, "MaxEtaAcceptance", 4.00, "Maximum eta to consider a track for extension"};

m_maxHgtdHoles

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

protectedinherited

Definition at line 148 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 151 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 136 of file TrackFindingBaseAlg.h.

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

m_maxOutliers

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

protectedinherited

Definition at line 137 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 146 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 149 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 138 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 147 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 150 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::HGTDTrackExtensionAlg::m_memorySafetyMargin {this, "MemorySafetyMargin", 1.2}

private

Definition at line 121 of file HGTDTrackExtensionAlg.h.

{this, "MemorySafetyMargin", 1.2};

m_minEtaAcceptance

Gaudi::Property<float> ActsTrk::HGTDTrackExtensionAlg::m_minEtaAcceptance {this, "MinEtaAcceptance", 2.38, "Minimum eta to consider a track for extension"}

private

Definition at line 88 of file HGTDTrackExtensionAlg.h.

{this, "MinEtaAcceptance", 2.38, "Minimum eta to consider a track for extension"};

m_minHgtdHits

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

protectedinherited

Definition at line 145 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 135 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 143 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 144 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_numHGTDHitsKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_numHGTDHitsKey {this, "numHGTDHits", m_trackParticleContainerName, "numHGTDHits", "Number of HGTD hits on the track extension"}

private

Definition at line 96 of file HGTDTrackExtensionAlg.h.

{this, "numHGTDHits", m_trackParticleContainerName, "numHGTDHits", "Number of HGTD hits on the track extension"};  

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_phiMax

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

protectedinherited

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

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

m_pixelCalibTool

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

protectedinherited

Definition at line 91 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 129 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 128 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 108 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_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 157 of file TrackFindingBaseAlg.h.

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

m_seedRefitPtMinFactor

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_seedRefitPtMinFactor {this, "seedRefitPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the seed refit"}

protectedinherited

Definition at line 115 of file TrackFindingBaseAlg.h.

{this, "seedRefitPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the seed refit"};

m_showResolvedStats

bool ActsTrk::TrackFindingBaseAlg::m_showResolvedStats = false

protectedinherited

Definition at line 351 of file TrackFindingBaseAlg.h.

m_statEtaBins

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

protectedinherited

Definition at line 156 of file TrackFindingBaseAlg.h.

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

m_stripCalibTool

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

protectedinherited

Definition at line 92 of file TrackFindingBaseAlg.h.

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

m_surfAcc

ActsTrk::detail::xAODUncalibMeasSurfAcc ActsTrk::HGTDTrackExtensionAlg::m_surfAcc {}

private

Definition at line 92 of file HGTDTrackExtensionAlg.h.

{};

m_trackContainerKey

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

protectedinherited

Definition at line 95 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_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> ActsTrk::TrackFindingBaseAlg::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

protectedinherited

Definition at line 88 of file TrackFindingBaseAlg.h.

{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

m_trackParticleContainerName

SG::ReadHandleKey<xAOD::TrackParticleContainer> ActsTrk::HGTDTrackExtensionAlg::m_trackParticleContainerName {this, "TrackParticleContainerName", "InDetTrackParticles", "Name of the TrackParticle container"}

private

Definition at line 79 of file HGTDTrackExtensionAlg.h.

{this, "TrackParticleContainerName", "InDetTrackParticles", "Name of the TrackParticle container"};

m_tracksBackendHandlesHelper

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

protectedinherited

Definition at line 96 of file TrackFindingBaseAlg.h.

{this};

m_trackStatePrinter

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

protectedinherited

Definition at line 89 of file TrackFindingBaseAlg.h.

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

m_twoWayinflateCovarianceFactor

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_twoWayinflateCovarianceFactor {this, "twoWayinflateCovarianceFactor", 1.0, "factor to multiply the initial covariance matrix at the beginning of two-way track finding"}

protectedinherited

Definition at line 113 of file TrackFindingBaseAlg.h.

{this, "twoWayinflateCovarianceFactor", 1.0, "factor to multiply the initial covariance matrix at the beginning of two-way track finding"};

m_unalibMeasSurfAcc

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

protectedinherited

Definition at line 83 of file TrackFindingBaseAlg.h.

{};

m_uncalibratedMeasurementContainerKeys

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

private

Definition at line 83 of file HGTDTrackExtensionAlg.h.

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

m_useAbsEtaForStat

bool ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat = false

protectedinherited

Definition at line 350 of file TrackFindingBaseAlg.h.

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_z0Max

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

protectedinherited

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

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

s_branchState

BranchState ActsTrk::TrackFindingBaseAlg::s_branchState {}

staticconstexprprotectedinherited

Definition at line 315 of file TrackFindingBaseAlg.h.

{};

---

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

• HGTDTrackExtensionAlg.h
• HGTDTrackExtensionAlg.cxx