NswSegmentFinderAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONR4_MUONPATTERNRECOGNITIONALGS_NSWSEGMENTFINDERALG_H
#define MUONR4_MUONPATTERNRECOGNITIONALGS_NSWSEGMENTFINDERALG_H
 
#include <AthenaBaseComps/AthReentrantAlgorithm.h>
#include <StoreGate/WriteHandleKey.h>
#include <StoreGate/ReadCondHandleKey.h>
 
#include <MuonSpacePoint/SpacePointContainer.h>
#include <MuonPatternEvent/MuonPatternContainer.h>
#include <MuonPatternHelpers/SegmentLineFitter.h>
#include <MuonPatternHelpers/SegmentAmbiSolver.h>
 
 
#include <MuonIdHelpers/MmIdHelper.h>
#include <MuonReadoutGeometryR4/MuonDetectorManager.h>
#include <MuonPatternEvent/MuonHoughDefs.h>
#include <MuonRecToolInterfacesR4/IPatternVisualizationTool.h>
 
#include "MuonRecToolInterfacesR4/ISpacePointCalibrator.h"
 
 
#include <MuonSpacePoint/SpacePointPerLayerSplitter.h>
 
#include <span>
#include <vector>
 
 
namespace MuonR4{
 
 
class NswSegmentFinderAlg : public AthReentrantAlgorithm {
  
    public:
        using AthReentrantAlgorithm::AthReentrantAlgorithm;
        virtual ~NswSegmentFinderAlg() = default;
        virtual StatusCode initialize() override;
        virtual StatusCode execute(const EventContext& ctx) const override;    
        virtual StatusCode finalize() override;
 
    private:
        
        enum class StripOrient{
          U, 
          V, 
          X, 
          P, 
          C, 
          Unknown
        };

        class SeedStatistics{
 
        public:
        
        using chIdx_t = Muon::MuonStationIndex::ChIndex;
        
        SeedStatistics() = default;
 
         //dump seed statistics to the map
        void addToStat(const MuonGMR4::SpectrometerSector* msSector,
                       unsigned int nSeeds, 
                       unsigned int nExtSeeds,
                       unsigned int nSegments);
 
        // print the seed counting stats in the end of the algorithm */
        void printTableSeedStats(MsgStream& msg) const;
        
        private:
 
        struct SeedField{
         unsigned int nSeeds{0};
          unsigned int nExtSeeds{0};
          unsigned int nSegments{0};
        };

          struct SectorField{  
            chIdx_t chIdx{};      
            int8_t phi{0};
            int8_t eta{0};
            bool operator<(SectorField const& o) const noexcept {
              if(chIdx != o.chIdx) {
                return chIdx < o.chIdx;
              }
              if(eta != o.eta) {
                return eta < o.eta;              
              }
              return phi < o.phi;
            }
          };
          using SeedStatistic_T = std::map<SectorField, SeedField>;
          SeedStatistic_T m_seedStat{};
 
          std::mutex m_mutex{};
 
        };

        StripOrient classifyStrip(const SpacePoint& spacePoint) const;
 
        using HitVec = SpacePointPerLayerSplitter::HitVec;
 
        using HitLayVec = SpacePointPerLayerSplitter::HitLayVec;
        using HitLaySpan_t = std::vector<std::reference_wrapper<const HitVec>>;
        using UsedHitMarker_t = std::vector<std::vector<unsigned int>>;
        using UsedHitSpan_t = std::vector<std::reference_wrapper<std::vector<unsigned int>>>;
        using InitialSeed_t = std::array<const SpacePoint*, 4>;
        using InitialSeedVec_t = std::vector<InitialSeed_t>;
        UsedHitMarker_t emptyBookKeeper(const HitLayVec& sortedSp) const;
        using SegmentSeedVec_t = std::vector<std::unique_ptr<SegmentSeed>>;
        using SegmentVec_t = std::vector<std::unique_ptr<Segment>>;
        
        enum class HitWindow{tooLow, 
                             inside, 
                             tooHigh}; 

        HitWindow hitFromIPCorridor(const SpacePoint& testHit, 
                                    const Amg::Vector3D& beamSpotPos, 
                                    const Amg::Vector3D& dirEstUp,
                                    const Amg::Vector3D& dirEstDn) const;
        void constructPreliminarySeeds(const Amg::Vector3D& beamSpot,
                                      const HitLaySpan_t& combinatoricLayers,
                                      const UsedHitSpan_t& usedHits,
                                      InitialSeedVec_t& outVec) const;
        std::unique_ptr<SegmentSeed> constructCombinatorialSeed(const InitialSeed_t& initialSeed,
                                                                const AmgSymMatrix(2)& bMatrix,
                                                                const HoughMaximum& max,
                                                                const ActsTrk::GeometryContext& gctx,
                                                                const HitLaySpan_t& extensionLayers,
                                                                const UsedHitSpan_t& usedHits) const;
        std::pair<SegmentSeedVec_t, SegmentVec_t> buildSegmentsFromMM(const EventContext& ctx,
                                                                      const ActsTrk::GeometryContext &gctx,                                                                     
                                                                      const HitLayVec& hitLayers,                                                                     
                                                                      const HoughMaximum& max,
                                                                      const Amg::Vector3D& beamSpotPos,
                                                                      UsedHitMarker_t& usedHits,
                                                                      bool useOnlyMM) const;
        std::pair<SegmentSeedVec_t, SegmentVec_t> buildSegmentsFromSTGC(const EventContext& ctx,
                                                                        const ActsTrk::GeometryContext &gctx,
                                                                        const HitLayVec& hitLayers,                                                                     
                                                                        const HoughMaximum& max,
                                                                        const Amg::Vector3D& beamSpotPos,
                                                                        UsedHitMarker_t& usedHits,
                                                                        bool usePad) const;
        std::unique_ptr<Segment> fitSegmentSeed(const EventContext& ctx,
                                                const ActsTrk::GeometryContext& gctx, 
                                                const SegmentSeed *patternSeed) const;

        void processSegment(std::unique_ptr<Segment> segment, 
                            const HitVec& seedHits, 
                            const HitLayVec& hitLayers, 
                            UsedHitMarker_t& usedHits,
                            SegmentVec_t& segments) const;
        
        void resolveAmbiguities(const ActsTrk::GeometryContext& gctx,
                                SegmentVec_t& segmentCandidates) const;

        void markHitsAsUsed(const HitVec& spacePoints,
                            const HitLayVec& allSortHits,
                            UsedHitMarker_t& usedHitMarker,
                            unsigned int increase,
                            bool markNeighborHits) const;
 
       
        HitVec extendHits(const Amg::Vector3D& startPos, 
                          const Amg::Vector3D& direction, 
                          const HitLaySpan_t& extensionLayers,
                          const UsedHitSpan_t& usedHits) const;

        std::pair<SegmentSeedVec_t, SegmentVec_t>
              findSegmentsFromMaximum(const HoughMaximum& max, 
                                      const ActsTrk::GeometryContext& gctx,
                                      const EventContext& ctx) const;
 
        // read handle key for the input maxima (from a previous eta-transform)
        SG::ReadHandleKey<EtaHoughMaxContainer> m_etaKey{this, "CombinatorialReadKey", "MuonHoughNswMaxima"};
 
        //write handle key for the segment seeds container
        SG::WriteHandleKey<SegmentSeedContainer> m_writeSegmentSeedKey{this, "MuonNswSegmentSeedWriteKey", "MuonNswSegmentSeeds"};
 
        // write handle key for the segments container
        SG::WriteHandleKey<SegmentContainer> m_writeSegmentKey{this, "MuonNswSegmentWriteKey", "MuonNswSegments"};
 
        // access to the ACTS geometry context 
        ActsTrk::GeoContextReadKey_t m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
 
        // access to the Muon Id Helper
        ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

        ToolHandle<MuonValR4::IPatternVisualizationTool> m_visionTool{this, "VisualizationTool", ""};
 
        //Space point calibration tool 
        ToolHandle<ISpacePointCalibrator> m_calibTool{this, "Calibrator", "" };
 
        // Pointer to the line segment fitter 
        std::unique_ptr<SegmentFit::SegmentLineFitter> m_lineFitter{};
 
        // Pointer to the segment ambiguity solver
        std::unique_ptr<SegmentFit::SegmentAmbiSolver> m_ambiSolver{};
  
        //the window in theta to search for hits in the seed extension
        DoubleProperty m_windowTheta {this, "thetaWindow", 2.5 * Gaudi::Units::deg};
        
        //apply a cut threshold in the pulls during the hit extension
        DoubleProperty m_minPullThreshold{this, "maxPull", 10.};
        
        //minimum number of hits required to form a seed after extension
        UnsignedIntegerProperty m_minSeedHits{this, "minSeedHits", 6};
 
        //maximum number of MM Clusters that are invalid in the seed
        UnsignedIntegerProperty m_maxInvalidClusters{this, "maxInvalidClusters", 4};
 
        //reject also hits from the seed even if it does not lead to succesful segment
        BooleanProperty m_markHitsFromSeed{this, "markHitsFromSeed", true};
 
        //skip stgc seed from the same multilayer
        BooleanProperty m_skipSameMultilayer{this, "skipSameMultilayer", true};
 
        //flag to use only MM layers for the estimation of the initial seed of the combinatorics
        BooleanProperty m_doOnlyMMCombinatorics{this, "doOnlyMMCombinatorics", false};
 
        //maximum number that hit is allowed to be used
        UnsignedIntegerProperty m_maxUsed{this, "maxHitIsUsed", 6};
 
        //minimum number of strips required for MMClusers not to be invalid
        UnsignedIntegerProperty m_minClusSize{this, "minClusterSize", 1};
 
        //maximum number of chi2 cut for the segment
        DoubleProperty m_maxChi2{this, "maxChi2", 5.};
 
        // maximum number of clusters in the layer for the seed finding
        UnsignedIntegerProperty m_maxClustersInLayer{this, "maxClustersInLayer", 8};
 
        //maximum number of dY window size for killing hits on the layer from the segments 
        DoubleProperty m_maxdYWindow{this, "maxdYWindow", 2.*Gaudi::Units::cm};  
 
        //maximum tanAlpha for the seed quality check
        DoubleProperty m_maxTanAlpha{this, "maxTanAlpha", 0.4};
 
        //dump statistics for the seeds per sector
        BooleanProperty m_dumpSeedStatistics{this, "dumpStatistics", true};
 
        //dump the space points in an obj file
        BooleanProperty m_dumpObj{this, "dumpObj", false};
 
        std::unique_ptr<SeedStatistics> m_seedCounter ATLAS_THREAD_SAFE{};
 
        const MuonGMR4::MuonDetectorManager* m_detMgr{};
        
       
};
 
}
 
#endif