Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic > Struct Template Reference

BinomialAccumulator. More...

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

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

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

Classes
struct	binomial_t

Public Member Functions
unsigned long	nEntries () const
template<typename Result = fp_result_type<Arithmetic>>
auto	efficiency () const
auto	eff () const
template<typename Result = fp_result_type<Arithmetic>>
auto	efficiencyErr () const
auto	effErr () const
BinomialAccumulator &	operator+= (binomial_t b)
Public Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< bool, Atomicity, bool, TrueAccumulator, FalseAccumulator >
constexpr	AccumulatorSet ()=default
	AccumulatorSet (construct_empty_t, const AccumulatorSet< bool, ato, InputType, TrueAccumulator ... > &)
	constructor of an empty AccumulatorSet, copying the (non existent) config from another GenericAccumulator More...
AccumulatorSet &	operator+= (const InputType by)
OutputType	value () const
void	reset ()
void	mergeAndReset (AccumulatorSet< bool, Ato, InputType, TrueAccumulator ... > &&other)
void	operator+ (AccumulatorSet< bool, Ato, InputType, TrueAccumulator ... > &&other)
Public Member Functions inherited from Gaudi::Accumulators::TrueAccumulator< Atomicity, bool >
unsigned long	nTrueEntries () const
Public Member Functions inherited from Gaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 >
	GenericAccumulator ()=default
	GenericAccumulator (construct_empty_t, const GenericAccumulator< InputType, unsigned long, ato, TrueTo1, Identity, VH > &)
	constructor of an empty GenericAccumulator, copying the (non existent) config from another GenericAccumulator More...
	GenericAccumulator (std::in_place_t, Args &&... args)
	GenericAccumulator (const GenericAccumulator &other)
GenericAccumulator	operator+= (const InputType by)
GenericAccumulator &	operator= (const GenericAccumulator &other)
OutputType	value () const
void	reset ()
void	mergeAndReset (GenericAccumulator< InputType, unsigned long, ato, TrueTo1, Identity, VH > &&other)
void	operator+ (GenericAccumulator< InputType, unsigned long, ato, TrueTo1, Identity, VH > &&other)

Additional Inherited Members
Public Types inherited from Gaudi::Accumulators::AccumulatorSet< bool, Atomicity, bool, TrueAccumulator, FalseAccumulator >
using	InputType = bool
using	OutputType = std::tuple< typename TrueAccumulator< Atomicity, bool >::OutputType... >
using	InternalType = std::tuple< typename TrueAccumulator< Atomicity, bool >::InternalType... >
using	JSONStringEntriesType = std::tuple< typename TrueAccumulator< Atomicity, bool >::JSONStringEntriesType... >
Public Types inherited from Gaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 >
using	InputType = bool
using	OutputType = std::decay_t< std::result_of_t< Identity(unsigned long)> >
using	InternalType = unsigned long
using	JSONStringEntriesType = std::string
Protected Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< bool, Atomicity, bool, TrueAccumulator, FalseAccumulator >
void	reset (const InternalType &t)
Protected Member Functions inherited from Gaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 >
void	reset (unsigned long in)
auto	rawValue () const
Static Protected Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< bool, Atomicity, bool, TrueAccumulator, FalseAccumulator >
static InternalType	extractJSONData (const nlohmann::json &j, const JSONStringEntriesType &entries)
Static Protected Member Functions inherited from Gaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 >
static unsigned long	extractJSONData (const nlohmann::json &j, const JSONStringEntriesType &entries)

Detailed Description

template<atomicity Atomicity, typename Arithmetic>
struct Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >

BinomialAccumulator.

A BinomialAccumulator is an Accumulator able to compute the efficiency of a process data

See also

Gaudi::Accumulators for detailed documentation

Definition at line 663 of file Accumulators.h.

Member Function Documentation

eff()

template<atomicity Atomicity, typename Arithmetic >

auto Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::eff ( ) const

inline

Definition at line 673 of file Accumulators.h.

{ return efficiency(); }

effErr()

template<atomicity Atomicity, typename Arithmetic >

auto Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::effErr ( ) const

inline

Definition at line 685 of file Accumulators.h.

{ return efficiencyErr(); }

efficiency()

template<atomicity Atomicity, typename Arithmetic >

template<typename Result = fp_result_type<Arithmetic>>

auto Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::efficiency ( ) const

inline

Definition at line 668 of file Accumulators.h.

                            {
      auto nbEntries = nEntries();
      if ( 1 > nbEntries ) return Result{ -1 };
      return static_cast<Result>( this->nTrueEntries() ) / nbEntries;
    }

efficiencyErr()

template<atomicity Atomicity, typename Arithmetic >

template<typename Result = fp_result_type<Arithmetic>>

auto Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::efficiencyErr ( ) const

inline

Definition at line 676 of file Accumulators.h.

                               {
      // Note the usage of using, aiming at using the std version of sqrt by default, without preventing
      // more specialized versions to be used via ADL (see http://en.cppreference.com/w/cpp/language/adl)
      using Gaudi::Accumulators::sqrt;
      using std::sqrt;
      auto nbEntries = nEntries();
      if ( 1 > nbEntries ) return Result{ -1 };
      return sqrt( static_cast<Result>( this->nTrueEntries() * this->nFalseEntries() ) / nbEntries ) / nbEntries;
    }

nEntries()

template<atomicity Atomicity, typename Arithmetic >

unsigned long Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::nEntries ( ) const

inline

Definition at line 665 of file Accumulators.h.

{ return this->nTrueEntries() + this->nFalseEntries(); };

operator+=()

template<atomicity Atomicity, typename Arithmetic >

BinomialAccumulator& Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::operator+= ( binomial_t  b )

inline

Definition at line 691 of file Accumulators.h.

                                                    {
      assert( b.nPass <= b.nTotal );
      TrueAccumulator<Atomicity, bool>::mergeAndReset(
          TrueAccumulator<atomicity::none, bool>{ std::in_place, b.nPass } );
      FalseAccumulator<Atomicity, bool>::mergeAndReset(
          FalseAccumulator<atomicity::none, bool>{ std::in_place, b.nTotal - b.nPass } );
      return *this;
    }

---

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

• GaudiKernel/include/Gaudi/Accumulators.h