GlobalPatternFinderDefs.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_FASTRECONSTRUCTIONALGS_PATTERNFINDERUTILITIES__H
#define MUONR4_FASTRECONSTRUCTIONALGS_PATTERNFINDERUTILITIES__H
 
#include "MuonFastRecoHelpers/GlobalPatternFinder.h"
 
#include "MuonRecToolInterfacesR4/IFastRecoVisualizationTool.h"
#include "MuonSpacePoint/SpacePoint.h"
#include "MuonTrackEvent/ExpandedSector.h"
 
namespace MuonR4::FastReco{
    using StIndex = GlobalPatternFinder::StIndex;
 
    static const SpacePointPerLayerSorter s_spSorter{};

    struct GlobalPatternFinder::HitPayload{
        explicit HitPayload(const Acts::GeometryContext& gctx,
                            const SpacePoint* sp,
                            const SpacePointBucket* bucket,
                            const Amg::Transform3D& localToGlobal);
        Amg::Vector3D sensorDir(const Acts::GeometryContext& gctx) const;

        double residualVariance(const Acts::GeometryContext& gctx, 
                                const Amg::Vector3D& contractionVector, 
                                const bool isProjected) const;

        Amg::Vector3D position{Amg::Vector3D::Zero()};
        const SpacePoint* spacePoint{nullptr};
        const SpacePointBucket* bucket{nullptr};
        double phiCov{0.};
        double stripAngle{0.};
        StIndex station{toStationIndex(spacePoint->msSector()->chamberIndex())};
        uint8_t locLayer{static_cast<uint8_t>(s_spSorter.sectorLayerNum(*spacePoint))};
        bool isPrecision{isPrecisionHit(*spacePoint)};
        bool nonOrthogonalStrips{false};
        bool operator==(const HitPayload& other) const;
        const SpacePoint* operator->() const { return spacePoint; }
        const SpacePoint& operator*() const { return *spacePoint; }
    };

    struct GlobalPatternFinder::SearchTreeData {
        std::vector<HitPayload> stripPayloads;
        SearchTree_t tree;
    };

    struct GlobalPatternFinder::CandidateHit {
        const HitPayload* hit{nullptr};
        uint8_t globLayer{0u};
        // Forward commonly used accessors for convenience
        const HitPayload* operator->() const { return hit; }
        const HitPayload& operator*() const { return *hit; }
        const SpacePoint* sp() const { return hit->spacePoint; }
        bool operator==(const CandidateHit& other) const { return *hit == *other.hit; }
        bool operator==(const HitPayload& other) const { return *hit == other; }
        // Print and stream operator
        friend std::ostream& operator<<(std::ostream& ostr, const CandidateHit& c) {
            c.print(ostr);
            return ostr;
        }
        void print(std::ostream& ostr) const;
    };
        
    enum class LineTestDecision : std::int8_t{
        eAddHit,
        eBranchPattern,
        eRejectHit
    };

    struct LineTestRes  {
        double residual{0.};
        double sigma{0.};
        LineTestDecision result {LineTestDecision::eRejectHit};
    };

    struct GlobalPatternFinder::PatternState {
        explicit PatternState(const CandidateHit& seed,
                              const std::int8_t expSector,
                              const Config* cfg,
                              const Acts::Logger* logger);
        PatternState(PatternState&& other) noexcept = default;
        PatternState& operator=(PatternState&& other) noexcept = default;
        PatternState(const PatternState& other) = default;
        PatternState& operator=(const PatternState& other) = default;
        ~PatternState() =default;
        void addHit(const CandidateHit& hit,
                    const double residual,
                    const double resSigma);
        void overWriteHit(const CandidateHit& newHit,
                            const double newResidual,
                            const double newResSigma);
        LineTestRes checkLineComp(const Acts::GeometryContext& gctx,
                                  const CandidateHit& testHit,
                                  const Amg::Vector3D& beamSpot);
        LineTestRes computeLineResidual(const Acts::GeometryContext& gctx,
                                        const CandidateHit& testHit) const;
        Amg::Vector3D projToPhiPlane(const Acts::GeometryContext& gctx,
                                     const HitPayload& hit) const;
        bool isPhiCompatible(const HitPayload& hit) const;
        bool isInPattern(const HitPayload& hit) const;
        void moveLineAnchorHit(const CandidateHit& refHit);
        void updateLineParameters(const Acts::GeometryContext& gctx,
                                  const Amg::Vector3D& beamSpot);
        void updatePatternPhi();
        double getMeanResidual2() const;
        uint8_t nBendingLayers() const;
        uint8_t nStations(const bool onlyGoodStations) const;
        std::vector<const SpacePointBucket*> getParentBuckets() const;
        const Acts::Logger& logger() const {
            return *m_logger;
        }

        const Config* cfg{nullptr};
        const Acts::Logger* m_logger{nullptr};
        Acts::CloneablePtr<PatHitVisual> visualInfo{nullptr};
        CandidateHit lastInsertedHit{};
        CandidateHit prevLayerHit{};
        CandidateHit lineAnchorHit{};
        Amg::Vector3D bendPlaneNorm{Amg::Vector3D::Zero()};
        Amg::Vector3D linePos{Amg::Vector3D::Zero()};
        Amg::Vector3D lineDir{Amg::Vector3D::Zero()};
        double leverArm{0.};
        double meanNormResidual2{0.};
        double lastResidual{0.};
        double lastResSigma{0.};
        double patPhi{0.};
        double patTheta{0.};
        double patPhiCov{0.};
        ExpandedSector expSect{static_cast<int8_t>(0)};
        uint8_t nPrecisionLayers{0u};
        uint8_t nTriggerLayers{0u};
        uint8_t nPhiLayers{0u};
        bool isFinalized{false};
        bool isOverlap{false};
        bool useBeamspot{false};
        bool needLineUpdate{false};
        
        std::array<std::vector<CandidateHit>, s_nStations> hitsPerStation{};
        std::vector<HitPayload> phiOnlyHits{};

        bool operator==(const PatternState& other) const = delete;
        void print(std::ostream& ostr, bool detailed) const;
    };

    struct GlobalPatternFinder::PatternPrintView {
        const PatternState& pat;
        bool detailed = false;

        friend std::ostream& operator<<(std::ostream& os, const PatternPrintView& v) {
            v.pat.print(os, v.detailed);
            return os;
        }
    };
    
}
 
#endif