SpacePointMakerAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONSPACEPOINTFORMATION_MUONSPACEPOINTMAKERALG_H
#define MUONSPACEPOINTFORMATION_MUONSPACEPOINTMAKERALG_H
 
#include "ActsGeometryInterfaces/ActsGeometryContext.h"
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 
#include "GeoPrimitives/GeoPrimitives.h"
#include "MuonSpacePoint/SpacePoint.h"
#include "StoreGate/WriteHandleKey.h"
 
 
 
#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"
 
 
namespace MuonR4{
    class SpacePointMakerAlg: public AthReentrantAlgorithm {
        public:
            using AthReentrantAlgorithm::AthReentrantAlgorithm; 
 
            ~SpacePointMakerAlg() = default;
 
            StatusCode execute(const EventContext& ctx) const override;
            StatusCode initialize() override;
            StatusCode finalize() override;
        
        private:
            template<class MeasType> Amg::Transform3D toChamberTransform(const ActsGeometryContext& gctx, 
                                                                         const Amg::Transform3D& sectorTrans,
                                                                         const MeasType* meas) const;
            template<class MeasType> Amg::Vector3D positionInChamber(const MeasType* meas,
                                                                     const Amg::Transform3D& toChamberTrans) const;
            template<class MeasType> Amg::Vector3D channelDirInChamber(const MeasType* meas,
                                                                       const Amg::Transform3D& toChamberTrans) const;
            template<class MeasType> Amg::Vector3D channelNormalInChamber(const MeasType* meas,
                                                                          const Amg::Transform3D& toChamberTrans) const;
            template<class MeasType> AmgSymMatrix(2) computeCov(const MeasType* primaryMeas,
                                                                const Amg::Vector3D& dir,
                                                                const Amg::Vector3D& nor) const;
            AmgSymMatrix(2) computeCov(const xAOD::UncalibratedMeasurement* primaryMeas,
                                       const xAOD::UncalibratedMeasurement* secondaryMeas,
                                       const Amg::Vector3D& nor1,
                                       const Amg::Vector3D& nor2) const;
            template <class MeasType> void fillSpacePoint (std::vector<SpacePoint>& pointColl,
                                                          const MeasType* primaryMeas,
                                                          const Amg::Transform3D& toChamberTrans) const;
            template <class MeasType> void fillSpacePoint (std::vector<SpacePoint>& pointColl,
                                                           const MeasType* primaryMeas,
                                                           const MeasType* secondaryMeas,
                                                           const Amg::Transform3D& toChamberTrans_eta, 
                                                           const Amg::Transform3D& toChamberTrans_phi) const;
            
            class SpacePointStatistics{
                public:
                    SpacePointStatistics(const Muon::IMuonIdHelperSvc* idHelperSvc);
                
                    void addToStat(const std::vector<SpacePoint>& spacePoints);
                    void dumpStatisics(MsgStream& msg) const;
 
                private:
                    struct StatField{
                        unsigned int measEtaPhi{0};
                        unsigned int measEta{0};
                        unsigned int measPhi{0};
                        unsigned int 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>;
 
  
            template <class ContType> 
                StatusCode loadContainerAndSort(const EventContext& ctx,
                                                const SG::ReadHandleKey<ContType>& key,
                                                PreSortedSpacePointMap& fillContainer) const;
                                                    
            using SpacePointBucketVec = std::vector<SpacePointBucket>;
 
            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;
            void newBucket(const SpacePoint& refSp,
                           SpacePointBucketVec& sortedPoints) const;
            template <class PrdType>
                bool passOccupancy2D(const std::vector<const PrdType*>& etaHits,
                                     const std::vector<const PrdType*>& phiHits) 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"};
 
 
            SG::ReadHandleKey<ActsGeometryContext> m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
 
            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<bool> m_doStat{this, "doStats", false, 
                                           "If enabled the algorithm keeps track how many hits have been made" };
            
            Gaudi::Property<unsigned int> 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"};
 
            Gaudi::Property<double> m_maxOccStgcEta{this, "maxSTGCEtaOccupancy", 0.1, 
                                                   "Maximum occpancy of sTgc eta hits in a gasGap"};
            Gaudi::Property<double> m_maxOccStgcPhi{this, "maxSTGCPhiOccupancy", 0.1, 
                                                    "Maximum occpancy of sTgc phi hits in a gasGap"};
 
    };
}
 
 
#endif