CaloExtensionAlg.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 */
#ifndef ACTSCALOALGS_CALOEXTENSIONALG_H
#define ACTSCALOALGS_CALOEXTENSIONALG_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 
#include "ActsEvent/CaloExtension.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODCaloEvent/CaloClusterContainer.h"
 
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/WriteDecorHandleKey.h"
 
#include "CaloDetDescr/CaloDetDescrManager.h"
#include "ActsGeometryInterfaces/ITrackingGeometrySvc.h"
#include "ActsGeometryInterfaces/IExtrapolationTool.h"
 
#include "egammaInterfaces/IegammaCaloClusterSelector.h"
 
#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
#include "ActsEvent/ContextUtility.h"
 
#include "Acts/Propagator/Propagator.hpp"
#include "Acts/Propagator/Navigator.hpp"
#include "Acts/Propagator/EigenStepper.hpp"
#include "Acts/Utilities/Grid.hpp"
 
#include <span>
#include <map>
 
namespace ActsTrk{
    class CaloExtensionAlg : public AthReentrantAlgorithm{
        public:
            using AthReentrantAlgorithm::AthReentrantAlgorithm;
            virtual StatusCode initialize() override final;
            virtual StatusCode execute(const EventContext& ctx) const override final;
 
        private:
            using ClusterVec_t = std::vector<const xAOD::CaloCluster*>;
            using EtaAxis_t = Acts::Axis<Acts::AxisType::Equidistant, 
                                         Acts::AxisBoundaryType::Bound>;
            using PhiAxis_t = Acts::Axis<Acts::AxisType::Equidistant, 
                                         Acts::AxisBoundaryType::Closed>;
            using SortedCluster_t = Acts::Grid<ClusterVec_t, EtaAxis_t, PhiAxis_t>;

            SortedCluster_t selectAndSort(const xAOD::CaloClusterContainer& clusters,
                                          const CaloDetDescrManager* detMgr) const;
                                          
            std::unique_ptr<CaloExtension> propagateToCaloExit(const EventContext& ctx,
                                                               const xAOD::TrackParticle* track) const;

            void matchClusters(const Acts::GeometryContext& tgContext,
                               std::span<const xAOD::CaloCluster* const> clusterContainer,
                               CaloExtension& caloExtension) const;

            bool checkBroadCriteria(const Acts::GeometryContext& tgContext,
                                    const xAOD::CaloCluster& cluster,
                                    const Acts::BoundTrackParameters& lastTrkPars) const;
            
            using CurvedStepper_t = Acts::EigenStepper<Acts::EigenStepperDefaultExtension>;
            using CurvedPropagator_t = Acts::Propagator<CurvedStepper_t, Acts::Navigator>;
            std::unique_ptr<CurvedPropagator_t> m_propagator{};
            ToolHandle<InDet::IInDetTrackSelectionTool> m_trackSelector{this, "TrackSelectionTool" , ""};
            ToolHandle<IegammaCaloClusterSelector> m_clusterSelector{this, "ClusterSelector", "egammaCaloClusterSelector", 
                                                                                "Tool that makes the cluster selection"};

            ServiceHandle<ActsTrk::ITrackingGeometrySvc> m_trackingGeometrySvc{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};
            ActsTrk::ContextUtility m_ctxProvider{this};

            ToolHandle<IExtrapolationTool> m_extrapolationTool{this, "ExtrapolationTool", ""};

            SG::ReadHandleKey<xAOD::CaloClusterContainer> m_clusterContainerKey {this,  "ClusterContainerName", "CaloCalTopoClusters"};
            SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trackParticleContainerKey{this, "TrackParticleContainerName",
                                                                                         "InDetTrackParticles" };

            SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> m_extensionDecorKey{this, "ExtensionDecoration", m_trackParticleContainerKey, 
                                                                                     "caloExtensionLink"};

            SG::ReadCondHandleKey<CaloDetDescrManager> m_caloDetDescrMgrKey {this, "CaloDetDescrManager", "CaloDetDescrManager"};
 
            SG::WriteHandleKey<CaloExtensionContainer> m_caloExtensionKey{this, "CaloExtensionName", "CaloExtension"};

            Gaudi::Property<float> m_trackPt{this, "minPt", 2.5*Gaudi::Units::GeV};

            Gaudi::Property<float> m_broadDeltaEta{this, "broadDeltaEta", 0.2, "Value of broad cut for delta eta" };
 
            Gaudi::Property<float> m_broadDeltaPhi{this, "broadDeltaPhi", 0.3, "Value of broad cut for delta phi" };
            Gaudi::Property<float> m_minClustEt{this, "minClusterEt", 10.*Gaudi::Units::MeV};
            Gaudi::Property<float> m_maxClustEta{this, "maxClustEta", 10.};
 
 
            using CaloSample = xAOD::CaloCluster::CaloSample;
            Gaudi::Property<float> m_narrowDeltaEta{this, "narrowDeltaEta", 0.05};
 
            Gaudi::Property<float> m_narrowDeltaPhi{this, "narrowDeltaPhi", 0.05};
 
            std::unordered_map<Acts::GeometryIdentifier, CaloSample> m_geoLayerIds{};
 
    };
}
 
#endif