#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	CKFOptions = Acts::CombinatorialKalmanFilterOptions< detail::RecoTrackContainer >

Public Member Functions
virtual	~HGTDTrackExtensionAlg ()=default

virtual StatusCode	initialize () override

virtual StatusCode	execute (const EventContext &) const override

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

virtual bool	filterPassed (const EventContext &ctx) const

virtual void	setFilterPassed (bool state, const EventContext &ctx) const

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

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

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
xAOD::TrackParticle *	CKFTrackExtension (const Acts::BoundTrackParameters *parameters)

const Acts::Logger &	logger () const
	Private access to the logger. More...

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

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

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

const xAOD::HGTDCluster *	getHGTDClusterFromState (const ActsTrk::detail::RecoConstTrackStateContainerProxy &state) const

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

bool	isHGTDSurface (const Acts::GeometryIdentifier &geoID) const

bool	getExtrapolationPosition (const EventContext &ctx, const detail::RecoTrackContainer::TrackProxy &track, float &x, float &y, float &z) const

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trackParticleContainerName {this, "TrackParticleContainerName", "", "Name of the TrackParticle container"}

SG::ReadHandleKey< xAOD::HGTDClusterContainer >	m_HGTDClusterContainerName {this, "HGTDClusterContainerName", "", "the HGTD clusters"}

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

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

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

ToolHandle< IActsExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool", ""}

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

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

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

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

ActsTrk::detail::xAODUncalibMeasSurfAcc	m_surfAcc {}

SG::ReadHandleKey< xAOD::UncalibratedMeasurementContainer >	m_uncalibratedMeasurementContainerKey_HGTD {this, "UncalibratedMeasurementContainerKey_HGTD", "", "input cluster collections for HGTD"}

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

std::unique_ptr< detail::CKF_config >	m_trackFinder

Acts::CalibrationContext	m_calibrationContext

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

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 61 of file HGTDTrackExtensionAlg.h.

Member Typedef Documentation

◆ CKFOptions

using ActsTrk::HGTDTrackExtensionAlg::CKFOptions = Acts::CombinatorialKalmanFilterOptions<detail::RecoTrackContainer>

Definition at line 68 of file HGTDTrackExtensionAlg.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~HGTDTrackExtensionAlg()

virtual ActsTrk::HGTDTrackExtensionAlg::~HGTDTrackExtensionAlg ( )

virtualdefault

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality

overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

 {
   return 0;
 }

◆ CKFTrackExtension()

xAOD::TrackParticle* ActsTrk::HGTDTrackExtensionAlg::CKFTrackExtension ( const Acts::BoundTrackParameters * parameters )

private

◆ collectMeasurements()

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

private

Definition at line 348 of file HGTDTrackExtensionAlg.cxx.

                                                                            {
  
   SG::ReadHandle<xAOD::HGTDClusterContainer> HGTDClustersHandle = SG::makeHandle(m_HGTDClusterContainerName, context);
   ATH_CHECK( HGTDClustersHandle.isValid() );
   const xAOD::HGTDClusterContainer* HGTDClusters = HGTDClustersHandle.cptr();
   
   ATH_MSG_DEBUG("Measurements (HGTD only) size: " << HGTDClustersHandle->size());
  
   if (not m_monTool.empty()) {
     {
       auto mon_nclusters = Monitored::Scalar("n_hgtd_clusters", HGTDClusters->size());
       auto mon = Monitored::Group(m_monTool, mon_nclusters);
     }
     
     // Add cluster position to monitoring tool
     for (const xAOD::HGTDCluster* cluster : *HGTDClustersHandle) {
       const Acts::Surface* surface = m_surfAcc.get(cluster);      
       if (not surface) continue;
       
       Acts::Vector3 globalPos = surface->center(m_trackingGeometryTool->getGeometryContext(context).context());
       
       // Get the time from local position (3rd coordinate)
       auto localPosition = cluster->localPosition<3>();  // Get 3D local position
       double clusterTime = localPosition[2];  // Time is in the third coordinate
       
       ATH_MSG_DEBUG("HGTD Cluster: "<< Amg::toString(globalPos) );
  
       auto mon_cluster_x = Monitored::Scalar("cluster_x", globalPos.x());
       auto mon_cluster_y = Monitored::Scalar("cluster_y", globalPos.y());
       auto mon_cluster_z = Monitored::Scalar("cluster_z", globalPos.z());
       auto mon_cluster_t = Monitored::Scalar("cluster_t", clusterTime);
       auto mon = Monitored::Group(m_monTool,
                   mon_cluster_x, mon_cluster_y, mon_cluster_z,
                   mon_cluster_t);
     }
   } // MONITORING
  
   measurements.addMeasurements(0,
                    *HGTDClusters,
                    *m_trackingGeometryTool->surfaceIdMap());
  
   return StatusCode::SUCCESS;
 }

◆ 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

Definition at line 733 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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                      {
     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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

overridevirtual

Definition at line 120 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<bool>> 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::ReadDecorHandle<xAOD::TrackParticleContainer, ElementLink<ActsTrk::TrackContainer>> actsTrackLink( m_actsTrackLinkKey, ctx );
   ATH_CHECK( actsTrackLink.isValid() );
   // ================================================== //
   // ============ RETRIEVE MEASUREMENTS =============== //
   // ================================================== //
  
   ATH_MSG_DEBUG("Reading input collection with key " << m_uncalibratedMeasurementContainerKey_HGTD.key());
  
   const xAOD::UncalibratedMeasurementContainer* uncalibratedMeasurementContainer{nullptr};
   ATH_CHECK(SG::get(uncalibratedMeasurementContainer ,m_uncalibratedMeasurementContainerKey_HGTD, ctx));
   ATH_MSG_DEBUG("Retrieved " << uncalibratedMeasurementContainer->size()
                   << " input elements from key " << m_uncalibratedMeasurementContainerKey_HGTD.key());
  
   // Modern approach uses surface accessor instead of detector element map
  
   ATH_MSG_DEBUG("Investigating HGTD geometry structure");
  
   Acts::GeometryContext geoContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
   Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
  
    
   // Get a list of all identifiers associated with HGTD clusters
   if (msgLvl(MSG::DEBUG)) { // DEBUG
     const xAOD::HGTDClusterContainer* hgtdInitHandle{nullptr};
     ATH_CHECK(SG::get(hgtdInitHandle, m_HGTDClusterContainerName, ctx));
     
     std::unordered_set<uint32_t> hgtdVolumes {};
     std::unordered_map<uint32_t, std::unordered_set<uint32_t>> hgtdLayers {}; // volume -> layers
         
     for (const xAOD::HGTDCluster* cluster : *hgtdInitHandle) {
       const Acts::Surface* surface = m_surfAcc.get(cluster);
       
       if (surface) {
     Acts::GeometryIdentifier geoID = surface->geometryId();
     uint32_t vol = geoID.volume();
     uint32_t layer = geoID.layer();
     
     hgtdVolumes.insert(vol);
     hgtdLayers[vol].insert(layer);
     
       }
       else {
     ATH_MSG_ERROR("Failed to retrieve surface for cluster " << cluster->index());
     return StatusCode::FAILURE;
       }
     }
     
     ATH_MSG_DEBUG("Found " << hgtdVolumes.size() << " different HGTD volumes");
     for (std::uint32_t vol : hgtdVolumes) {
       ATH_MSG_DEBUG("HGTD Volume " << vol << " has " << hgtdLayers[vol].size() << " layers:");
       for (std::uint32_t lyr : hgtdLayers[vol]) {
         ATH_MSG_DEBUG(" - Layer " << lyr);
       }
     }
   } // DEBUG
   
   detail::TrackFindingMeasurements measurements(1ul); // only one measurement collection: HGTD clusters
   ATH_CHECK( collectMeasurements(ctx, measurements) );
  
   using DefaultTrackStateCreator = Acts::TrackStateCreator<ActsTrk::detail::UncalibSourceLinkAccessor::Iterator,detail::RecoTrackContainer>;
  
   ActsTrk::detail::UncalibSourceLinkAccessor slAccessor(measurements.measurementRanges());  
   DefaultTrackStateCreator::SourceLinkAccessor slAccessorDelegate;
   slAccessorDelegate.connect<&ActsTrk::detail::UncalibSourceLinkAccessor::range>(&slAccessor);
  
   // acts_tracking_geometry is already declared in processTrackExtension function
  
   ATH_MSG_DEBUG("Create " << uncalibratedMeasurementContainer->size()
   << " source links from measurements in "
   << m_uncalibratedMeasurementContainerKey_HGTD.key());
  
   if (m_trackStatePrinter.isSet()) {
     m_trackStatePrinter->printMeasurements(ctx, 
     {uncalibratedMeasurementContainer}, //wrap in a braced initializer list to make a vector
     measurements.measurementOffsets());
   }
  
   Acts::PropagatorPlainOptions plainOptions(geoContext, mfContext);
   plainOptions.direction = Acts::Direction::Forward(); 
   
   HGTDTrackExtensionAlg::CKFOptions options(geoContext,
                         mfContext,
                         m_calibrationContext,
                         //slAccessorDelegate,
                         m_trackFinder->ckfExtensions,
                         plainOptions);
  
   auto calibrator = detail::OnTrackCalibrator<detail::RecoTrackStateContainer>(m_trackingGeometryTool.get(),
                                            m_pixelCalibTool,
                                            m_stripCalibTool,
                                            m_hgtdCalibTool);
   
   DefaultTrackStateCreator defaultTrackStateCreator{};
   defaultTrackStateCreator.sourceLinkAccessor = slAccessorDelegate;
   defaultTrackStateCreator.calibrator.template connect<&detail::OnTrackCalibrator<detail::RecoTrackStateContainer>::calibrate>(&calibrator);
   
   options.extensions.createTrackStates.template connect<
     &DefaultTrackStateCreator::createTrackStates>(&defaultTrackStateCreator);
   
   // ================================================== //
   // ============ LOOP OVER TRACKPARTICLES ============ //
   // ================================================== //
  
   // Loop over each track particle and decorate it with various information
   for (const xAOD::TrackParticle* trackParticle : *trackParticles) {
     // Default to empty track data
     TrackExtensionData trackData;
     // Check if the TrackParticle has a link to an ACTS track
     ElementLink<ActsTrk::TrackContainer> link_to_track = actsTrackLink(*trackParticle);
     if (!link_to_track.isValid()) {
       ATH_MSG_ERROR("Invalid ACTS track link for TrackParticle " << trackParticle->index());
       return StatusCode::FAILURE;
     }
  
     std::optional<ActsTrk::TrackContainer::ConstTrackProxy> optional_track = *link_to_track;
     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();
  
     Acts::VectorTrackContainer trackBackend;
     Acts::VectorMultiTrajectory trackStateBackend;
     detail::RecoTrackContainer tracksContainerTemp(trackBackend, trackStateBackend);
  
     // 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
       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"));
  
     // Now use the *last measurement parameters* parameters for the CKF
     auto result = m_trackFinder->ckf.findTracks(lastMeasurementStateParameters, options,tracksContainerTemp);
  
     ATH_MSG_DEBUG("Built " << tracksContainerTemp.size() << " tracks from it");
  
     for (const detail::RecoTrackContainer::TrackProxy trackProxy : tracksContainerTemp) {
       trackData = processTrackExtension(ctx, trackParticle, trackProxy);
     }
  
     // 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
  
   
   return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

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

◆ filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

◆ getExtrapolationPosition()

bool ActsTrk::HGTDTrackExtensionAlg::getExtrapolationPosition	(	const EventContext &	ctx,
		const detail::RecoTrackContainer::TrackProxy &	track,
		float &	x,
		float &	y,
		float &	z
	)		const

private

Definition at line 648 of file HGTDTrackExtensionAlg.cxx.

                                       {
   
   // Default values
   x = 0.0;
   y = 0.0;
   z = 0.0;
   
   // Get the position at the first HGTD layer
   bool foundHGTDSurface = false;
   
   // Explicitly capture ctx and geoContext in the lambda
   Acts::GeometryContext geoContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
   track.container().trackStateContainer().visitBackwards(
       track.tipIndex(),
       [this, &foundHGTDSurface, &x, &y, &z, geoContext](const auto& state) {
           // Skip if already found or no reference surface
           if (foundHGTDSurface || !state.hasReferenceSurface()) {
               return;
           }
           
           const auto& surface = state.referenceSurface();
           Acts::GeometryIdentifier geoID = surface.geometryId();
           
           // Check if this is an HGTD surface
           if (isHGTDSurface(geoID)) {
               // Instead of getting the surface center, use the predicted parameters
               if (state.hasPredicted()) {
                   // Get the local predicted parameters
                   const auto& predicted = state.predicted();
                   
                   // Get the local predicted position (first two components of the predicted vector)
                   // Local coordinates: [loc0, loc1, phi, theta, q/p, time]
                   Acts::Vector2 localPos(predicted[Acts::eBoundLoc0], predicted[Acts::eBoundLoc1]);
                   
                   // Transform to global coordinates
                   Acts::Vector3 globalPos = surface.localToGlobal(
                       geoContext,
                       localPos,
                       Acts::Vector3::Zero());  // Direction doesn't matter for position
                   
                   // Store coordinates
                   x = globalPos.x();
                   y = globalPos.y();
                   z = globalPos.z();
                   
                   ATH_MSG_DEBUG("Predicted position on HGTD surface: (" << x << ", " << y << ", " << z << ")");
                   foundHGTDSurface = true;
               } else {
                   // Fallback to surface center if predicted parameters not available
                   Acts::Vector3 globalPos = surface.center(geoContext);
                   x = globalPos.x();
                   y = globalPos.y();
                   z = globalPos.z();
                   
                   ATH_MSG_DEBUG("Fallback to surface center for HGTD: (" << x << ", " << y << ", " << z << ")");
                   foundHGTDSurface = true;
               }
           }
       });
   
   return foundHGTDSurface;
 }

◆ getHGTDClusterFromState()

const xAOD::HGTDCluster * ActsTrk::HGTDTrackExtensionAlg::getHGTDClusterFromState ( const ActsTrk::detail::RecoConstTrackStateContainerProxy & state ) const

private

Definition at line 819 of file HGTDTrackExtensionAlg.cxx.

                                                                                                                                        {
   if (state.hasUncalibratedSourceLink()) {
     auto sl = state.getUncalibratedSourceLink().template get<ATLASUncalibSourceLink>();
     assert( sl != nullptr);
     const xAOD::UncalibratedMeasurement &uncalib_cluster = getUncalibratedMeasurement(sl);
     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();
         
         // Check if this is an HGTD surface
         if (isHGTDSurface(geoID)) {
           ATH_MSG_DEBUG("This is an HGTD surface with ID: " << geoID.volume() << ":" << geoID.layer());
           
           // Get the current context
           EventContext ctx = Gaudi::Hive::currentContext();
           
           // Modern approach uses surface accessor instead of detector element map
           
           // Get the HGTD clusters
           SG::ReadHandle<xAOD::HGTDClusterContainer> hgtdClusters(m_HGTDClusterContainerName, ctx);
           if (!hgtdClusters.isValid()) {
             ATH_MSG_WARNING("Failed to retrieve HGTD clusters");
             return nullptr;
           }
           
           // Get global position of the state surface
           const Acts::GeometryContext& geoContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
           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

Definition at line 615 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
   }
 }

◆ initialize()

StatusCode ActsTrk::HGTDTrackExtensionAlg::initialize ( )

overridevirtual

Definition at line 42 of file HGTDTrackExtensionAlg.cxx.

 {
   ATH_MSG_DEBUG("Initializing " << name() << "...");
  
   ATH_CHECK(m_trackParticleContainerName.initialize());
   ATH_CHECK(m_HGTDClusterContainerName.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_actsTrackLinkKey.initialize());
   
   // Initialize HGTD-extension related keys
   ATH_CHECK(m_uncalibratedMeasurementContainerKey_HGTD.initialize());
  
   // Checks for logger
   ATH_CHECK(m_trackingGeometryTool.retrieve());
   ATH_CHECK(m_extrapolationTool.retrieve());
   
   ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
   ATH_CHECK(m_trackStatePrinter.retrieve(EnableTool{not m_trackStatePrinter.empty()}));
   ATH_CHECK(m_pixelCalibTool.retrieve(EnableTool{not m_pixelCalibTool.empty()}));
   ATH_CHECK(m_stripCalibTool.retrieve(EnableTool{not m_stripCalibTool.empty()}));
   ATH_CHECK(m_hgtdCalibTool.retrieve(EnableTool{not m_hgtdCalibTool.empty()}));
  
   //Initialize logger
   m_logger = makeActsAthenaLogger(this, "Acts");
  
   // Initialize surface accessor
   m_surfAcc = ActsTrk::detail::xAODUncalibMeasSurfAcc{m_trackingGeometryTool.get()};
  
  
   auto magneticField = std::make_unique<ATLASMagneticFieldWrapper>();
   std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry = m_trackingGeometryTool->trackingGeometry();
  
   detail::Stepper stepper(std::move(magneticField));
   detail::Navigator::Config cfg{trackingGeometry};
   cfg.resolvePassive = true;
   cfg.resolveMaterial = true;
   cfg.resolveSensitive = true;
   detail::Navigator navigator(cfg, logger().cloneWithSuffix("Navigator"));
   detail::Propagator propagator(std::move(stepper), std::move(navigator), logger().cloneWithSuffix("Prop"));
  
   // Using the CKF propagator as extrapolator
   detail::Extrapolator extrapolator = propagator;
  
   // Configure track selector for extension
   Acts::TrackSelector::EtaBinnedConfig trackSelectorCfg(std::vector<double>({0, 4}));  //abs value here
   trackSelectorCfg.cutSets[0].ptMin = 500;        
   trackSelectorCfg.cutSets[0].ptMax = 1000000;    
   trackSelectorCfg.cutSets[0].minMeasurements = 1; 
   trackSelectorCfg.cutSets[0].maxHoles = 4;     
   trackSelectorCfg.cutSets[0].maxOutliers = 4;    
   trackSelectorCfg.cutSets[0].maxHolesAndOutliers = 4; 
   trackSelectorCfg.cutSets[0].maxSharedHits = 4; 
   trackSelectorCfg.cutSets[0].maxChi2 = 10000000.0;     
  
   ATH_MSG_DEBUG(trackSelectorCfg);
  
   detail::CKF_config ckfConfig{
       std::move(extrapolator),
       detail::CKF{std::move(propagator), logger().cloneWithSuffix("CKF")},
       {},
       Acts::TrackSelector{trackSelectorCfg}};
  
   m_trackFinder = std::make_unique<detail::CKF_config>(std::move(ckfConfig));
  
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

◆ isHGTDSurface()

bool ActsTrk::HGTDTrackExtensionAlg::isHGTDSurface ( const Acts::GeometryIdentifier & geoID ) const

private

Definition at line 715 of file HGTDTrackExtensionAlg.cxx.

                                                                                    {
   // Get volume and layer
   std::uint32_t volume = geoID.volume();
   std::uint32_t layer = geoID.layer();
   
   // Check if it's one of the known HGTD volumes
   if (volume == 2 || volume == 25) {
     // Check if it's one of the HGTD layers
     if (layer == 2 || layer == 4 || layer == 6 || layer == 8) {
       return true;
     }
   }
   
   return false;
 }

◆ logger()

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

inlineprivate

Private access to the logger.

Definition at line 73 of file HGTDTrackExtensionAlg.h.

73 { return *m_logger; }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

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

◆ processTrackExtension()

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

private

Definition at line 393 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_trackingGeometryTool->getGeometryContext(ctx).context();
     const Acts::TrackingGeometry* acts_tracking_geometry = m_trackingGeometryTool->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<bool> hasHitInLayer = {false, false, false, false};
     std::vector<float> chi2PerLayer = {0.0, 0.0, 0.0, 0.0};
     std::vector<float> timePerLayer = {0.0, 0.0, 0.0, 0.0};
     std::vector<float> rawTimePerLayer = {0.0, 0.0, 0.0, 0.0};
  
     std::vector<int> truthClassPerLayer = {-1, -1, -1, -1};
     std::vector<bool> isShadowedPerLayer = {false, false, false, false};
     std::vector<bool> isMergedPerLayer = {false, false, false, false};
     std::vector<bool> primaryExpectedPerLayer = {false, false, false, false};
     
     // 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;
     
     trackProxy.container().trackStateContainer().visitBackwards(
       trackProxy.tipIndex(),
         [&](const auto& state) {
             auto flags = state.typeFlags();
             if (flags.test(Acts::TrackStateFlag::HoleFlag)) {
                 nHoles++;
             } else if (flags.test(Acts::TrackStateFlag::OutlierFlag)) {
                 nOutliers++;
             } else if (flags.test(Acts::TrackStateFlag::MeasurementFlag)) {
                 nMeasurements++;
                 
                 // Check if this is an HGTD hit
                 if (state.hasReferenceSurface() && flags.test(Acts::TrackStateFlag::MeasurementFlag)) {
                     const auto& surface = state.referenceSurface();
                     Acts::GeometryIdentifier geoID = surface.geometryId();
                     
                     if (isHGTDSurface(geoID)) {
                 std::size_t layerIndex = getHGTDLayerIndex(geoID);
  
                         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 = static_cast<float>(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(state);
  
                 if (cluster) {
                   auto localPos = cluster->localPosition<3>();
                   rawTime = static_cast<float>(localPos[2]);
                   ATH_MSG_DEBUG("Got raw time from cluster local position: " << rawTime);
                 } else {
                   ATH_MSG_WARNING("Could not get cluster from state");
                 }
  
                 // Store the raw time
                 rawTimePerLayer[layerIndex] = rawTime;
                 
  
                 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]);
                         
                     
           }
         }
     }
       
     });
     
     // If we didn't find any HGTD hits but we still have a valid bestTrack,
     // we should try to predict where the track would intersect HGTD
     if (nHGTDHits == 0 && !foundExtrapolation) {
         
         // Try to calculate the extrapolation position using your existing method
         if (getExtrapolationPosition(ctx, trackProxy, extrapX, extrapY, extrapZ)) {
             ATH_MSG_DEBUG("!!! Didn't find any HGTD hits but calculated extrapolation position: x=" << extrapX 
                           << ", y=" << extrapY << ", z=" << extrapZ);
             foundExtrapolation = true;
         }
     }
     
     ATH_MSG_DEBUG("Track Statistics: "
                 << " nMeasurements=" << nMeasurements
                 << " nHGTDHits=" << nHGTDHits
                 << " nHoles=" << nHoles 
                 << " nOutliers=" << nOutliers
                 << " extrapolation found: " << (foundExtrapolation ? "yes" : "no"));
     
  
     // Fill the data structure with results
     data.hasClusterVec = {hasHitInLayer[0], hasHitInLayer[1], hasHitInLayer[2], hasHitInLayer[3]};
     data.chi2Vec = {chi2PerLayer[0], chi2PerLayer[1], chi2PerLayer[2], chi2PerLayer[3]};
     data.timeVec = {timePerLayer[0], timePerLayer[1], timePerLayer[2], timePerLayer[3]};
     data.rawTimeVec = {rawTimePerLayer[0], rawTimePerLayer[1], rawTimePerLayer[2], rawTimePerLayer[3]};
     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();
   }

◆ setFilterPassed()

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

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

 {
   return BaseAlg::sysExecute (ctx);
 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ 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

◆ m_actsTrackLinkKey

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

private

Definition at line 90 of file HGTDTrackExtensionAlg.h.

◆ m_calibrationContext

Acts::CalibrationContext ActsTrk::HGTDTrackExtensionAlg::m_calibrationContext

private

Definition at line 156 of file HGTDTrackExtensionAlg.h.

◆ m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_extrapolationTool

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

private

Definition at line 102 of file HGTDTrackExtensionAlg.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 86 of file HGTDTrackExtensionAlg.h.

◆ 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 87 of file HGTDTrackExtensionAlg.h.

◆ m_hgtdCalibTool

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

private

Definition at line 109 of file HGTDTrackExtensionAlg.h.

◆ m_HGTDClusterContainerName

SG::ReadHandleKey<xAOD::HGTDClusterContainer> ActsTrk::HGTDTrackExtensionAlg::m_HGTDClusterContainerName {this, "HGTDClusterContainerName", "", "the HGTD clusters"}

private

Definition at line 77 of file HGTDTrackExtensionAlg.h.

◆ 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 84 of file HGTDTrackExtensionAlg.h.

◆ 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 85 of file HGTDTrackExtensionAlg.h.

◆ 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 83 of file HGTDTrackExtensionAlg.h.

◆ 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 82 of file HGTDTrackExtensionAlg.h.

◆ m_logger

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

private

Definition at line 121 of file HGTDTrackExtensionAlg.h.

◆ 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 94 of file HGTDTrackExtensionAlg.h.

◆ 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 93 of file HGTDTrackExtensionAlg.h.

◆ m_monTool

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

private

Definition at line 98 of file HGTDTrackExtensionAlg.h.

◆ 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 80 of file HGTDTrackExtensionAlg.h.

◆ m_pixelCalibTool

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

private

Definition at line 105 of file HGTDTrackExtensionAlg.h.

◆ m_stripCalibTool

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

private

Definition at line 107 of file HGTDTrackExtensionAlg.h.

◆ m_surfAcc

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

private

Definition at line 114 of file HGTDTrackExtensionAlg.h.

◆ m_trackFinder

std::unique_ptr<detail::CKF_config> ActsTrk::HGTDTrackExtensionAlg::m_trackFinder

private

Definition at line 123 of file HGTDTrackExtensionAlg.h.

◆ m_trackingGeometryTool

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

private

Definition at line 100 of file HGTDTrackExtensionAlg.h.

◆ m_trackParticleContainerName

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

private

Definition at line 76 of file HGTDTrackExtensionAlg.h.

◆ m_trackStatePrinter

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

private

Definition at line 112 of file HGTDTrackExtensionAlg.h.

◆ m_uncalibratedMeasurementContainerKey_HGTD

SG::ReadHandleKey<xAOD::UncalibratedMeasurementContainer> ActsTrk::HGTDTrackExtensionAlg::m_uncalibratedMeasurementContainerKey_HGTD {this, "UncalibratedMeasurementContainerKey_HGTD", "", "input cluster collections for HGTD"}

private

Definition at line 117 of file HGTDTrackExtensionAlg.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.

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CKFOptions

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ ~HGTDTrackExtensionAlg()

Member Function Documentation

◆ cardinality()

◆ CKFTrackExtension()

◆ collectMeasurements()

◆ correctTOF()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ getExtrapolationPosition()

◆ getHGTDClusterFromState()

◆ getHGTDLayerIndex()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ isHGTDSurface()

◆ logger()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ processTrackExtension()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_actsTrackLinkKey

◆ m_calibrationContext

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_extrapolationTool

◆ m_extrapXKey

◆ m_extrapYKey

◆ m_hgtdCalibTool

◆ m_HGTDClusterContainerName

◆ m_layerClusterRawTimeKey

◆ m_layerClusterTimeKey

◆ m_layerExtensionChi2Key

◆ m_layerHasExtensionKey

◆ m_logger

◆ m_maxEtaAcceptance

◆ m_minEtaAcceptance

◆ m_monTool

◆ m_numHGTDHitsKey

◆ m_pixelCalibTool

◆ m_stripCalibTool

◆ m_surfAcc

◆ m_trackFinder

◆ m_trackingGeometryTool