| # Gaudi Framework, version v22r4 |

Home |  | Generated: Fri Sep 2 2011

Static Public Member Functions

# Gaudi::Utils::HistoStats Class Reference

The collection of trivial functions to access the statistical information for the histograms. More...

`#include <GaudiUtils/HistoStats.h>`

List of all members.

## Static Public Member Functions
static double | moment (const AIDA::IHistogram1D *histo, const unsigned int order, const double value=0)
| get the "bin-by-bin"-moment around the specified "value"
static double | momentErr (const AIDA::IHistogram1D *histo, const unsigned int order)
| evaluate the uncertanty for 'bin-by-bin'-moment
static double | centralMoment (const AIDA::IHistogram1D *histo, const unsigned int order)
| evaluate the 'bin-by-bin'-central moment (around the mean value)
static double | centralMomentErr (const AIDA::IHistogram1D *histo, const unsigned int order)
| evaluate the uncertanty for 'bin-by-bin'-central moment (around the mean value) ( the uncertanty is calculated with O(1/n2) precision)
static double | skewness (const AIDA::IHistogram1D *histo)
| get the skewness for the histogram
static double | skewnessErr (const AIDA::IHistogram1D *histo)
| get the error in skewness for the histogram
static double | kurtosis (const AIDA::IHistogram1D *histo)
| get the kurtosis for the histogram
static double | kurtosisErr (const AIDA::IHistogram1D *histo)
| get the error in kurtosis for the histogram
static double | mean (const AIDA::IHistogram1D *histo)
| get the mean value for the histogram (just for completeness)
static double | meanErr (const AIDA::IHistogram1D *histo)
| get an error in the mean value
static double | rms (const AIDA::IHistogram1D *histo)
| get the rms value for the histogram (just for completeness)
static double | rmsErr (const AIDA::IHistogram1D *histo)
| get an error in the rms value
static double | nEff (const AIDA::IHistogram1D *histo)
| get the effective entries (just for completeness)
static double | sumBinHeightErr (const AIDA::IHistogram1D *histo)
| get an error in the sum bin height ("in-range integral")
static double | sumAllBinHeightErr (const AIDA::IHistogram1D *histo)
| get an error in the sum of all bin height ("integral")
static double | overflowEntriesFrac (const AIDA::IHistogram1D *histo)
| the fraction of overflow entries (useful for shape comparison)
static double | underflowEntriesFrac (const AIDA::IHistogram1D *histo)
| the fraction of underflow entries (useful for shape comparison)
static double | overflowEntriesFracErr (const AIDA::IHistogram1D *histo)
| error on fraction of overflow entries (useful for shape comparison)
static double | underflowEntriesFracErr (const AIDA::IHistogram1D *histo)
| the error on fraction of underflow entries (useful for shape comparison)
static double | overflowIntegralFrac (const AIDA::IHistogram1D *histo)
| the fraction of overflow intergal (useful for shape comparison)
static double | underflowIntegralFrac (const AIDA::IHistogram1D *histo)
| the fraction of underflow integral (useful for shape comparison)
static double | overflowIntegralFracErr (const AIDA::IHistogram1D *histo)
| the error on fraction of overflow intergal
static double | underflowIntegralFracErr (const AIDA::IHistogram1D *histo)
| the error on fraction of underflow integral
static long | nEntries (const AIDA::IHistogram1D *histo, const int imax)
| get number of entries in histogram up to the certain bin (not-included)
static long | nEntries (const AIDA::IHistogram1D *histo, const int imin, const int imax)
| get number of entries in histogram form the certain minimal bin up to the certain maximal bin (not-included)
static double | nEntriesFrac (const AIDA::IHistogram1D *histo, const int imax)
| get the fraction of entries in histogram up to the certain bin (not-included)
static double | nEntriesFrac (const AIDA::IHistogram1D *histo, const int imin, const int imax)
| get fraction of entries in histogram form the certain minimal bin up to the certain maximal bin (not-included)
static double | nEntriesFracErr (const AIDA::IHistogram1D *histo, const int imax)
| get the (binominal) error for the fraction of entries in histogram up to the certain bin (not-included)
static double | nEntriesFracErr (const AIDA::IHistogram1D *histo, const int imin, const int imax)
| get the (binomial) error for the fraction of entries in histogram from the certain minimal bin up to the certain maximal bin (not-included)

## Detailed Description

The collection of trivial functions to access the statistical information for the histograms.

Author:
  Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
  2007-08-06

Definition at line 31 of file HistoStats.h.

## Member Function Documentation

double Gaudi::Utils::HistoStats::centralMoment | ( | const AIDA::IHistogram1D * | histo,
|  | const unsigned int | order
| ) |  | `[static]`

evaluate the 'bin-by-bin'-central moment (around the mean value)

Parameters:

  histo | histogram
  order | the moment parameter
  value | central value

Returns:
  the evaluated central moment

Definition at line 119 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                        // RETURN
      if ( 0 == order ) { return 1.0   ; }                        // RETURN
      if ( 1 == order ) { return 0.0   ; }                        // RETURN
      if ( 2 == order )
      {
        const double sigma = histo->rms() ;
        return sigma * sigma ;                                    // RETURN
      }
      // delegate the actual evaluation to another method:
      return moment ( histo , order , mean ( histo ) ) ;
    }

double Gaudi::Utils::HistoStats::centralMomentErr | ( | const AIDA::IHistogram1D * | histo,
|  | const unsigned int | order
| ) |  | `[static]`

evaluate the uncertanty for 'bin-by-bin'-central moment (around the mean value) ( the uncertanty is calculated with O(1/n2) precision)

Parameters:

  histo | histogram
  order | the moment parameter
  value | central value

Returns:
  the evaluated uncertanty in the central moment

Definition at line 144 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                    // RETURN
      const double n    = nEff ( histo ) ;
      if ( 0 >= n     ) { return 0.0   ; }                    // RETURN
      const double mu2  = centralMoment ( histo , 2             ) ; // mu(2)
      const double muo  = centralMoment ( histo ,     order     ) ; // mu(o)
      const double mu2o = centralMoment ( histo , 2 * order     ) ; // mu(2o)
      const double muom = centralMoment ( histo ,     order - 1 ) ; // mu(o-1)
      const double muop = centralMoment ( histo ,     order + 1 ) ; // mu(o+1)
      double result  =  mu2o  ;
      result        -=  2.0   * order * muom * muop ;
      result        -=  muo   * muo   ;
      result        +=  order * order * mu2  * muom * muom ;
      result        /=  n     ;
      result = std::max ( 0.0 , result ) ;
      return std:: sqrt ( result ) ;                            // RETURN
    }

double Gaudi::Utils::HistoStats::kurtosis | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get the kurtosis for the histogram

Definition at line 192 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                    // RETURN
      const double mu4 = centralMoment ( histo , 4 ) ;
      const double s4  = std::pow ( rms ( histo ) , 4 ) ;
      return ( std::fabs(s4)>0 ? mu4/s4 - 3.0 : 0.0 );
    }

double Gaudi::Utils::HistoStats::kurtosisErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get the error in kurtosis for the histogram

Definition at line 203 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                    // RETURN
      const double n = nEff ( histo ) ;
      if ( 3 > n      ) { return 0.0 ; }                      // RETURN
      double result = 24 * n ;
      result *= ( n - 2 ) * ( n - 3 ) ;
      result /= ( n + 1 ) * ( n + 1 ) ;
      result /= ( n + 3 ) * ( n + 5 ) ;
      return std::sqrt ( result ) ;
    }

double Gaudi::Utils::HistoStats::mean | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get the mean value for the histogram (just for completeness)

Definition at line 227 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }
      return histo -> mean() ;
    }

double Gaudi::Utils::HistoStats::meanErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get an error in the mean value

Definition at line 236 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }
      const double n = nEff ( histo ) ;
      return 0 >= n ? 0.0 : rms ( histo ) / std::sqrt ( n ) ;
    }

double Gaudi::Utils::HistoStats::moment | ( | const AIDA::IHistogram1D * | histo,
|  | const unsigned int | order,
|  | const double | value = `0`
| ) |  | `[static]`

get the "bin-by-bin"-moment around the specified "value"

Parameters:

  histo | histogram
  order | the moment parameter
  value | central value

Returns:
  the evaluated moment

Definition at line 49 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                       // RETURN
      if ( 0 == order ) { return 1.0   ; }                       // RETURN
      if ( 1 == order ) { return mean( histo ) - value ; }       // RETURN
      if ( 2 == order )
      {
        const double _r =         rms  ( histo ) ;
        const double _d = value - mean ( histo ) ;
        return _r *_r + _d * _d ;                            // RETURN
      }
      const double n = nEff ( histo )  ;
      if ( 0 >= n     ) { return 0.0   ; }                    // RETURN

      const int _order = (int) order ;

      // get the exis
      const AIDA::IAxis& axis = histo -> axis () ;
      // number of bins
      const int nBins = axis.bins() ;
      double result = 0 ;
      double weight = 0 ;
      // loop over all bins
      for ( int i = 0 ; i < nBins ; ++i )
      {
        const double lE   = axis . binLowerEdge ( i ) ;
        const double uE   = axis . binUpperEdge ( i ) ;
        //
        const double yBin = histo -> binHeight    ( i ) ;   // bin weight
        const double xBin = 0.5 * ( lE + uE ) ;             // bin center
        //
        weight += yBin ;
        result += yBin * std::pow ( xBin - value , _order ) ;
      }
      if ( 0 != weight ) { result /= weight ; }
      return result ;
    }

double Gaudi::Utils::HistoStats::momentErr | ( | const AIDA::IHistogram1D * | histo,
|  | const unsigned int | order
| ) |  | `[static]`

evaluate the uncertanty for 'bin-by-bin'-moment

Parameters:

  histo | histogram
  order | the moment parameter
  value | central value

Returns:
  the evaluated uncertanty in the moment

Definition at line 97 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                   // RETURN
      const double n = nEff ( histo ) ;
      if ( 0 >= n     ) { return 0.0   ; }                   // RETURN
      const double a2o = moment ( histo , 2 * order ) ;      // a(2o)
      const double ao  = moment ( histo ,     order ) ;      // a(o)
      double result = a2o - ao*ao ;
      result        /= n ;
      result = std::max ( 0.0 , result ) ;
      return std:: sqrt ( result ) ;                            // RETURN
    }

double Gaudi::Utils::HistoStats::nEff | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get the effective entries (just for completeness)

Definition at line 218 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }
      return histo -> equivalentBinEntries () ;
    }

long Gaudi::Utils::HistoStats::nEntries | ( | const AIDA::IHistogram1D * | histo,
|  | const int | imin,
|  | const int | imax
| ) |  | `[static]`

get number of entries in histogram form the certain minimal bin up to the certain maximal bin (not-included)

Parameters:

  histo | the pointer to the histogram
  imin | the minimal bin number (included)
  imax | the maximal bin number (not included)
  number | of entries

Definition at line 491 of file HistoStats.cpp.

    {
      if ( 0 == histo   ) { return s_long_bad ; }                         // RETURN
      if ( imin == imax ) { return 0          ; }                         // RETURN
      if ( imax < imin  ) { return nEntries  ( histo , imax ,imin ) ; }   // RETURN
      //
      long result = 0 ;
      if ( 0 > imin  )
      { result += histo -> binEntries( AIDA::IAxis::UNDERFLOW_BIN )  ; }
      // get the exis
      const AIDA::IAxis& axis = histo -> axis () ;
      // number of bins
      const int nBins = axis.bins() ;
      if ( nBins  < imin ) { return 0 ; }                                 // RETURN
      // loop over all bins
      for ( int i = 0 ; i < nBins ; ++i )
      { if ( imin <= i && i < imax ) { result += histo->binEntries ( i ) ; } }
      //
      if ( nBins  < imax )
      { result += histo -> binEntries( AIDA::IAxis::OVERFLOW_BIN ) ; }
      //
      return result ;                                                      // RETURN
    }

long Gaudi::Utils::HistoStats::nEntries | ( | const AIDA::IHistogram1D * | histo,
|  | const int | imax
| ) |  | `[static]`

get number of entries in histogram up to the certain bin (not-included)

Attention:
  underflow bin is included!

Parameters:

  histo | the pointer to the histogram
  imax | the bin number (not included)
  number | of entries

Definition at line 461 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_long_bad ; }                            // RETURN
      if ( 0 > imax   ) { return 0          ; }                            // RETURN
      long result = histo -> binEntries( AIDA::IAxis::UNDERFLOW_BIN )  ;

      // get the exis
      const AIDA::IAxis& axis = histo -> axis () ;
      // number of bins
      const int nBins = axis.bins() ;
      // loop over all bins
      for ( int i = 0 ; i < nBins ; ++i )
      { if ( i < imax ) { result += histo->binEntries ( i ) ; } }
      //
      if ( nBins  < imax )
      { result += histo -> binEntries( AIDA::IAxis::OVERFLOW_BIN ) ; }
      //
      return result ;
    }

double Gaudi::Utils::HistoStats::nEntriesFrac | ( | const AIDA::IHistogram1D * | histo,
|  | const int | imin,
|  | const int | imax
| ) |  | `[static]`

get fraction of entries in histogram form the certain minimal bin up to the certain maximal bin (not-included)

Parameters:

  histo | the pointer to the histogram
  imin | the minimal bin number (included)
  imax | the maximal bin number (not included)
  fraction | of entries

Definition at line 549 of file HistoStats.cpp.

    {
      if ( 0 == histo   ) { return s_bad ; }                              // RETURN
      const double N = histo->allEntries () ;
      if ( 0 >= N       ) { return s_bad ; }                              // RETURN
      const long   n = nEntries ( histo , imin , imax ) ;
      if ( 0 >  n       ) { return s_bad ; }                              // RETURN
      if ( n >  N       ) { return s_bad ; }                              // RETURN
      //
      return n / N ;                                                      // REUTRN
    }

double Gaudi::Utils::HistoStats::nEntriesFrac | ( | const AIDA::IHistogram1D * | histo,
|  | const int | imax
| ) |  | `[static]`

get the fraction of entries in histogram up to the certain bin (not-included)

Attention:
  underflow bin is included!

Parameters:

  histo | the pointer to the histogram
  imax | the bin number (not included)
  fraction | of entries

Definition at line 526 of file HistoStats.cpp.

    {
      if ( 0 == histo   ) { return s_bad ; }                              // RETURN
      //
      const double N = histo->allEntries () ;
      if ( 0 >= N       ) { return s_bad ; }                              // RETURN
      const long   n = nEntries ( histo , imax ) ;
      if ( 0 >  n       ) { return s_bad ; }                              // RETURN
      if ( n >  N       ) { return s_bad ; }                              // RETURN
      //
      return n / N ;                                                      // REUTRN
    }

double Gaudi::Utils::HistoStats::nEntriesFracErr | ( | const AIDA::IHistogram1D * | histo,
|  | const int | imin,
|  | const int | imax
| ) |  | `[static]`

get the (binomial) error for the fraction of entries in histogram from the certain minimal bin up to the certain maximal bin (not-included)

Parameters:

  histo | the pointer to the histogram
  imin | the minimal bin number (included)
  imax | the maximal bin number (not included)
  error | for the fraction of entries

Definition at line 598 of file HistoStats.cpp.

    {
      if ( 0 == histo   ) { return s_bad ; }                              // RETURN
      //
      const double N = histo->allEntries () ;
      if ( 0 >= N       ) { return s_bad ; }                              // RETURN
      const long   n = nEntries ( histo , imin , imax ) ;
      if ( 0 >  n       ) { return s_bad ; }                              // RETURN
      if ( n >  N       ) { return s_bad ; }                              // RETURN
      //
      const double _n1 = std::max ( (double)       n   , 1.0 ) ;
      const double _n2 = std::max (          ( N - n ) , 1.0 ) ;
      //
      return std::sqrt ( _n1 * _n2 / N ) / N ;                             // RETURN
    }

double Gaudi::Utils::HistoStats::nEntriesFracErr | ( | const AIDA::IHistogram1D * | histo,
|  | const int | imax
| ) |  | `[static]`

get the (binominal) error for the fraction of entries in histogram up to the certain bin (not-included)

Attention:
  underflow bin is included!

Parameters:

  histo | the pointer to the histogram
  imax | the bin number (not included)
  error | for the fraction of entries

Definition at line 572 of file HistoStats.cpp.

    {
      if ( 0 == histo   ) { return s_bad ; }                              // RETURN
      //
      const double N = histo->allEntries () ;
      if ( 0 >= N       ) { return s_bad ; }                              // RETURN
      const long   n = nEntries ( histo , imax ) ;
      if ( 0 >  n       ) { return s_bad ; }                              // RETURN
      if ( n >  N       ) { return s_bad ; }                              // RETURN
      //
      const double _n1 = std::max ( (double)       n   , 1.0 ) ;
      const double _n2 = std::max (          ( N - n ) , 1.0 ) ;
      //
      return std::sqrt ( _n1 * _n2 / N ) / N ;                             // RETURN
    }

double Gaudi::Utils::HistoStats::overflowEntriesFrac | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

the fraction of overflow entries (useful for shape comparison)

Definition at line 309 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                                // REUTRN
      const long overflow = histo -> binEntries ( AIDA::IAxis::OVERFLOW_BIN )  ;
      if ( 0 == overflow ) { return 0 ; }                                 // REUTRN
      const long all      = histo->allEntries() ;
      if ( 0 == all      ) { return 0 ; }                  // "CONVENTION?"  RETURN
      if ( 0 >  all      ) { return s_bad ; }     // Lets be a bit paranoic, RETURN
      //
      double _tmp = (double) overflow ;
      _tmp /= all ;
      //
      return _tmp ;
    }

double Gaudi::Utils::HistoStats::overflowEntriesFracErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

error on fraction of overflow entries (useful for shape comparison)

Definition at line 373 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; } // RETURN
      //
      const double overflow = histo -> binEntries ( AIDA::IAxis::OVERFLOW_BIN );
      const double all      = histo -> allEntries () ;
      //
      if ( 0 > overflow || 0 >= all || overflow > all ) { return s_bad ; }
      //
      const double n  = std::max ( overflow , 1.0 ) ;
      const double N  = all ;
      const double n1 = std::max ( N - n , 1.0 ) ;
      //
      return std::sqrt ( n * n1 / N ) / N ; // use the binomial formula
    }

double Gaudi::Utils::HistoStats::overflowIntegralFrac | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

the fraction of overflow intergal (useful for shape comparison)

Definition at line 345 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                                // REUTRN
      const double overflow = histo -> binHeight ( AIDA::IAxis::OVERFLOW_BIN )  ;
      if ( 0 == overflow ) { return 0 ; }                                 // REUTRN
      const double all      = histo -> sumAllBinHeights() ;
      if ( 0 == all      ) { return 0 ; }                  // "CONVENTION?"  RETURN
      //
      return overflow / all ;
    }

double Gaudi::Utils::HistoStats::overflowIntegralFracErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

the error on fraction of overflow intergal

Definition at line 411 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                                // RETURN
      //
      const double all       = histo -> sumAllBinHeights () ;
      if ( 0 == all       ) { return s_bad ; }                            // RETURN
      const double overflow  = histo -> binHeight ( AIDA::IAxis::OVERFLOW_BIN )  ;
      const double oErr      = histo -> binError  ( AIDA::IAxis::OVERFLOW_BIN )  ;
      if ( 0 > oErr       ) { return s_bad ; }                            // RETURN
      const double aErr      = sumAllBinHeightErr ( histo ) ;
      if ( 0 > aErr       ) { return s_bad ; }                            // RETURN
      //
      double error2  = oErr * oErr ;
      error2        += aErr * aErr * overflow * overflow / all / all ;
      error2        /=  all *  all ;

      return std::sqrt ( error2 ) ;
    }

double Gaudi::Utils::HistoStats::rms | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get the rms value for the histogram (just for completeness)

Definition at line 246 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }
      return histo -> rms () ;
    }

double Gaudi::Utils::HistoStats::rmsErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get an error in the rms value

Definition at line 255 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }
      const double n = nEff ( histo ) ;
      if ( 1 >=  n ) { return 0.0 ; }
      double result = 2 + kurtosis ( histo ) ;
      result += 2.0 /( n - 1 ) ;
      result /= 4.0 * n ;
      result = std::max ( result , 0.0 ) ;
      return histo -> rms() * std::sqrt ( result ) ;
    }

double Gaudi::Utils::HistoStats::skewness | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get the skewness for the histogram

Definition at line 167 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                      // RETURN
      const double mu3 = centralMoment ( histo , 3 ) ;
      const double s3  = std::pow ( rms ( histo ) , 3 ) ;
      return ( std::fabs(s3)>0 ? mu3/s3 : 0.0 );
    }

double Gaudi::Utils::HistoStats::skewnessErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get the error in skewness for the histogram

Definition at line 178 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                     // RETURN
      const double n = nEff ( histo ) ;
      if ( 2 > n      ) { return 0.0   ; }                     // RETURN
      double result = 6 ;
      result *= ( n - 2 )  ;
      result /= ( n + 1 ) * ( n + 3 ) ;
      return std::sqrt ( result ) ;
    }

double Gaudi::Utils::HistoStats::sumAllBinHeightErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get an error in the sum of all bin height ("integral")

Definition at line 293 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }
      //
      const double error = sumBinHeightErr( histo ) ;
      if ( 0 > error ) { return s_bad ; }
      const double err1 = histo->binError ( AIDA::IAxis::UNDERFLOW_BIN ) ;
      const double err2 = histo->binError ( AIDA::IAxis::OVERFLOW_BIN  ) ;
      //
      return std::sqrt ( error * error + err1 * err1 + err2 * err2 ) ;
    }

double Gaudi::Utils::HistoStats::sumBinHeightErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

get an error in the sum bin height ("in-range integral")

Definition at line 270 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }
      //
      double error2 = 0 ;
      // get the exis
      const AIDA::IAxis& axis = histo -> axis () ;
      // number of bins
      const int nBins = axis.bins() ;
      // loop over all bins
      for ( int i = 0 ; i < nBins ; ++i )
      {
        // get the error in each bin
        const double berr = histo->binError ( i ) ;
        // accumulate the errors:
        error2 += berr * berr ;
      }
      return std::sqrt ( error2 ) ;
    }

double Gaudi::Utils::HistoStats::underflowEntriesFrac | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

the fraction of underflow entries (useful for shape comparison)

Definition at line 327 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                                // REUTRN
      const long underflow = histo -> binEntries ( AIDA::IAxis::UNDERFLOW_BIN )  ;
      if ( 0 == underflow ) { return 0 ; }                                // REUTRN
      const long all      = histo->allEntries() ;
      if ( 0 == all      ) { return 0 ; }                  // "CONVENTION?"  RETURN
      if ( 0 >  all      ) { return s_bad ; }     // Lets be a bit paranoic, RETURN
      //
      double _tmp = (double) underflow ;
      _tmp /= all ;
      //
      return _tmp ;
    }

double Gaudi::Utils::HistoStats::underflowEntriesFracErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

the error on fraction of underflow entries (useful for shape comparison)

Definition at line 392 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; } // RETURN
      //
      const double underflow = histo -> binEntries ( AIDA::IAxis::UNDERFLOW_BIN );
      const double all       = histo -> allEntries () ;
      //
      if ( 0 > underflow || 0 >= all || underflow > all ) { return s_bad ; }
      //
      const double n  = std::max ( underflow , 1.0 ) ;
      const double N  = all ;
      const double n1 = std::max ( N - n , 1.0 ) ;
      //
      return std::sqrt ( n * n1 / N ) / N ; // use the binomial formula
    }

double Gaudi::Utils::HistoStats::underflowIntegralFrac | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

the fraction of underflow integral (useful for shape comparison)

Definition at line 359 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                                // REUTRN
      const double underflow = histo -> binHeight ( AIDA::IAxis::UNDERFLOW_BIN )  ;
      if ( 0 == underflow ) { return 0 ; }                                // REUTRN
      const double all      = histo -> sumAllBinHeights() ;
      if ( 0 == all      ) { return 0 ; }                  // "CONVENTION?"  RETURN
      //
      return underflow / all ;
    }

double Gaudi::Utils::HistoStats::underflowIntegralFracErr | ( | const AIDA::IHistogram1D * | histo ) | `[static]`

the error on fraction of underflow integral

Definition at line 433 of file HistoStats.cpp.

    {
      if ( 0 == histo ) { return s_bad ; }                                // RETURN
      //
      const double all       = histo -> sumAllBinHeights () ;
      if ( 0 == all       ) { return s_bad ; }                            // RETURN
      const double underflow  = histo -> binHeight ( AIDA::IAxis::UNDERFLOW_BIN )  ;
      const double oErr       = histo -> binError  ( AIDA::IAxis::UNDERFLOW_BIN )  ;
      if ( 0 > oErr       ) { return s_bad ; }                            // RETURN
      const double aErr      = sumAllBinHeightErr ( histo ) ;
      if ( 0 > aErr       ) { return s_bad ; }                            // RETURN
      //
      double error2  = oErr * oErr ;
      error2        += aErr * aErr * underflow * underflow / all / all ;
      error2        /=  all *  all ;
      //
      return std::sqrt ( error2 ) ;
    }

The documentation for this class was generated from the following files:

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r4/GaudiUtils/GaudiUtils/HistoStats.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r4/GaudiUtils/src/Lib/HistoStats.cpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines