HGTDTrackExtensionAlg.h

Go to the documentation of this file.

 
#ifndef HGTDTRACKEXTENSIONALG_H
#define HGTDTRACKEXTENSIONALG_H
 
// Base Class
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 
// Gaudi
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/EventContext.h"
 
// Athena
#include "xAODInDetMeasurement/HGTDClusterContainer.h"
#include "xAODTracking/TrackParticle.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "AthenaMonitoringKernel/GenericMonitoringTool.h"
#include "xAODMeasurementBase/UncalibratedMeasurement.h"
#include "GeoPrimitives/GeoPrimitives.h"
 
// STL
#include <memory>
#include <string>
 
// Handle Keys
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/CondHandleKeyArray.h"
#include "StoreGate/WriteDecorHandleKey.h"
#include "StoreGate/ReadDecorHandleKey.h"
#include "ActsEvent/TrackContainerHandlesHelper.h"
#include "src/detail/Definitions.h"
#include "src/detail/DuplicateSeedDetector.h"
#include "src/detail/TrackFindingMeasurements.h"
#include "src/TrackStatePrinterTool.h"
 
// Acts
#include "Acts/EventData/TrackContainer.hpp"
#include "ActsEvent/TrackParameters.h"
#include "ActsEvent/TrackContainer.h"
#include "ActsToolInterfaces/IPixelOnTrackCalibratorTool.h"
#include "ActsToolInterfaces/IStripOnTrackCalibratorTool.h"
#include "ActsToolInterfaces/IHGTDOnTrackCalibratorTool.h"
 
// Tools
#include "ActsGeometryInterfaces/IExtrapolationTool.h"
#include "ActsGeometryInterfaces/ITrackingGeometryTool.h"
#include "ActsCalibrators/xAODUncalibMeasSurfAcc.h"
#include "Acts/Surfaces/PerigeeSurface.hpp"
 
 
namespace ActsTrk {
 
class HGTDTrackExtensionAlg : public AthReentrantAlgorithm {
 
public:
  using AthReentrantAlgorithm::AthReentrantAlgorithm;
  virtual ~HGTDTrackExtensionAlg() = default;
  virtual StatusCode initialize() override;
  virtual StatusCode execute(const EventContext&) const override;
  using CKFOptions = Acts::CombinatorialKalmanFilterOptions<detail::RecoTrackContainer>;
 
private:
  xAOD::TrackParticle* CKFTrackExtension(const Acts::BoundTrackParameters* parameters);
  const Acts::Logger &logger() const { return *m_logger; }
  
  // Properties
  SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trackParticleContainerName{this, "TrackParticleContainerName", "", "Name of the TrackParticle container"};
  SG::ReadHandleKey<xAOD::HGTDClusterContainer> m_HGTDClusterContainerName{this, "HGTDClusterContainerName", "", "the HGTD clusters"};
 
  // WriteDecorHandleKeys for decorating tracks
  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"};
  
  // Tool Handles
  ToolHandle<GenericMonitoringTool> 
      m_monTool{this, "MonTool", "", "Monitoring tool"};
  PublicToolHandle<ActsTrk::ITrackingGeometryTool> 
      m_trackingGeometryTool{this, "TrackingGeometryTool", ""};
  ToolHandle<ActsTrk::IExtrapolationTool> 
      m_extrapolationTool{this, "ExtrapolationTool", ""};
  
  ToolHandle<ActsTrk::IPixelOnTrackCalibratorTool<detail::RecoTrackStateContainer>>
      m_pixelCalibTool{this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"};
  ToolHandle<ActsTrk::IStripOnTrackCalibratorTool<detail::RecoTrackStateContainer>>
      m_stripCalibTool{this, "StripCalibrator", "", "Opt. strip measurement calibrator"};
  ToolHandle<ActsTrk::IHGTDOnTrackCalibratorTool<detail::RecoTrackStateContainer>>
      m_hgtdCalibTool{this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"}; 
 
  ToolHandle<ActsTrk::TrackStatePrinterTool> 
      m_trackStatePrinter{this, "TrackStatePrinter", "", "optional track state printer"};
 
  ActsTrk::detail::xAODUncalibMeasSurfAcc m_surfAcc{};
 
  //HGTD
  SG::ReadHandleKey<xAOD::UncalibratedMeasurementContainer> m_uncalibratedMeasurementContainerKey_HGTD{this, "UncalibratedMeasurementContainerKey_HGTD", "", "input cluster collections for HGTD"};
  // Removed DetectorElementToActsGeometryIdMap - modern approach uses surface accessor
 
  // logging instance
  std::unique_ptr<const Acts::Logger> m_logger;
 
  std::unique_ptr<detail::CKF_config> m_trackFinder;
 
  StatusCode collectMeasurements(const EventContext& context,
                 detail::TrackFindingMeasurements& measurements) const;

  struct TrackExtensionData {
    std::vector<char> hasClusterVec = {false, false, false, false};  
    std::vector<float> chi2Vec = {0.0, 0.0, 0.0, 0.0};             
    std::vector<float> rawTimeVec = {0.0, 0.0, 0.0, 0.0};          
    std::vector<float> timeVec = {0.0, 0.0, 0.0, 0.0};             
    float extrapX = 0.0;  
    float extrapY = 0.0;  
    float extrapZ = 0.0;  
    int numHGTDHits = 0;  
  };
 
  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 EventContext& ctx, const ActsTrk::detail::RecoConstTrackStateContainerProxy& state) const;
 
  Acts::CalibrationContext m_calibrationContext; 
 
  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;
 
};
} // namespace ActsTrk
 
 
#endif // HGTDTRACKEXTENSIONALG_H