| # Gaudi Framework, version v25r0 |

Home |  | Generated: Mon Feb 17 2014

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Static Public Member Functions | List of all members
Gaudi::Utils::HistoStats Class Reference

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

`#include <GaudiUtils/HistoStats.h>`

## 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 ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

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 | 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 ;
}

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
}

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::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::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::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::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_v25r0/GaudiUtils/GaudiUtils/HistoStats.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v25r0/GaudiUtils/src/Lib/HistoStats.cpp