CombinatorialNSWSeedFinderAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONR4_MUONPATTERNRECOGNITIONALGS_COMBINATORIALNSWSEEDFINDERALG_H
#define MUONR4_MUONPATTERNRECOGNITIONALGS_COMBINATORIALNSWSEEDFINDERALG_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
 
#include <MuonSpacePoint/SpacePointContainer.h>
#include <MuonPatternEvent/MuonPatternContainer.h>
 
#include "MuonIdHelpers/MmIdHelper.h"
#include "MuonReadoutGeometryR4/MuonDetectorManager.h"
#include "MuonPatternEvent/MuonHoughDefs.h"
#include "MuonRecToolInterfacesR4/IPatternVisualizationTool.h"
#include <MuonSpacePoint/SpacePointPerLayerSplitter.h>
 
#include <span>
#include <vector>
 
 
namespace MuonR4{
 
 
class CombinatorialNSWSeedFinderAlg : public AthReentrantAlgorithm {
  
    public:
        using AthReentrantAlgorithm::AthReentrantAlgorithm;
        virtual ~CombinatorialNSWSeedFinderAlg() = default;
        virtual StatusCode initialize() override;
        virtual StatusCode execute(const EventContext& ctx) const override;    
 
    private:
        
        enum class StripOrient{
          U, 
          V, 
          X, 
          P, 
          C, 
          Unknown
        };
        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<char>>;
        using UsedHitSpan_t = std::vector<std::reference_wrapper<std::vector<char>>>;
        using InitialSeed_t = std::array<const SpacePoint*, 4>;
        using InitialSeedVec_t = std::vector<InitialSeed_t>;
        UsedHitMarker_t emptyBookKeeper(const HitLayVec& sortedSp) const;
        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 constructPrelimnarySeeds(const Amg::Vector3D& beamSpot,
                                      const HitLaySpan_t& combinatoricLayers,
                                      const UsedHitSpan_t& usedHits,
                                      InitialSeedVec_t& outVec) const;
        std::unique_ptr<SegmentSeed> buildSegmentSeed(const InitialSeed_t& initialSeed,
                                                      const AmgSymMatrix(2)& bMatrix, 
                                                      const HoughMaximum& max, 
                                                      const HitLaySpan_t& extensionLayers,
                                                      const UsedHitSpan_t& usedHits) const;
        void markHitsAsUsed(const SegmentSeed& seed,
                            const HitLayVec& allSortHits,
                            UsedHitMarker_t& usedHitMarker) const;
        //extend the seed with compatilbe hits using extrapolation to the layers
        HitVec extendHits(const Amg::Vector3D& startPos, 
                          const Amg::Vector3D& direction, 
                          const HitLaySpan_t& extensionLayers,
                          const UsedHitSpan_t& usedHits) 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 otuput 
        SG::WriteHandleKey<SegmentSeedContainer> m_writeKey{this, "CombinatorialPhiWriteKey", "MuonHoughNswSegmentSeeds"};
 
        // access to the ACTS geometry context 
        SG::ReadHandleKey<ActsGeometryContext> m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};
 
        // access to the Muon Id Helper
        ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
 
        //build and return seeds from the same eta maximum
        std::vector<std::unique_ptr<SegmentSeed>> 
              findSeedsFromMaximum(const HoughMaximum& max, 
                                   const ActsGeometryContext& gctx) const;
  
        //the window in theta to search for hits in the seed extension
        DoubleProperty m_windowTheta {this, "thetaWindow", 0.5 * Gaudi::Units::deg};
        
        //apply a cut threshold in the pulls during the hit extension
        DoubleProperty m_minPullThreshold{this, "maxPull", 5.};
        
        ToolHandle<MuonValR4::IPatternVisualizationTool> m_visionTool{this, "VisualizationTool", ""};
 
 
 
 
 
};
 
}
 
#endif