21#include <nlohmann/json.hpp>
30 template <
typename Tuple,
typename Seq>
32 template <
typename Tuple,
size_t... I>
36 template <
typename Tuple,
unsigned int N>
37 using SubTuple_t =
typename SubTuple<Tuple, std::make_index_sequence<N>>::type;
40 template <
typename T,
unsigned int ND,
typename = std::make_
integer_sequence<
unsigned int, ND>>
42 template <
typename T,
unsigned int ND,
unsigned int... S>
43 struct make_tuple<T, ND,
std::integer_sequence<unsigned int, S...>> {
44 template <
unsigned int>
46 using type = std::tuple<typeMap<S>...>;
48 template <
typename T,
unsigned int ND>
49 using make_tuple_t =
typename make_tuple<T, ND>::type;
52 template <
typename AxisTupleType>
53 struct AxisToArithmetic;
54 template <
typename... Axis>
55 struct AxisToArithmetic<
std::tuple<Axis...>> {
56 using type = std::tuple<
typename Axis::ArithmeticType...>;
58 template <
typename AxisTupleType>
59 using AxisToArithmetic_t =
typename AxisToArithmetic<AxisTupleType>::type;
60 template <
typename ProfArithmetic,
typename AxisTupleType>
71 std::format(
"Histogram title \'{}\' has whitespace at front or back -- please remove", sv ),
81 template <
typename Arithmetic>
91 template <
typename Arithmetic>
93 return v.first * v.second;
101 template <
typename Arithmetic>
103 return v.first * v.first * v.second;
111 template <
typename Arithmetic>
122 template <
typename Arithmetic, atomicity Atomicity>
131 return { v.first.load( std::memory_order_relaxed ), v.second.load( std::memory_order_relaxed ) };
138 return { v.first.exchange( newv.first ), v.second.exchange( newv.second ) };
140 return { std::exchange( v.first, newv.first ), std::exchange( v.second, newv.second ) };
150 a.second += b.second;
160 template <atomicity Atomicity,
typename Arithmetic>
162 :
GenericAccumulator<std::pair<Arithmetic, Arithmetic>, std::pair<unsigned long, Arithmetic>, Atomicity,
163 WeightedProfileTransform, ExtractWeight, WeightedAdder<Arithmetic, Atomicity>> {
167 using Base::operator+=;
170 *
this += { 1ul, weight };
183 template <atomicity Atomicity,
typename Arithmetic>
185 :
GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedProduct> {
196 template <atomicity Atomicity,
typename Arithmetic =
double>
198 :
GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedSquare> {
209 template <atomicity Atomicity,
typename Arithmetic>
218 template <atomicity Atomicity,
typename Arithmetic>
228 template <
typename Arithmetic>
244 :
Axis( (unsigned int)def.bins(), def.lowEdge(), def.highEdge(), def.
title() ) {}
247 unsigned int index( Arithmetic value )
const {
251 if constexpr ( std::is_integral_v<Arithmetic> ) {
256 if ( !std::isfinite( floatIdx ) ) {
return floatIdx > 0 ?
numBins() + 1 : 0; }
257 idx =
static_cast<int>( floatIdx );
259 return idx < 0 ? 0 : ( (
unsigned int)idx >
numBins() ?
numBins() + 1 : (
unsigned int)idx );
266 <<
"\"" << axis.
m_title <<
"\", (";
267 for (
auto const& label : axis.
m_labels ) { o <<
"\"" << label <<
"\", "; }
315 if constexpr ( std::is_floating_point_v<Arithmetic> ) {
328 template <
typename Arithmetic>
330 j = nlohmann::json{ {
"nBins", axis.
numBins() },
333 {
"title", axis.
title() } };
352 template <
typename Arithmetic,
unsigned int NIndex>
356 template <
unsigned int NIndex,
typename... Elements>
361 template <
class... AxisType>
362 requires(
sizeof...( AxisType ) == NIndex )
366 template <
class... AxisType>
367 requires(
sizeof...( AxisType ) == NIndex )
372 template <
class... AxisType>
373 requires(
sizeof...( AxisType ) == NIndex )
379 template <
int N,
class Tuple>
383 unsigned int localIndex = axis.index(
std::get<N>( *
this ) );
384 if constexpr ( N + 1 == NIndex )
389 template <
int N,
class Tuple>
392 unsigned int localNBins = axis.numBins() + 2;
393 if constexpr ( N + 1 == NIndex )
398 template <
int N,
class Tuple>
401 bool localAnswer = axis.inAcceptance(
std::get<N>( *
this ) );
402 if constexpr ( N + 1 == NIndex )
414 template <
typename ArithmeticTuple,
unsigned int NIndex,
typename WArithmetic>
418 template <
class... AxisType>
419 requires(
sizeof...( AxisType ) == NIndex )
421 return this->
first.computeIndex( axis );
423 template <
class... AxisType>
424 requires(
sizeof...( AxisType ) == NIndex )
429 template <
class... AxisType>
430 requires(
sizeof...( AxisType ) == NIndex )
432 return this->
first.inAcceptance( axis );
481 template <
atomicity Atomicity,
typename InputType,
typename Arithmetic,
482 template <atomicity Ato,
typename Arith>
typename BaseAccumulatorT,
typename AxisTupleType>
484 template <atomicity,
typename,
typename,
template <atomicity,
typename>
typename,
typename>
497 template <atomicity ato>
512 template <atomicity ato>
516 for (
unsigned int index = 0; index <
m_totNBins; index++ ) {
520 [[nodiscard]]
auto operator[](
typename InputType::ValueType v ) {
524 template <
unsigned int N>
549 std::tuple_element_t<0, AxisTupleType>
const&
_getAxis(
size_t i,
552 std::format(
"Retrieving axis {} in Histogram of dimension {}", i, std::tuple_size_v<AxisTupleType> ) );
555 requires( std::tuple_size_v<AxisTupleType> != N )
574 template <atomicity Atomicity,
typename Arithmetic,
typename ND,
typename AxisTupleType>
584 template <atomicity Atomicity,
typename Arithmetic,
typename ND,
typename AxisTupleType>
595 template <atomicity Atomicity,
typename Arithmetic,
typename ND,
typename AxisTupleType>
606 template <atomicity Atomicity,
typename Arithmetic,
typename ND,
typename AxisTupleType>
669 template <
unsigned int ND,
atomicity Atomicity,
typename Arithmetic,
const char* Type,
670 template <atomicity,
typename,
typename,
typename>
typename Accumulator,
typename AxisTupleType>
672 template <
unsigned int ND,
atomicity Atomicity,
typename Arithmetic,
const char* Type,
673 template <atomicity,
typename,
typename,
typename>
typename Accumulator,
typename... AxisTypes>
675 :
public BufferableCounter<Atomicity, Accumulator, Arithmetic, std::integral_constant<unsigned int, ND>,
676 std::tuple<AxisTypes...>> {
681 using AccumulatorType = Accumulator<Atomicity, Arithmetic, NumberDimensions, AxisTupleType>;
685 inline static const std::string
typeString{ std::string{ Type } +
':' +
typeid( Arithmetic ).name() };
687 template <
typename OWNER>
693 template <
typename OWNER>
697 template <
typename stream>
699 o << ND <<
"D Histogram with config ";
700 std::apply( [&o](
auto&&... args ) { ( ( o << args <<
"\n" ), ... ); }, this->axis() );
703 std::ostream&
print( std::ostream& o,
bool tableFormat =
false )
const override {
710 virtual void to_json( nlohmann::json& j )
const {
713 bins.
reserve( this->totNBins() );
714 unsigned long totNEntries{ 0 };
715 for (
unsigned int i = 0; i < this->totNBins(); i++ ) {
717 totNEntries += this->nEntries( i );
720 j = { {
"type",
std::string( Type ) +
":" +
typeid( Arithmetic ).name() },
723 {
"empty", totNEntries == 0 },
724 {
"nEntries", totNEntries },
725 {
"axis", this->axis() },
743 typename AxisTupleType = make_tuple_t<Axis<Arithmetic>, ND>>
749 typename AxisTupleType = make_tuple_t<Axis<Arithmetic>, ND>>
755 typename AxisTupleType = make_tuple_t<Axis<Arithmetic>, ND>>
761 typename AxisTupleType = make_tuple_t<Axis<Arithmetic>, ND>>
_Tp abs(const complex< _Tp > &)
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
constexpr auto tuple_cat(_Tpls &&... __tpls) -> typename __tuple_cat_result< _Tpls... >::__type
auto declval() noexcept -> decltype(__declval< _Tp >(0))
constexpr const __tuple_element_t< __i, tuple< _Elements... > > && get(const tuple< _Elements... > &&__t) noexcept
constexpr tuple< typename __decay_and_strip< _Elements >::__type... > make_tuple(_Elements &&... __args)
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
basic_string< char > string
bool isspace(_CharT __c, const locale &__loc)
integer_sequence< size_t, _Idx... > index_sequence
static constexpr _Tp epsilon() noexcept
constexpr void push_back(const value_type &__x)
constexpr void reserve(size_type __n)
constexpr bool empty() const noexcept
constexpr pointer get() const noexcept
Definition of a default type of Histogram Axis It contains number of bins, min and max value plus a t...
std::string const & title() const
void setMinValue(Arithmetic v)
Arithmetic minValue() const
unsigned int numBins() const
void setMaxValue(Arithmetic v)
Arithmetic m_minValue
min and max values on this axis
std::vector< std::string > m_labels
labels for the bins
Axis(unsigned int nBins=0, Arithmetic minValue=Arithmetic{}, Arithmetic maxValue=Arithmetic{}, std::string title={}, std::vector< std::string > labels={})
std::vector< std::string > const & labels() const
bool inAcceptance(Arithmetic value) const
says whether the given value is within the range of the axis
void setNumBins(unsigned int n)
Arithmetic ArithmeticType
Arithmetic maxValue() const
friend std::ostream & operator<<(std::ostream &o, Axis const &axis)
Axis(Gaudi::Histo1DDef const &def)
void setTitle(std::string const &t)
std::string m_title
title of this axis
unsigned int nBins
number of bins for this Axis FIXME : should be private and called m_nBins but will break backward com...
unsigned int index(Arithmetic value) const
returns the bin number for a given value, ranging from 0 (underflow) to nBins+1 (overflow)
Arithmetic m_ratio
precomputed ratio to convert a value into bin number equal to nBins/(maxValue-minValue).
Buffer is a non atomic Accumulator which, when it goes out-of-scope, updates the underlying thread-sa...
BufferableCounter()=default
friend class GenericAccumulator
Internal Accumulator class dealing with Histograming.
auto maxValue(unsigned int i) const
HistogramingAccumulatorInternal(AxisTupleType axis)
auto operator[](typename InputType::ValueType v)
std::integral_constant< unsigned int, std::tuple_size_v< AxisTupleType > > ND
friend class HistogramingAccumulatorInternal
void mergeAndReset(HistogramingAccumulatorInternal< ato, InputType, Arithmetic, BaseAccumulatorT, AxisTupleType > &other)
auto & _getAxis(size_t i, std::integral_constant< size_t, N >) const
auto binValue(unsigned int i) const
BaseAccumulator & accumulator(unsigned int index) const
std::tuple_element_t< 0, AxisTupleType > const & _getAxis(size_t i, typename std::tuple_size< AxisTupleType >::type) const
HistogramingAccumulatorInternal & operator+=(InputType v)
BaseAccumulatorT< Atomicity, Arithmetic > BaseAccumulator
auto nBins(unsigned int i) const
HistogramingAccumulatorInternal(construct_empty_t, const HistogramingAccumulatorInternal< ato, InputType, Arithmetic, BaseAccumulatorT, AxisTupleType > &other)
typename InputType::ValueType AxisTupleArithmeticType
std::unique_ptr< BaseAccumulator[]> m_value
auto minValue(unsigned int i) const
auto nEntries(unsigned int i) const
friend void reset(HistogramingCounterBase &c)
std::ostream & print(std::ostream &o, bool tableFormat=false) const override
prints the counter to a stream
MsgStream & print(MsgStream &o, bool tableFormat=false) const override
std::tuple< AxisTypes... > AxisTupleType
std::string const & title() const
typename AccumulatorType::AxisTupleArithmeticType AxisTupleArithmeticType
friend void mergeAndReset(HistogramingCounterBase &h, HistogramingCounterBase &o)
std::string const m_title
friend void to_json(nlohmann::json &j, HistogramingCounterBase const &h)
Accumulator< Atomicity, Arithmetic, NumberDimensions, AxisTupleType > AccumulatorType
HistogramingCounterBase(OWNER *owner, std::string const &name, std::string const &title, AxisTypes... allAxis)
This constructor takes the axis one by one, when ND >= 2. If ND = 1, the other one can be used.
stream & printImpl(stream &o, bool) const
typename std::tuple_element< 0, AxisTupleType >::type::ArithmeticType AxisArithmeticType
for backward compatibility with previous implementation, should not be used FIXME
std::integral_constant< unsigned int, ND > NumberDimensions
static const std::string typeString
HistogramingCounterBase(OWNER *owner, std::string const &name, std::string const &title, AxisTupleType axis)
This constructor takes the axis as a tuple.
virtual void to_json(nlohmann::json &j) const
BufferableCounter< Atomicity, Accumulator, Arithmetic, NumberDimensions, AxisTupleType > Parent
A base counter dealing with Histograms.
Simple helper class for description of 1D-histogram The class is targeted to act as the primary "hist...
GaudiException(std::string Message, std::string Tag, StatusCode Code)
Constructor (1).
Definition of the MsgStream class used to transmit messages.
constexpr static const auto FAILURE
void requireValidTitle(std::string_view sv)
constexpr char profilehistogramString[]
constexpr char histogramString[]
constexpr char weightedProfilehistogramString[]
constexpr char weightedHistogramString[]
Efficient counter implementations for Gaudi.
AveragingAccumulatorBase< Atomicity, Arithmetic, WeightedCountAccumulator, WeightedSumAccumulator > WeightedAveragingAccumulator
WeightedAveragingAccumulator.
HistogramingAccumulatorInternal< Atomicity, WeightedHistoInputType< ProfileAxisToArithmetic_t< Arithmetic, AxisTupleType >, ND::value, Arithmetic >, Arithmetic, WeightedSigmaAccumulator, AxisTupleType > WeightedProfileHistogramingAccumulator
Class implementing a weighted profile histogram accumulator.
void to_json(nlohmann::json &j, const Axis< Arithmetic > &axis)
automatic conversion of the Axis type to json
HistogramingAccumulatorInternal< Atomicity, WeightedHistoInputType< AxisToArithmetic_t< AxisTupleType >, ND::value, Arithmetic >, Arithmetic, WeightedCountAccumulator, AxisTupleType > WeightedHistogramingAccumulator
Class implementing a weighted histogram accumulator.
HistogramingAccumulatorInternal< Atomicity, HistoInputType< AxisToArithmetic_t< AxisTupleType >, ND::value >, unsigned long, IntegralAccumulator, AxisTupleType > HistogramingAccumulator
Class implementing a regular histogram accumulator.
HistogramingCounterBase< ND, Atomicity, Arithmetic, naming::histogramString, HistogramingAccumulator, AxisTupleType > StaticHistogram
standard static histograming counter. See HistogramingCounterBase for details
HistogramingCounterBase< ND, Atomicity, Arithmetic, naming::weightedProfilehistogramString, WeightedProfileHistogramingAccumulator, AxisTupleType > StaticWeightedProfileHistogram
weighted static profile histograming counter. See HistogramingCounterBase for details
atomicity
Defines atomicity of the accumulators.
HistogramingAccumulatorInternal< Atomicity, HistoInputType< ProfileAxisToArithmetic_t< Arithmetic, AxisTupleType >, ND::value >, Arithmetic, SigmaAccumulator, AxisTupleType > ProfileHistogramingAccumulator
Class implementing a profile histogram accumulator.
HistogramingCounterBase< ND, Atomicity, Arithmetic, naming::profilehistogramString, ProfileHistogramingAccumulator, AxisTupleType > StaticProfileHistogram
profile static histograming counter. See HistogramingCounterBase for details
HistogramingCounterBase< ND, Atomicity, Arithmetic, naming::weightedHistogramString, WeightedHistogramingAccumulator, AxisTupleType > StaticWeightedHistogram
standard static histograming counter with weight. See HistogramingCounterBase for details
void fetch_add(AtomicType &atVar, Arithmetic value)
generic fetch_add, also dealing with atomic types with no fetch_add member method
SigmaAccumulatorBase< Atomicity, Arithmetic, WeightedAveragingAccumulator, WeightedSquareAccumulator > WeightedSigmaAccumulator
WeightedSigmaAccumulator.
SigmaAccumulatorBase< Atomicity, Arithmetic, AveragingAccumulator, SquareAccumulator > SigmaAccumulator
SigmaAccumulator.
AveragingAccumulatorBase.
An Adder ValueHandler, taking weight into account and computing a count plus the sum of the weights I...
static constexpr bool isAtomic
std::conditional_t< isAtomic, AtomicType, OutputType > InternalType
static RegularType exchange(InternalType &v, RegularType newv) noexcept
std::pair< std::atomic< unsigned long >, std::atomic< Arithmetic > > AtomicType
static constexpr OutputType DefaultValue()
static constexpr OutputType getValue(const InternalType &v) noexcept
static void merge(InternalType &a, RegularType b) noexcept
std::pair< unsigned long, Arithmetic > RegularType
WeightedCountAccumulator.
Arithmetic sumOfWeights() const
unsigned long nEntries() const
GenericAccumulator< std::pair< Arithmetic, Arithmetic >, std::pair< unsigned long, Arithmetic >, Atomicity, WeightedProfileTransform, ExtractWeight, WeightedAdder< Arithmetic, Atomicity > > Base
WeightedCountAccumulator operator+=(const Arithmetic weight)
overload of operator+= to be able to only give weight and no value
A Product functor, take a pair (value, weight) as input.
WeightedSquareAccumulator.
A WeightedSquare functor, take a pair (value, weight) as input.
constant used to disambiguate construction of an empty Accumulator versus the copy constructor.