MuonCalib::RtFromPoints Class Reference

#include <RtFromPoints.h>

Collaboration diagram for MuonCalib::RtFromPoints:

Public Member Functions
	RtFromPoints ()=default
	Default constructor. More...

Static Public Member Functions
static RtChebyshev	getRtChebyshev (const std::vector< SamplePoint > &sample_points, const unsigned int &order)
	< get an RtChebyshev resembling the r(t) function as described by the sample points in the vector "sample_points"; use Chebyshev polynomials up to order "order"; x1 coordinate of the sample points contains the drift time, x2 the corresponding radius; the method takes the minimum and maximum x1 values in the set of sample points a lower and upper limits in RtChebyshev More...
static RtRelationLookUp	getRtRelationLookUp (const std::vector< SamplePoint > &sample_points)

Static Private Member Functions
static void	get_min_max (const std::vector< SamplePoint > &sample_points, double &x_min, double &x_max)

Detailed Description

This class allows the user to retrieve an RtChebyshev or RtRelationLookUp object corresponding to a set of (r, t) points.

Definition at line 30 of file RtFromPoints.h.

Constructor & Destructor Documentation

RtFromPoints()

MuonCalib::RtFromPoints::RtFromPoints ( )

default

Default constructor.

Member Function Documentation

get_min_max()

void RtFromPoints::get_min_max ( const std::vector< SamplePoint > &  sample_points, double &  x_min, double &  x_max  )

staticprivate

Definition at line 21 of file RtFromPoints.cxx.

                                                                                                        {
    for (unsigned int k = 0; k < sample_points.size(); k++) {
        if (k == 0) {
            x_min = sample_points[k].x1();
            x_max = x_min;
        }
        if (x_min > sample_points[k].x1()) { x_min = sample_points[k].x1(); }
        if (x_max < sample_points[k].x1()) { x_max = sample_points[k].x1(); }
    }
 
    return;
}

getRtChebyshev()

RtChebyshev RtFromPoints::getRtChebyshev ( const std::vector< SamplePoint > &  sample_points, const unsigned int &  order  )

static

< get an RtChebyshev resembling the r(t) function as described by the sample points in the vector "sample_points"; use Chebyshev polynomials up to order "order"; x1 coordinate of the sample points contains the drift time, x2 the corresponding radius; the method takes the minimum and maximum x1 values in the set of sample points a lower and upper limits in RtChebyshev

get an RtRelationLookUp resembling the r(t) function as described by the sample points in the vector "sample_points"; x1 coordinate of the sample points contains the drift time, x2 the corresponding radius; the method takes the minimum and maximum x1 values in the set of sample points a lower and upper limits in RtRelationLookUp

Definition at line 39 of file RtFromPoints.cxx.

                                                                                                               {
    // VARIABLES //
    std::vector<double> rt_param(order + 3);            // input parameters of RtChebyshev
    BaseFunctionFitter fitter(order + 1);               // Chebyshev fitter
    ChebyshevPolynomial chebyshev;                      // Chebyshev polynomial
    std::vector<SamplePoint> my_points(sample_points);  // copy of the sample to add reduced times
 
    // GET THE MINIMUM AND MAXIMUM TIMES AND CALCULATE REDUCED TIMES //
    get_min_max(sample_points, rt_param[0], rt_param[1]);
 
    double mean(0.5 * (rt_param[1] + rt_param[0]));
    double length(rt_param[1] - rt_param[0]);
    for (unsigned int k = 0; k < my_points.size(); k++) { my_points[k].set_x1(2 * (sample_points[k].x1() - mean) / length); }
 
    // PERFORM A CHEBYSHEV FIT TO THE SAMPLE POINTS //
    fitter.fit_parameters(my_points, 1, sample_points.size(), chebyshev);
       
    for (unsigned int k = 0; k < order + 1; k++) { rt_param[k + 2] = fitter.coefficients()[k]; }
 
    // CREATE AN RtChebyshev OBJECT WITH THE CORRECT PARAMETERS //
    RtChebyshev rt_chebyshev(rt_param);
    return rt_chebyshev;
}  // end RtFromPoints::getRtChebyshev

getRtRelationLookUp()

RtRelationLookUp RtFromPoints::getRtRelationLookUp ( const std::vector< SamplePoint > &  sample_points )

static

Definition at line 76 of file RtFromPoints.cxx.

                                                                                              {
    // create spline rt relation
    CalibFunc ::ParVec pars(2 * sample_points.size());
    for (unsigned int i = 0; i < sample_points.size(); i++) {
        pars[2 * i] = sample_points[i].x1();
        pars[2 * i + 1] = sample_points[i].x2();
    }
    RtSpline rt(pars);
 
    // variables
    unsigned int nb_points(100);                                                         // number of (r, t) points
    double bin_width((rt.tUpper() - rt.tLower()) / static_cast<double>(nb_points - 1));  // step size
    std::vector<double> rt_param(nb_points + 2);                                         // r-t parameters
 
    // CREATE AN RtRelationLookUp OBJECT WITH THE CORRECT PARAMETERS //
    rt_param[0] = rt.tLower();
    rt_param[1] = bin_width;
    for (unsigned int k = 0; k < nb_points; k++) { rt_param[k + 2] = rt.radius(rt.tLower() + k * bin_width); }
    RtRelationLookUp rt_relation_look_up(rt_param);
 
    return rt_relation_look_up;
}

---

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

• RtFromPoints.h
• RtFromPoints.cxx