MuonFastSegmentFittingAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_MUONFASTRECOALGS_MUONFASTSEGMENTFITTINGALG__H
#define MUONR4_MUONFASTRECOALGS_MUONFASTSEGMENTFITTINGALG__H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "StoreGate/WriteHandleKey.h"
 
#include "MuonFastRecoEvent/GlobalPattern.h"
#include "xAODMuon/MuonSegmentContainer.h"
 
#include "MuonRecToolInterfacesR4/ISpacePointCalibrator.h"
#include "MuonRecToolInterfacesR4/IxAODSegmentCnvTool.h"
#include "MuonPatternHelpers/SegmentLineFitter.h"
#include "MuonPatternHelpers/MdtSegmentSeedGenerator.h"
#include "MuonSpacePoint/SpacePointPerLayerSorter.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
 
namespace MuonR4{
 
    class MuonFastSegmentFittingAlg: public AthReentrantAlgorithm{
        public:
 
            using AthReentrantAlgorithm::AthReentrantAlgorithm;
            virtual ~MuonFastSegmentFittingAlg() = default;
 
            virtual StatusCode initialize() override;
            virtual StatusCode execute(const EventContext& ctx) const override;
 
        private:
            using StIndex = Muon::MuonStationIndex::StIndex;
            using Hit_t = const SpacePoint*;
            using HitVec_t = std::vector<Hit_t>;
            using Bucket_t = const SpacePointBucket*;
            using Seed_t = std::unique_ptr<SegmentSeed>;
            using Segment_t = std::unique_ptr<Segment>;
            using Parameters = SegmentFit::Parameters;
            using LineFitter = MuonR4::SegmentFit::SegmentLineFitter;
            using MdtSegmentSeeder = MuonR4::SegmentFit::MdtSegmentSeedGenerator;

            using SegmentSeedPair_t = std::pair<Seed_t, Segment_t>;
            using SegmentSeedOpt_t = std::optional<SegmentSeedPair_t>;
            
            std::vector<SegmentSeedPair_t> processPattern(const EventContext& ctx,
                                                          const ActsTrk::GeometryContext& gctx,
                                                          const GlobalPattern& pattern) const;
            SegmentSeedOpt_t fitSegment(const EventContext& ctx,
                                        const Amg::Transform3D& localToGlobal,
                                        Bucket_t parentBucket,
                                        HitVec_t&& hits) const;
            std::pair<HitVec_t, Parameters> initializePars(const Amg::Transform3D& localToGlobal,
                                                           const HitVec_t& hits) const;
            enum class CoordPlane : std::uint8_t {               
                etaPlane = 0,
                phiPlane = 1
            };

            enum class ParamDefs2D : std::uint8_t {
                slope = 0,
                intercept = 1,
                nParams = 2
            };

            struct Beamspot {
                double coord{0.};
                double z{0.};
                double cov_coordCoord{0.};
            };

            using Line2D_t = std::array<double, Acts::toUnderlying(ParamDefs2D::nParams)>;
            using RegressionRes_t = std::pair<HitVec_t, std::optional<Line2D_t>>;
            RegressionRes_t linearRegression(const CoordPlane Plane,
                                             const HitVec_t& hits,
                                             const std::optional<Beamspot>& beamspot = std::nullopt) const;
            const Segment* findSegmentToAddPhi(std::vector<SegmentSeedPair_t>& segs) const;
            double beamspotCov(const CoordPlane Plane, 
                               const Amg::Transform3D& localToGlobal) const;
 
            SG::ReadHandleKey<GlobalPatternContainer> m_inPatterns{this, "InPatterns", "MuonR4GlobalPatterns", "Global patterns to read"}; 
            SG::WriteHandleKey<xAOD::MuonSegmentContainer> m_outSegments{this, "OutSegments", "FastMuonSegments", "Segments to write"};

            using DecorKey_t = SG::WriteDecorHandleKey<xAOD::MuonSegmentContainer>;
            DecorKey_t m_patternKey{this, "ParentPatternKey", m_outSegments, "GlobalPatternLink", "Parent global pattern for the segments"};
            DecorKey_t m_localSegParKey{this, "LocalSegParKey", m_outSegments, "localSegPars"};
            DecorKey_t m_localSegCovKey{this, "LocalCovParKey", m_outSegments, "localSegCov"};
            DecorKey_t m_prdLinkKey{this, "PrdLinkKey",  m_outSegments, "prdLinks" };
            DecorKey_t m_prdStateKey{this, "PrdStateKey", m_outSegments, "prdState"};
            SG::WriteHandleKey<xAOD::CombinedMuonStripContainer> m_combMeasKey{this, "combinedPrdKey", "FastCombinedPrdKey"};
              
            ActsTrk::GeoContextReadKey_t m_geoCtxKey{this, "AlignmentKey", "ActsAlignment", "cond handle key"};        
            ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
            ToolHandle<ISpacePointCalibrator> m_calibTool{this, "Calibrator", "" };
            ToolHandle<IxAODSegmentCnvTool> m_segmentCnvTool{this, "SegmentCnvTool", ""};
            ToolHandle<MuonValR4::IPatternVisualizationTool> m_segVisionTool{this, "VisualizationTool", ""};

            BooleanProperty m_recalibInFit{this, "recalibInFit" , false};
            BooleanProperty m_hessianResidual{this, "useHessianResidual", false};
            DoubleProperty m_seedHitChi2{this, "ResoSeedHitAssoc", 5. };
            BooleanProperty m_recalibSeed{this, "SeedRecalibrate", false};
            DoubleProperty m_goodSegmentCut{this, "GoodSegmentCut", 2.};
            UnsignedIntegerProperty m_goodSegmentDoF{this, "GoodSegmentDoF", 5};
            DoubleProperty m_outlierRemovalCut{this, "OutlierRemoval", 3.};
            DoubleProperty m_recoveryPull{this, "RecoveryPull", 3.};
            UnsignedIntegerProperty m_precHitCut{this, "PrecHitCut" , 3};
            BooleanProperty m_useFastFitter{this, "useFastFitter", false};
            BooleanProperty m_fastPreFitter{this, "useFastPreFitter", false};
            BooleanProperty m_ignoreFailedPreFit{this, "ignoreFailedPreFit", false};
            UnsignedIntegerProperty m_maxIter{this, "maxIterations", 50};
            BooleanProperty m_beamSpotRadius{this, "BeamSpotRadius", 30.*Gaudi::Units::cm};
            BooleanProperty m_beamSpotLength{this, "BeamSpotLength", 2.*Gaudi::Units::m};

            SpacePointPerLayerSorter m_spSorter{};
            std::unique_ptr<LineFitter> m_fitter{};
            std::unique_ptr<LineFitter> m_nswFitter{};
            std::unique_ptr<MdtSegmentSeeder> m_mdtSeeder{};
            Acts::SquareMatrix<3> m_beamspotCov {Acts::SquareMatrix<3>::Zero()};
 
            friend std::ostream& operator<<(std::ostream& os, CoordPlane plane);
            friend std::ostream& operator<<(std::ostream& os, ParamDefs2D param);
            friend std::ostream& operator<<(std::ostream& os, const Line2D_t& line);
            friend std::ostream& operator<<(std::ostream& os, const Beamspot& bs);
    };
 
}
 
#endif