MuonCalib::RtFromPoints Class Reference

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

#include <RtFromPoints.h>

Collaboration diagram for MuonCalib::RtFromPoints:

Static Public Member Functions
static std::unique_ptr< IRtRelation >	getRtChebyshev (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Converts a list of r-t data points into a r(t) relation expressed as a series of chebychev polynomials.
static std::unique_ptr< ITrRelation >	getTrChebyshev (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Converts a list of r-t data points into a t(r) relation expressed as a series of chebychev polynomials.
static std::unique_ptr< IRtResolution >	getResoChebyshev (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Converts a list of reso - t into a reso(t) relation expressed as a series of chebychev polynomials.
static std::unique_ptr< IRtResolution >	getResoChebyshev (const std::vector< SamplePoint > &dataPoints, const IRtRelationPtr rtRelPtr, const double relUnc, const unsigned order)
	Converts a list of sample points into a drift radius resolution function.
static std::unique_ptr< IRtRelation >	getRtLegendre (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Converts a list of r-t data points into a r(t) relation expressed as a series of legendre polynomials.
static std::unique_ptr< ITrRelation >	getTrLegendre (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Converts a list of t(r) data points into a t(r) relation expressed as a series of legendre polynomials.
static std::unique_ptr< IRtRelation >	getRtSimplePoly (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Converts a list of r(t) data points into a r(t) relation expressed as a series of elementary monomonials.
static std::unique_ptr< ITrRelation >	getTrSimplePoly (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Converts a list of t(r) data points into a t(r) relation expressed as a series of elementary monomonials.
static std::unique_ptr< IRtRelation >	getRtRelationLookUp (const std::vector< SamplePoint > &sample_points)

Static Private Member Functions
static CalibFunc::ParVec	chebyFit (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Executes the fit of chebychev polynomials to the data points.
static CalibFunc::ParVec	legendreFit (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Executes the fit of Legendre polynomials to the data points.
static CalibFunc::ParVec	simplePolyFit (const std::vector< SamplePoint > &dataPoints, const unsigned order)
	Exectues the fit of simple monomials to the data points.

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 22 of file RtFromPoints.h.

Member Function Documentation

chebyFit()

CalibFunc::ParVec RtFromPoints::chebyFit ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

staticprivate

Executes the fit of chebychev polynomials to the data points.

Parameters

dataPoints	Data points to fit. No normalization of the domain required
order	Number of Chebychev polynomials to use in the fit

Definition at line 51 of file RtFromPoints.cxx.

                                                               {
 
    const auto [minT, maxT] = interval(dataPoints);
    CalibFunc::ParVec pars{minT, maxT};
    BaseFunctionFitter fitter{order};
    ChebyshevPolynomial chebyshev{};                      // Chebyshev polynomial
 
 
    fitter.fit_parameters(normalizeDomain(dataPoints), 1, dataPoints.size(), chebyshev);
    for (unsigned k = 0; k < fitter.coefficients().size(); k++) { 
        pars.emplace_back(fitter.coefficients()[k]); 
    }
    return pars;
}

getResoChebyshev() [1/2]

std::unique_ptr< IRtResolution > RtFromPoints::getResoChebyshev ( const std::vector< SamplePoint > & dataPoints, const IRtRelationPtr rtRelPtr, const double relUnc, const unsigned order )

static

Converts a list of sample points into a drift radius resolution function.

The resolution is parametrized as a series of Chebychev polynomials.

Parameters

dataPoints	List of data points to convert. The points need to have a resolution attached
rtRelPtr	Pointer to the rt-relation acting as mediator from t -> r
relUnc	Relative uncertainty on each point.
order	Order of the chebychev polynomial

Definition at line 88 of file RtFromPoints.cxx.

                                                                                                         {    
    std::vector<double> chebyCoeff = chebyFit(resoFromRadius(dataPoints, relUnc), order);
    chebyCoeff.erase(chebyCoeff.begin(), chebyCoeff.begin() +2);
    return std::make_unique<RadiusResolutionChebyshev>(chebyCoeff, rtRelPtr);
}

getResoChebyshev() [2/2]

std::unique_ptr< IRtResolution > RtFromPoints::getResoChebyshev ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

static

Converts a list of reso - t into a reso(t) relation expressed as a series of chebychev polynomials.

Parameters

dataPoints	List of data points to be converted x1 -> drift time & x2 -> resolution
order	Number of chebychev polynomials to fit

Definition at line 85 of file RtFromPoints.cxx.

                                                                                                                         {
    return std::make_unique<RtResolutionChebyshev>(chebyFit(dataPoints, order));
}

getRtChebyshev()

std::unique_ptr< IRtRelation > RtFromPoints::getRtChebyshev ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

static

Converts a list of r-t data points into a r(t) relation expressed as a series of chebychev polynomials.

Parameters

dataPoints	List of data points to be converted x1 -> drift time & x2 -> drift radius
order	Number of chebychev polynomials to fit

Definition at line 79 of file RtFromPoints.cxx.

                                                                                                                      {
    return std::make_unique<RtChebyshev>(chebyFit(dataPoints, order));
}  // end RtFromPoints::getRtChebyshev

getRtLegendre()

std::unique_ptr< IRtRelation > RtFromPoints::getRtLegendre ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

static

Converts a list of r-t data points into a r(t) relation expressed as a series of legendre polynomials.

Parameters

dataPoints	List of data points to be converted x1 -> drift radius & x2 -> drift time
order	Number of legendre polynomials to use in the fit

Definition at line 95 of file RtFromPoints.cxx.

                                                                                                                     {
    return std::make_unique<RtLegendre>(legendreFit(dataPoints, order));
}

getRtRelationLookUp()

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

static

Definition at line 112 of file RtFromPoints.cxx.

                                                                                                     {
    // create spline rt relation
    CalibFunc ::ParVec pars(2 * dataPoints.size());
    for (unsigned i = 0; i < dataPoints.size(); i++) {
        pars[2 * i] = dataPoints[i].x1();
        pars[2 * i + 1] = dataPoints[i].x2();
    }
    RtSpline rt(pars);
 
    // variables
    unsigned 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 k = 0; k < nb_points; k++) { rt_param[k + 2] = rt.radius(rt.tLower() + k * bin_width); }
    return std::make_unique<RtRelationLookUp>(rt_param);
}

getRtSimplePoly()

std::unique_ptr< IRtRelation > RtFromPoints::getRtSimplePoly ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

static

Converts a list of r(t) data points into a r(t) relation expressed as a series of elementary monomonials.

Parameters

dataPoints	List of data points to be converted x1 -> drift time & x2 -> drift radius
order	Order of the maximum monomial in the fit

Definition at line 101 of file RtFromPoints.cxx.

                                                                                                                       {
    return std::make_unique<RtSimplePolynomial>(simplePolyFit(dataPoints, order));
}

getTrChebyshev()

std::unique_ptr< ITrRelation > RtFromPoints::getTrChebyshev ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

static

Converts a list of r-t data points into a t(r) relation expressed as a series of chebychev polynomials.

Parameters

dataPoints	List of data points to be converted x1 -> drift radius & x2 -> drift time
order	Number of chebychev polynomials to fit

Definition at line 82 of file RtFromPoints.cxx.

                                                                                                                      {
    return std::make_unique<TrChebyshev>(chebyFit(dataPoints, order));
}

getTrLegendre()

std::unique_ptr< ITrRelation > RtFromPoints::getTrLegendre ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

static

Converts a list of t(r) data points into a t(r) relation expressed as a series of legendre polynomials.

Parameters

dataPoints	List of data points to be converted x1 -> drift radius & x2 -> drift time
order	Number of chebychev polynomials to fit

Definition at line 98 of file RtFromPoints.cxx.

                                                                                                                     {
    return std::make_unique<TrLegendre>(legendreFit(dataPoints, order));
}

getTrSimplePoly()

std::unique_ptr< ITrRelation > RtFromPoints::getTrSimplePoly ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

static

Converts a list of t(r) data points into a t(r) relation expressed as a series of elementary monomonials.

Parameters

dataPoints	List of data points to be converted x1 -> drift radius & x2 -> drift time
order	Order of the maximum monomial in the fit 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 104 of file RtFromPoints.cxx.

                                                                                                                       {
    return std::make_unique<TrSimplePolynomial>(simplePolyFit(dataPoints, order));
}

legendreFit()

CalibFunc::ParVec RtFromPoints::legendreFit ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

staticprivate

Executes the fit of Legendre polynomials to the data points.

Parameters

dataPoints	Data points to fit. No normalization of the domain required
order	Number of Legendre polynomials to use in the fit

Definition at line 37 of file RtFromPoints.cxx.

                                                                  {
    const auto [minT, maxT] = interval(dataPoints);
 
    CalibFunc::ParVec pars{minT, maxT};
    BaseFunctionFitter fitter{order};
    LegendrePolynomial legendre{};
    fitter.fit_parameters(normalizeDomain(dataPoints), 1, dataPoints.size(), legendre);
    for (unsigned k = 0; k < fitter.coefficients().size(); k++) { 
        pars.emplace_back(fitter.coefficients()[k]); 
    }
    return pars;
}

simplePolyFit()

CalibFunc::ParVec RtFromPoints::simplePolyFit ( const std::vector< SamplePoint > & dataPoints, const unsigned order )

staticprivate

Exectues the fit of simple monomials to the data points.

Parameters

dataPoints	Data points to fit.
order	Number of Legendre polynomials to use in the fit

Definition at line 66 of file RtFromPoints.cxx.

                                                                    {
    const auto [minT, maxT] = interval(dataPoints);
    CalibFunc::ParVec pars{minT, maxT};
    BaseFunctionFitter fitter{order};
    SimplePolynomial simplePoly{};
    fitter.fit_parameters(normalizeDomain(dataPoints), 1, dataPoints.size(), simplePoly);
    for (unsigned k = 0; k < fitter.coefficients().size(); k++) { 
        pars.emplace_back(fitter.coefficients()[k]); 
    }
    return pars;
 
}

---

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

• RtFromPoints.h
• RtFromPoints.cxx