widthestimators::binned Namespace Reference

Functions
template<typename T>
std::vector< double >	get_cum_sum (const T &histo, bool normed=false)
	cumulative sum (e.g.
template<typename T>
std::pair< double, double >	find_window (const T &histo, double prob=PROB_1SIGMA)
	return smallest window (first value, second value) containing prob fraction of the events
template<typename T>
double	smallest_interval (const T &histo, double prob=PROB_1SIGMA)
template<typename T>
double	s68 (const T &histo)
template<typename T>
double	s90 (const T &histo)

Function Documentation

find_window()

template<typename T>

std::pair< double, double > widthestimators::binned::find_window	(	const T &	histo,
		double	prob = PROB_1SIGMA )

return smallest window (first value, second value) containing prob fraction of the events

Definition at line 59 of file widthestimators.h.

        {
        if (histo->GetNbinsX() <= 3 || histo->Integral() == 0.)
            {
                return std::make_pair<double>(0, 0);
            }
 
            std::vector<double> cum_sum = get_cum_sum(histo, true);
            double min_width = histo->GetBinCenter(histo->GetNbinsX()) - histo->GetBinCenter(1);
            std::pair<int, int> window_bin(0, histo->GetNbinsX() + 1);
 
            for (int ibin = 0; ibin != histo->GetNbinsX() + 1; ++ibin)
            {
                const double target_prob = prob + cum_sum[ibin];
                if (target_prob > 1)
                    break;
 
                const auto up_it = std::upper_bound(cum_sum.begin() + ibin, cum_sum.end(), target_prob);
                const auto end_bin = std::distance(cum_sum.begin(), up_it);
                const double width = histo->GetBinCenter(end_bin) - histo->GetBinCenter(ibin);
 
                if (width < min_width)
                {
                    min_width = width;
                    window_bin.first = ibin;
                    window_bin.second = end_bin;
                }
            }
            return std::make_pair<double>(histo->GetBinCenter(window_bin.first), histo->GetBinCenter(window_bin.second));
        }

get_cum_sum()

template<typename T>

std::vector< double > widthestimators::binned::get_cum_sum	(	const T &	histo,
		bool	normed = false )

cumulative sum (e.g.

(non-normalized) empirical CDF)

Definition at line 37 of file widthestimators.h.

        {
            // use double since it can be weighted
            std::vector<double> cum_sum(histo->GetNbinsX() + 2);
 
            std::partial_sum(
                histo->GetArray(),
                histo->GetArray() + histo->GetNbinsX() + 2,
                cum_sum.begin());
 
            if (normed)
            {
                const double last_value = cum_sum.back();
                std::transform(cum_sum.begin(), cum_sum.end(), cum_sum.begin(),
                               [&last_value](auto &c) { return c / last_value; });
            }
 
            return cum_sum;
        }

s68()

template<typename T>

double widthestimators::binned::s68

(

const T &

histo

)

Definition at line 98 of file widthestimators.h.

{ return smallest_interval(histo, PROB_1SIGMA); }

s90()

template<typename T>

double widthestimators::binned::s90

(

const T &

histo

)

Definition at line 101 of file widthestimators.h.

{ return smallest_interval(histo, 0.90); }

smallest_interval()

template<typename T>

double widthestimators::binned::smallest_interval	(	const T &	histo,
		double	prob = PROB_1SIGMA )

Definition at line 91 of file widthestimators.h.

        {
            const auto window = find_window(histo, prob);
            return 0.5 * (window.second - window.first);
        }