GlobalPatternFinder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_FASTRECONSTRUCTIONALGS_GLOBALPATTERNFINDER__H
#define MUONR4_FASTRECONSTRUCTIONALGS_GLOBALPATTERNFINDER__H
 
#include "MuonFastRecoEvent/GlobalPattern.h"
#include "MuonRecToolInterfacesR4/IFastRecoVisualizationTool.h"
#include "MuonSpacePoint/SpacePointContainer.h"
#include "MuonSpacePoint/SpacePointPerLayerSorter.h"
#include <MuonSpacePoint/SpacePointHelpers.h>
 
#include "Acts/Utilities/KDTree.hpp"
 
namespace MuonR4::FastReco{
    

    class GlobalPatternFinder {
        public:  
            using StIndex = Muon::MuonStationIndex::StIndex;
            using LayerIndex = Muon::MuonStationIndex::LayerIndex;
     
            struct Config {
                bool useMdtHits {true};
                bool seedFromMdt {false};
                std::vector<LayerIndex> layerSeedings{LayerIndex::Middle, LayerIndex::Outer};
                /********* Pattern bulding acceptance **********/ 
                double thetaSearchWindow {0.05};
                double nResidualSigma {3.0};
                double lowConfidenceResSigma {50};
                double nPhiSigma {3.0};
                /********* Pile-up & Fake rate suppression *****/
                unsigned int minTriggerLayers {3};
                unsigned int minPrecisionLayers {0};
                unsigned int minPhiLayers {1};
                unsigned int minStationLayers {4};
                double meanNormRes2Cut {0.2};
                /********* Pattern recovery power **************/
                unsigned int maxSeedAttempts {2};
                unsigned int maxMissLayersInStation {2};
                /********* Numerical stability *****************/
                double minHitDistance4Line {40};
                const MuonValR4::IFastRecoVisualizationTool* visionTool{nullptr};
                const Muon::IMuonIdHelperSvc* idHelperSvc{nullptr};
                /********** Beamspot settings ************/
                double beamSpotRadius{30.*Gaudi::Units::cm};
                double beamSpotLength{2.*Gaudi::Units::m};
            };

            GlobalPatternFinder(Config&& config,
                                std::unique_ptr<const Acts::Logger> logger = Acts::getDefaultLogger(
                                    "GlobalPatternFinder", Acts::Logging::Level::INFO));

            std::vector<GlobalPattern> findPatterns(const ActsTrk::GeometryContext& gctx,
                                                    std::span<const SpacePointContainer*> spacepoints) const;
 
        private:
            static const int s_nStations{Acts::toUnderlying(StIndex::StIndexMax)};
            struct HitPayload;
            struct CandidateHit;
            struct PatternState;
            using PatternStateVec = std::vector<PatternState>;
            using PatHitVisual = MuonValR4::IFastRecoVisualizationTool::PatternHitVisualInfo;
            using SearchTree_t = Acts::KDTree<2, const HitPayload*, double, std::array, 50>;
            enum class SeedCoords : std::uint8_t{
                eSector,
                eTheta
            };

            struct SearchTreeData;

            SearchTreeData constructTree(const ActsTrk::GeometryContext& gctx,
                                         std::span<const SpacePointContainer*> spacepoints) const;
            PatternStateVec findPatternsInEta(const Acts::GeometryContext& gctx,
                                              const SearchTree_t& orderedSpacepoints,
                                              std::vector<PatHitVisual>* visualInfo = nullptr) const;
            void extendPatterns(const Acts::GeometryContext& gctx,
                                PatternStateVec& startPatterns,
                                PatternStateVec& endPatterns,
                                const CandidateHit& testHit,
                                const Amg::Vector3D& beamSpot,
                                std::vector<PatHitVisual>* visualInfo = nullptr) const;
            bool passPatternCuts(const PatternState& pat) const;
            static bool isBetter(const PatternState& a, 
                                 const PatternState& b);
            PatternStateVec resolveOverlaps(PatternStateVec& toResolve,
                                            std::vector<PatHitVisual>* visualInfo = nullptr) const;
            void addPhiOnlyHits(const ActsTrk::GeometryContext& gctx,
                                PatternStateVec& patterns) const;
            GlobalPattern convertToPattern(const PatternState& candidate) const;
            std::vector<GlobalPattern> convertToPattern(const PatternStateVec& candidates) const;
            enum class LayerOrdering : std::int8_t{
                eSameLayer,
                eLowerLayer,
                eHigherLayer
            };

            static LayerOrdering checkLayerOrdering(const HitPayload& hit1,
                                                    const HitPayload& hit2);
            void addVisualInfo(const PatternState& candidate, 
                               PatHitVisual::PatternStatus status,
                               std::vector<PatHitVisual>* visualInfo) const;

            struct PatternPrintView;
            static PatternPrintView brief(const PatternState& p);
            static PatternPrintView detailed(const PatternState& p);

            SpacePointPerLayerSorter m_spSorter{};

            Config m_cfg;
            std::unique_ptr<const Acts::Logger> m_logger{};
            const Acts::Logger& logger() const {
                return *m_logger;
            }
    };
}
 
#endif