RtResolutionLookUp.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONCALIB_RTRESOLUTIONLOOKUP_H
#define MUONCALIB_RTRESOLUTIONLOOKUP_H
 
#include <iostream>
 
#include "AthenaKernel/getMessageSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "MdtCalibData/IRtResolution.h"
 
namespace MuonCalib {
 
    class RtResolutionLookUp : public IRtResolution {
    public:
        explicit RtResolutionLookUp(const ParVec& vec) : IRtResolution(vec) {
            if (vec.size() < 4) {
                MsgStream log(Athena::getMessageSvc(), "RtResolutionLookUp");
                log << MSG::WARNING << "<to few parameters>" << endmsg;
            } else {
                m_t_min = par(0);
                m_bin_size = par(1);
            }
        }
 
        virtual std::string name() const override { return "RtResolutionLookUp"; }
 
        double resolution(double t, double) const override final;
        virtual unsigned int nDoF() const override final{
            return nPar() -2;
        }
 
        double tLower() const {
            return m_t_min;
        }
 
        double tUpper() const {
            return m_t_min +  m_bin_size * nDoF();
        }
 
    private:
        int getBin(double t) const { return static_cast<int>((t - m_t_min) / m_bin_size); }
 
        double getRadius(int bin) const { return par(bin + 2); }
        // returns best matching bin within rtRange
        int binInRtRange(double t) const;
 
        double m_t_min{9e9};
        double m_bin_size{1.};
    };
 
    inline double RtResolutionLookUp::resolution(double t, double) const {
        // get first bin
        int bin = binInRtRange(t);
 
        // shift bin so we are using the last two bins for extrapolation
        if (static_cast<unsigned>(bin) >= nDoF() - 1) bin = nDoF() - 2;
 
        double r1 = getRadius(bin);      // get bin value
        double r2 = getRadius(bin + 1);  // get value of next bin
        double dr = r2 - r1;
 
        // scale factor for interpolation
        double scale = (t - m_t_min) / m_bin_size - (double)bin;
 
        double reso = r1 + dr * scale;
        return reso >= 0 ? reso : 0;
    }
 
    inline int RtResolutionLookUp::binInRtRange(double t) const {
        // get bin
        int bin = getBin(t);
 
        // if t corresponds to a negative bin return first
        if (bin < 0) bin = 0;
 
        // if t corresponds to a bin outside the range of the lookup table return the last bin
        if (static_cast<unsigned>(bin) >= nDoF()) bin = nDoF() - 1;
 
        return bin;
    }
}  // namespace MuonCalib
#endif