HGTDTrackExtensionAlg.h

Go to the documentation of this file.

 
#ifndef HGTDTRACKEXTENSIONALG_H
#define HGTDTRACKEXTENSIONALG_H
 
// Base Class
#include "TrackFindingBaseAlg.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"
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "InDetReadoutGeometry/SiDetectorElementStatus.h"
#include "ActsGeometry/ActsVolumeIdToDetectorElementCollectionMap.h"
#include "BeamSpotConditionsData/BeamSpotData.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/TrackFinding/TrackStateCreator.hpp"
#include "Acts/EventData/TrackContainer.hpp"
#include "ActsEvent/TrackParameters.h"
#include "ActsEvent/TrackContainer.h"
 
// Tools
#include "ActsGeometryInterfaces/ITrackingGeometryTool.h"
#include "ActsCalibrators/xAODUncalibMeasSurfAcc.h"
#include "Acts/Surfaces/PerigeeSurface.hpp"
 
 
namespace ActsTrk {
 
using AtlUncalibSourceLinkAccessor = detail::UncalibSourceLinkAccessor;
using DefaultTrackStateCreator = Acts::TrackStateCreator<ActsTrk::detail::UncalibSourceLinkAccessor::Iterator,detail::RecoTrackContainer>; 
 
class HGTDTrackExtensionAlg : public TrackFindingBaseAlg {
 
public:
  using TrackFindingBaseAlg::TrackFindingBaseAlg;
  virtual ~HGTDTrackExtensionAlg() = default;
  virtual StatusCode initialize() override;
  virtual StatusCode execute(const EventContext &ctx) const override;
 
  using ExpectedLayerPattern = std::array<unsigned int, 4>;
 
private:
  // Properties
  SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trackParticleContainerName{this, "TrackParticleContainerName", "InDetTrackParticles", "Name of the TrackParticle container"};
  SG::ReadHandleKey<xAOD::HGTDClusterContainer> m_HGTDClusterContainerName{this, "HGTDClusterContainerName", "HGTD_Clusters", "Name of the HGTD_Cluster container"};
 
  // Measurement collections
  SG::ReadHandleKeyArray<xAOD::UncalibratedMeasurementContainer> m_uncalibratedMeasurementContainerKeys{this, "UncalibratedMeasurementContainerKeys", {}, "input cluster collections"};
 
  SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> m_actsTrackLinkKey {this, "ActsTrackLink", m_trackParticleContainerName, "actsTrack", "Link to Acts track"};
  
  // Configuration
  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
  ActsTrk::detail::xAODUncalibMeasSurfAcc m_surfAcc{};
  
 
  // 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::WriteDecorHandleKey<xAOD::TrackParticleContainer> m_hgtdTrackLinkKey {this, "hgtdTrackLink", m_trackParticleContainerName, "hgtdTrackLink", "Link to Hgtd track"};
 

  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;                                             
  };
 
  using TrackFindingBaseAlg::CKF_pimpl;
 
  Gaudi::Property< float > m_memorySafetyMargin {this, "MemorySafetyMargin", 1.2};
  mutable std::atomic<std::size_t> m_nTrackReserve ATLAS_THREAD_SAFE {0ul};
  mutable std::atomic<std::size_t> m_nTrackStateReserve ATLAS_THREAD_SAFE {0ul};

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

  bool addTrack(
    const DetectorContextHolder& detContext,
    detail::RecoTrackContainerProxy &track,
    const Acts::Surface& refSurface,
    const Acts::TrackExtrapolationStrategy& extrapolationStrategy,
    detail::RecoTrackContainer &actsTracksContainer,
    const detail::MeasurementIndex& measurementIndex,
    const detail::RecoTrackContainer& tracksContainerTemp) const;
  
  Acts::Result<void> extrapolateTrackToReferenceSurface(
    const DetectorContextHolder& detContext,
    detail::RecoTrackContainerProxy &track,
    const Acts::Surface &referenceSurface,
    const detail::Extrapolator &propagator,
    Acts::TrackExtrapolationStrategy strategy,
    ExpectedLayerPattern& expectedLayerPattern) const;

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

  TrackExtensionData processTrackExtension(
    const EventContext& ctx,
    const xAOD::TrackParticle* trackParticle,
    const detail::RecoTrackContainer::TrackProxy& trackProxy,
    const xAOD::HGTDClusterContainer* hgtdClusters) 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 xAOD::HGTDClusterContainer* hgtdClusters) const;
  
  std::size_t getHGTDLayerIndex(
    const Acts::GeometryIdentifier& geoID) const;
                          
};
} // namespace ActsTrk
 
 
#endif // HGTDTRACKEXTENSIONALG_H