Counters.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_COUNTERS_H
#define GAUDIKERNEL_COUNTERS_H 1

#include "boost/algorithm/string/predicate.hpp"
#include "boost/format.hpp"
#include <atomic>
#include <cmath>
#include <initializer_list>
#include <iostream>
#include <limits>
#include <sstream>
#include <tuple>
#include <type_traits>
#include <utility>

#include "GaudiKernel/apply.h"
#include "GaudiKernel/detected.h"

namespace Gaudi
{
  namespace Accumulators
  {

    enum class atomicity { none, full };

    template <unsigned long N>
    struct Constant {
      template <typename U>
      constexpr unsigned long operator()( U&& ) const noexcept
      {
        return N;
      }
    };

    struct Identity {
      template <typename U>
      constexpr decltype( auto ) operator()( U&& v ) const noexcept
      {
        return std::forward<U>( v );
      }
    };

    struct Square {
      template <typename U>
      constexpr decltype( auto ) operator()( U&& v ) const noexcept
      {
        return v * v;
      }
    };

    template <typename T, typename = int>
    using has_fetch_add_ = decltype( std::atomic<T>{}.fetch_add( 0 ) );
    template <typename T>
    using has_fetch_add = typename Gaudi::cpp17::is_detected<has_fetch_add_, T>::value_t;

    template <typename Arithmetic, typename Result = double>
    using fp_result_type = std::conditional_t<std::is_integral<Arithmetic>::value, Result, Arithmetic>;

    template <typename Arithmetic, atomicity Atomicity>
    struct BaseValueHandler;

    template <typename Arithmetic>
    struct BaseValueHandler<Arithmetic, atomicity::none> {
      using OutputType   = Arithmetic;
      using InternalType = Arithmetic;
      static constexpr OutputType getValue( const InternalType& v ) noexcept { return v; };
      static Arithmetic exchange( InternalType& v, Arithmetic newv ) noexcept { return std::exchange( v, newv ); }
    };

    template <typename Arithmetic>
    struct BaseValueHandler<Arithmetic, atomicity::full> {
      using OutputType   = Arithmetic;
      using InternalType = std::atomic<Arithmetic>;
      static constexpr OutputType getValue( const InternalType& v ) noexcept
      {
        return v.load( std::memory_order_relaxed );
      };
      static Arithmetic exchange( InternalType& v, Arithmetic newv ) noexcept { return v.exchange( newv ); }
    };

    template <typename Arithmetic, atomicity Atomicity = atomicity::full>
    struct Adder;

    template <typename Arithmetic>
    struct Adder<Arithmetic, atomicity::none> : BaseValueHandler<Arithmetic, atomicity::none> {
      using typename BaseValueHandler<Arithmetic, atomicity::none>::OutputType;
      using typename BaseValueHandler<Arithmetic, atomicity::none>::InternalType;
      static constexpr OutputType DefaultValue() { return Arithmetic{}; }
      static void merge( InternalType& a, Arithmetic b ) noexcept { a += b; };
    };

    template <typename Arithmetic>
    struct Adder<Arithmetic, atomicity::full> : BaseValueHandler<Arithmetic, atomicity::full> {
      using typename BaseValueHandler<Arithmetic, atomicity::full>::OutputType;
      using typename BaseValueHandler<Arithmetic, atomicity::full>::InternalType;
      static constexpr OutputType DefaultValue() { return Arithmetic{}; }
#if __cplusplus > 201402L
      static void merge( InternalType& a, Arithmetic b ) noexcept
      {
        if ( DefaultValue() == b ) return; // avoid atomic operation if b is "0"
        // C++ 17 version
        if
          constexpr( has_fetch_add<InternalType>::value ) { a.fetch_add( b, std::memory_order_relaxed ); }
        else {
          auto current = BaseValueHandler<Arithmetic, atomicity::full>::getValue( a );
          while ( !a.compare_exchange_weak( current, current + b ) )
            ;
        }
      };
#else
      // C++11 version
    private:
      template <typename T>
      static void add( InternalType& a, T b, std::false_type )
      {
        auto current = a.load( std::memory_order_relaxed );
        while ( !a.compare_exchange_weak( current, current + b ) )
          ;
      }
      template <typename T>
      static void add( InternalType& a, T b, std::true_type )
      {
        a.fetch_add( b, std::memory_order_relaxed );
      }

    public:
      static void merge( InternalType& a, Arithmetic b ) noexcept
      {
        if ( DefaultValue() == b ) return; // avoid atomic operation if b is "0"
        add( a, b, has_fetch_add<InternalType>{} );
      }
#endif
    };

    template <typename Arithmetic, atomicity Atomicity, typename Compare, Arithmetic ( *Initial )()>
    struct Extremum;

    template <typename Arithmetic, typename Compare, Arithmetic ( *Initial )()>
    struct Extremum<Arithmetic, atomicity::none, Compare, Initial> : BaseValueHandler<Arithmetic, atomicity::none> {
      using typename BaseValueHandler<Arithmetic, atomicity::none>::OutputType;
      using typename BaseValueHandler<Arithmetic, atomicity::none>::InternalType;
      static constexpr OutputType DefaultValue() { return Initial(); }
      static void merge( InternalType& a, Arithmetic b ) noexcept
      {
        if ( Compare{}( b, a ) ) a = b;
      };
    };

    template <typename Arithmetic, typename Compare, Arithmetic ( *Initial )()>
    struct Extremum<Arithmetic, atomicity::full, Compare, Initial> : BaseValueHandler<Arithmetic, atomicity::full> {
      using typename BaseValueHandler<Arithmetic, atomicity::full>::OutputType;
      using typename BaseValueHandler<Arithmetic, atomicity::full>::InternalType;
      static constexpr OutputType DefaultValue() { return Initial(); }
      static void merge( InternalType& a, Arithmetic b ) noexcept
      {
        Arithmetic prev_value = BaseValueHandler<Arithmetic, atomicity::full>::getValue( a );
        while ( Compare{}( b, prev_value ) && !a.compare_exchange_weak( prev_value, b ) )
          ;
      };
    };

    template <typename Arithmetic, atomicity Atomicity = atomicity::full>
    using Minimum = Extremum<Arithmetic, Atomicity, std::less<Arithmetic>, std::numeric_limits<Arithmetic>::max>;

    template <typename Arithmetic, atomicity Atomicity = atomicity::full>
    using Maximum = Extremum<Arithmetic, Atomicity, std::greater<Arithmetic>, std::numeric_limits<Arithmetic>::lowest>;

    template <typename InputType, typename InnerType, atomicity Atomicity = atomicity::full,
              typename InputTransform = Identity, typename OutputTransform = Identity,
              typename ValueHandler = Adder<InnerType, Atomicity>>
    class GenericAccumulator
    {
      template <typename A, typename B, atomicity C, typename D, typename E, typename F>
      friend class GenericAccumulator;

    public:
      using OutputType = std::decay_t<std::result_of_t<OutputTransform( InnerType )>>;
      GenericAccumulator operator+=( const InputType by )
      {
        ValueHandler::merge( m_value, InputTransform{}( by ) );
        return *this;
      }
      GenericAccumulator() : m_value( ValueHandler::DefaultValue() ) {}
      GenericAccumulator( const GenericAccumulator& other ) : m_value( ValueHandler::getValue( other.m_value ) ) {}
      GenericAccumulator& operator=( const GenericAccumulator& other )
      {
        m_value = ValueHandler::getValue( other.m_value );
        return *this;
      }
      OutputType          value() const { return OutputTransform{}( ValueHandler::getValue( m_value ) ); }
      void                reset() { reset( ValueHandler::DefaultValue() ); }
      template <atomicity ato, typename VH>
      void mergeAndReset( GenericAccumulator<InputType, InnerType, ato, InputTransform, OutputTransform, VH>&& other )
      {
        auto otherValue = VH::exchange( other.m_value, VH::DefaultValue() );
        ValueHandler::merge( m_value, otherValue );
      }

    protected:
      void reset( InnerType in ) { m_value = std::move( in ); }

    private:
      typename ValueHandler::InternalType m_value;
    };

    template <typename Arithmetic, atomicity Atomicity, template <typename, atomicity> class... Bases>
    class AccumulatorSet : public Bases<Arithmetic, Atomicity>...
    {
    public:
      using InputType            = Arithmetic;
      using OutputType           = std::tuple<typename Bases<Arithmetic, Atomicity>::OutputType...>;
      constexpr AccumulatorSet() = default;
      AccumulatorSet& operator+=( const InputType by )
      {
        (void)std::initializer_list<int>{( Bases<Arithmetic, Atomicity>::operator+=( by ), 0 )...};
        return *this;
      }
      OutputType          value() const { return std::make_tuple( Bases<Arithmetic, Atomicity>::value()... ); }
      void                reset() { (void)std::initializer_list<int>{( Bases<Arithmetic, Atomicity>::reset(), 0 )...}; }
      template <atomicity Ato>
      void mergeAndReset( AccumulatorSet<Arithmetic, Ato, Bases...>&& other )
      {
        (void)std::initializer_list<int>{
            ( Bases<Arithmetic, Atomicity>::mergeAndReset( static_cast<Bases<Arithmetic, Ato>&&>( other ) ), 0 )...};
      }

    protected:
      void reset( const std::tuple<typename Bases<Arithmetic, Atomicity>::OutputType...>& t )
      {
        Gaudi::apply(
            [this]( const auto&... i ) {
              (void)std::initializer_list<int>{( this->Bases<Arithmetic, Atomicity>::reset( i ), 0 )...};
            },
            t );
      }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct MaxAccumulator
        : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity, Identity, Maximum<Arithmetic, Atomicity>> {
      Arithmetic max() const { return this->value(); }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct MinAccumulator
        : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity, Identity, Minimum<Arithmetic, Atomicity>> {
      Arithmetic min() const { return this->value(); }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct CountAccumulator : GenericAccumulator<Arithmetic, unsigned long, Atomicity, Constant<1>> {
      unsigned long nEntries() const { return this->value(); }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct SumAccumulator : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Identity> {
      Arithmetic sum() const { return this->value(); }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct SquareAccumulator : GenericAccumulator<Arithmetic, Arithmetic, Atomicity, Square> {
      Arithmetic sum2() const { return this->value(); };
    };

    struct TrueTo1 {
      unsigned int operator()( bool v ) const { return v; }
    };

    template <typename Arithmetic, atomicity Atomicity>
    struct TrueAccumulator : GenericAccumulator<Arithmetic, unsigned long, Atomicity, TrueTo1> {
      unsigned long nTrueEntries() const { return this->value(); };
    };

    struct FalseTo1 {
      unsigned int operator()( bool v ) const { return !v; }
    };

    template <typename Arithmetic, atomicity Atomicity>
    struct FalseAccumulator : GenericAccumulator<Arithmetic, unsigned long, Atomicity, FalseTo1> {
      unsigned long nFalseEntries() const { return this->value(); };
    };

    template <typename Arithmetic, atomicity Atomicity = atomicity::full>
    struct BinomialAccumulator : AccumulatorSet<bool, Atomicity, TrueAccumulator, FalseAccumulator> {
      unsigned long nEntries() const { return this->nTrueEntries() + this->nFalseEntries(); };

      template <typename Result = fp_result_type<Arithmetic>>
      auto efficiency() const
      {
        auto nbEntries = nEntries();
        if ( 1 > nbEntries ) return Result{-1};
        return static_cast<Result>( this->nTrueEntries() ) / nbEntries;
      }
      auto eff() const { return efficiency(); }

      template <typename Result = fp_result_type<Arithmetic>>
      auto efficiencyErr() const
      {
        // 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 std::sqrt;
        auto nbEntries = nEntries();
        if ( 1 > nbEntries ) return Result{-1};
        return sqrt( static_cast<Result>( this->nTrueEntries() * this->nFalseEntries() ) / nbEntries ) / nbEntries;
      }
      auto effErr() const { return efficiencyErr(); }
    };

    template <typename Arithmetic, atomicity Atomicity = atomicity::full>
    struct AveragingAccumulator : AccumulatorSet<Arithmetic, Atomicity, CountAccumulator, SumAccumulator> {

      template <typename Result = fp_result_type<Arithmetic>>
      auto mean() const
      {
        auto n = this->nEntries();
        return ( n > 0 ) ? static_cast<Result>( this->sum() ) / n : Result{};
      }
    };

    template <typename Arithmetic, atomicity Atomicity = atomicity::full>
    struct SigmaAccumulator : AccumulatorSet<Arithmetic, Atomicity, AveragingAccumulator, SquareAccumulator> {

      template <typename Result = fp_result_type<Arithmetic>>
      auto biased_sample_variance() const
      {
        auto   n   = this->nEntries();
        Result sum = this->sum();
        return ( n > 0 ) ? ( this->sum2() - sum * ( sum / n ) ) / n : Result{};
      }

      template <typename Result = fp_result_type<Arithmetic>>
      auto unbiased_sample_variance() const
      {
        auto   n   = this->nEntries();
        Result sum = this->sum();
        return ( n > 1 ) ? ( this->sum2() - sum * ( sum / n ) ) / ( n - 1 ) : Result{};
      }

      template <typename Result = fp_result_type<Arithmetic>>
      auto standard_deviation() const
      {
        // 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 std::sqrt;
        Result v = biased_sample_variance();
        return ( 0 > v ) ? Result{} : sqrt( v );
      }
      [[deprecated( "The name 'rms' has changed to standard_deviation" )]] Arithmetic rms() const
      {
        return standard_deviation();
      }

      template <typename Result = fp_result_type<Arithmetic>>
      auto meanErr() const
      {
        auto n = this->nEntries();
        if ( 0 == n ) return Result{};
        // 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 std::sqrt;
        Result v = biased_sample_variance();
        return ( 0 > v ) ? Result{} : sqrt( v / n );
      }
    };

    template <typename Arithmetic, atomicity Atomicity = atomicity::full>
    using StatAccumulator = AccumulatorSet<Arithmetic, Atomicity, SigmaAccumulator, MinAccumulator, MaxAccumulator>;

    template <typename Arithmetic, template <typename Int, atomicity Ato> class ContainedAccumulator>
    class Buffer : public ContainedAccumulator<Arithmetic, atomicity::none>
    {
      using prime_type = ContainedAccumulator<Arithmetic, atomicity::full>;
      using base_type  = ContainedAccumulator<Arithmetic, atomicity::none>;

    public:
      Buffer() = delete;
      Buffer( prime_type& p ) : base_type(), m_prime( p ) {}
      Buffer( const Buffer& ) = delete;
      void operator=( const Buffer& ) = delete;
      Buffer( Buffer&& other ) : base_type( other ), m_prime( other.m_prime ) { other.reset(); }
      void             push() { m_prime.mergeAndReset( static_cast<base_type&&>( *this ) ); }
      ~Buffer() { push(); }

    private:
      prime_type& m_prime;
    };

    struct PrintableCounter {
      PrintableCounter() = default;
      template <class OWNER>
      PrintableCounter( OWNER* o, const std::string& tag )
      {
        o->registerCounter( tag, *this );
      }
      virtual ~PrintableCounter() = default;
      virtual std::ostream& print( std::ostream&, bool tableFormat = false ) const = 0;
      virtual std::ostream& print( std::ostream& o, const std::string& tag ) const
      {
        o << boost::format{" | %|-48.48s|%|50t|"} % ( "\"" + tag + "\"" );
        return print( o, true );
      }
      virtual bool toBePrinted() const { return true; }
      std::string toString() const
      {
        std::ostringstream ost;
        print( ost );
        return ost.str();
      }
    };

    inline std::ostream& operator<<( std::ostream& stream, const PrintableCounter& counter )
    {
      return counter.print( stream );
    }

    template <typename Arithmetic, atomicity Atomicity, template <typename Int, atomicity Ato> class Accumulator>
    struct BufferableCounter : PrintableCounter {
      using PrintableCounter::PrintableCounter;
      Buffer<Arithmetic, Accumulator> buffer() { return {*static_cast<Accumulator<Arithmetic, Atomicity>*>( this )}; }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct Counter : BufferableCounter<Arithmetic, Atomicity, Counter>, CountAccumulator<Arithmetic, Atomicity> {
      using BufferableCounter<Arithmetic, Atomicity, Counter>::BufferableCounter;
      Counter& operator++()
      {
        ( *this ) += Arithmetic{};
        return *this;
      }
      Counter operator++( int )
      {
        auto copy = *this;
        ++( *this );
        return copy;
      }
      using BufferableCounter<Arithmetic, Atomicity, Counter>::print;
      std::ostream& print( std::ostream& o, bool tableFormat = false ) const override
      {
        // Avoid printing empty counters in non DEBUG mode
        std::string fmt( "#=%|-7lu|" );
        if ( tableFormat ) {
          fmt = "|%|10d| |";
        }
        o << boost::format{fmt} % this->nEntries();
        return o;
      }
      virtual bool toBePrinted() const override
      {
        return this->nEntries() > 0;
        ;
      }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct AveragingCounter : BufferableCounter<Arithmetic, Atomicity, AveragingCounter>,
                              AveragingAccumulator<Arithmetic, Atomicity> {
      using BufferableCounter<Arithmetic, Atomicity, AveragingCounter>::BufferableCounter;
      using BufferableCounter<Arithmetic, Atomicity, AveragingCounter>::print;
      std::ostream& print( std::ostream& o, bool tableFormat = false ) const override
      {
        std::string fmt;
        if ( tableFormat ) {
          fmt = "|%|10d| |%|11.7g| |%|#11.5g| |";
        } else {
          fmt = "#=%|-7lu| Sum=%|-11.5g| Mean=%|#10.4g|";
        }
        return o << boost::format{fmt} % this->nEntries() % this->sum() % this->mean();
      }
      virtual bool toBePrinted() const override
      {
        return this->nEntries() > 0;
        ;
      }
    };
    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    using SummingCounter = AveragingCounter<Arithmetic, Atomicity>;

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct SigmaCounter : BufferableCounter<Arithmetic, Atomicity, SigmaCounter>,
                          SigmaAccumulator<Arithmetic, Atomicity> {
      using BufferableCounter<Arithmetic, Atomicity, SigmaCounter>::BufferableCounter;
      using BufferableCounter<Arithmetic, Atomicity, SigmaCounter>::print;
      std::ostream& print( std::ostream& o, bool tableFormat = false ) const override
      {
        std::string fmt;
        if ( tableFormat ) {
          fmt = "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |";
        } else {
          fmt = "#=%|-7lu| Sum=%|-11.5g| Mean=%|#10.4g| +- %|-#10.5g|";
        }
        return o << boost::format{fmt} % this->nEntries() % this->sum() % this->mean() % this->standard_deviation();
      }
      virtual bool toBePrinted() const override
      {
        return this->nEntries() > 0;
        ;
      }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct StatCounter : BufferableCounter<Arithmetic, Atomicity, StatCounter>, StatAccumulator<Arithmetic, Atomicity> {
      using BufferableCounter<Arithmetic, Atomicity, StatCounter>::BufferableCounter;
      using BufferableCounter<Arithmetic, Atomicity, StatCounter>::print;
      std::ostream& print( std::ostream& o, bool tableFormat = false ) const override
      {
        std::string fmt;
        if ( tableFormat ) {
          fmt = "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |";
        } else {
          fmt = "#=%|-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();
      }
      virtual bool toBePrinted() const override { return this->nEntries() > 0; }
    };

    template <typename Arithmetic = double, atomicity Atomicity = atomicity::full>
    struct BinomialCounter : BufferableCounter<Arithmetic, Atomicity, BinomialCounter>,
                             BinomialAccumulator<Arithmetic, Atomicity> {
      using BufferableCounter<Arithmetic, Atomicity, BinomialCounter>::BufferableCounter;
      std::ostream& print( std::ostream& o, bool tableFormat = false ) const override
      {
        std::string fmt;
        if ( tableFormat ) {
          fmt = "|%|10d| |%|11.5g| |(%|#9.7g| +- %|-#8.7g|)%% |";
        } else {
          fmt = "#=%|-7lu| Sum=%|-11.5g| Eff=|(%|#9.7g| +- %|-#8.6g|)%%|";
        }
        return o << boost::format{fmt} % this->nEntries() % this->nTrueEntries() % ( this->efficiency() * 100 ) %
                        ( this->efficiencyErr() * 100 );
      }
      virtual std::ostream& print( std::ostream& o, const std::string& tag ) const override
      {
        // override default print to add a '*' in from of the name
        o << boost::format{" |*%|-48.48s|%|50t|"} % ( "\"" + tag + "\"" );
        return print( o, true );
      }
    };

    template <typename Counter, typename Container, typename Fun>
    void accumulate( Counter& counter, const Container& container, Fun f = Identity{} )
    {
      auto b = counter.buffer();
      for ( const auto& elem : container ) b += f( elem );
    }

  } // namespace Accumulators

} // namespace Gaudi

class StatEntity : public Gaudi::Accumulators::PrintableCounter,
                   public Gaudi::Accumulators::AccumulatorSet<double, Gaudi::Accumulators::atomicity::full,
                                                              Gaudi::Accumulators::StatAccumulator,
                                                              Gaudi::Accumulators::BinomialAccumulator>
{
public:
  using AccParent = Gaudi::Accumulators::AccumulatorSet<double, Gaudi::Accumulators::atomicity::full,
                                                        Gaudi::Accumulators::StatAccumulator,
                                                        Gaudi::Accumulators::BinomialAccumulator>;
  using BinomialAccParent = Gaudi::Accumulators::BinomialAccumulator<double, Gaudi::Accumulators::atomicity::full>;
  using Gaudi::Accumulators::StatAccumulator<double, Gaudi::Accumulators::atomicity::full>::nEntries;
  using AccParent::reset;
  StatEntity() = default;
  template <class OWNER>
  StatEntity( OWNER* o, const std::string& tag )
  {
    o->registerCounter( tag, *this );
  }
  StatEntity( const unsigned long entries, const double flag, const double flag2, const double minFlag,
              const double maxFlag )
  {
    reset( std::make_tuple(
        std::make_tuple( std::make_tuple( std::make_tuple( entries, flag ), flag2 ), minFlag, maxFlag ),
        std::make_tuple( 0, 0 ) ) );
  }
  void reset() { AccParent::reset(); }
  void operator=( double by )
  {
    this->reset();
    ( *this ) += by;
  }
  StatEntity& operator-=( double by )
  {
    ( *this ) += ( -by );
    return *this;
  }
  StatEntity& operator++()
  {
    ( *this ) += 1.0;
    return *this;
  }
  StatEntity operator++( int )
  {
    auto copy = *this;
    ++( *this );
    return copy;
  }
  StatEntity& operator--()
  {
    ( *this ) += -1.0;
    return *this;
  }
  StatEntity operator--( int )
  {
    auto copy = *this;
    --( *this );
    return copy;
  }
  bool operator<( const StatEntity& se ) const
  {
    return std::make_tuple( nEntries(), sum(), min(), max(), sum2() ) <
           std::make_tuple( se.nEntries(), se.sum(), se.min(), se.max(), se.sum2() );
  };
  // using AccumulatorSet::operator+=;
  StatEntity& operator+=( double by )
  {
    this->AccumulatorSet::operator+=( by );
    return *this;
  }
  StatEntity& operator+=( StatEntity by )
  {
    mergeAndReset( std::move( by ) );
    return *this;
  }
  unsigned long add( const double v )
  {
    *this += v;
    return nEntries();
  }
  unsigned long addFlag( const double v ) { return add( v ); }
  // aliases (a'la ROOT)
  double Sum() const { return sum(); }                // get sum
  double Mean() const { return mean(); }              // get mean
  double MeanErr() const { return meanErr(); }        // get error in mean
  double rms() const { return standard_deviation(); } // get rms
  double Rms() const { return standard_deviation(); } // get rms
  double RMS() const { return standard_deviation(); } // get rms
  double Eff() const { return eff(); }                // get efficiency
  double Min() const { return min(); }                // get minimal value
  double Max() const { return max(); }                // get maximal value
  // some legacy methods, to be removed ...
  double      flag() const { return sum(); }
  double      flag2() const { return sum2(); }
  double      flagMean() const { return mean(); }
  double      flagRMS() const { return standard_deviation(); }
  double      flagMeanErr() const { return meanErr(); }
  double      flagMin() const { return min(); }
  double      flagMax() const { return max(); }
  static bool effCounter( const std::string& name )
  {
    using boost::algorithm::icontains;
    return icontains( name, "eff" ) || icontains( name, "acc" ) || icontains( name, "filt" ) ||
           icontains( name, "fltr" ) || icontains( name, "pass" );
  }
  std::ostream& printFormatted( std::ostream& o, const std::string& format ) const
  {
    boost::format fmt{format};
    fmt % nEntries() % sum() % mean() % standard_deviation() % min() % max();
    return o << fmt.str();
  }
  using Gaudi::Accumulators::PrintableCounter::print;
  std::ostream& print( std::ostream& o, bool tableFormat, const std::string& name, bool flag = true,
                       std::string fmtHead = "%|-48.48s|%|27t|" ) const
  {
    if ( flag && effCounter( name ) && 0 <= eff() && 0 <= effErr() && sum() <= nEntries() &&
         ( 0 == min() || 1 == min() ) && ( 0 == max() || 1 == max() ) ) {
      // efficiency printing
      std::string fmt;
      if ( tableFormat ) {
        if ( name.empty() ) {
          fmt = "|%|10d| |%|11.5g| |(%|#9.7g| +- %|-#8.7g|)%%|   -------   |   -------   |";
          return o << boost::format{fmt} % BinomialAccParent::nEntries() % sum() % ( efficiency() * 100 ) %
                          ( efficiencyErr() * 100 );
        } else {
          fmt = " |*" + fmtHead + "|%|10d| |%|11.5g| |(%|#9.7g| +- %|-#8.7g|)%%|   -------   |   -------   |";
          return o << boost::format{fmt} % ( "\"" + name + "\"" ) % BinomialAccParent::nEntries() % sum() %
                          ( efficiency() * 100 ) % ( efficiencyErr() * 100 );
        }
      } else {
        fmt = "#=%|-7lu| Sum=%|-11.5g| Eff=|(%|#9.7g| +- %|-#8.6g|)%%|";
        return o << boost::format{fmt} % BinomialAccParent::nEntries() % sum() % ( efficiency() * 100 ) %
                        ( efficiencyErr() * 100 );
      }
    } else {
      // Standard printing
      std::string fmt;
      if ( tableFormat ) {
        if ( name.empty() ) {
          fmt = "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |";
          return o << boost::format{fmt} % nEntries() % sum() % mean() % standard_deviation() % min() % max();

        } else {
          fmt = " | " + fmtHead + "|%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |";
          return o << boost::format{fmt} % ( "\"" + name + "\"" ) % nEntries() % sum() % mean() % standard_deviation() %
                          min() % max();
        }
      } else {
        fmt = "#=%|-7lu| Sum=%|-11.5g| Mean=%|#10.4g| +- %|-#10.5g| Min/Max=%|#10.4g|/%|-#10.4g|";
        return o << boost::format{fmt} % nEntries() % sum() % mean() % standard_deviation() % min() % max();
      }
    }
  }
  virtual std::ostream& print( std::ostream& o, const std::string& tag ) const override
  {
    return print( o, true, tag, true );
  }
  std::ostream& print( std::ostream& o, bool tableFormat = false ) const override
  {
    std::string emptyName;
    return print( o, tableFormat, emptyName, true );
  }
  std::string toString() const
  {
    std::ostringstream ost;
    print( ost );
    return ost.str();
  }
  std::ostream& fillStream( std::ostream& o ) const { return print( o ); }
};

#endif // GAUDIKERNEL_COUNTERS_H