xAODChargedTracksWeightFilter::Spline Struct Reference

#include <xAODChargedTracksWeightFilter.h>

Collaboration diagram for xAODChargedTracksWeightFilter::Spline:

Classes
struct	Point
	Linear spline representation of a function used to calculate weights. More...

Public Member Functions
StatusCode	initialize (std::vector< double > &x, std::vector< double > &y)
double	get_minimum (double min, double max) const
	get minimum over certain range (requires initialization to extrapolate) More...
double	value (int nch) const
	get value for certain x More...

Public Attributes
std::vector< Point >	points
	n-1 spline points filled at initialization More...

Detailed Description

Definition at line 28 of file xAODChargedTracksWeightFilter.h.

Member Function Documentation

get_minimum()

double xAODChargedTracksWeightFilter::Spline::get_minimum	(	double	min,
		double	max
	)		const

get minimum over certain range (requires initialization to extrapolate)

Definition at line 238 of file xAODChargedTracksWeightFilter.cxx.

                                                                                    {
    // evaluate minimum of the spline over a defined range
 
    // spline must be initialized
    if(points.empty()) return -1;
 
    const double dummy = -1;
 
    // if min, max are in between points, or extrapolation needed 
    auto minimum = std::min(value(min), value(max));
 
    //  find boundary points and scan the allowed range
    auto min_item = std::lower_bound(points.begin(), points.end(), Point(min, dummy, dummy), comp_x);
    auto max_item = std::upper_bound(points.begin(), points.end(), Point(max, dummy, dummy), comp_x);
 
    if(min_item != max_item) {
        const auto smallest = std::min_element(min_item, max_item, comp_y);
        minimum = std::min(minimum, smallest-> y);
    }
 
    return minimum;
}

initialize()

StatusCode xAODChargedTracksWeightFilter::Spline::initialize	(	std::vector< double > &	x,
		std::vector< double > &	y
	)

Definition at line 261 of file xAODChargedTracksWeightFilter.cxx.

                                                                                                        {
 
    if(x.size() < 2 || x.size() != y.size()) {
        std::cout << "Spline not properly defined. SplineX, SplineY vectors are required to have at least 2 elements and same size.\n";
        return StatusCode::FAILURE;
    }  
 
    // calculate slope terms
    for(size_t i=0; i< x.size()-1; i++){
 
        const auto & x0 = x[i];
        const auto & y0 = y[i];
        const auto & x1 = x[i+1];
        const auto & y1 = y[i+1];
 
        const auto dx = x1 - x0;
        const auto dy = y1 - y0;
 
        if(dx <=0) {
            std::cout << "Spline not properly defined. SplineX is required to be monotonically increasing.\n";
            return StatusCode::FAILURE;
        }
 
        points.push_back( Point(x[i], y[i], dy/dx));
    }
 
    return StatusCode::SUCCESS;
}

value()

double xAODChargedTracksWeightFilter::Spline::value

(

int

nch

)

const

get value for certain x

Definition at line 217 of file xAODChargedTracksWeightFilter.cxx.

                                                               {
 
    const double dummy = -1;
 
    // find lowest weight in allowed range
    auto lower = std::upper_bound(points.begin(), points.end(), 
            Point(nch, dummy, dummy), comp_x);
 
    if(lower != points.begin()) lower--;
 
    const auto & x = lower-> x;
    const auto & y = lower-> y;;
    const auto & slope = lower-> slope;;
 
    // weight using linear spline
    const auto w_fc = (nch-x)*slope + y;
 
    if(w_fc<0) return 0;   // extrapolation gives negative value
    else return w_fc;
}

Member Data Documentation

points

std::vector<Point> xAODChargedTracksWeightFilter::Spline::points

n-1 spline points filled at initialization

Definition at line 42 of file xAODChargedTracksWeightFilter.h.

---

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

• xAODChargedTracksWeightFilter.h
• xAODChargedTracksWeightFilter.cxx