---

StatEntity.h

Go to the documentation of this file.

#ifndef    __GAUDI_CHRONOSTATSVC_STATENTITY_H__
#define    __GAUDI_CHRONOSTATSVC_STATENTITY_H__

#include <iomanip> 
#include <iostream> 
#include <strstream> 
#include <cmath> 
#include <algorithm> 
#include <functional> 

#include "GaudiKernel/IChronoStatSvc.h"


#ifdef linux
#define   __ADJUST_THE_STREAM__(s,w,p)  s.precision(p); \
                                        s << std::setw(w); \
                                        s.setf( std::ios::left       , std::ios::adjustfield ); \
                                        s.setf( std::ios::scientific , std::ios::floatfield  ); 
#else
#define   __ADJUST_THE_STREAM__(s,w,p)  ; 
#endif 

class ChronoStatSvc;

class StatEntity
{
 public:
  StatEntity() 
    : m_se_nEntries          (     0    ) 
    , m_se_accumulatedFlag   (     0    )
    , m_se_minimalFlag       (  5000000 ) 
    , m_se_maximalFlag       ( -5000000 ) 
    , m_se_accumulatedFlag2  (     0    )
    , m_se_accumulatedWeight (     1    ) 
    , m_se_minimalWeight     (  5000000 ) 
    , m_se_maximalWeight     ( -5000000 ) 
    {};
  ~StatEntity(){};
 public:
  inline const unsigned long              &  nEntries   () const ; 
  inline const IChronoStatSvc::StatFlag   &  flag       () const ;
  inline const IChronoStatSvc::StatFlag   &  flag2      () const ;
  inline const IChronoStatSvc::StatFlag      flagMean   () const ; 
  inline const IChronoStatSvc::StatFlag      flagRMS    () const ;
  inline const IChronoStatSvc::StatFlag      flagMeanErr() const ;
  inline const IChronoStatSvc::StatFlag   &  flagMin    () const ;
  inline const IChronoStatSvc::StatFlag   &  flagMax    () const ;
  inline const IChronoStatSvc::StatWeight &  weight             () const ;
  inline const IChronoStatSvc::StatWeight &  weightMin          () const ;
  inline const IChronoStatSvc::StatWeight &  weightMax          () const ;
  inline const IChronoStatSvc::StatWeight    weightHarmonicMean () const ;
  inline unsigned long addFlagAndWeight   ( const IChronoStatSvc::StatFlag  & Flag    , 
                                            const IChronoStatSvc::StatWeight& Weight  ) ; 
  inline const std::string stringOutPut() const;
  inline bool operator< ( const StatEntity& se ) const ;
  inline bool operator<=( const StatEntity& se ) const ;
  inline bool operator> ( const StatEntity& se ) const ;
  inline bool operator>=( const StatEntity& se ) const ;
 public:
  class ComparePairOfStatEntityAndStatTag;
 private:
  unsigned long                m_se_nEntries          ; 
  IChronoStatSvc::StatFlag     m_se_accumulatedFlag   ; 
  IChronoStatSvc::StatFlag     m_se_minimalFlag       ;
  IChronoStatSvc::StatFlag     m_se_maximalFlag       ; 
  IChronoStatSvc::StatFlag     m_se_accumulatedFlag2  ;
  IChronoStatSvc::StatWeight   m_se_accumulatedWeight ; 
  IChronoStatSvc::StatWeight   m_se_minimalWeight     ; 
  IChronoStatSvc::StatWeight   m_se_maximalWeight     ; 
};
inline const unsigned long              &  StatEntity::nEntries   () const { return m_se_nEntries         ; } ; 
inline const IChronoStatSvc::StatFlag   &  StatEntity::flag       () const { return m_se_accumulatedFlag  ; } ;
inline const IChronoStatSvc::StatFlag   &  StatEntity::flag2      () const { return m_se_accumulatedFlag2 ; } ; 
inline const IChronoStatSvc::StatFlag      StatEntity::flagMean   () const 
{ return ( 0 >= nEntries() ) ? 0 : flag() / nEntries() ; } ; 
inline const IChronoStatSvc::StatFlag      StatEntity::flagRMS    () const 
{
  IChronoStatSvc::StatFlag Flag = ( 0 >= nEntries() ) ? 0 : flag2() / nEntries() - flagMean() * flagMean() ; 
  return ( 0 > Flag ) ? 0 : sqrt( Flag ); 
}
inline const IChronoStatSvc::StatFlag      StatEntity::flagMeanErr() const 
{ return ( 0 >= nEntries() ) ? 0 : flagRMS() / sqrt( (IChronoStatSvc::StatFlag) nEntries() )  ; } ; 
inline const IChronoStatSvc::StatFlag   &  StatEntity::flagMin    () const { return m_se_minimalFlag  ; } ;
inline const IChronoStatSvc::StatFlag   &  StatEntity::flagMax    () const { return m_se_maximalFlag  ; } ;
inline const IChronoStatSvc::StatWeight &  StatEntity::weight     () const { return m_se_accumulatedWeight; } ;  
inline const IChronoStatSvc::StatWeight &  StatEntity::weightMin  () const { return m_se_minimalWeight ; } ; 
inline const IChronoStatSvc::StatWeight &  StatEntity::weightMax  () const { return m_se_maximalWeight ; } ; 
inline const IChronoStatSvc::StatWeight    StatEntity::weightHarmonicMean () const 
{ return ( 0 >= nEntries() || weight() <= 0 ) ? 0 : exp( log( weight() ) / ( IChronoStatSvc::StatWeight) nEntries() ) ; }
inline bool StatEntity::operator< ( const StatEntity& se ) const 
{  
  if( nEntries() <  se.nEntries()                                                  ) { return true; } 
  if( nEntries() == se.nEntries() && flag() <  se.flag()                           ) { return true; } 
  if( nEntries() == se.nEntries() && flag() == se.flag() && weight() < se.weight() ) { return true; }; 
  return false; 
} 
class StatEntity::ComparePairOfStatEntityAndStatTag 
: public std::binary_function < const std::pair<const StatEntity*,const IChronoStatSvc::StatTag*>& ,
                                const std::pair<const StatEntity*,const IChronoStatSvc::StatTag*>& , bool >
{
 public:
  inline bool operator() ( const std::pair<const StatEntity*,const IChronoStatSvc::StatTag*>& p1,
                           const std::pair<const StatEntity*,const IChronoStatSvc::StatTag*>& p2 ) const
    {
      const StatEntity* se1 = p1.first;
      const StatEntity* se2 = p2.first;
      return ( 0 == se1 || 0 == se2 ) ? true : (*se1)<(*se2) ;
    };

};
inline unsigned long StatEntity::addFlagAndWeight ( const IChronoStatSvc::StatFlag  & Flag    , 
                                                    const IChronoStatSvc::StatWeight& Weight  )
{  
  m_se_accumulatedFlag   += Flag        ;                              ;
  m_se_minimalFlag        = ( m_se_minimalFlag   < Flag   ) ? m_se_minimalFlag : Flag ;  
  m_se_maximalFlag        = ( m_se_maximalFlag   > Flag   ) ? m_se_maximalFlag : Flag ;  
  m_se_accumulatedFlag2  += Flag * Flag ; 
  m_se_accumulatedWeight *= Weight      ;
  m_se_minimalWeight      = ( m_se_minimalWeight < Weight ) ? m_se_minimalWeight : Weight ;  
  m_se_maximalWeight      = ( m_se_maximalWeight > Weight ) ? m_se_maximalWeight : Weight ;  
  return ++m_se_nEntries ;  
};
inline const std::string StatEntity::stringOutPut() const
{  
  const int buffer_size = 1024;  
  char buffer[ buffer_size ] = { 0 , 0 }; 
  std::ostrstream ost( buffer , buffer_size); 
  ost << " #=" << std::setw(5)  << nEntries() ;  
  if( 0 == flag() && ( 0 == flagRMS() || flagMin() == flagMax() ) ) { /* nothing to be done */ } 
  else 
    { 
      ost << " Flag=";
      __ADJUST_THE_STREAM__(ost,8,2);
      ost << flag();
      ost << " Mean=";
      __ADJUST_THE_STREAM__(ost,8,2);
      ost << flagMean ();
      if( 0 != flagRMS() || flagMin() != flagMax() ) 
        { 
          ost << "+-"      ; 
          __ADJUST_THE_STREAM__(ost,8,2);
          ost << flagRMS() ;   
          ost << " Min="   ; 
          __ADJUST_THE_STREAM__(ost,8,2);
          ost << flagMin() ; 
          ost << " Max="   ; 
          __ADJUST_THE_STREAM__(ost,8,2);
          ost << flagMax() ;   
        } 
      
    }
  if( 1 == weight() && ( weightMin() == weightMax() ) ) { /* nothing to be done */ }
  else 
    { 
      ost << " Weight=" ;
      __ADJUST_THE_STREAM__(ost,8,2);
      ost << weight()   ;
      ost << " 'Mean'=" ;
          __ADJUST_THE_STREAM__(ost,8,2);
      ost << weightHarmonicMean() ;
      if( weightMin() != weightMax() ) 
        { 
          ost << "\tMin="     ; 
          __ADJUST_THE_STREAM__(ost,8,2);
          ost << weightMin()  ;
          ost << "\tMax="     ;
          __ADJUST_THE_STREAM__(ost,8,2);
          ost << weightMax()  ; 
        } 
    }
  unsigned int len = strlen(ost.str()); 
  char *resstr = new char[len+1]; 
  strncpy(resstr,ost.str(),len);
  resstr[len] = 0; 
  std::string res( resstr ); 
  delete [] resstr;
  return res;
};
#endif // __GAUDI_CHRONOSTATSVC_STATENTITY_H__

---