MuonCalib::RtResolutionChebyshev Class Reference

#include <RtResolutionChebyshev.h>

Inheritance diagram for MuonCalib::RtResolutionChebyshev:

Collaboration diagram for MuonCalib::RtResolutionChebyshev:

Public Types
typedef std::vector< double >	ParVec

Public Member Functions
	RtResolutionChebyshev (const ParVec &vec)
	initialization constructor, More...
std::string	name (void) const
	get the class name More...
double	resolution (double t, double bgRate=0.0) const
	returns resolution for a give time and background rate More...
double	tLower (void) const
	< get the lower drift-time bound More...
double	tUpper (void) const
	get the number of parameters used to describe the resolution More...
unsigned int	numberOfResParameters (void) const
	get the coefficients of the r(t) polynomial More...
std::vector< double >	resParameters (void) const
	get the reduced time which is the argument of the Chebyshev polynomial More...
double	get_reduced_time (const double &t) const
virtual std::string	typeName () const
unsigned int	nPar () const
const ParVec &	parameters () const
double	par (unsigned int index) const

Private Member Functions
void	_init (void)
	initialization method More...

Private Attributes
const Tschebyscheff_polynomial *	m_Chebyshev
	pointer to the Chebyshev polynomials More...
ParVec	m_parameters

Detailed Description

This class contains the implementation of a spatial resolution \( \sigma \) parametrized by a linear combination of Chebyshev polyonomials.

Convention:

\[ \sigma(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.

Author

Olive.nosp@m.r.Ko.nosp@m.rtner.nosp@m.@cer.nosp@m.n.ch

Date

05.06.2006

Definition at line 50 of file RtResolutionChebyshev.h.

Member Typedef Documentation

ParVec

typedef std::vector<double> MuonCalib::CalibFunc::ParVec

inherited

Definition at line 36 of file CalibFunc.h.

Constructor & Destructor Documentation

RtResolutionChebyshev()

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

inlineexplicit

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 70 of file RtResolutionChebyshev.h.

: IRtResolution(vec) { _init(); }

Member Function Documentation

_init()

void RtResolutionChebyshev::_init ( void  )

private

initialization method

Definition at line 16 of file RtResolutionChebyshev.cxx.

                                      {
    // check for consistency //
    if (nPar() < 3) {
        throw std::runtime_error(Form("File: %s, Line: %d\nRtResolutionChebyshev::_init() - Not enough parameters!", __FILE__, __LINE__));
    }
    if (parameters()[0] >= parameters()[1]) {
        throw std::runtime_error(
            Form("File: %s, Line: %d\nRtResolutionChebyshev::_init() - Lower time boundary >= upper time boundary!", __FILE__, __LINE__));
    }
 
    // pointer to the chebyshev service //
    m_Chebyshev = Tschebyscheff_polynomial::get_Tschebyscheff_polynomial();
 
    return;
}

get_reduced_time()

double RtResolutionChebyshev::get_reduced_time ( const double &  t ) const

inline

Definition at line 111 of file RtResolutionChebyshev.cxx.

                                                                           {
    return 2 * (t - 0.5 * (parameters()[1] + parameters()[0])) / (parameters()[1] - parameters()[0]);
}

name()

std::string RtResolutionChebyshev::name ( void  ) const

virtual

get the class name

get the resolution corresponding to the drift time t; if t is not within [t_low, t_up] an unphysical radius of 99999 is returned; the background rate is ignored in present implementation

Implements MuonCalib::CalibFunc.

Definition at line 37 of file RtResolutionChebyshev.cxx.

{ return std::string("RtResolutionChebyshev"); }

nPar()

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

inlineinherited

Definition at line 39 of file CalibFunc.h.

{ return m_parameters.size(); }

numberOfResParameters()

unsigned int RtResolutionChebyshev::numberOfResParameters

(

void

)

const

get the coefficients of the r(t) polynomial

Definition at line 92 of file RtResolutionChebyshev.cxx.

{ return nPar() - 2; }

par()

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

inlineinherited

Definition at line 41 of file CalibFunc.h.

                                                    {
            if (index < nPar())
                return m_parameters[index];
            else
                return 0.;
        }

parameters()

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

inlineinherited

Definition at line 40 of file CalibFunc.h.

{ return m_parameters; }

resolution()

double RtResolutionChebyshev::resolution ( double  t, double  bgRate = 0.0  ) const

virtual

returns resolution for a give time and background rate

Implements MuonCalib::IRtResolution.

Definition at line 44 of file RtResolutionChebyshev.cxx.

                                                                 {
    // INITIAL TIME CHECK //
 
    if (t != tLower() && t != tUpper()) {
        // get resolution for tmin and tmax to get reasonable boundary conditrions
        double res_min(resolution(tLower())), res_max(resolution(tUpper()));
 
        // if x is out of bounds, return 99999 //
        if (t < parameters()[0]) return res_min;
 
        if (t > parameters()[1]) return res_max;
    }
    // VARIABLES //
    // argument of the Chebyshev polynomials
    double x(2 * (t - 0.5 * (parameters()[1] + parameters()[0])) / (parameters()[1] - parameters()[0]));
    double resol(0.0);  // auxiliary resolution
 
    // CALCULATE r(t) //
    for (unsigned int k = 0; k < nPar() - 2; k++) { resol = resol + parameters()[k + 2] * m_Chebyshev->value(k, x); }
 
    return resol;
}

resParameters()

std::vector< double > RtResolutionChebyshev::resParameters

(

void

)

const

get the reduced time which is the argument of the Chebyshev polynomial

Definition at line 99 of file RtResolutionChebyshev.cxx.

                                                                 {
    std::vector<double> alpha(nPar() - 2);
    for (unsigned int k = 0; k < alpha.size(); k++) { alpha[k] = parameters()[k + 2]; }
 
    return alpha;
}

tLower()

double RtResolutionChebyshev::tLower

(

void

)

const

< get the lower drift-time bound

get the upper drift-time bound

Definition at line 78 of file RtResolutionChebyshev.cxx.

{ return parameters()[0]; }

tUpper()

double RtResolutionChebyshev::tUpper

(

void

)

const

get the number of parameters used to describe the resolution

Definition at line 85 of file RtResolutionChebyshev.cxx.

{ return parameters()[1]; }

typeName()

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

inlinevirtualinherited

Implements MuonCalib::CalibFunc.

Definition at line 18 of file IRtResolution.h.

{ return "IRtResolution"; }

Member Data Documentation

m_Chebyshev

const Tschebyscheff_polynomial* MuonCalib::RtResolutionChebyshev::m_Chebyshev

private

pointer to the Chebyshev polynomials

Definition at line 53 of file RtResolutionChebyshev.h.

m_parameters

ParVec MuonCalib::CalibFunc::m_parameters

privateinherited

Definition at line 51 of file CalibFunc.h.

---

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

• RtResolutionChebyshev.h
• RtResolutionChebyshev.cxx