Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND > Struct Template Reference

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

Classes
struct	OutputTypeTS

Public Types
using	InputType = std::conditional_t<ND == 1, Arithmetic, std::array<Arithmetic, ND>>
using	OutputType = std::array<Arithmetic, NSUMS( ND )>
using	InternalType = std::conditional_t<Atomicity == atomicity::full, OutputTypeTS, OutputType>

Static Public Member Functions
static constexpr OutputType	getValue (const InternalType &v) noexcept
static OutputType	exchange (InternalType &v, OutputType newv) noexcept
static constexpr OutputType	DefaultValue ()
static void	merge (InternalType &a, const OutputType &b) noexcept
static void	merge (InternalType &a, InputType b) noexcept

Detailed Description

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>
struct Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >

Definition at line 32 of file StaticRootHistogram.h.

Member Typedef Documentation

InputType

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>

using Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::InputType = std::conditional_t<ND == 1, Arithmetic, std::array<Arithmetic, ND>>

Definition at line 33 of file StaticRootHistogram.h.

InternalType

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>

using Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::InternalType = std::conditional_t<Atomicity == atomicity::full, OutputTypeTS, OutputType>

Definition at line 53 of file StaticRootHistogram.h.

OutputType

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>

using Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::OutputType = std::array<Arithmetic, NSUMS( ND )>

Definition at line 34 of file StaticRootHistogram.h.

Member Function Documentation

DefaultValue()

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>

constexpr OutputType Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::DefaultValue ( )

inlinestaticconstexpr

Definition at line 67 of file StaticRootHistogram.h.

{ return InternalType{}; }

exchange()

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>

OutputType Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::exchange ( InternalType & v, OutputType newv )

inlinestaticnoexcept

Definition at line 58 of file StaticRootHistogram.h.

                                                                            {
      if constexpr ( Atomicity == atomicity::full ) {
        OutputType old;
        for ( unsigned int i = 0; i < NSUMS( ND ); i++ ) { old[i] = v[i].exchange( newv[i] ); }
        return old;
      } else {
        return std::exchange( v, newv );
      }
    }

getValue()

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>

constexpr OutputType Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::getValue ( const InternalType & v )

inlinestaticconstexprnoexcept

Definition at line 54 of file StaticRootHistogram.h.

                                                                           {
      // Note automatic conversion will happen
      return v;
    };

merge() [1/2]

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>

void Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::merge ( InternalType & a, const OutputType & b )

inlinestaticnoexcept

Definition at line 68 of file StaticRootHistogram.h.

                                                                                       {
      if constexpr ( Atomicity == atomicity::full ) {
        for ( unsigned int i = 0; i < NSUMS( ND ); i++ ) { fetch_add( a[i], b[i] ); }
      } else {
        for ( unsigned int i = 0; i < ND * ( ND + 3 ); i++ ) a[i] += b[i];
      }
    }

merge() [2/2]

template<typename Arithmetic, atomicity Atomicity, unsigned int ND>

void Gaudi::Accumulators::SigmasValueHandler< Arithmetic, Atomicity, ND >::merge ( InternalType & a, InputType b )

inlinestaticnoexcept

Definition at line 75 of file StaticRootHistogram.h.

                                                               {
      // prepare values to increment internal values
      OutputType diff{};
      diff[0] = 1.;
      if constexpr ( ND == 1 ) {
        // no operator[] for b in this case
        diff[1] = b;
        diff[2] = b * b;
      } else {
        for ( unsigned int i = 0; i < ND; i++ ) diff[i + 1] += b[i];
        unsigned int n = 1 + ND;
        for ( unsigned int i = 0; i < ND; i++ ) {
          for ( unsigned int j = i; j < ND; j++ ) {
            diff[n] = b[i] * b[j];
            n++;
          }
        }
      }
      // Now increase original counter
      if constexpr ( Atomicity == atomicity::full ) {
        for ( unsigned int i = 0; i < NSUMS( ND ); i++ ) { fetch_add( a[i], diff[i] ); }
      } else {
        for ( unsigned int i = 0; i < NSUMS( ND ); i++ ) a[i] += diff[i];
      }
    }

---

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

• GaudiKernel/include/Gaudi/Accumulators/StaticRootHistogram.h