| # Gaudi Framework, version v21r8 |

Home |  | Generated: 17 Mar 2010

# HistoDump.cpp File Reference

`#include <cmath>`
`#include <vector>`
`#include <iostream>`
`#include <utility>`
`#include <sstream>`
`#include "AIDA/IHistogram1D.h"`
`#include "AIDA/IProfile1D.h"`
`#include "AIDA/IAxis.h"`
`#include "AIDA/IAnnotation.h"`
`#include "GaudiKernel/StatusCode.h"`
`#include "TH1.h"`
`#include "TProfile.h"`
`#include "TAxis.h"`
`#include "boost/format.hpp"`
`#include "GaudiUtils/HistoDump.h"`
`#include "GaudiUtils/HistoTableFormat.h"`
`#include "GaudiUtils/HistoStats.h"`

Include dependency graph for HistoDump.cpp:

Go to the source code of this file.

## Functions
StatusCode | _getHisto (const TH1 *root, Histo &hist)
| "convert ROOT histogram into "local" histogram
StatusCode | _getHisto (const TProfile *root, Histo &hist, const bool)
| "convert ROOT 1D-profile into "local" histogram
StatusCode | _getHisto (const AIDA::IHistogram1D *aida, Histo &hist)
| "convert AIDA histogram into "local" histogram
StatusCode | _getHisto (const AIDA::IProfile1D *aida, Histo &hist, const bool spread)
| "convert AIDA 1D-profile into "local" histogram
unsigned int | rebin (const unsigned int bins, const unsigned int imax)
| find the approrpriate rebin factor (I suspect that there is some intelligent STD/STL routine for this purpose)
std::pair< double, int > | decompose (double v)
| decompose the double value into decimal significand (I suspect that there is some intelligent STD/STL routine for this purpose)
double | _pow (double __x, unsigned long __n)
| "efficient" pow-function
double | rValMax (const double v)
| find the proper "round" value
double | rValMin (const double v)
| find the proper "round" value
double | rValMax (const double v)
| find the proper "round" value
double | rValMin (const double v)
| find the proper "round" value
std::string | yLabel (const double value)
| make the label for y-axis
std::string | xLabel (const double value)
| make the label for x-axis
char | symbBin (const Histo::Bin &bin, const double yLow, const double yHigh, const bool yNull, const bool errors)
| get "correct" symbol
std::ostream & | dumpText (const Histo &histo, const std::size_t width, const std::size_t height, const bool errors, std::ostream &stream)
| dump the local histogram in text form
GAUDI_API std::ostream & | Gaudi::Utils::Histos::histoDump_ (const AIDA::IHistogram1D *histo, std::ostream &stream, const std::size_t width=80, const std::size_t height=50, const bool errors=false)
| dump the text representation of the histogram
GAUDI_API std::string | Gaudi::Utils::Histos::histoDump (const AIDA::IHistogram1D *histo, const std::size_t width=80, const std::size_t height=50, const bool errors=false)
| dump the text representation of the histogram
GAUDI_API std::ostream & | Gaudi::Utils::Histos::histoDump_ (const AIDA::IProfile1D *histo, std::ostream &stream, const std::size_t width=80, const std::size_t height=50, const bool spread=true)
| dump the text representation of 1D-profile
GAUDI_API std::string | Gaudi::Utils::Histos::histoDump (const AIDA::IProfile1D *histo, const std::size_t width=80, const std::size_t height=50, const bool spread=true)
| dump the text representation of the 1D-profile
GAUDI_API std::ostream & | Gaudi::Utils::Histos::histoDump_ (const TH1 *histo, std::ostream &stream, const std::size_t width=80, const std::size_t height=50, const bool errors=false)
| dump the text representation of the histogram
GAUDI_API std::ostream & | Gaudi::Utils::Histos::histoDump_ (const TProfile *histo, std::ostream &stream, const std::size_t width=80, const std::size_t height=50)
| dump the text representation of the Profile
GAUDI_API std::string | Gaudi::Utils::Histos::histoDump (const TH1 *histo, const std::size_t width=80, const std::size_t height=50, const bool errors=false)
| dump the text representation of the histogram
GAUDI_API std::string | Gaudi::Utils::Histos::histoDump (const TProfile *histo, const std::size_t width=80, const std::size_t height=50)
| dump the text representation of the histogram

## Function Documentation

StatusCode @702::_getHisto | ( | const AIDA::IProfile1D * | aida,
|  | Histo & | hist,
|  | const bool | spread |
| ) |  |  | `[static]`

"convert AIDA 1D-profile into "local" histogram

Parameters:

  | aida | (INPUT) pointer to AIDA 1D-profile
  | hist | (OUTPUT) local histogram

Returns:
  StatusCode

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 238 of file HistoDump.cpp.

    00241   {
    00242     // clear the histogram
    00243     hist.bins.clear() ;
    00244     //
    00245     if ( 0 == aida ) { return StatusCode::FAILURE ; } // RETURN
    00246     //
    00247     const AIDA::IAxis& axis  = aida -> axis () ;
    00248     const int          nbins = axis .  bins () ;
    00249     //
    00250     // underflow bin
    00251     hist.under = Histo::Bin ( aida -> binHeight ( AIDA::IAxis::UNDERFLOW_BIN ) ,
    00252                               spread ?
    00253                               aida -> binRms    ( AIDA::IAxis::UNDERFLOW_BIN ) :
    00254                               aida -> binError  ( AIDA::IAxis::UNDERFLOW_BIN ) ,
    00255                               axis .  lowerEdge ()  ) ;
    00256     // overflow bin
    00257     hist.over  = Histo::Bin ( aida -> binHeight ( AIDA::IAxis::OVERFLOW_BIN  ) ,
    00258                               spread ?
    00259                               aida -> binRms    ( AIDA::IAxis::OVERFLOW_BIN  ) :
    00260                               aida -> binError  ( AIDA::IAxis::OVERFLOW_BIN  ) ,
    00261                               axis .  upperEdge ()  ) ;
    00262     //
    00263     for ( int ibin = 0 ; ibin < nbins ; ++ibin )
    00264     {
    00265       // add to the local histo
    00266       Histo::Bin bin ( aida -> binHeight    ( ibin ) ,
    00267                        spread ?
    00268                        aida -> binRms       ( ibin ) :
    00269                        aida -> binError     ( ibin ) ,
    00270                        axis .  binLowerEdge ( ibin ) ) ;
    00271       hist.bins.push_back ( bin ) ;
    00272     }
    00273     return StatusCode::SUCCESS ;
    00274   }

StatusCode @702::_getHisto | ( | const AIDA::IHistogram1D * | aida,
|  | Histo & | hist |
| ) |  |  | `[static]`

"convert AIDA histogram into "local" histogram

Parameters:

  | aida | (INPUT) pointer to AIDA histogram
  | hist | (OUTPUT) local histogram

Returns:
  StatusCode

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 200 of file HistoDump.cpp.

    00201   {
    00202     // clear the histogram
    00203     hist.bins.clear() ;
    00204     //
    00205     if ( 0 == aida ) { return StatusCode::FAILURE ; } // RETURN
    00206     //
    00207     const AIDA::IAxis& axis  = aida -> axis () ;
    00208     const int          nbins = axis .  bins () ;
    00209     //
    00210    // underflow bin
    00211     hist.under = Histo::Bin ( aida -> binHeight ( AIDA::IAxis::UNDERFLOW_BIN ) ,
    00212                               aida -> binError  ( AIDA::IAxis::UNDERFLOW_BIN ) ,
    00213                               axis .  lowerEdge ()  ) ;
    00214     // overflow bin
    00215     hist.over  = Histo::Bin ( aida -> binHeight ( AIDA::IAxis::OVERFLOW_BIN  ) ,
    00216                               aida -> binError  ( AIDA::IAxis::OVERFLOW_BIN  ) ,
    00217                               axis .  upperEdge ()  ) ;
    00218     //
    00219     for ( int ibin = 0 ; ibin < nbins ; ++ibin )
    00220     {
    00221       // add to the local histo
    00222       Histo::Bin bin ( aida -> binHeight    ( ibin ) ,
    00223                        aida -> binError     ( ibin ) ,
    00224                        axis .  binLowerEdge ( ibin ) ) ;
    00225       hist.bins.push_back ( bin ) ;
    00226     }
    00227     return StatusCode::SUCCESS ;
    00228   }

StatusCode @702::_getHisto | ( | const TProfile * | root,
|  | Histo & | hist,
|  | const | bool |
| ) |  |  | `[static]`

"convert ROOT 1D-profile into "local" histogram

Parameters:

  | root | (INPUT) pointer to ROOT 1D-profile
  | hist | (OUTPUT) local histogram

Returns:
  StatusCode

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 184 of file HistoDump.cpp.

    00187   {
    00188     const TH1* histo = root ;
    00189     return _getHisto ( histo , hist ) ;
    00190   }

StatusCode @702::_getHisto | ( | const TH1 * | root,
|  | Histo & | hist |
| ) |  |  | `[static]`

"convert ROOT histogram into "local" histogram

Parameters:

  | root | (INPUT) pointer to ROOT histogram
  | hist | (OUTPUT) local histogram

Returns:
  StatusCode

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 145 of file HistoDump.cpp.

    00146   {
    00147     // clear the histogram
    00148     hist.bins.clear() ;
    00149     //
    00150     if ( 0 == root  ) { return StatusCode::FAILURE ; } // RETURN
    00151     const TAxis* axis  = root->GetXaxis() ;
    00152     if ( 0 == axis  ) { return StatusCode::FAILURE ; } // RETURN
    00153     const int    nbins = axis->GetNbins () ;
    00154     if ( 0 == nbins ) { return StatusCode::FAILURE ; } // RETURN
    00155
    00156     // underflow bin
    00157     hist.under = Histo::Bin ( root -> GetBinContent ( 0         ) ,
    00158                               root -> GetBinError   ( 0         ) ,
    00159                               axis -> GetXmin       ()            ) ;
    00160     // overflow bin
    00161     hist.over  = Histo::Bin ( root -> GetBinContent ( nbins + 1 ) ,
    00162                               root -> GetBinError   ( nbins + 1 ) ,
    00163                               axis -> GetXmax       ()            ) ;
    00164     //
    00165     //
    00166     for ( int ibin = 1 ; ibin <= nbins ; ++ibin )
    00167     {
    00168       // add to the local histo
    00169       Histo::Bin bin ( root -> GetBinContent   ( ibin ) ,
    00170                        root -> GetBinError     ( ibin ) ,
    00171                        axis -> GetBinLowEdge   ( ibin ) ) ;
    00172       hist.bins.push_back ( bin ) ;
    00173     }
    00174     return StatusCode::SUCCESS ;
    00175   }

double @702::_pow | ( | double | __x,
|  | unsigned long | __n |
| ) |  |  | `[inline, static]`

"efficient" pow-function

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 324 of file HistoDump.cpp.

    00325   {
    00326     double __y = __n % 2 ? __x : 1;
    00327     while ( __n >>= 1 )
    00328     {
    00329       __x = __x * __x;
    00330       if ( __n % 2) { __y = __y * __x; }
    00331     }
    00332     return __y ;
    00333   }

std::pair<double,int> @702::decompose | ( | double | v | ) | `[static]`

decompose the double value into decimal significand (I suspect that there is some intelligent STD/STL routine for this purpose)

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 296 of file HistoDump.cpp.

    00297   {
    00298     if      ( 0 == v ) { return std::make_pair ( 0.0 , 0 ) ;  }       // RETURN
    00299     else if ( 1 == v ) { return std::make_pair ( 1.0 , 0 ) ;  }       // RETURN
    00300     else if ( 0 >  v )
    00301     {
    00302       std::pair<double,int> r = decompose ( -v ) ;
    00303       return std::pair<double,int>( -r.first , r.second ) ;          // RETURN
    00304     }
    00305     else if ( 0.1 > v  )
    00306     {
    00307       int i       = 0 ;
    00308       while ( 0.1 > v   ) { ++i ; v *= 10 ; }       // STUPID
    00309       return std::make_pair ( v , -i ) ;
    00310     }
    00311     else if ( 1  < v  )
    00312     {
    00313       int i       = 0 ;
    00314       while ( 1  <= v  ) { ++i ; v /= 10 ; }       // STUPID
    00315       return std::make_pair ( v , i ) ;
    00316     }
    00317     return std::make_pair ( v , 1 ) ;
    00318   }

std::ostream& @702::dumpText | ( | const Histo & | histo,
|  | const std::size_t | width,
|  | const std::size_t | height,
|  | const bool | errors,
|  | std::ostream & | stream |
| ) |  |  | `[static]`

dump the local histogram in text form

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

try to define the proper "Y-binning"

underflow bin:

overflow bin:

Definition at line 423 of file HistoDump.cpp.

    00428   {
    00429     if (  40    > width  ) { return dumpText ( histo ,  40   , height , errors , stream ) ; }
    00430     if ( 200    < width  ) { return dumpText ( histo , 200   , height , errors , stream ) ; }
    00431     if ( 150    < height ) { return dumpText ( histo , width , 150    , errors , stream ) ; }
    00432     if (  20    > height ) { return dumpText ( histo , width , 20     , errors , stream ) ; }
    00433     if ( height > width  ) { return dumpText ( histo , width , width  , errors , stream ) ; }
    00434     //
    00435     const unsigned int nBins = histo.bins.size() ;
    00436     if ( nBins > width  )
    00437     {
    00438       // rebin histogram
    00439       Histo r = histo.rebin ( rebin ( nBins , width ) ) ;
    00440       return dumpText ( r , width , height , errors , stream ) ;
    00441     }
    00442     //
    00443     // get the Y-scale
    00444     double yMax = std::max ( rValMax ( histo.maxY ( errors ) ) , 0.0 ) ;
    00445     double yMin = std::min ( rValMin ( histo.minY ( errors ) ) , 0.0 ) ;
    00446
    00447     if ( yMin == yMax ) { yMax = yMin + 1 ; }
    00449     std::pair<double,int> r = decompose ( yMax - yMin ) ;
    00450     double _ny = std::ceil ( 10 * r.first ) ; //   1 <= ny < 10
    00451     if ( 1 >=  _ny  ) { _ny = 10 ; }
    00452     int yBins  = (int) std::max ( 1. , std::ceil ( height / _ny ) ) ;
    00453
    00454     yBins     *= (int) _ny ;
    00455     if ( 20     > yBins ) { yBins = 20    ; }
    00456     const double yScale = ( yMax - yMin ) / yBins ;
    00457
    00458     //
    00459     const int ySkip =
    00460       0 == yBins % 13 ? 13 :
    00461       0 == yBins % 11 ? 11 :
    00462       0 == yBins %  9 ?  9 :
    00463       0 == yBins %  8 ?  8 :
    00464       0 == yBins %  7 ?  7 :
    00465       0 == yBins %  6 ?  6 :
    00466       0 == yBins %  5 ?  5 :
    00467       0 == yBins %  4 ?  4 : 10 ;
    00468
    00469     const int xSkip =
    00470       // 0 == nBins % 8 ? 8 :
    00471       0 == nBins % 7 ? 7 :
    00472       0 == nBins % 6 ? 6 :
    00473       0 == nBins % 5 ? 5 :
    00474       0 == nBins % 4 ? 4 : 10 ;
    00475
    00476     int iNull = histo.nullBin() ;
    00477
    00478     if ( 0 <= iNull ) { iNull %= xSkip ; }
    00479     else              { iNull  = 0     ; }
    00480
    00481     stream << std::endl ;
    00482
    00483     for ( int yLine = -1  ; yLine < yBins ; ++yLine )
    00484     {
    00485       const double yHigh = yMax - yScale *   yLine       ;
    00486       // const double yLow  = yHigh - yScale         ;
    00487       const double yLow  = yMax - yScale * ( yLine + 1 ) ;
    00488       //
    00489       std::string line1 = " " ;
    00490
    00491       const bool ynull  = ( yLow <= 0 && 0 < yHigh )    ;
    00492       const bool yfirst = -1 == yLine || yBins -1  == yLine ;
    00493       const bool ylab   =
    00494         ( 0  == ( yLine + 1 ) % ySkip ) || yfirst || ynull ;
    00495
    00496       if ( ylab ) { line1 += yLabel ( ( yLow <= 0 && 0 < yHigh ) ? 0.0 : yLow )  ; }
    00497       else        { line1 += std::string( 10 , ' ' )                             ; }
    00498       //
    00499       line1 += " " ;
    00500       //
    00502       line1 += symbBin ( histo.under , yLow , yHigh , ynull , errors ) ;
    00503       //
    00504       line1 +=
    00505         ynull ? "-+" :
    00506         ylab  ? " +" : " |" ;
    00507       //
    00508       std::string line2 ;
    00509       //
    00510       for  ( Histo::Bins::const_iterator ibin = histo.bins.begin() ;
    00511              histo.bins.end() != ibin ; ++ibin )
    00512       {
    00513         //char symb = ' ' ;
    00514         const int i = ibin - histo.bins.begin () ;
    00515         //
    00516         const bool xnull =
    00517           ibin->lower <= 0 && ( ibin + 1 ) != histo.bins.end() && 0 < (ibin+1)->lower ;
    00518         const bool xlab  =  iNull == i % xSkip ;
    00519         //
    00520         char symb = symbBin ( *ibin, yLow , yHigh , ynull , errors ) ;
    00521         //
    00522         if ( ' ' == symb )
    00523         {
    00524           if      ( ( ynull || yfirst ) && xlab ) { symb = '+' ; }
    00525           else if (   ynull || yfirst           ) { symb = '-' ; }
    00526           //
    00527           else if ( ylab && xnull               ) { symb = '+' ; }
    00528           else if (         xnull               ) { symb = '|' ; }
    00529           //
    00530           else if ( ylab || xlab                ) { symb = '.' ; }
    00531           //
    00532         }
    00533         line2 += symb ;
    00534         //
    00535       }
    00536       //
    00537       std::string line3 =
    00538         ynull ? "->" :
    00539         ylab  ? "+ " : "| " ;
    00540       //
    00542       line3 += symbBin ( histo.over , yLow , yHigh , ynull , errors ) ;
    00543       //
    00544       stream << line1 << line2 << line3  << std::endl ;
    00545       //
    00546     }
    00547
    00548     // get x-labels
    00549     std::vector<std::string> xlabels ;
    00550     for ( Histo::Bins::const_iterator ib = histo.bins.begin() ; histo.bins.end() != ib ; ++ib )
    00551     { xlabels.push_back ( xLabel ( ib->lower )  ) ; }
    00552     // overflow& underflow  label
    00553     const std::string oLabel = xLabel ( histo.over.lower  ) ;
    00554     const std::string uLabel = xLabel ( histo.under.lower ) ;
    00555     //
    00556     static const std::string s_UNDERFLOW ( "UNDERFLOW" ) ;
    00557     static const std::string s_OVERFLOW  ( " OVERFLOW" ) ;
    00558     //
    00559     //
    00560     for ( unsigned int yLine = 0 ; yLine < 12 ; ++yLine )
    00561     {
    00562       std::string line = std::string ( 12 , ' ' ) ;
    00563       //
    00564       if ( yLine < s_UNDERFLOW.size() ) { line += s_UNDERFLOW[yLine] ; }
    00565       else                              { line += ' '                ; }
    00566       //
    00567       line += ' ' ;
    00568       //
    00569       if ( uLabel.size() > yLine ) { line += uLabel[yLine] ; }
    00570       else                         { line += ' '           ; }
    00571       //
    00572       for  ( Histo::Bins::const_iterator ibin = histo.bins.begin() ; histo.bins.end() != ibin ; ++ibin )
    00573       {
    00574         int ib  = ibin - histo.bins.begin() ;
    00575         const bool xlab  =  ( iNull == ib % xSkip ) ;
    00576         if ( xlab && yLine < xlabels[ib].size() ) { line += xlabels[ib][yLine] ; }
    00577         else { line += ' ' ; }
    00578       }
    00579       //
    00580       if ( oLabel.size() > yLine ) { line += oLabel[yLine] ; }
    00581       else                         { line += ' '           ; }
    00582       //
    00583       line += ' ' ;
    00584       //
    00585       if ( yLine < s_OVERFLOW.size() ) { line += s_OVERFLOW[yLine] ; }
    00586       else                             { line += ' '               ; }
    00587       //
    00588       stream << line << std::endl ;
    00589     }
    00590     //
    00591     return stream ; // RETURN
    00592   }

unsigned int @702::rebin | ( | const unsigned int | bins,
|  | const unsigned int | imax |
| ) |  |  | `[inline, static]`

find the approrpriate rebin factor (I suspect that there is some intelligent STD/STL routine for this purpose)

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 282 of file HistoDump.cpp.

    00284   {
    00285     if ( 0 == imax  ) { return 1 ; }                                  // RETURN
    00286     unsigned int ibin = 1 ;
    00287     while ( bins > imax * ibin ) { ++ibin ; }
    00288     return ibin ;                                                     // RETURN
    00289   }

double @702::rValMax | ( | const double | v | ) | `[inline, static]`

find the proper "round" value

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 351 of file HistoDump.cpp.

    00352   {
    00353     if      ( 0 == v  ) { return 0                   ; }             // REUTRN
    00354     else if ( 0 >  v  ) { return -1 * rValMin ( -v ) ; }             // RETURN
    00355     // decompose the double value into decimal significand and mantissa
    00356     std::pair<double,int> r = decompose ( v ) ;
    00357     //
    00358     const double f = std::ceil ( 20 * r.first ) / 2 ; // + 1 ;
    00359     const int    l = r.second                   - 1 ;
    00360     return 0 < l ? f * _pow ( 10 ,  l ) : f / _pow ( 10 , -l ) ;
    00361   }

double @702::rValMax | ( | const double | v | ) | `[inline, static]`

find the proper "round" value

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

double @702::rValMin | ( | const double | v | ) | `[inline, static]`

find the proper "round" value

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 367 of file HistoDump.cpp.

    00368   {
    00369     if      ( 0 == v  ) { return 0                   ; }             // REUTRN
    00370     else if ( 0 >  v  ) { return -1 * rValMax ( -v ) ; }             // RETURN
    00371     // decompose the double value into decimal significand and mantissa
    00372     std::pair<double,int> r = decompose ( v ) ;
    00373     const double f = std::floor ( 20 * r.first ) / 2 ; // - 1 ;
    00374     const int    l = r.second - 1   ;
    00375     return 0 < l ? f * _pow ( 10 ,  l ) : f / _pow ( 10 , -l ) ;
    00376   }

double @702::rValMin | ( | const double | v | ) | `[inline, static]`

find the proper "round" value

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

char @702::symbBin | ( | const Histo::Bin & | bin,
|  | const double | yLow,
|  | const double | yHigh,
|  | const bool | yNull,
|  | const bool | errors |
| ) |  |  | `[static]`

get "correct" symbol

Definition at line 401 of file HistoDump.cpp.

    00406   {
    00407     if      ( errors && yLow  <= bin.height && bin.height < yHigh             ) { return '*' ; } // O
    00408     else if ( errors && yHigh <  bin.height -  bin.error                      ) { return ' ' ; }
    00409     else if ( errors && yLow  >= bin.height +  bin.error                      ) { return ' ' ; }
    00410     else if ( errors                                                          ) { return 'I' ; }
    00411     else if ( yLow  <= bin.height  && bin.height < yHigh                      ) { return '*' ; }
    00412     else if ( 0 <= bin.height && yLow  <= bin.height  && 0 <  yHigh && !yNull ) { return '*' ; } // +
    00413     else if ( 0 >  bin.height && yHigh >  bin.height  && 0 >= yLow  && !yNull ) { return '*' ; } // -
    00414     //
    00415     return ' ' ;
    00416   }

std::string @702::xLabel | ( | const double | value | ) | `[inline, static]`

make the label for x-axis

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 393 of file HistoDump.cpp.

    00394   {
    00395     boost::format fmt ( "%9.3g" ) ;
    00396     fmt % value ;
    00397     return fmt.str () ;
    00398   }

std::string @702::yLabel | ( | const double | value | ) | `[inline, static]`

make the label for y-axis

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-19

Definition at line 382 of file HistoDump.cpp.

    00383   {
    00384     boost::format fmt ( "%10.3g" ) ;
    00385     fmt % value ;
    00386     return fmt.str () ;
    00387   }

## Variable Documentation

Bins bins

histogram bins:

Definition at line 130 of file HistoDump.cpp.

double error

bin error

Definition at line 71 of file HistoDump.cpp.

double height

bin height

Definition at line 69 of file HistoDump.cpp.

double lower

lower edge

Definition at line 73 of file HistoDump.cpp.

Bin over

overflow bin

Definition at line 134 of file HistoDump.cpp.

Bin under

underflow bin

Definition at line 132 of file HistoDump.cpp.