SegmentFittingAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_MUONPATTERNRECOGNTIONALGS_SEGMENTFITTINGALG__H
#define MUONR4_MUONPATTERNRECOGNTIONALGS_SEGMENTFITTINGALG__H
 
#include "MuonPatternEvent/MuonPatternContainer.h"
 
#include "MuonSpacePoint/CalibratedSpacePoint.h"
#include "MuonRecToolInterfacesR4/ISpacePointCalibrator.h"
#include "MuonRecToolInterfacesR4/IPatternVisualizationTool.h"
 
#include "xAODMeasurementBase/UncalibratedMeasurementContainer.h"
#include "MuonPatternEvent/SegmentFitterEventData.h"
#include "MuonPatternEvent/MuonHoughDefs.h"
#include "MuonPatternHelpers/SegmentAmbiSolver.h"
 
#include "xAODMuon/MuonSegmentContainer.h"
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/ReadDecorHandleKeyArray.h"
 
#include <set>
 
 
namespace MuonR4{
    class SegmentFittingAlg: public AthReentrantAlgorithm{
        public:
            using AthReentrantAlgorithm::AthReentrantAlgorithm;
            virtual ~SegmentFittingAlg();
            virtual StatusCode initialize() override;
            virtual StatusCode execute(const EventContext& ctx) const override;
 
            using HitVec = SegmentFitResult::HitVec;
 
        private:
            using Parameters = SegmentFit::Parameters;
            template <class ContainerType> StatusCode retrieveContainer(const EventContext& ctx,
                                                                        const SG::ReadHandleKey<ContainerType>& key,
                                                                        const ContainerType* & contToPush) const;
            SegmentFitResult fitSegmentHits(const EventContext& ctx,
                                            const ActsGeometryContext& gctx,
                                            const Parameters& startPars,
                                            SegmentFitResult::HitVec&& calibHits) const;
 
 
            std::vector<std::unique_ptr<Segment>> fitSegmentSeed(const EventContext& ctx,
                                                                 const ActsGeometryContext& gctx,
                                                                 const SegmentSeed* seed) const;             
            bool removeOutliers(const EventContext& ctx,
                                const ActsGeometryContext& gctx,
                                const SegmentSeed& seed,
                                SegmentFitResult& fitResult) const;
 
            bool plugHoles(const EventContext& ctx,
                           const ActsGeometryContext& gctx,
                           const SegmentSeed& seed,
                           SegmentFitResult& toRecover) const;
            void eraseWrongHits(SegmentFitResult& candidate) const;            
            static std::unique_ptr<Segment> convertToSegment(const Amg::Transform3D& locToGlobTrf, 
                                                             const SegmentSeed* parentSeed,
                                                             SegmentFitResult&& toConvert);
           
            void resolveAmbiguities(const ActsGeometryContext& gctx,
                                    std::vector<std::unique_ptr<Segment>>& segmentCandidates) const;
 
            SG::ReadHandleKey<SegmentSeedContainer> m_seedKey{this, "ReadKey", "MuonHoughStationSegmentSeeds"};
            // write handle key for the output segment seeds 
            SG::WriteHandleKey<SegmentContainer> m_outSegments{this, "MuonSegmentContainer", "R4MuonSegments"};
            // access to the ACTS geometry context 
            SG::ReadHandleKey<ActsGeometryContext> 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_doBeamspotConstraint{this, "doBeamspotConstraint", false};
            Gaudi::Property<double> m_beamSpotR{this, "BeamSpotRadius", 30.* Gaudi::Units::cm};
            Gaudi::Property<double> m_beamSpotL{this, "BeamSpotLength", 20. * Gaudi::Units::m};
 
            
            Gaudi::Property<double> m_seedHitChi2{this, "ResoSeedHitAssoc", 5. };
            Gaudi::Property<bool> m_recalibSeed{this, "SeedRecalibrate", false};
            Gaudi::Property<bool> m_refineSeed{this, "SeedRefine", false};
            Gaudi::Property<double> m_outlierRemovalCut{this, "OutlierRemoval", 5.};
            Gaudi::Property<double> m_recoveryPull{this, "RecoveryPull", 5.};
 
            std::unique_ptr<SegmentAmbiSolver> m_ambiSolver{};
 
    };
}
 
 
#endif