MuonCalib::RtChebyshev Class Reference

This class contains the implementation of an r(t) relationship parametrized by a linear combination of Chebyshev polyonomials. More...

#include <RtChebyshev.h>

Inheritance diagram for MuonCalib::RtChebyshev:

Collaboration diagram for MuonCalib::RtChebyshev:

Public Types
using	ParVec = std::vector<double>

Public Member Functions
	RtChebyshev (const ParVec &vec)
	initialization constructor,
virtual std::string	name () const override final
	get the class name
virtual double	radius (double t) const override final
	get the drift velocity
virtual double	driftVelocity (double t) const override final
	get the drift acceleration
virtual double	driftAcceleration (double t) const override final
	Returns the acceleration of the r-t relation.
virtual double	tLower () const override final
	< get the lower drift-time bound
virtual double	tUpper () const override final
	Returns the upper time covered by the r-t.
virtual double	tBinWidth () const override final
	Returns the step-size for the sampling.
virtual unsigned	nDoF () const override final
	get the coefficients of the r(t) polynomial
std::vector< double >	rtParameters () const
virtual std::string	typeName () const override final
double	GetTmaxDiff () const
	return the difference in total dirft time between the two multilayers (ML1 - ML2)
bool	hasTmaxDiff () const
void	SetTmaxDiff (const double d)
	set the difference in total drift time betwene the two multilayers (ML1 - ML2)
double	getReducedTime (const double t) const
	map the in the interval [tLower;tUpper] onto the interval [-1.;1.
double	dReducedTimeDt () const
	CalibFunc (const ParVec &vec)
unsigned int	nPar () const
const ParVec &	parameters () const
double	par (unsigned int index) const

Static Protected Attributes
static constexpr double	s_tBinWidth = 1.e-3

Private Attributes
std::optional< double >	m_tmax_diff {std::nullopt}
ParVec	m_parameters {}

Detailed Description

This class contains the implementation of an r(t) relationship parametrized by a linear combination of Chebyshev polyonomials.

Convention:

\[ r(t) = \sum_{k=0}^{K} p_k*T_k(2*(t-0.5*(tupper+tlower))/(tupper-tlower) \]

where T_k is the Chebyshev polynomial of k-th order, tupper and tlower are upper and lower drift-time bounds.

Units: [t] = ns, [r] = mm, [v] = mm/ns.

Definition at line 29 of file RtChebyshev.h.

Member Typedef Documentation

ParVec

using MuonCalib::CalibFunc::ParVec = std::vector<double>

inherited

Definition at line 35 of file CalibFunc.h.

Constructor & Destructor Documentation

RtChebyshev()

RtChebyshev::RtChebyshev ( const ParVec & vec )

explicit

initialization constructor,

size of ParVec - 2 = order of the r(t) polynomial,

ParVec[0] = t_low (smallest allowed drift time), ParVec[1] = t_up (largest allowed drift time). ParVec[2...] = parameters of the Chebyshev polynomial

Definition at line 9 of file RtChebyshev.cxx.

                                          : 
    IRtRelation(vec) { 
    // check for consistency //
    if (nPar() < 3) {
        THROW_EXCEPTION("RtChebyshev::_init() - Not enough parameters!");
    }
    if (tLower() >= tUpper()) {
        THROW_EXCEPTION("Lower time boundary ("<<tLower()<<")>= upper time ("<<tUpper()<<") boundary!");
    }
}  // end RtChebyshev::_init

Member Function Documentation

CalibFunc()

MuonCalib::CalibFunc::CalibFunc ( const ParVec & vec )

inlineexplicitinherited

Definition at line 36 of file CalibFunc.h.

                                                  : 
                    m_parameters{vec} {}

dReducedTimeDt()

double MuonCalib::IRtRelation::dReducedTimeDt ( ) const

inlineinherited

Definition at line 53 of file IRtRelation.h.

                                      {
            return unitIntervalPrime(tLower(), tUpper());
        }

driftAcceleration()

double RtChebyshev::driftAcceleration ( double t ) const

finaloverridevirtual

Returns the acceleration of the r-t relation.

Implements MuonCalib::IRtRelation.

Definition at line 62 of file RtChebyshev.cxx.

                                                    {
    double acc{0.};
    // Argument of the Chebyshev polynomials
    const double x = getReducedTime(t);
    const double dx_dt = std::pow(dReducedTimeDt(), 2);
    for (unsigned int k = 2; k < nDoF(); ++k) {
        acc += par(k+2) *  chebyshevPoly1st2Prime(k, x) * dx_dt;
    }
    return acc * t;
}

driftVelocity()

double RtChebyshev::driftVelocity ( double t ) const

finaloverridevirtual

get the drift acceleration

Implements MuonCalib::IRtRelation.

Definition at line 47 of file RtChebyshev.cxx.

                                                { 
    // Set derivative to 0 outside of the bounds
    if (t < tLower() || t > tUpper()) return 0.0;
 
    // Argument of the Chebyshev polynomials
    const double x = getReducedTime(t);
    // Chain rule
    const double dx_dt = dReducedTimeDt();
    double drdt{0.};
    for (unsigned int k = 1; k < nDoF(); ++k) {
        // Calculate the contribution to dr/dt using k * U_{k-1}(x) * dx/dt
        drdt += par(k+2) *  chebyshevPoly1stPrime(k, x) * dx_dt;
    }
    return drdt; 
}

getReducedTime()

double MuonCalib::IRtRelation::getReducedTime ( const double t ) const

inlineinherited

map the in the interval [tLower;tUpper] onto the interval [-1.;1.

] where tLower is mapped to -1. & tUpper to 1.;

Definition at line 49 of file IRtRelation.h.

                                                     {
           return mapToUnitInterval(t, tLower(), tUpper());
        }

GetTmaxDiff()

double MuonCalib::IRtRelation::GetTmaxDiff ( ) const

inlineinherited

return the difference in total dirft time between the two multilayers (ML1 - ML2)

Definition at line 40 of file IRtRelation.h.

{ return m_tmax_diff.value_or(0.); }

hasTmaxDiff()

bool MuonCalib::IRtRelation::hasTmaxDiff ( ) const

inlineinherited

Definition at line 42 of file IRtRelation.h.

{ return m_tmax_diff.has_value(); }

name()

std::string RtChebyshev::name ( ) const

finaloverridevirtual

get the class name

get the radius corresponding to the drift time t; if t is not within [t_low, t_up] an unphysical radius of 99999 is returned

Implements MuonCalib::CalibFunc.

Definition at line 20 of file RtChebyshev.cxx.

{ return "RtChebyshev"; }

nDoF()

unsigned RtChebyshev::nDoF ( ) const

finaloverridevirtual

get the coefficients of the r(t) polynomial

Implements MuonCalib::IRtRelation.

Definition at line 74 of file RtChebyshev.cxx.

{ return nPar() -2; }

nPar()

unsigned int MuonCalib::CalibFunc::nPar ( ) const

inlineinherited

Definition at line 39 of file CalibFunc.h.

{ return m_parameters.size(); }

par()

double MuonCalib::CalibFunc::par ( unsigned int index ) const

inlineinherited

Definition at line 41 of file CalibFunc.h.

                                                 {
                return index < nPar() ? m_parameters[index] : 0.;
            }

parameters()

const ParVec & MuonCalib::CalibFunc::parameters ( ) const

inlineinherited

Definition at line 40 of file CalibFunc.h.

{ return m_parameters; }

radius()

double RtChebyshev::radius ( double t ) const

finaloverridevirtual

get the drift velocity

Implements MuonCalib::IRtRelation.

Definition at line 23 of file RtChebyshev.cxx.

                                         {
    // INITIAL TIME CHECK //
    if (t < tLower()) return 0.0;
    if (t > tUpper()) return 14.6;
 
    // VARIABLES //
    // argument of the Chebyshev polynomials
    double x = getReducedTime(t);
    double rad{0.0};  // auxiliary radius

    // CALCULATE r(t) //
    for (unsigned int k = 0; k < nDoF(); k++) { 
        rad += par(k+2) * chebyshevPoly1st(k, x); 
    }
    return std::max(rad, 0.);
}

rtParameters()

std::vector< double > RtChebyshev::rtParameters

(

)

const

Definition at line 76 of file RtChebyshev.cxx.

                                                  {
    return std::vector<double>{parameters().begin() +2, parameters().end()};
}

SetTmaxDiff()

void MuonCalib::IRtRelation::SetTmaxDiff ( const double d )

inlineinherited

set the difference in total drift time betwene the two multilayers (ML1 - ML2)

Definition at line 45 of file IRtRelation.h.

{ m_tmax_diff = d; }

tBinWidth()

double RtChebyshev::tBinWidth ( ) const

finaloverridevirtual

Returns the step-size for the sampling.

Implements MuonCalib::IRtRelation.

Definition at line 21 of file RtChebyshev.cxx.

{ return s_tBinWidth; }

tLower()

double RtChebyshev::tLower ( ) const

finaloverridevirtual

< get the lower drift-time bound

get the upper drift-time bound

Implements MuonCalib::IRtRelation.

Definition at line 72 of file RtChebyshev.cxx.

{ return par(0); }

tUpper()

double RtChebyshev::tUpper ( ) const

finaloverridevirtual

Returns the upper time covered by the r-t.

Implements MuonCalib::IRtRelation.

Definition at line 73 of file RtChebyshev.cxx.

{ return par(1); }

typeName()

virtual std::string MuonCalib::IRtRelation::typeName ( ) const

inlinefinaloverridevirtualinherited

Implements MuonCalib::CalibFunc.

Definition at line 23 of file IRtRelation.h.

{ return "IRtRelation"; }

Member Data Documentation

m_parameters

ParVec MuonCalib::CalibFunc::m_parameters {}

privateinherited

Definition at line 48 of file CalibFunc.h.

{};

m_tmax_diff

std::optional<double> MuonCalib::IRtRelation::m_tmax_diff {std::nullopt}

privateinherited

Definition at line 58 of file IRtRelation.h.

{std::nullopt};

s_tBinWidth

double MuonCalib::IRtRelation::s_tBinWidth = 1.e-3

staticconstexprprotectedinherited

Definition at line 60 of file IRtRelation.h.

---

The documentation for this class was generated from the following files:

• RtChebyshev.h
• RtChebyshev.cxx