StatEntity.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_STATENTITY_H
#define GAUDIKERNEL_STATENTITY_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <iostream>
#include <mutex>
#include <string>
// ============================================================================
// Gaudi
// ============================================================================
#include "GaudiKernel/Kernel.h"
// ============================================================================
class GAUDI_API StatEntity final
{
public:
  // ==========================================================================
  StatEntity() = default;
  /* The full constructor from all important values:
   * @attention it need to be coherent with
   *            the actual structure of the class
   *            and the format description
   *  @see StatEntity::format
   *  @param entries number of entries
   *  @param flag  accumulated flag
   *  @param flag2 accumulated statistics: flag**2
   *  @param minFlag the minimum value for flag
   *  @param maxFlag the maximum value for flag
   */
  StatEntity( const unsigned long entries, const double flag, const double flag2, const double minFlag,
              const double maxFlag );
  StatEntity( const StatEntity& );
  StatEntity& operator=( const StatEntity& );
  // ==========================================================================
public: // the basic quantities
  // ==========================================================================
  const unsigned long& nEntries() const { return m_se.nEntries; }
  const double& sum() const { return m_se.accumulatedFlag; }
  const double& sum2() const { return m_se.accumulatedFlag2; }
  double mean() const { return m_se.mean(); }
  double rms() const { return m_se.rms(); }
  double meanErr() const { return m_se.meanErr(); }
  const double& min() const { return m_se.minimalFlag; }
  const double& max() const { return m_se.maximalFlag; }
  // ==========================================================================
public:
  // ==========================================================================
  double efficiency() const { return m_se.efficiency(); }
  double efficiencyErr() const { return m_se.efficiencyErr(); }
  double eff() const { return efficiency(); }
  double effErr() const { return efficiencyErr(); }
  // ==========================================================================
  // operators
  // ==========================================================================
public:
  StatEntity& operator+=( const double f )
  {
    addFlag( f );
    return *this;
  }
  StatEntity& operator++() { return ( *this ) += 1; }
  StatEntity& operator++( int ) { return ++( *this ); }
  StatEntity& operator-=( const double f )
  {
    addFlag( -f );
    return *this;
  }
  StatEntity& operator--() { return ( *this ) -= 1; }
  StatEntity& operator--( int ) { return --( *this ); }
  StatEntity& operator=( const double f )
  {
    // reset the statistics
    reset(); 
    // use the regular increment
    return ( ( *this ) += f ); 
  }
  StatEntity& operator+=( const StatEntity& other );
  // ==========================================================================
public:
  // ==========================================================================
  GAUDI_API friend bool operator<( const StatEntity& lhs, const StatEntity& rhs );
  unsigned long add( const double Flag );
  void reset();
  void setnEntriesBeforeReset( unsigned long nEntriesBeforeReset );
  std::string toString() const;
  std::ostream& print( std::ostream& o = std::cout ) const;
  std::ostream& fillStream( std::ostream& o ) const { return print( o ); }
  // ==========================================================================
public: // aliases (a'la ROOT)
  // ==========================================================================
  inline double Sum() const { return sum(); } // get sum
  inline double Mean() const { return mean(); } // get mean
  inline double MeanErr() const { return meanErr(); } // get error in mean
  inline double Rms() const { return rms(); } // get rms
  inline double RMS() const { return rms(); } // get rms
  inline double Eff() const { return eff(); } // get efficiency
  inline double Min() const { return min(); } // get minimal value
  inline double Max() const { return max(); } // get maximal value
  // ==========================================================================
public: // some legacy methods, to be removed ...
  // ==========================================================================
  inline double flag() const { return sum(); }
  inline double flag2() const { return sum2(); }
  inline double flagMean() const { return mean(); }
  inline double flagRMS() const { return rms(); }
  inline double flagMeanErr() const { return meanErr(); }
  inline double flagMin() const { return min(); }
  inline double flagMax() const { return max(); }
  inline unsigned long addFlag( const double Flag ) { return add( Flag ); }
  // ==========================================================================
public:
  // ==========================================================================
  static const std::string& format();
  static int size();
  // ==========================================================================
  // ============================================================================
  GAUDI_API friend StatEntity operator+( const StatEntity& entity, const double value );
  GAUDI_API friend StatEntity operator+( const double value, const StatEntity& entity );
  GAUDI_API friend StatEntity operator+( const StatEntity& entity, const StatEntity& value );
  GAUDI_API friend StatEntity operator-( const StatEntity& entity, const double value );
  GAUDI_API friend std::ostream& operator<<( std::ostream& stream, const StatEntity& entity );
  // ============================================================================
private:
  // ==========================================================================
  struct se {
    unsigned long nEntries = 0;
    double accumulatedFlag  = 0;
    double accumulatedFlag2 = 0;
    double minimalFlag      = std::numeric_limits<double>::max();
    double maximalFlag      = -1 * std::numeric_limits<double>::max();
    // DR number of calls before reset
    long nEntriesBeforeReset = -1; // ?

    se& operator+=( const struct se& other )
    {
      nEntries += other.nEntries;
      accumulatedFlag += other.accumulatedFlag;
      accumulatedFlag2 += other.accumulatedFlag2;
      minimalFlag = std::min( minimalFlag, other.minimalFlag );
      maximalFlag = std::max( maximalFlag, other.maximalFlag );
      return *this;
    }

    unsigned long add( double Flag );
    double mean() const;
    double rms() const;
    double meanErr() const;
    double efficiency() const;
    double efficiencyErr() const;

    friend bool operator<( const struct se& lhs, const struct se& rhs )
    {
      auto order = []( const auto& s ) {
        return std::tie( s.nEntries, s.accumulatedFlag, s.minimalFlag, s.maximalFlag, s.accumulatedFlag2 );
      };
      return order( lhs ) < order( rhs );
    };
  } m_se = {};
  // Mutex to protect calls of add/reset/operator++, i.e. all _writes_ to (but not reads from!) m_se;
  std::mutex m_mutex;
  // ==========================================================================
};
namespace Gaudi
{
  // ==========================================================================
  namespace Utils
  {
    // ========================================================================
    GAUDI_API std::string formatAsTableRow(
        const StatEntity& counter, const bool flag,
        const std::string& format1 = " |%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |",
        const std::string& format2 = "*|%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%|   -----   |   -----   |" );
    // ========================================================================
    GAUDI_API std::string formatAsTableRow(
        const std::string& name, const StatEntity& counter, const bool flag = true,
        const std::string& format1 = " %|-15.15s|%|17t||%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |",
        const std::string& format2 =
            "*%|-15.15s|%|17t||%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%|   -----   |   -----   |" );
    // ========================================================================
    GAUDI_API std::string formatAsTableRow(
        const std::string& name, const std::string& group, const StatEntity& entity, const bool flag = true,
        const std::string& format1 =
            " %|15.15s|%|-15.15s|%|32t||%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |",
        const std::string& format2 =
            "*%|15.15s|%|-15.15s|%|32t||%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%|    -----    |   -----   |" );
    // ========================================================================
  } //                                            end of namespace Gaudi::Utils
  // ==========================================================================
} //                                                     end of namespace Gaudi
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIKERNEL_STATENTITY_H
// ============================================================================