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

Protected Member Functions
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.

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

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< ActsTrk::IExtrapolationTool >	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.
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 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 ( ) const

overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

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

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.

95{ return m_detStore; }

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

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

85{ return m_evtStore; }

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

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

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

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

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

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

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

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

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

◆ 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 = 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();
  }

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

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysStart()

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

overridevirtualinherited

Handle START transition.

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

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

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

◆ 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<ActsTrk::IExtrapolationTool> ActsTrk::HGTDTrackExtensionAlg::m_extrapolationTool {this, "ExtrapolationTool", ""}

private

Definition at line 102 of file HGTDTrackExtensionAlg.h.

102{this, "ExtrapolationTool", ""};

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

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

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

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

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

◆ m_HGTDClusterContainerName

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

private

Definition at line 77 of file HGTDTrackExtensionAlg.h.

77{this, "HGTDClusterContainerName", "", "the HGTD clusters"};

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

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

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

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

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

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

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

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

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

◆ m_monTool

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

private

Definition at line 98 of file HGTDTrackExtensionAlg.h.

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

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

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

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

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

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

◆ m_surfAcc

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

private

Definition at line 114 of file HGTDTrackExtensionAlg.h.

114{};

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

100{this, "TrackingGeometryTool", ""};

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

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

◆ m_trackStatePrinter

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

private

Definition at line 112 of file HGTDTrackExtensionAlg.h.

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

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

117{this, "UncalibratedMeasurementContainerKey_HGTD", "", "input cluster collections for HGTD"};

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

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ getExtrapolationPosition()

◆ getHGTDClusterFromState()

◆ getHGTDLayerIndex()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ isHGTDSurface()

◆ logger()

◆ msg()

◆ 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

◆ m_trackParticleContainerName

◆ m_trackStatePrinter

◆ m_uncalibratedMeasurementContainerKey_HGTD

◆ m_varHandleArraysDeclared

◆ m_vhka