SegmentLineFitter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONPATTERNHELPERS_MDTSEGMENTFITTER_H
#define MUONPATTERNHELPERS_MDTSEGMENTFITTER_H
 
#include <GeoPrimitives/GeoPrimitives.h>
#include <AthenaBaseComps/AthMessaging.h>
 
#include <MuonSpacePoint/CalibratedSpacePoint.h>
#include <MuonRecToolInterfacesR4/ISpacePointCalibrator.h>
#include <MuonRecToolInterfacesR4/IPatternVisualizationTool.h>
 
 
#include <MuonPatternEvent/Segment.h>
#include <MuonPatternEvent/SegmentSeed.h>
 
 
#include <Acts/Seeding/CompositeSpacePointLineFitter.hpp>
 
namespace MuonR4::SegmentFit {
    class SegmentLineFitter: public AthMessaging {
        public:
            using Fitter_t = Acts::Experimental::CompositeSpacePointLineFitter;
            using LinePar_t = Fitter_t::ParamVec_t; 
            using Hit_t = std::unique_ptr<CalibratedSpacePoint>;
            using HitVec_t = std::vector<Hit_t>;
            using FitPars_t = Fitter_t::FitParameters;
            using Result_t = Fitter_t::FitResult<HitVec_t>;
            using FitOpts_t = Fitter_t::FitOptions<HitVec_t, ISpacePointCalibrator>;
            using Selector_t = Fitter_t::Selector_t<CalibratedSpacePoint>;
            using HitState = CalibratedSpacePoint::State;
            struct ConfigSwitches{
                const ISpacePointCalibrator* calibrator{nullptr};
                const MuonValR4::IPatternVisualizationTool* visionTool{nullptr};
                const Muon::IMuonIdHelperSvc* idHelperSvc{nullptr};
                bool doBeamSpot{true};
                double beamSpotRadius{30.*Gaudi::Units::cm};
                double beamSpotLength{2.*Gaudi::Units::m};
                double outlierRemovalCut{5.};
                double recoveryPull{5.};
                unsigned nPrecHitCut{3u};
                unsigned nRecoveryLoops{10u};
            };
           
            struct Config : public Fitter_t::Config,
                            public ConfigSwitches {
                static RangeArray defaultRanges();
                Config() {
                    ranges = defaultRanges();
                }
 
            };

            SegmentLineFitter(const std::string& name,
                             Config&& config);

            std::unique_ptr<Segment> fitSegment(const EventContext& ctx,
                                                const SegmentSeed* parent,
                                                const LinePar_t& startPars,
                                                const Amg::Transform3D& localToGlobal,
                                                HitVec_t&& calibHits) const;
 
        private:
            Fitter_t m_fitter;
            ConfigSwitches m_cfg{};
            Selector_t m_goodHitSel{};
            void centerAlongWire(Result_t& fitResult) const;
            Result_t callLineFit(const Acts::CalibrationContext& cctx,
                                 const Parameters& startPars,
                                 const Amg::Transform3D& localToGlobal,
                                 HitVec_t&& calibHits) const;
            bool removeOutliers(const Acts::CalibrationContext& cctx,
                                const SegmentSeed& seed,
                                const Amg::Transform3D& localToGlobal,
                                Result_t& fitResult) const;
            bool plugHoles(const Acts::CalibrationContext& cctx,
                           const SegmentSeed& seed,
                           const Amg::Transform3D& localToGlobal,
                           Result_t& toRecover) const;
            void eraseWrongHits(Result_t& candidate) const;
            void cleanStripLayers(const Amg::Vector3D& linePos,
                                  const Amg::Vector3D& lineDir,
                                  HitVec_t& hits) const;
            std::unique_ptr<Segment> convertToSegment(const Amg::Transform3D& locToGlobTrf, 
                                                      const SegmentSeed* parentSeed,
                                                      Result_t&& toConvert) const;
 
    };  
}
 
 
#endif