SegmentFittingAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_MUONPATTERNRECOGNTIONALGS_SEGMENTFITTINGALG__H
#define MUONR4_MUONPATTERNRECOGNTIONALGS_SEGMENTFITTINGALG__H
 
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/ReadDecorHandleKeyArray.h"
 
 
#include "MuonSpacePoint/CalibratedSpacePoint.h"
#include "MuonRecToolInterfacesR4/ISpacePointCalibrator.h"
#include "MuonRecToolInterfacesR4/IPatternVisualizationTool.h"
 
#include "MuonPatternEvent/MuonPatternContainer.h"
#include "MuonPatternEvent/SegmentFitterEventData.h"
#include "MuonPatternEvent/MuonHoughDefs.h"
 
#include "MuonPatternHelpers/SegmentAmbiSolver.h"
#include "MuonPatternHelpers/SegmentLineFitter.h"
#include "MuonPatternHelpers/MdtSegmentSeedGenerator.h"
 
 
namespace MuonR4 {
    class SegmentFittingAlg: public AthReentrantAlgorithm {
        public:
            using AthReentrantAlgorithm::AthReentrantAlgorithm;
            virtual ~SegmentFittingAlg();
            virtual StatusCode initialize() override;
            virtual StatusCode execute(const EventContext& ctx) const override;
        private:
            using SegmentVec_t = std::vector<std::unique_ptr<Segment>>;
 
            using Parameters = SegmentFit::Parameters;
            SegmentVec_t fitSegmentSeed(const EventContext& ctx,
                                        const ActsTrk::GeometryContext& gctx,
                                        const SegmentSeed* seed) const;             
            void resolveAmbiguities(const ActsTrk::GeometryContext& gctx,
                                    SegmentVec_t& segmentCandidates) const;
 

            std::optional<SpacePointPerLayerSplitter::HitVec> makeBilRecoveryHits(const SegmentSeed& seed) const;
            std::optional<SpacePointPerLayerSplitter::HitVec> makeBimBirRecoveryHits( const SegmentSeed& seed) const;

            SG::ReadHandleKey<SegmentSeedContainer> m_seedKey{this, "ReadKey", "MuonHoughStationSegmentSeeds"};
            // write handle key for the output segment seeds 
            SG::WriteHandleKey<SegmentContainer> m_outSegments{this, "OutSegmentContainer", "R4MuonSegments"};
            // access to the ACTS geometry context 
            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<MuonValR4::IPatternVisualizationTool> m_visionTool{this, "VisualizationTool", ""};
 
            Gaudi::Property<bool> m_doT0Fit{this, "fitSegmentT0", true};
            Gaudi::Property<bool> m_recalibInFit{this, "recalibInFit" , false};
            Gaudi::Property<bool> m_tryPatternPars{this, "tryPatternPars", false};
            Gaudi::Property<bool> m_hessianResidual{this, "useHessianResidual", false};
            Gaudi::Property<bool> m_doBeamspotConstraint{this, "doBeamspotConstraint", false};
            Gaudi::Property<double> m_beamSpotR{this, "BeamSpotRadius", 30.* Gaudi::Units::cm};
            Gaudi::Property<double> m_beamSpotL{this, "BeamSpotLength", 2. * Gaudi::Units::m};
            static constexpr auto s_stIdxMax = Acts::toUnderlying(Muon::MuonStationIndex::StIndex::StIndexMax);
            Gaudi::Property<std::vector<double>> m_seedMaxBsR{this, "SeedMaxDistanceBsRadius", 
                                                              std::vector<double>(s_stIdxMax, 2.)};
            Gaudi::Property<std::vector<double>> m_seedMaxBsL{this, "SeedMaxDistanceBsLength", 
                                                              std::vector<double>(s_stIdxMax, 2.)};

            Gaudi::Property<double> m_seedHitChi2{this, "ResoSeedHitAssoc", 5. };
            Gaudi::Property<bool> m_recalibSeed{this, "SeedRecalibrate", false};
            Gaudi::Property<double> m_outlierRemovalCut{this, "OutlierRemoval", 5.};
            Gaudi::Property<double> m_recoveryPull{this, "RecoveryPull", 5.};
            Gaudi::Property<unsigned> m_precHitCut{this, "PrecHitCut" , 3};
            Gaudi::Property<bool> m_useFastFitter{this, "useFastFitter", true};
            Gaudi::Property<bool> m_fastPreFitter{this, "useFastPreFitter", false};
            Gaudi::Property<bool> m_ignoreFailedPreFit{this, "ignoreFailedPreFit", false};
            Gaudi::Property<unsigned> m_maxIter{this, "maxIterations", 50};
            Gaudi::Property<unsigned> m_busyLayerLimit{this, "busyLayerLimit",  4};
            std::unique_ptr<SegmentFit::SegmentAmbiSolver> m_ambiSolver{};
            std::unique_ptr<SegmentFit::SegmentLineFitter> m_fitter{};
            std::unique_ptr<SegmentFit::MdtSegmentSeedGenerator> m_seeder{};

            Gaudi::Property<bool> m_allowSegmentSeedingFallback{this, "allowSegmentSeedingFallback", true};

            Gaudi::Property<double> m_singleMlEdgeTolerance{ this, "SingleMlEdgeTolerance", 50. * Gaudi::Units::mm, "For Single-ML fallback to not trigger, the trajectory has to penetrate at least this much into the second multilayer (from either side) in local precision coordinate"};

            Gaudi::Property<double> m_singleMlPhiEdgeTolerance{ this, "SingleMlPhiEdgeTolerance", 0. * Gaudi::Units::mm, "For Single-ML fallback to not trigger, the trajectory has to penetrate at least this much into the second multilayer (from either side) in local phi coordinate"};

            int m_bilStation{-1};
            int m_bimStation{-1};
            int m_birStation{-1};
 
    };
}
 
 
#endif