MuonCalib::TrRelation Class Reference

#include <TrRelation.h>

Inheritance diagram for MuonCalib::TrRelation:

Collaboration diagram for MuonCalib::TrRelation:

Public Member Functions
	TrRelation (const IRtRelation &input_rt)
	< Constructor. More...
	TrRelation (const std::vector< double > &r_values, const std::vector< double > &t_values)
double	tFromR (const double r, bool &out_of_bound_flag) const
	< Get t(r). out_of_bound_flag is set to true if r is out of bounds. More...
double	rFromT (const double t, bool &out_of_bound_flag) const

Static Private Member Functions
static double	getTFromR (const double r, const IRtRelation &input_rt)

Private Attributes
std::vector< double >	m_r
std::vector< double >	m_t

Detailed Description

Definition at line 39 of file TrRelation.h.

Constructor & Destructor Documentation

TrRelation() [1/2]

TrRelation::TrRelation

(

const IRtRelation &

input_rt

)

< Constructor.

The user has to provide the input r-t relationship to be inverted. Constructor. The user has to provide (r, t) pairs stored in the vectors r_values and t_values. The r and t values must be in increasing order.

Definition at line 20 of file TrRelation.cxx.

                                                  {
    // VARIABLES //
    unsigned int nb_points(100);  // number of r-t points used internally
    // step size in r
    double step_size(input_rt.radius(input_rt.tUpper()) / static_cast<double>(nb_points - 1));
    m_r = std::vector<double>(nb_points);
    m_t = std::vector<double>(nb_points);
 
    // FILL THE (r, t) PAIRS //
    for (unsigned int k = 0; k < nb_points; k++) {
        m_r[k] = k * step_size;
        m_t[k] = getTFromR(m_r[k], input_rt);
    }
 
}  // end TrRelation::TrRelation

TrRelation() [2/2]

TrRelation::TrRelation	(	const std::vector< double > &	r_values,
		const std::vector< double > &	t_values
	)

Definition at line 45 of file TrRelation.cxx.

  : m_r (r_values),
    m_t (t_values)
{
}

Member Function Documentation

getTFromR()

double TrRelation::getTFromR ( const double  r, const IRtRelation &  input_rt  )

staticprivate

Definition at line 128 of file TrRelation.cxx.

                                                                        {
    // VARIABLES //
    double precision(0.001);          // spatial precision of the inversion
    double t_max(input_rt.tUpper());  // upper time search limit
    double t_min(input_rt.tLower());  // lower time search limit
 
    // SEARCH FOR THE CORRESPONDING DRIFT TIME //
    while (t_max - t_min > 0.1 && std::abs(input_rt.radius(0.5 * (t_min + t_max)) - r) > precision) {
        if (input_rt.radius(0.5 * (t_min + t_max)) > r) {
            t_max = 0.5 * (t_min + t_max);
        } else {
            t_min = 0.5 * (t_min + t_max);
        }
    }
 
    return 0.5 * (t_min + t_max);
}  // end TrRelation::getTFromR

rFromT()

double TrRelation::rFromT	(	const double	t,
		bool &	out_of_bound_flag
	)		const

Definition at line 92 of file TrRelation.cxx.

                                                                       {
    // CHECK BOUNDS //
    if (t < m_t[0]) {
        out_of_bound_flag = true;
        return m_r[0];
    }
    if (t > m_t[m_r.size() - 1]) {
        out_of_bound_flag = true;
        return m_r[m_r.size() - 1];
    }
 
    // INTERPOLATION //
    for (unsigned int k = 0; k < m_r.size() - 1; k++) {
        if (t >= m_t[k] && t <= m_t[k + 1]) {
            if (m_t[k] == m_t[k + 1]) {
                out_of_bound_flag = false;
                return m_r[k];
            }
            out_of_bound_flag = false;
            return m_r[k] + (t - m_t[k]) * (m_r[k + 1] - m_r[k]) / (m_t[k + 1] - m_t[k]);
        }
    }
    MsgStream log(Athena::getMessageSvc(), "TrRelation");
    log << MSG::ERROR << "Class TrRelation, method rFromT: ERROR!" << endmsg;
    return 0.0;
}  // end TrRelation::rFromT

tFromR()

double TrRelation::tFromR	(	const double	r,
		bool &	out_of_bound_flag
	)		const

< Get t(r). out_of_bound_flag is set to true if r is out of bounds.

Get r(t). out_of_bound_flag is set to true if t is out of bounds.

Definition at line 56 of file TrRelation.cxx.

                                                                       {
    // CHECK BOUNDS //
    if (r < m_r[0]) {
        out_of_bound_flag = true;
        return m_t[0];
    }
    if (r > m_r[m_r.size() - 1]) {
        out_of_bound_flag = true;
        return m_t[m_r.size() - 1];
    }
 
    // INTERPOLATION //
    for (unsigned int k = 0; k < m_r.size() - 1; k++) {
        if (r >= m_r[k] && r <= m_r[k + 1]) {
            if (m_r[k] == m_r[k + 1]) {
                out_of_bound_flag = false;
                return m_t[k];
            }
            out_of_bound_flag = false;
            return m_t[k] + (r - m_r[k]) * (m_t[k + 1] - m_t[k]) / (m_r[k + 1] - m_r[k]);
        }
    }
    MsgStream log(Athena::getMessageSvc(), "TrRelation");
    log << MSG::ERROR << "Class TrRelation, method tFromR: ERROR!" << endmsg;
    return 0.0;
}  // end TrRelation::tFromR

Member Data Documentation

m_r

std::vector<double> MuonCalib::TrRelation::m_r

private

Definition at line 58 of file TrRelation.h.

m_t

std::vector<double> MuonCalib::TrRelation::m_t

private

Definition at line 59 of file TrRelation.h.

---

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

• TrRelation.h
• TrRelation.cxx