hep Namespace Reference

Classes
class	callback
class	chkpt
class	chkpt_with_rng
class	distribution_parameters
class	distribution_result
class	integrand
class	mc_point
class	mc_result
class	mpi_callback
class	multi_channel_chkpt
class	multi_channel_integrand
class	multi_channel_point
class	multi_channel_point2
class	multi_channel_result
class	multi_channel_weight_info
class	plain_result
class	projector
class	vegas_chkpt
class	vegas_pdf
class	vegas_point
class	vegas_result
struct	weighted_equally
struct	weighted_with_variance

Typedefs
template<typename T , typename F , bool distributions>
using	integrand_type = integrand< T, typename std::decay< F >::type, distributions >
template<typename I >
using	numeric_type_of = typename std::remove_reference< I >::type::numeric_type
template<typename RandomNumberEngine , typename T >
using	multi_channel_chkpt_with_rng = chkpt_with_rng< RandomNumberEngine, multi_channel_chkpt< T > >
template<typename T >
using	default_multi_channel_chkpt = decltype(make_multi_channel_chkpt< T >())
template<typename T , typename F , typename M , bool distributions>
using	multi_channel_integrand_type = multi_channel_integrand< T, typename std::decay< F >::type, typename std::decay< M >::type, distributions >
template<typename T >
using	plain_chkpt = chkpt< plain_result< T > >
template<typename RandomNumberEngine , typename T >
using	plain_chkpt_with_rng = chkpt_with_rng< RandomNumberEngine, plain_chkpt< T > >
template<typename T >
using	default_plain_chkpt = decltype(make_plain_chkpt< T >())
template<typename RandomNumberEngine , typename T >
using	vegas_chkpt_with_rng = chkpt_with_rng< RandomNumberEngine, vegas_chkpt< T > >
template<typename T >
using	default_vegas_chkpt = decltype(make_vegas_chkpt< T >())

Enumerations
enum	callback_mode { callback_mode::silent, callback_mode::silent_and_write_chkpt, callback_mode::verbose, callback_mode::verbose_and_write_chkpt }
enum	multi_channel_map { multi_channel_map::calculate_coordinates, multi_channel_map::calculate_densities }

Functions
template<typename T >
distribution_parameters< T >	make_dist_params (std::size_t bins, T x_min, T x_max, std::string const &name="")
template<typename T >
std::vector< T >	mid_points_x (distribution_result< T > const &result)
template<typename T >
std::vector< T >	mid_points_y (distribution_result< T > const &result)
template<typename T , typename F >
integrand_type< T, F, false >	make_integrand (F &&function, std::size_t dimensions)
template<typename T , typename F , typename... D>
integrand_type< T, F, true >	make_integrand (F &&function, std::size_t dimensions, D &&... parameters)
template<template< typename > class Accumulator, typename IteratorOverMcResults >
hep_mc_result_if< IteratorOverMcResults >	accumulate (IteratorOverMcResults begin, IteratorOverMcResults end)
template<template< typename > class Accumulator, typename IteratorOverPlainResults >
hep_plain_result_if< IteratorOverPlainResults >	accumulate (IteratorOverPlainResults begin, IteratorOverPlainResults end)
template<template< typename > class Accumulator, typename IteratorOverMcResults >
hep_numeric_type< IteratorOverMcResults >	chi_square_dof (IteratorOverMcResults begin, IteratorOverMcResults end)
template<typename T >
mc_result< T >	create_result (std::size_t calls, std::size_t non_zero_calls, std::size_t finite_calls, T value, T error)
template<typename I , typename Checkpoint = default_multi_channel_chkpt<numeric_type_of<I>>, typename Callback = mpi_callback<Checkpoint>>
Checkpoint	mpi_multi_channel (MPI_Comm communicator, I &&integrand, std::vector< std::size_t > const &iteration_calls, Checkpoint chkpt=make_multi_channel_chkpt< numeric_type_of< I >>(), Callback callback=mpi_callback< Checkpoint >())
template<typename I , typename Checkpoint = default_plain_chkpt<numeric_type_of<I>>, typename Callback = mpi_callback<Checkpoint>>
Checkpoint	mpi_plain (MPI_Comm communicator, I &&integrand, std::vector< std::size_t > const &iteration_calls, Checkpoint chkpt=make_plain_chkpt< numeric_type_of< I >>(), Callback callback=mpi_callback< Checkpoint >())
template<typename I , typename Checkpoint = default_vegas_chkpt<numeric_type_of<I>>, typename Callback = mpi_callback<Checkpoint>>
Checkpoint	mpi_vegas (MPI_Comm communicator, I &&integrand, std::vector< std::size_t > const &iteration_calls, Checkpoint chkpt=make_vegas_chkpt< numeric_type_of< I >>(), Callback callback=mpi_callback< Checkpoint >())
template<typename I , typename R >
multi_channel_result< numeric_type_of< I > >	multi_channel_iteration (I &&integrand, std::size_t calls, std::vector< numeric_type_of< I >> const &channel_weights, R &generator)
template<typename I , typename Checkpoint = default_multi_channel_chkpt<numeric_type_of<I>>, typename Callback = callback<Checkpoint>>
Checkpoint	multi_channel (I &&integrand, std::vector< std::size_t > const &iteration_calls, Checkpoint chkpt=make_multi_channel_chkpt< numeric_type_of< I >>(), Callback callback=callback< Checkpoint >())
template<typename T , typename RandomNumberEngine = std::mt19937>
multi_channel_chkpt_with_rng< RandomNumberEngine, T >	make_multi_channel_chkpt (T min_weight=T(), T beta=T(0.25), RandomNumberEngine const &rng=std::mt19937())
template<typename T , typename RandomNumberEngine = std::mt19937>
multi_channel_chkpt_with_rng< RandomNumberEngine, T >	make_multi_channel_chkpt (std::vector< T > const &channel_weights, T min_weight=T(), T beta=T(0.25), RandomNumberEngine const &rng=std::mt19937())
template<typename T , typename RandomNumberEngine >
multi_channel_chkpt_with_rng< RandomNumberEngine, T >	make_multi_channel_chkpt (std::istream &in)
template<typename T , typename F , typename M >
multi_channel_integrand_type< T, F, M, false >	make_multi_channel_integrand (F &&function, std::size_t dimensions, M &&map, std::size_t map_dimensions, std::size_t channels)
template<typename T , typename F , typename M , typename... Ds>
multi_channel_integrand_type< T, F, M, true >	make_multi_channel_integrand (F &&function, std::size_t dimensions, M &&map, std::size_t map_dimensions, std::size_t channels, Ds &&... parameters)
template<typename T >
T	multi_channel_max_difference (multi_channel_result< T > const &result)
template<typename T >
std::vector< T >	multi_channel_refine_weights (std::vector< T > const &weights, std::vector< T > const &adjustment_data, T minimum_weight, T beta)
template<typename T >
std::vector< std::size_t >	minimal_weight_channels (multi_channel_weight_info< T > const &info)
template<typename I , typename R >
plain_result< numeric_type_of< I > >	plain_iteration (I &&integrand, std::size_t calls, R &generator)
template<typename I , typename Checkpoint = default_plain_chkpt<numeric_type_of<I>>, typename Callback = callback<Checkpoint>>
Checkpoint	plain (I &&integrand, std::vector< std::size_t > const &iteration_calls, Checkpoint chkpt=make_plain_chkpt< numeric_type_of< I >>(), Callback callback=callback< Checkpoint >())
template<typename T , typename RandomNumberEngine = std::mt19937>
plain_chkpt_with_rng< RandomNumberEngine, T >	make_plain_chkpt (RandomNumberEngine const &generator=std::mt19937())
template<typename T , typename RandomNumberEngine >
plain_chkpt_with_rng< RandomNumberEngine, T >	make_plain_chkpt (std::istream &in)
template<typename I , typename R >
vegas_result< numeric_type_of< I > >	vegas_iteration (I &&integrand, std::size_t calls, vegas_pdf< numeric_type_of< I >> const &pdf, R &generator)
template<typename I , typename Checkpoint = default_vegas_chkpt<numeric_type_of<I>>, typename Callback = callback<Checkpoint>>
Checkpoint	vegas (I &&integrand, std::vector< std::size_t > const &iteration_calls, Checkpoint chkpt=make_vegas_chkpt< numeric_type_of< I >>(), Callback callback=callback< Checkpoint >())
template<typename T , typename RandomNumberEngine = std::mt19937>
vegas_chkpt_with_rng< RandomNumberEngine, T >	make_vegas_chkpt (std::size_t bins=128, T alpha=T(1.5), RandomNumberEngine const &rng=std::mt19937())
template<typename T , typename RandomNumberEngine = std::mt19937>
vegas_chkpt_with_rng< RandomNumberEngine, T >	make_vegas_chkpt (vegas_pdf< T > const &pdf, T alpha=T(1.5), RandomNumberEngine const &rng=std::mt19937())
template<typename T , typename RandomNumberEngine >
vegas_chkpt_with_rng< RandomNumberEngine, T >	make_vegas_chkpt (std::istream &in)
template<typename T >
T	vegas_icdf (vegas_pdf< T > const &pdf, std::vector< T > &random_numbers, std::vector< std::size_t > &bin)
template<typename T >
vegas_pdf< T >	vegas_refine_pdf (vegas_pdf< T > const &pdf, T alpha, std::vector< T > const &data)

Function Documentation

multi_channel_refine_weights()

template<typename T >

std::vector<T> hep::multi_channel_refine_weights ( std::vector< T > const &  weights, std::vector< T > const &  adjustment_data, T  minimum_weight, T  beta  )

inline

Uses adjustment_data from a previous call of multi_channel_iteration to refine weights. The procedure is the one suggested in Ref. [2] with the following modifications:

• the weights are check if they are smaller then the given minimum_weight. If this is the case they are set to the value of minimum_weight which, after the normalization of all weights, make them a little smaller then the given minimum weight,
• adjustment_data is raised to the power given by beta. The reference given above suggest beta = 0.5, but the default value is smaller which sometimes gives a more stable convergence.

Examples:

multi_channel_disabled_channels.cpp.