BFieldCorFunc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MuonCalib_BFieldCorFuncH
#define MuonCalib_BFieldCorFuncH
namespace MuonCalib {
 
}
 
 
// STL //
#include <string>
#include <vector>
#include <limits>
 
// CLHEP //
#include "EventPrimitives/EventPrimitives.h"
 
// MuonCalib //
#include "MdtCalibData/IMdtBFieldCorFunc.h"
#include "MdtCalibData/IRtRelation.h"
 
namespace MuonCalib {
 
    class IRtRelation;
 
    
    class BFieldCorFunc : public IMdtBFieldCorFunc {
    public:
        // Constructors //
        explicit BFieldCorFunc(const std::string &quality, const CalibFunc::ParVec &parameters, const IRtRelation *rt);
        explicit BFieldCorFunc(const CalibFunc::ParVec &parameters, const IRtRelation *rt);
 
        // Methods //
        // get-methods //

        double epsilon() const;
 
        // set-methods //
        //  void setEpsilon(const double  eps);

        void setRtRelationship(const IRtRelation &rt);
 
        // methods required by the base class "IMdtBFieldCorFunc" //
        std::string name() const;  

        double correction(double t, double B_wire, double B_mu) const;

        double correction_to_B(double t, double B_wire, double B_mu, double B_factor = -1.0) const;
 
    private:
        // data //
 
        // parameters (copy of m_parameter in the base class, needed to enable overwriting)
        std::vector<double> m_param{};
 
        // quality setting //
        std::string m_quality{};  // quality string ("high", "medium", "low")
        double m_step_size{0.};     // integration step size steering the quality
 
        // correction function //
        Amg::VectorX m_alpha;  // parameter of the fit function describing the
                               // integral part of the correction function
 
 
        // information about r(t) used to calculate the correction function //
 
        // minimum and maximum drift times allowed by the r-t relationship
        double m_t_min{-std::numeric_limits<double>::max()};
        double m_t_max{std::numeric_limits<double>::max()};
        // minimum and maximum drift radius
        double m_r_min{-std::numeric_limits<double>::max()};
        double m_r_max{std::numeric_limits<double>::max()};
 
        // private methods //
        // initialization method, parameters are the parameters passed to constructor of this class
        void init(const std::string &quality, const CalibFunc::ParVec &params, const IRtRelation *rt);
 
        // get t(r) for the relationship "rt", the method is auxiliary and not optimized;
        // it will disappear when the t(r) will be available in the MuonCalib framework
        double t_from_r(const double r, const IRtRelation *rt) const;
 
        // get the integral in the correction function from r_min to r_max; rt contains the drift
        // velocity needed to calculate the integral
        double integral(const double r_min, const double r_max, const IRtRelation *rt) const;
    };
 
}  // namespace MuonCalib
 
#endif