MdtSegmentFitter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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 <MuonPatternEvent/SegmentSeed.h>
#include <MuonPatternEvent/SegmentFitterEventData.h>
#include <MuonPatternHelpers/MatrixUtils.h>
#include <GaudiKernel/SystemOfUnits.h>
 
 
namespace MuonR4{
    class ISpacePointCalibrator;
    class MdtSegmentFitter: public AthMessaging{
        public:
            using ParamDefs = SegmentFit::ParamDefs;
            using Parameters = SegmentFit::Parameters;
            using HitType = std::unique_ptr<CalibratedSpacePoint>;
            using HitVec = std::vector<HitType>;
 
            struct Config{
                unsigned int nMaxCalls{100};
                double tolerance{1.e-7};
                bool doTimeFit{true};
                bool reCalibrate{false};
                bool useSecOrderDeriv{false};
                unsigned int nParsOutOfBounds{1};
                const ISpacePointCalibrator* calibrator{nullptr};
                unsigned int noMoveIter{2};
                using RangeArray = std::array<std::array<double,2>, SegmentFit::toInt(ParamDefs::nPars)>;
                static RangeArray defaultRanges();
 
                RangeArray ranges{defaultRanges()};
                
            };
            struct LineWithPartials{
                static constexpr unsigned nPars{4};
                Amg::Vector3D pos{Amg::Vector3D::Zero()};
                Amg::Vector3D dir{Amg::Vector3D::Zero()};
                std::array<Amg::Vector3D, nPars> gradient{make_array<Amg::Vector3D, nPars>(Amg::Vector3D::Zero())};
                std::array<Amg::Vector3D, sumUp(nPars)> hessian{make_array<Amg::Vector3D, sumUp(nPars)>(Amg::Vector3D::Zero())};
            };
            struct ResidualAuxillaries{
                static constexpr unsigned nLinePars = LineWithPartials::nPars;
                Amg::Vector3D projDir{Amg::Vector3D::Zero()};
                std::array<Amg::Vector3D, nLinePars> partProjDir{make_array<Amg::Vector3D, nLinePars>(Amg::Vector3D::Zero())};
                std::array<double, nLinePars> partWirePlaneProj{make_array<double, nLinePars>(0.)};
                double projIntoWirePlane{0.};
                double projDirLenSq{0.};
                double invProjLenSq{0.};
                double invProjLen{0.};
 
            };
            struct ResidualWithPartials: public ResidualAuxillaries{
                static constexpr unsigned nPars{toInt(ParamDefs::nPars)};
                Amg::Vector3D residual{Amg::Vector3D::Zero()};
                std::array<Amg::Vector3D, nPars> gradient{make_array<Amg::Vector3D, nPars>(Amg::Vector3D::Zero())};
                std::array<Amg::Vector3D, sumUp(nPars)> hessian{make_array<Amg::Vector3D, sumUp(nPars)>(Amg::Vector3D::Zero())};
                bool evalPhiPars{true};
            };
 
            MdtSegmentFitter(const std::string& name,
                             Config&& config);
            
            SegmentFitResult fitSegment(const EventContext& ctx,
                                        HitVec&& calibHits,
                                        const Parameters& startPars,
                                        const Amg::Transform3D& localToGlobal) const;
        private:
            Config m_cfg{};
            bool recalibrate(const EventContext& ctx,
                             SegmentFitResult& fitResult) const;
            bool updateHitSummary(SegmentFitResult& fitResult) const;
        public:
            static void updateLinePartials(const Parameters& fitPars, 
                                           LineWithPartials& line);
            void calculateWireResiduals(const LineWithPartials& line,
                                        const CalibratedSpacePoint& spacePoint,
                                        ResidualWithPartials& residual) const;
            void calculateStripResiduals(const LineWithPartials& line,
                                        const CalibratedSpacePoint& spacePoint,
                                        ResidualWithPartials& residual) const;
        private:   
            void updateDriftSigns(const Amg::Vector3D& segPos, const Amg::Vector3D& segDir, 
                                  SegmentFitResult& fitRes)const;
            using MeasCov_t = CalibratedSpacePoint::Covariance_t;
            void updateDerivatives(const ResidualWithPartials& fitMeas,
                                   const MeasCov_t& measCovariance,
                                   AmgVector(5)& gradient,
                                   AmgSymMatrix(5)& hessian,
                                   double& chi2,
                                   int startPar) const;
            
 
            enum class UpdateStatus{
                allOkay = 0,
                outOfBounds = 1,
                noChange = 2,
            };
            template <unsigned int nDim>
                UpdateStatus updateParameters(Parameters& currentPars,
                                              Parameters& previousPars,
                                              Parameters& currGrad,
                                              Parameters& prevGrad,
                                              const AmgSymMatrix(5)& hessian) const;
            
            template <unsigned int nDim>
                void blockCovariance(const AmgSymMatrix(5)& hessian,                                    
                                     SegmentFit::Covariance&  covariance) const;
 
 
    };
}
 
 
#endif