An interpolating_function_p which is the cumulative integral of a histogram.Note than binedges should be one element longer than binheights, since the lower & upper edges are specified. Note that this is a malformed spline, since the second derivatives are all zero, so it has less continuity. Also, note that the bin edges can be given in backwards order to generate the reversed accumulation (starting at the high end) More...

#include <geant4/tree/geant4-10.6-release/examples/extended/electromagnetic/TestEm7/include/c2_function.hh>

Inheritance diagram for accumulated_histogram< float_type >:

Collaboration diagram for accumulated_histogram< float_type >:

Public Member Functions
	accumulated_histogram (const std::vector< float_type >binedges, const std::vector< float_type > binheights, bool normalize=false, bool inverse_function=false, bool drop_zeros=true)
	Construct the integrated histogram.

Public Member Functions inherited from interpolating_function_p< float_type >
	interpolating_function_p ()
	an empty linear-linear cubic-spline interpolating_function_p

	interpolating_function_p (const c2_function_transformation< float_type > &transform)
	an empty cubic-spline interpolating_function_p with a specific transform

interpolating_function_p < float_type > &	load (const std::vector< float_type > &x, const std::vector< float_type > &f, bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope, bool splined=true)
	do the dirty work of constructing the spline from a function.

interpolating_function_p < float_type > &	load_pairs (std::vector< std::pair< float_type, float_type > > &data, bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope, bool splined=true)
	do the dirty work of constructing the spline from a function.

interpolating_function_p < float_type > &	sample_function (const c2_function< float_type > &func, float_type amin, float_type amax, float_type abs_tol, float_type rel_tol, bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope)
	do the dirty work of constructing the spline from a function.

interpolating_function_p < float_type > &	load_random_generator_function (const std::vector< float_type > &bincenters, const c2_function< float_type > &binheights)
	initialize from a grid of points and a c2_function (un-normalized) to an interpolator which, when evaluated with a uniform random variate on [0,1] returns random numbers distributed as the input function.

interpolating_function_p < float_type > &	load_random_generator_bins (const std::vector< float_type > &bins, const std::vector< float_type > &binheights, bool splined=true)

virtual float_type	value_with_derivatives (float_type x, float_type yprime, float_type yprime2) const
	get the value and derivatives.

virtual	~interpolating_function_p ()
	destructor

virtual interpolating_function_p < float_type > &	clone () const

void	get_data (std::vector< float_type > &xvals, std::vector< float_type > &yvals) const

void	get_internal_data (std::vector< float_type > &xvals, std::vector< float_type > &yvals, std::vector< float_type > &y2vals) const

void	set_lower_extrapolation (float_type bound)

void	set_upper_extrapolation (float_type bound)

interpolating_function_p < float_type > &	unary_operator (const c2_function< float_type > &source) const

interpolating_function_p < float_type > &	binary_operator (const c2_function< float_type > &rhs, const c2_binary_function< float_type > *combining_stub) const

interpolating_function_p < float_type > &	add_pointwise (const c2_function< float_type > &rhs) const

interpolating_function_p < float_type > &	subtract_pointwise (const c2_function< float_type > &rhs) const

interpolating_function_p < float_type > &	multiply_pointwise (const c2_function< float_type > &rhs) const

interpolating_function_p < float_type > &	divide_pointwise (const c2_function< float_type > &rhs) const

void	clone_data (const interpolating_function_p< float_type > &rhs)

Public Member Functions inherited from c2_function< float_type >
const std::string	cvs_header_vers () const
	get versioning information for the header file

const std::string	cvs_file_vers () const
	get versioning information for the source file

virtual	~c2_function ()
	destructor

float_type	operator() (float_type x) const
	evaluate the function in the classic way, ignoring derivatives.

float_type	operator() (float_type x, float_type yprime, float_type yprime2) const
	get the value and derivatives.

float_type	find_root (float_type lower_bracket, float_type upper_bracket, float_type start, float_type value, int error=0, float_type final_yprime=0, float_type *final_yprime2=0) const
	solve f(x)==value very efficiently, with explicit knowledge of derivatives of the function

float_type	partial_integrals (std::vector< float_type > xgrid, std::vector< float_type > *partials=0, float_type abs_tol=1e-12, float_type rel_tol=1e-12, int derivs=2, bool adapt=true, bool extrapolate=true) const

float_type	integral (float_type amin, float_type amax, std::vector< float_type > *partials=0, float_type abs_tol=1e-12, float_type rel_tol=1e-12, int derivs=2, bool adapt=true, bool extrapolate=true) const
	a fully-automated integrator which uses the information provided by the get_sampling_grid() function to figure out what to do.

c2_piecewise_function_p < float_type > *	adaptively_sample (float_type amin, float_type amax, float_type abs_tol=1e-12, float_type rel_tol=1e-12, int derivs=2, std::vector< float_type > xvals=0, std::vector< float_type > yvals=0) const
	create a c2_piecewise_function_p from c2_connector_function_p segments which is a representation of the parent function to the specified accuracy, but maybe much cheaper to evaluate

float_type	xmin () const

float_type	xmax () const

void	set_domain (float_type amin, float_type amax)

size_t	get_evaluations () const

void	reset_evaluations () const
	reset the counter

void	increment_evaluations () const
	count evaluations

bool	check_monotonicity (const std::vector< float_type > &data, const char message[]) const
	check that a vector is monotonic, throw an exception if not, and return a flag if it is reversed

virtual void	set_sampling_grid (const std::vector< float_type > &grid)
	establish a grid of 'interesting' points on the function.

std::vector< float_type > *	get_sampling_grid_pointer () const
	get the sampling grid, which may be a null pointer

virtual void	get_sampling_grid (float_type amin, float_type amax, std::vector< float_type > &grid) const

void	preen_sampling_grid (std::vector< float_type > *result) const
	The grid is modified in place.

void	refine_sampling_grid (std::vector< float_type > &grid, size_t refinement) const

c2_function< float_type > &	normalized_function (float_type amin, float_type amax, float_type norm=1.0) const
	create a new c2_function from this one which is normalized on the interval

c2_function< float_type > &	square_normalized_function (float_type amin, float_type amax, float_type norm=1.0) const

c2_function< float_type > &	square_normalized_function (float_type amin, float_type amax, const c2_function< float_type > &weight, float_type norm=1.0) const
	create a new c2_function from this one which is square-normalized with the provided weight on the interval

c2_sum_p< float_type > &	operator+ (const c2_function< float_type > &rhs) const
	factory function to create a c2_sum_p from a regular algebraic expression.

c2_diff_p< float_type > &	operator- (const c2_function< float_type > &rhs) const
	factory function to create a c2_diff_p from a regular algebraic expression.

c2_product_p< float_type > &	operator* (const c2_function< float_type > &rhs) const
	factory function to create a c2_product_p from a regular algebraic expression.

c2_ratio_p< float_type > &	operator/ (const c2_function< float_type > &rhs) const

c2_composed_function_p < float_type > &	operator() (const c2_function< float_type > &inner) const
	compose this function outside another.

float_type	get_trouble_point () const
	Find out where a calculation ran into trouble, if it got a nan. If the most recent computation did not return a nan, this is undefined.

void	claim_ownership () const
	increment our reference count. Destruction is only legal if the count is zero.

size_t	release_ownership_for_return () const
	decrement our reference count. Do not destroy at zero.

void	release_ownership () const

size_t	count_owners () const
	get the reference count, mostly for debugging

void	fill_fblock (c2_fblock< float_type > &fb) const
	fill in a c2_fblock<float_type>... a shortcut for the integrator & sampler

Additional Inherited Members
Public Attributes inherited from interpolating_function_p< float_type >
const c2_function_transformation < float_type > &	fTransform

Protected Member Functions inherited from interpolating_function_p< float_type >
void	spline (bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope)
	create the spline coefficients

Static Protected Member Functions inherited from interpolating_function_p< float_type >
static bool	comp_pair (std::pair< float_type, float_type > const &i, std::pair< float_type, float_type > const &j)

Protected Attributes inherited from interpolating_function_p< float_type >
std::vector< float_type >	Xraw

std::vector< float_type >	X

std::vector< float_type >	F

std::vector< float_type >	y2

c2_const_ptr< float_type >	sampler_function

bool	xInverted

size_t	lastKLow

Detailed Description

template<typename float_type = double>
class accumulated_histogram< float_type >

An interpolating_function_p which is the cumulative integral of a histogram.

Note than binedges should be one element longer than binheights, since the lower & upper edges are specified. Note that this is a malformed spline, since the second derivatives are all zero, so it has less continuity. Also, note that the bin edges can be given in backwards order to generate the reversed accumulation (starting at the high end)

Definition at line 2172 of file c2_function.hh.

View newest version in sPHENIX GitHub at line 2172 of file c2_function.hh

Constructor & Destructor Documentation

template<typename float_type = double>

accumulated_histogram< float_type >::accumulated_histogram	(	const std::vector< float_type >	binedges,
		const std::vector< float_type >	binheights,
		bool	normalize = `false`,
		bool	inverse_function = `false`,
		bool	drop_zeros = `true`
	)

Construct the integrated histogram.

Parameters

binedges	the edges of the bins in binheights. It should have one more element than binheights
binheights	the number of counts in each bin.
normalize	if true, normalize integral to 1
inverse_function	if true, drop zero channels, and return inverse function for random generation
drop_zeros	eliminate null bins before integrating, so integral is strictly monotonic.

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

geant4/tree/geant4-10.6-release/examples/extended/electromagnetic/TestEm7/include/c2_function.hh

Public Member Functions

Additional Inherited Members

Detailed Description

template<typename float_type = double> class accumulated_histogram< float_type >

Constructor & Destructor Documentation

template<typename float_type = double>
class accumulated_histogram< float_type >