ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
c2_piecewise_function_p< float_type > Class Template Reference

create a c2_function which is a piecewise assembly of other c2_functions.The functions must have increasing, non-overlapping domains. Any empty space between functions will be filled with a linear interpolation. More...

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

+ Inheritance diagram for c2_piecewise_function_p< float_type >:
+ Collaboration diagram for c2_piecewise_function_p< float_type >:

Public Member Functions

 c2_piecewise_function_p ()
 construct the container
 
virtual ~c2_piecewise_function_p ()
 destructor
 
virtual float_type value_with_derivatives (float_type x, float_type *yprime, float_type *yprime2) const
 get the value and derivatives.
 
void append_function (const c2_function< float_type > &func)
 append a new function to the sequence
 
- 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
 

Protected Attributes

std::vector< c2_const_ptr
< float_type > > 
functions
 
int lastKLow
 
- Protected Attributes inherited from c2_function< float_type >
std::vector< float_type > * sampling_grid
 
bool no_overwrite_grid
 
float_type fXMin
 
float_type fXMax
 
size_t evaluations
 
float_type bad_x_point
 this point may be used to record where a calculation ran into trouble
 

Additional Inherited Members

- Protected Member Functions inherited from c2_function< float_type >
 c2_function (const c2_function< float_type > &src)
 
 c2_function ()
 
virtual void set_sampling_grid_pointer (std::vector< float_type > &grid)
 

Detailed Description

template<typename float_type>
class c2_piecewise_function_p< float_type >

create a c2_function which is a piecewise assembly of other c2_functions.

The functions must have increasing, non-overlapping domains. Any empty space between functions will be filled with a linear interpolation.

Note
If you want a smooth connection, instead of the default linear interpolation, create a c2_connector_function_p to bridge the gap. The linear interpolation is intended to be a barely intelligent bridge, and may never get used by anyone.
The creation of the container results in the creation of an explicit sampling grid. If this is used with functions with a large domain, or which generate very dense sampling grids, it could eat a lot of memory. Do not abuse this by using functions which can generate gigantic grids.
See Also
ref piecewise_applications_subsec "Sample Applications"
c2_plugin_function_p page
c2_connector_function_p page
Adaptive sampling

Definition at line 83 of file c2_function.hh.

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

Constructor & Destructor Documentation

template<typename float_type>
c2_piecewise_function_p< float_type >::c2_piecewise_function_p ( )

construct the container

template<typename float_type>
virtual c2_piecewise_function_p< float_type >::~c2_piecewise_function_p ( )
virtual

destructor

Member Function Documentation

template<typename float_type>
void c2_piecewise_function_p< float_type >::append_function ( const c2_function< float_type > &  func)

append a new function to the sequence

This takes a c2_function, and appends it onto the end of the piecewise collection. The domain of the function (which MUST be set) specifies the place it will be used in the final function. If the domain exactly abuts the domain of the previous function, it will be directly attached. If there is a gap, the gap will be filled in by linear interpolation.

Parameters
funca c2_function with a defined domain to be appended to the collection

Referenced by LJZBLScreening().

+ Here is the caller graph for this function:

template<typename float_type>
virtual float_type c2_piecewise_function_p< float_type >::value_with_derivatives ( float_type  x,
float_type *  yprime,
float_type *  yprime2 
) const
virtual

get the value and derivatives.

There is required checking for null pointers on the derivatives, and most implementations should operate faster if derivatives are not

Parameters
[in]xthe point at which to evaluate the function
[out]yprimethe first derivative (if pointer is non-null)
[out]yprime2the second derivative (if pointer is non-null)
Returns
the value of the function

Implements c2_function< float_type >.

Member Data Documentation

template<typename float_type>
std::vector<c2_const_ptr<float_type> > c2_piecewise_function_p< float_type >::functions
protected

Definition at line 2327 of file c2_function.hh.

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

template<typename float_type>
int c2_piecewise_function_p< float_type >::lastKLow
mutableprotected

Definition at line 2328 of file c2_function.hh.

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


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