SpacePointMakerAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONSPACEPOINTFORMATION_MUONSPACEPOINTMAKERALG_H
#define MUONSPACEPOINTFORMATION_MUONSPACEPOINTMAKERALG_H
 
#include "ActsGeometryInterfaces/GeometryContext.h"
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 
#include "GeoPrimitives/GeoPrimitives.h"
#include "MuonSpacePoint/SpacePoint.h"
#include "StoreGate/WriteHandleKey.h"
#include "Acts/Utilities/PointerTraits.hpp"
 
 
 
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonReadoutGeometryR4/MuonDetectorManager.h"
#include "MuonSpacePoint/SpacePointContainer.h"
#include "xAODMuonPrepData/MdtDriftCircleContainer.h"
#include "xAODMuonPrepData/RpcMeasurementContainer.h"
#include "xAODMuonPrepData/TgcStripContainer.h"
#include "xAODMuonPrepData/MMClusterContainer.h"
#include "xAODMuonPrepData/sTgcMeasContainer.h"
#include <xAODMuonViews/ChamberViewer.h>
 
 
namespace MuonR4{
    class SpacePointMakerAlg: public AthReentrantAlgorithm {
        public:
            template <Acts::PointerConcept Prd_t>
            using PrdVec_t = std::vector<Prd_t>;
            template <typename T>
            using EtaPhi2DHits = std::array<PrdVec_t<T>, 3>;
            template <typename T>
            using EtaPhi2DHitsVec = std::vector<EtaPhi2DHits<T>>;
 
            using AthReentrantAlgorithm::AthReentrantAlgorithm; 
            ~SpacePointMakerAlg() = default;
 
            StatusCode execute(const EventContext& ctx) const override;
            StatusCode initialize() override;
            StatusCode finalize() override;
        
        private:
            struct BucketParameters {
                double spacePointWindow{0.8 * Gaudi::Units::m};
                double maxBucketLength{2.0 * Gaudi::Units::m};
                double spacePointOverlap{0.25 * Gaudi::Units::m};
            };

            struct ResolvedParameter {
                double value{0.};
                bool matched{false};
            };

            class SpacePointStatistics{
                public:
                    SpacePointStatistics(const Muon::IMuonIdHelperSvc* idHelperSvc);
                    void addToStat(const std::vector<SpacePoint>& spacePoints);
                    void dumpStatisics(MsgStream& msg) const;
                private:
                    struct StatField{
                        unsigned measEtaPhi{0};
                        unsigned measEta{0};
                        unsigned measPhi{0};
                        unsigned allHits() const;
                    };

                    struct FieldKey{
                        using StIdx_t = Muon::MuonStationIndex::StIndex;
                        using TechIdx_t = Muon::MuonStationIndex::TechnologyIndex; 
                        StIdx_t stIdx{StIdx_t::StUnknown};
                        TechIdx_t techIdx{TechIdx_t::TechnologyUnknown};
                        int eta{0};
                        bool operator<(const FieldKey& other) const;
                    };
 
                    const Muon::IMuonIdHelperSvc* m_idHelperSvc{};
                    std::mutex m_mutex{};
                    using StatMap_t = std::map<FieldKey, StatField>;
                    StatMap_t m_map{};
            };

            struct SpacePointsPerChamber{
                std::vector<SpacePoint> etaHits{};
                std::vector<SpacePoint> phiHits{};                
            };

            using PreSortedSpacePointMap = std::unordered_map<const MuonGMR4::SpectrometerSector*, SpacePointsPerChamber>;
            
            using SpacePointBucketVec = std::vector<SpacePointBucket>;
            template <typename ContType> 
                StatusCode loadContainerAndSort(const EventContext& ctx,
                                                const SG::ReadHandleKey<ContType>& key,
                                                PreSortedSpacePointMap& fillContainer) const;
            template <typename PrdType>
                bool passOccupancy2D(const PrdVec_t<PrdType>& etaHits,
                                     const PrdVec_t<PrdType>& phiHits) const;
            template <typename ContType>
                EtaPhi2DHitsVec<typename ContType::const_value_type> splitHitsPerGasGap(xAOD::ChamberViewer<ContType>& viewer) const;
            template <typename PrdType> 
                void fillUncombinedSpacePoints(const ActsTrk::GeometryContext& gctx,
                                               const Amg::Transform3D& sectorTrans,
                                               const PrdVec_t<const PrdType*>& prdsToFill,
                                               std::vector<SpacePoint>& outColl) const; 
            void distributePointsAndStore(SpacePointsPerChamber&& hitsPerChamber,
                                          SpacePointContainer& finalContainer) const;
            void distributePrimaryPoints(std::vector<SpacePoint>&& spacePoints,
                                         SpacePointBucketVec& splittedContainer) const;
            void distributePhiPoints(std::vector<SpacePoint>&& spacePoints,
                                     SpacePointBucketVec& splittedContainer) const;

            bool splitBucket(const SpacePoint& spacePoint,
                             const double firstSpPos,
                             const SpacePointBucketVec& sortedPoints,
                             const BucketParameters& bucketParams) const;
            void newBucket(const SpacePoint& refSp,
                           SpacePointBucketVec& sortedPoints,
                           const BucketParameters& bucketParams) const;
 
            using BucketPatternMap = std::map<std::string, double, std::less<>>;

            std::string chamberConfigKey(const MuonGMR4::Chamber& chamber) const;

            std::optional<BucketParameters> resolveBucketParameters(const MuonGMR4::Chamber& chamber) const;
            ResolvedParameter resolveParameter( const std::string_view chamberKey, const double defaultValue, const BucketPatternMap& patterns) const; 
            const BucketParameters& getBucketParameters(const SpacePoint& spacePoint) const;
 
            SG::ReadHandleKey<xAOD::MdtDriftCircleContainer> m_mdtKey{this, "MdtKey", "xMdtMeasurements",
                                                                      "Key to the uncalibrated Drift circle measurements"};
            
            SG::ReadHandleKey<xAOD::RpcMeasurementContainer> m_rpcKey{this, "RpcKey", "xRpcMeasurements",
                                                                "Key to the uncalibrated 1D rpc hits"};
            
            SG::ReadHandleKey<xAOD::TgcStripContainer> m_tgcKey{this, "TgcKey", "xTgcStrips",
                                                                "Key to the uncalibrated 1D tgc hits"};
 
            SG::ReadHandleKey<xAOD::MMClusterContainer> m_mmKey{this, "MmKey", "xAODMMClusters",
                                                                "Key to the uncalibrated 1D Mm hits"};
 
            SG::ReadHandleKey<xAOD::sTgcMeasContainer> m_stgcKey{this, "sTgcKey", "xAODsTgcMeasurements"};
 
 
            ActsTrk::GeoContextReadKey_t m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
 
            const MuonGMR4::MuonDetectorManager* m_detMgr{nullptr};
 
            ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "IdHelperSvc",  "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
            
            SG::WriteHandleKey<SpacePointContainer> m_writeKey{this, "WriteKey", "MuonSpacePoints"};

            Gaudi::Property<double> m_spacePointWindow{this, "spacePointWindowSize", 0.8*Gaudi::Units::m,
                                                       "Maximal distance between consecutive hits in a bucket"};

            Gaudi::Property<double> m_maxBucketLength{this, "maxBucketLength", 2.*Gaudi::Units::m,
                                                       "Maximal size of a space point bucket"};
            
            Gaudi::Property<double> m_spacePointOverlap{this, "spacePointOverlap", 25.*Gaudi::Units::cm,
                                                        "Hits that are within <spacePointOverlap> of the bucket margin. "
                                                        "Are copied to the next bucket"};

            Gaudi::Property<BucketPatternMap> m_spacePointWindowPatterns{ this, "spacePointWindowPatterns", {},
                                                    "Chamber-pattern dependent space point window. " "Examples: BML*=0.5, BIL_eta3_phi3=0.2"};

            Gaudi::Property<BucketPatternMap> m_maxBucketLengthPatterns{ this, "maxBucketLengthPatterns", {},
                                                    "Chamber-pattern dependent max bucket length. " "Examples: BML*=0.5, BIL_eta3_phi3=0.2"};
            
            Gaudi::Property<BucketPatternMap> m_spacePointOverlapPatterns{ this, "spacePointOverlapPatterns", {},
                                                    "Chamber-dependent overrides of spacePointOverlap" };

            std::unordered_map<const MuonGMR4::Chamber*, BucketParameters> m_bucketParameters{};
            BucketParameters m_defaultBucketParameters{};
    
            Gaudi::Property<bool> m_doStat{this, "doStats", false, 
                                           "If enabled the algorithm keeps track how many hits have been made" };
            
            Gaudi::Property<unsigned> m_capacityBucket{this,"CapacityBucket" , 50};
            std::unique_ptr<SpacePointStatistics> m_statCounter ATLAS_THREAD_SAFE{};
 
            Gaudi::Property<double> m_maxOccRpcEta{this, "maxRpcEtaOccupancy", 0.1, 
                                                   "Maximum occpancy of Rpc eta hits in a gasGap"};
            Gaudi::Property<double> m_maxOccRpcPhi{this, "maxRpcPhiOccupancy", 0.1, 
                                                   "Maximum occpancy of Rpc phi hits in a gasGap"};
 
            Gaudi::Property<double> m_maxOccTgcEta{this, "maxTgcEtaOccupancy", 0.1, 
                                                   "Maximum occpancy of Tgc eta hits in a gasGap"};
            Gaudi::Property<double> m_maxOccTgcPhi{this, "maxTgcPhiOccupancy", 0.1, 
                                                   "Maximum occpancy of Tgc phi hits in a gasGap"};
    };
}
 
 
#endif