A counter aiming at computing average and sum2 / variance / standard deviation. More...

#include </builds/gaudi/Gaudi/GaudiKernel/include/Gaudi/Accumulators.h>

Inheritance diagram for Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >:

[legend]

Collaboration diagram for Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >:

[legend]

Public Member Functions
template<typename OWNER>
	StatCounter (OWNER *o, std::string const &name)

template<typename stream>
stream &	printImpl (stream &o, bool tableFormat) const

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

bool	toBePrinted () const override
	hint whether we should print that counter or not.

Public Member Functions inherited from Gaudi::Accumulators::BufferableCounter< atomicity::full, StatAccumulator, double >
	BufferableCounter ()=default

	BufferableCounter (OWNER *o, std::string const &name)

	BufferableCounter (BufferableCounter const &)=delete

BufferType	buffer ()

BufferableCounter &	operator= (BufferableCounter const &)=delete

	~BufferableCounter ()

Public Member Functions inherited from Gaudi::Accumulators::PrintableCounter
	PrintableCounter ()=default

virtual	~PrintableCounter ()=default
	destructor

template<typename stream>
stream &	printImpl (stream &s, std::string_view tag) const

virtual std::ostream &	print (std::ostream &o, std::string_view tag) const
	prints the counter to a stream in table format, with the given tag

virtual MsgStream &	print (MsgStream &o, std::string_view tag) const

std::string	toString () const
	get a string representation

Public Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, Arithmetic, SigmaAccumulator, MinAccumulator, MaxAccumulator >
constexpr	AccumulatorSet ()=default

	AccumulatorSet (construct_empty_t, const AccumulatorSet< Arithmetic, ato, InputType, SigmaAccumulator... > &)
	constructor of an empty AccumulatorSet, copying the (non existent) config from another GenericAccumulator

AccumulatorSet &	operator+= (const InputType by)

OutputType	value () const

void	reset ()

void	mergeAndReset (AccumulatorSet< Arithmetic, Ato, InputType, SigmaAccumulator... > &other)

void	operator+ (AccumulatorSet< Arithmetic, Ato, InputType, SigmaAccumulator... > &&other)

constexpr	AccumulatorSet ()=default

	AccumulatorSet (construct_empty_t, const AccumulatorSet< Arithmetic, ato, InputType, SigmaAccumulator... > &)
	constructor of an empty AccumulatorSet, copying the (non existent) config from another GenericAccumulator

AccumulatorSet &	operator+= (const InputType by)

OutputType	value () const

void	reset ()

void	mergeAndReset (AccumulatorSet< Arithmetic, Ato, InputType, SigmaAccumulator... > &other)

void	operator+ (AccumulatorSet< Arithmetic, Ato, InputType, SigmaAccumulator... > &&other)

Public Member Functions inherited from Gaudi::Accumulators::SigmaAccumulatorBase< Atomicity, Arithmetic, AveragingAccumulator, SquareAccumulator >
auto	biased_sample_variance () const

auto	unbiased_sample_variance () const

auto	standard_deviation () const

Arithmetic	rms () const

auto	meanErr () const

auto	biased_sample_variance () const

auto	unbiased_sample_variance () const

auto	standard_deviation () const

Arithmetic	rms () const

auto	meanErr () const

Public Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, InputTypeT, Bases >
constexpr	AccumulatorSet ()=default

template<atomicity ato>
	AccumulatorSet (construct_empty_t, const AccumulatorSet< Arithmetic, ato, InputType, Bases... > &)
	constructor of an empty AccumulatorSet, copying the (non existent) config from another GenericAccumulator

AccumulatorSet &	operator+= (const InputType by)

OutputType	value () const

void	reset ()

template<atomicity Ato>
void	mergeAndReset (AccumulatorSet< Arithmetic, Ato, InputType, Bases... > &other)

template<atomicity Ato>
void	operator+ (AccumulatorSet< Arithmetic, Ato, InputType, Bases... > &&other)

Static Public Member Functions
static StatCounter	fromJSON (const nlohmann::json &j)

Static Public Attributes
static const std::string	typeString { std::string{ "counter:StatCounter:" } + typeid( Arithmetic ).name() }

Static Public Attributes inherited from Gaudi::Accumulators::BufferableCounter< atomicity::full, StatAccumulator, double >
static const std::string	typeString

Friends
void	reset (StatCounter &c)

void	mergeAndReset (StatCounter &c, StatCounter &o)

void	to_json (nlohmann::json &j, StatCounter const &c)

Additional Inherited Members
Public Types inherited from Gaudi::Accumulators::BufferableCounter< atomicity::full, StatAccumulator, double >
using	BufferType

Public Types inherited from Gaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, Arithmetic, SigmaAccumulator, MinAccumulator, MaxAccumulator >
using	InputType

using	OutputType

using	InternalType

using	JSONStringEntriesType

Public Types inherited from Gaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, InputTypeT, Bases >
using	InputType = InputTypeT

using	OutputType = std::tuple<typename Bases<Atomicity, Arithmetic>::OutputType...>

using	InternalType = std::tuple<typename Bases<Atomicity, Arithmetic>::InternalType...>

using	JSONStringEntriesType = std::tuple<typename Bases<Atomicity, Arithmetic>::JSONStringEntriesType...>

Protected Member Functions inherited from Gaudi::Accumulators::BufferableCounter< atomicity::full, StatAccumulator, double >
	BufferableCounter (OWNER *o, std::string const &name, SELF &self, CARGS... args)

Protected Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, Arithmetic, SigmaAccumulator, MinAccumulator, MaxAccumulator >
	AccumulatorSet (const InternalType &t)

void	reset (const InternalType &t)

	AccumulatorSet (const InternalType &t)

void	reset (const InternalType &t)

Protected Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, InputTypeT, Bases >
	AccumulatorSet (const InternalType &t)

void	reset (const InternalType &t)

Static Protected Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, Arithmetic, SigmaAccumulator, MinAccumulator, MaxAccumulator >
static InternalType	extractJSONData (const nlohmann::json &j, const JSONStringEntriesType &entries)

static InternalType	extractJSONData (const nlohmann::json &j, const JSONStringEntriesType &entries)

Static Protected Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< Arithmetic, Atomicity, InputTypeT, Bases >
static InternalType	extractJSONData (const nlohmann::json &j, const JSONStringEntriesType &entries)

Detailed Description

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>
struct Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >

A counter aiming at computing average and sum2 / variance / standard deviation.

See also: Gaudi::Accumulators for detailed documentation

Definition at line 1053 of file Accumulators.h.

Constructor & Destructor Documentation

◆ StatCounter()

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

template<typename OWNER>

Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >::StatCounter	(	OWNER *	o,
		std::string const &	name )

inline

Definition at line 1057 of file Accumulators.h.

1058 : BufferableCounter<Atomicity, StatAccumulator, Arithmetic>( o, name, *this ) {}

Gaudi::Accumulators::BufferableCounter< atomicity::full, StatAccumulator, double >::BufferableCounter

BufferableCounter()=default

Gaudi::Accumulators::StatCounter

A counter aiming at computing average and sum2 / variance / standard deviation.

Definition Accumulators.h:1053

Member Function Documentation

◆ fromJSON()

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

static StatCounter Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >::fromJSON ( const nlohmann::json & j )

inlinestatic

Definition at line 1087 of file Accumulators.h.

                                                         {
      return StatAccumulator<Atomicity, Arithmetic>::extractJSONData(
          j, { { { "nEntries", "sum" }, "sum2" }, "min", "max" } );
    }

◆ print() [1/2]

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

MsgStream & Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >::print	(	MsgStream &	o,
		bool	tableFormat = false ) const

inlineoverridevirtual

Implements Gaudi::Accumulators::PrintableCounter.

Definition at line 1072 of file Accumulators.h.

1072{ return printImpl( o, tableFormat ); }

Gaudi::Accumulators::StatCounter::printImpl

stream & printImpl(stream &o, bool tableFormat) const

Definition Accumulators.h:1062

◆ print() [2/2]

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

std::ostream & Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >::print	(	std::ostream &	,
		bool	tableFormat = false ) const

inlineoverridevirtual

prints the counter to a stream

Implements Gaudi::Accumulators::PrintableCounter.

Definition at line 1069 of file Accumulators.h.

                                                                                {
      return printImpl( o, tableFormat );
    }

◆ printImpl()

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

template<typename stream>

stream & Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >::printImpl	(	stream &	o,
		bool	tableFormat ) const

inline

Definition at line 1062 of file Accumulators.h.

                                                           {
      auto fmt = ( tableFormat ? "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |"
                               : "#=%|-7lu| Sum=%|-11.5g| Mean=%|#10.4g| +- %|-#10.5g| Min/Max=%|#10.4g|/%|-#10.4g|" );
      return o << boost::format{ fmt } % this->nEntries() % this->sum() % this->mean() % this->standard_deviation() %
                      this->min() % this->max();
    }

◆ toBePrinted()

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

bool Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >::toBePrinted ( ) const

inlineoverridevirtual

hint whether we should print that counter or not.

Typically empty counters may not be printed

Reimplemented from Gaudi::Accumulators::PrintableCounter.

Definition at line 1073 of file Accumulators.h.

1073{ return this->nEntries() > 0; }

Friends And Related Symbol Documentation

◆ mergeAndReset

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

void mergeAndReset	(	StatCounter< Arithmetic, Atomicity > &	c,
		StatCounter< Arithmetic, Atomicity > &	o )

friend

Definition at line 1075 of file Accumulators.h.

1075{ c.mergeAndReset( o ); }

Gaudi::Accumulators::StatCounter::mergeAndReset

friend void mergeAndReset(StatCounter &c, StatCounter &o)

Definition Accumulators.h:1075

◆ reset

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

void reset ( StatCounter< Arithmetic, Atomicity > & c )

friend

Definition at line 1074 of file Accumulators.h.

1074{ c.reset(); }

Gaudi::Accumulators::StatCounter::reset

friend void reset(StatCounter &c)

Definition Accumulators.h:1074

◆ to_json

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

void to_json	(	nlohmann::json &	j,
		StatCounter< Arithmetic, Atomicity > const &	c )

friend

Definition at line 1076 of file Accumulators.h.

                                                                 {
      j = { { "type", c.typeString },
            { "empty", c.nEntries() == 0 },
            { "nEntries", c.nEntries() },
            { "sum", c.sum() },
            { "mean", c.mean() },
            { "sum2", c.sum2() },
            { "standard_deviation", c.standard_deviation() },
            { "min", c.min() },
            { "max", c.max() } };
    }

Member Data Documentation

◆ typeString

template<typename Arithmetic = double, atomicity Atomicity = atomicity::full>

const std::string Gaudi::Accumulators::StatCounter< Arithmetic, Atomicity >::typeString { std::string{ "counter:StatCounter:" } + typeid( Arithmetic ).name() }

inlinestatic

Definition at line 1054 of file Accumulators.h.

1054{ std::string{ "counter:StatCounter:" } + typeid( Arithmetic ).name() };

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

GaudiKernel/include/Gaudi/Accumulators.h

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ StatCounter()

Member Function Documentation

◆ fromJSON()

◆ print() [1/2]

◆ print() [2/2]

◆ printImpl()

◆ toBePrinted()

Friends And Related Symbol Documentation

◆ mergeAndReset

◆ reset

◆ to_json

Member Data Documentation

◆ typeString