HistoDump.cpp

Go to the documentation of this file.

#ifdef __ICC
// disable icc remark #2259: non-pointer conversion from "X" to "Y" may lose significant bits
//   TODO: To be removed, since it comes from ROOT TMathBase.h
#pragma warning( disable : 2259 )
// disable icc remark #1572: floating-point equality and inequality comparisons are unreliable
//   The comparison are meant
#pragma warning( disable : 1572 )
#endif
#ifdef WIN32
// Disable warning
//   warning C4996: 'sprintf': This function or variable may be unsafe.
// coming from TString.h
#pragma warning( disable : 4996 )
#endif
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <cmath>
#include <iostream>
#include <numeric>
#include <sstream>
#include <utility>
#include <vector>
// ============================================================================
// AIDA
// ============================================================================
#include "AIDA/IAnnotation.h"
#include "AIDA/IAxis.h"
#include "AIDA/IHistogram1D.h"
#include "AIDA/IProfile1D.h"
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/StatusCode.h"
// ============================================================================
// ROOT
// ============================================================================
#include "TAxis.h"
#include "TH1.h"
#include "TProfile.h"
// ============================================================================
// Boost
// ============================================================================
#include "boost/format.hpp"
// ============================================================================
// Local
// ============================================================================
#include "GaudiUtils/HistoDump.h"
#include "GaudiUtils/HistoStats.h"
#include "GaudiUtils/HistoTableFormat.h"
// ============================================================================
namespace
{
  // ==========================================================================
  struct Histo {
    // ========================================================================
    Histo() = default;
    // ========================================================================
    struct Bin {
      // ======================================================================
      Bin( const double h = 0, const double e = 0, const double l = -1 ) : height( h ), error( e ), lower( l ) {}
      // ======================================================================
      double height; //  bin height
      double error; //   bin error
      double lower; //  lower edge
      // ======================================================================
      Bin& operator+=( const Bin& right )
      {
        height += right.height;
        const double e2 = error * error + right.error * right.error;
        error           = std::sqrt( e2 );
        return *this;
      }
      // ======================================================================
    };
    // ========================================================================
    double maxY( const bool withErr ) const
    {
      return std::accumulate(
          std::begin( bins ), std::end( bins ), std::max( under.height, over.height ),
          [&]( double m, const Bin& b ) { return std::max( m, withErr ? b.height + b.error : b.height ); } );
    }
    double minY( const bool withErr ) const
    {
      return std::accumulate(
          std::begin( bins ), std::end( bins ), std::min( under.height, over.height ),
          [&]( double m, const Bin& b ) { return std::min( m, withErr ? b.height - b.error : b.height ); } );
    }
    Histo rebin( const unsigned int bin ) const
    {
      // create new histogram
      Histo nh;
      // copy overflow & underflow bins
      nh.under = under;
      nh.over  = over;
      // rebin
      for ( unsigned int ibin = 0; ibin < bins.size(); ++ibin ) {
        const Bin& current = bins[ibin];
        if ( nh.bins.empty() ) {
          nh.bins.push_back( current );
        } else if ( 0 == ibin % bin ) {
          nh.bins.push_back( current );
        } else {
          nh.bins.back() += current;
        }
      }
      return nh;
    }
    // find "null-bin", if any
    int nullBin() const
    {
      for ( auto ib = bins.cbegin(); bins.cend() != ib + 1; ++ib ) {
        if ( ib->lower <= 0 && 0 < ( ib + 1 )->lower ) {
          return ib - bins.cbegin();
        }
      }
      return -1;
    }
    // ========================================================================
    typedef std::vector<Bin> Bins;
    // ========================================================================
    Bins bins; // histogram bins
    Bin under; //  underflow bin
    Bin over; //   overflow bin
    // ========================================================================
  };
  // ==========================================================================
  StatusCode _getHisto( const TH1* root, Histo& hist )
  {
    // clear the histogram
    hist.bins.clear();
    //
    if ( !root ) {
      return StatusCode::FAILURE;
    } // RETURN
    const TAxis* axis = root->GetXaxis();
    if ( !axis ) {
      return StatusCode::FAILURE;
    } // RETURN
    const int nbins = axis->GetNbins();
    if ( 0 == nbins ) {
      return StatusCode::FAILURE;
    } // RETURN

    // underflow bin
    hist.under = Histo::Bin( root->GetBinContent( 0 ), root->GetBinError( 0 ), axis->GetXmin() );
    // overflow bin
    hist.over = Histo::Bin( root->GetBinContent( nbins + 1 ), root->GetBinError( nbins + 1 ), axis->GetXmax() );
    //
    //
    for ( int ibin = 1; ibin <= nbins; ++ibin ) {
      // add to the local histo
      hist.bins.emplace_back( root->GetBinContent( ibin ), root->GetBinError( ibin ), axis->GetBinLowEdge( ibin ) );
    }
    return StatusCode::SUCCESS;
  }
  // ==========================================================================
  StatusCode _getHisto( const TProfile* root, Histo& hist, const bool /* spread */ )
  {
    const TH1* histo = root;
    return _getHisto( histo, hist );
  }
  // ==========================================================================
  StatusCode _getHisto( const AIDA::IHistogram1D* aida, Histo& hist )
  {
    // clear the histogram
    hist.bins.clear();
    //
    if ( !aida ) {
      return StatusCode::FAILURE;
    } // RETURN
    //
    const AIDA::IAxis& axis  = aida->axis();
    const int          nbins = axis.bins();
    //
    // underflow bin
    hist.under = Histo::Bin( aida->binHeight( AIDA::IAxis::UNDERFLOW_BIN ),
                             aida->binError( AIDA::IAxis::UNDERFLOW_BIN ), axis.lowerEdge() );
    // overflow bin
    hist.over = Histo::Bin( aida->binHeight( AIDA::IAxis::OVERFLOW_BIN ), aida->binError( AIDA::IAxis::OVERFLOW_BIN ),
                            axis.upperEdge() );
    //
    for ( int ibin = 0; ibin < nbins; ++ibin ) {
      // add to the local histo
      hist.bins.emplace_back( aida->binHeight( ibin ), aida->binError( ibin ), axis.binLowerEdge( ibin ) );
    }
    return StatusCode::SUCCESS;
  }
  // ==========================================================================
  StatusCode _getHisto( const AIDA::IProfile1D* aida, Histo& hist, const bool spread )
  {
    // clear the histogram
    hist.bins.clear();
    //
    if ( !aida ) {
      return StatusCode::FAILURE;
    } // RETURN
    //
    const AIDA::IAxis& axis  = aida->axis();
    const int          nbins = axis.bins();
    //
    // underflow bin
    hist.under =
        Histo::Bin( aida->binHeight( AIDA::IAxis::UNDERFLOW_BIN ),
                    spread ? aida->binRms( AIDA::IAxis::UNDERFLOW_BIN ) : aida->binError( AIDA::IAxis::UNDERFLOW_BIN ),
                    axis.lowerEdge() );
    // overflow bin
    hist.over =
        Histo::Bin( aida->binHeight( AIDA::IAxis::OVERFLOW_BIN ),
                    spread ? aida->binRms( AIDA::IAxis::OVERFLOW_BIN ) : aida->binError( AIDA::IAxis::OVERFLOW_BIN ),
                    axis.upperEdge() );
    //
    for ( int ibin = 0; ibin < nbins; ++ibin ) {
      // add to the local histo
      hist.bins.emplace_back( aida->binHeight( ibin ), spread ? aida->binRms( ibin ) : aida->binError( ibin ),
                              axis.binLowerEdge( ibin ) );
    }
    return StatusCode::SUCCESS;
  }
  // ==========================================================================
  inline unsigned int rebin( const unsigned int bins, const unsigned int imax )
  {
    if ( 0 == imax ) {
      return 1;
    } // RETURN
    unsigned int ibin = 1;
    while ( bins > imax * ibin ) {
      ++ibin;
    }
    return ibin; // RETURN
  }
  // ==========================================================================
  std::pair<double, int> decompose( double v )
  {
    if ( 0 == v ) {
      return {0.0, 0};
    } // RETURN
    else if ( 1 == v ) {
      return {1.0, 0};
    } // RETURN
    else if ( 0 > v ) {
      auto r = decompose( -v );
      return {-r.first, r.second}; // RETURN
    } else if ( 0.1 > v ) {
      int i = 0;
      while ( 0.1 > v ) {
        ++i;
        v *= 10;
      } // STUPID
      return {v, -i};
    } else if ( 1 < v ) {
      int i = 0;
      while ( 1 <= v ) {
        ++i;
        v /= 10;
      } // STUPID
      return {v, i};
    }
    return {v, 1};
  }
  // ==========================================================================
  inline double _pow( double x, unsigned long n )
  {
    double y = n % 2 ? x : 1;
    while ( n >>= 1 ) {
      x = x * x;
      if ( n % 2 ) {
        y *= x;
      }
    }
    return y;
  }
  // forward declaration to break cyclic dependency between rValMin and rValMax
  inline double rValMin( double v );
  // ==========================================================================
  inline double rValMax( double v )
  {
    if ( 0 == v ) {
      return 0;
    } // RETURN
    else if ( 0 > v ) {
      return -1 * rValMin( -v );
    } // RETURN
    // decompose the double value into decimal significand and mantissa
    std::pair<double, int> r = decompose( v );
    //
    const double f = std::ceil( 20 * r.first ) / 2; // + 1 ;
    const int    l = r.second - 1;
    return 0 < l ? f * _pow( 10, l ) : f / _pow( 10, -l );
  }
  // ==========================================================================
  inline double rValMin( double v )
  {
    if ( 0 == v ) {
      return 0;
    } // RETURN
    else if ( 0 > v ) {
      return -1 * rValMax( -v );
    } // RETURN
    // decompose the double value into decimal significand and mantissa
    std::pair<double, int> r = decompose( v );
    const double f = std::floor( 20 * r.first ) / 2; // - 1 ;
    const int    l = r.second - 1;
    return 0 < l ? f * _pow( 10, l ) : f / _pow( 10, -l );
  }
  // ==========================================================================
  inline std::string yLabel( double value )
  {
    boost::format fmt( "%10.3g" );
    fmt % value;
    return fmt.str();
  }
  // ==========================================================================
  inline std::string xLabel( const double value )
  {
    boost::format fmt( "%9.3g" );
    fmt % value;
    return fmt.str();
  }
  // ==========================================================================
  char symbBin( const Histo::Bin& bin, const double yLow, const double yHigh, const bool yNull, const bool errors )
  {
    if ( errors && yLow <= bin.height && bin.height < yHigh ) {
      return '*';
    } // O
    else if ( errors && yHigh < bin.height - bin.error ) {
      return ' ';
    } else if ( errors && yLow >= bin.height + bin.error ) {
      return ' ';
    } else if ( errors ) {
      return 'I';
    } else if ( yLow <= bin.height && bin.height < yHigh ) {
      return '*';
    } else if ( 0 <= bin.height && yLow <= bin.height && 0 < yHigh && !yNull ) {
      return '*';
    } // +
    else if ( 0 > bin.height && yHigh > bin.height && 0 >= yLow && !yNull ) {
      return '*';
    } // -
    //
    return ' ';
  }
  // ==========================================================================
  std::ostream& dumpText( const Histo& histo, const std::size_t width, const std::size_t height, const bool errors,
                          std::ostream& stream )
  {
    if ( 40 > width ) {
      return dumpText( histo, 40, height, errors, stream );
    }
    if ( 200 < width ) {
      return dumpText( histo, 200, height, errors, stream );
    }
    if ( 150 < height ) {
      return dumpText( histo, width, 150, errors, stream );
    }
    if ( 20 > height ) {
      return dumpText( histo, width, 20, errors, stream );
    }
    if ( height > width ) {
      return dumpText( histo, width, width, errors, stream );
    }
    //
    const unsigned int nBins = histo.bins.size();
    if ( nBins > width ) {
      // rebin histogram
      Histo r = histo.rebin( rebin( nBins, width ) );
      return dumpText( r, width, height, errors, stream );
    }
    //
    // get the Y-scale
    double yMax = std::max( rValMax( histo.maxY( errors ) ), 0.0 );
    double yMin = std::min( rValMin( histo.minY( errors ) ), 0.0 );

    if ( yMin == yMax ) {
      yMax = yMin + 1;
    }
    std::pair<double, int> r = decompose( yMax - yMin );
    double _ny = std::ceil( 10 * r.first ); //   1 <= ny < 10
    if ( 1 >= _ny ) {
      _ny = 10;
    }
    int yBins = (int)std::max( 1., std::ceil( height / _ny ) );

    yBins *= (int)_ny;
    if ( 20 > yBins ) {
      yBins = 20;
    }
    const double yScale = ( yMax - yMin ) / yBins;

    //
    const int ySkip =
        0 == yBins % 13
            ? 13
            : 0 == yBins % 11
                  ? 11
                  : 0 == yBins % 9
                        ? 9
                        : 0 == yBins % 8
                              ? 8
                              : 0 == yBins % 7 ? 7 : 0 == yBins % 6 ? 6 : 0 == yBins % 5 ? 5 : 0 == yBins % 4 ? 4 : 10;

    const int xSkip =
        // 0 == nBins % 8 ? 8 :
        0 == nBins % 7 ? 7 : 0 == nBins % 6 ? 6 : 0 == nBins % 5 ? 5 : 0 == nBins % 4 ? 4 : 10;

    int iNull = histo.nullBin();

    if ( 0 <= iNull ) {
      iNull %= xSkip;
    } else {
      iNull = 0;
    }

    stream << std::endl;

    for ( int yLine = -1; yLine < yBins; ++yLine ) {
      const double yHigh = yMax - yScale * yLine;
      // const double yLow  = yHigh - yScale         ;
      const double yLow = yMax - yScale * ( yLine + 1 );
      //
      std::string line1 = " ";

      const bool ynull  = ( yLow <= 0 && 0 < yHigh );
      const bool yfirst = -1 == yLine || yBins - 1 == yLine;
      const bool ylab   = ( 0 == ( yLine + 1 ) % ySkip ) || yfirst || ynull;

      if ( ylab ) {
        line1 += yLabel( ( yLow <= 0 && 0 < yHigh ) ? 0.0 : yLow );
      } else {
        line1 += std::string( 10, ' ' );
      }
      //
      line1 += " ";
      //
      line1 += symbBin( histo.under, yLow, yHigh, ynull, errors );
      //
      line1 += ynull ? "-+" : ylab ? " +" : " |";
      //
      std::string line2;
      //
      for ( auto ibin = histo.bins.cbegin(); histo.bins.cend() != ibin; ++ibin ) {
        // char symb = ' ' ;
        const int i = ibin - histo.bins.cbegin();
        //
        const bool xnull = ibin->lower <= 0 && ( ibin + 1 ) != histo.bins.cend() && 0 < ( ibin + 1 )->lower;
        const bool xlab  = iNull == i % xSkip;
        //
        char symb = symbBin( *ibin, yLow, yHigh, ynull, errors );
        //
        if ( ' ' == symb ) {
          if ( ( ynull || yfirst ) && xlab ) {
            symb = '+';
          } else if ( ynull || yfirst ) {
            symb = '-';
          }
          //
          else if ( ylab && xnull ) {
            symb = '+';
          } else if ( xnull ) {
            symb = '|';
          }
          //
          else if ( ylab || xlab ) {
            symb = '.';
          }
          //
        }
        line2 += symb;
        //
      }
      //
      std::string line3 = ynull ? "->" : ylab ? "+ " : "| ";
      //
      line3 += symbBin( histo.over, yLow, yHigh, ynull, errors );
      //
      stream << line1 << line2 << line3 << std::endl;
      //
    }

    // get x-labels
    std::vector<std::string> xlabels;
    for ( auto ib = histo.bins.cbegin(); histo.bins.cend() != ib; ++ib ) {
      xlabels.push_back( xLabel( ib->lower ) );
    }
    // overflow& underflow  label
    const std::string oLabel = xLabel( histo.over.lower );
    const std::string uLabel = xLabel( histo.under.lower );
    //
    static const std::string s_UNDERFLOW( "UNDERFLOW" );
    static const std::string s_OVERFLOW( " OVERFLOW" );
    //
    //
    for ( unsigned int yLine = 0; yLine < 12; ++yLine ) {
      std::string line = std::string( 12, ' ' );
      //
      if ( yLine < s_UNDERFLOW.size() ) {
        line += s_UNDERFLOW[yLine];
      } else {
        line += ' ';
      }
      //
      line += ' ';
      //
      if ( uLabel.size() > yLine ) {
        line += uLabel[yLine];
      } else {
        line += ' ';
      }
      //
      for ( auto ibin = histo.bins.cbegin(); histo.bins.cend() != ibin; ++ibin ) {
        int        ib   = ibin - histo.bins.cbegin();
        const bool xlab = ( iNull == ib % xSkip );
        if ( xlab && yLine < xlabels[ib].size() ) {
          line += xlabels[ib][yLine];
        } else {
          line += ' ';
        }
      }
      //
      if ( oLabel.size() > yLine ) {
        line += oLabel[yLine];
      } else {
        line += ' ';
      }
      //
      line += ' ';
      //
      if ( yLine < s_OVERFLOW.size() ) {
        line += s_OVERFLOW[yLine];
      } else {
        line += ' ';
      }
      //
      stream << line << std::endl;
    }
    //
    return stream; // RETURN
  }
}
// ============================================================================
/*  dump the text representation of the histogram
 *  @param histo  (INPUT) the histogram
 *  @param stream (OUTUT) the stream
 *  @param width  (INPUT) the maximal column width
 *  @param height (INPUT) the proposed coulmn height
 *  @param errors (INPUT) print/plot errors
 *  @return the stream
 *  @author Vanya BELYAEV  Ivan.BElyaev@nikhef.nl
 *  @date 2009-09-19
 */
// ============================================================================
std::ostream& Gaudi::Utils::Histos::histoDump_( const AIDA::IHistogram1D* histo, std::ostream& stream,
                                                const std::size_t width, const std::size_t height, const bool errors )
{
  stream << std::endl;
  if ( !histo ) {
    return stream;
  } // RETURN
  Histo      hist;
  StatusCode sc = _getHisto( histo, hist );
  if ( sc.isFailure() ) {
    return stream;
  } // RETURN
  //
  stream << boost::format( " Histo TES   : \"%s\"" ) % path( histo ) << std::endl
         << boost::format( " Histo Title : \"%s\"" ) % histo->title() << std::endl
         << std::endl;
  //
  stream << boost::format( " Mean        : %11.5g +- %-10.4g " ) % Gaudi::Utils::HistoStats::mean( histo ) %
                Gaudi::Utils::HistoStats::meanErr( histo )
         << std::endl
         << boost::format( " Rms         : %11.5g +- %-10.4g " ) % Gaudi::Utils::HistoStats::rms( histo ) %
                Gaudi::Utils::HistoStats::rmsErr( histo )
         << std::endl
         << boost::format( " Skewness    : %11.5g +- %-10.4g " ) % Gaudi::Utils::HistoStats::skewness( histo ) %
                Gaudi::Utils::HistoStats::skewnessErr( histo )
         << std::endl
         << boost::format( " Kurtosis    : %11.5g +- %-10.4g " ) % Gaudi::Utils::HistoStats::kurtosis( histo ) %
                Gaudi::Utils::HistoStats::kurtosisErr( histo )
         << std::endl
         << std::endl;
  //
  stream << boost::format( " Entries     :\n | %=9s | %=9s | %=9s | %9s | %=11s | %=11s | %=11s |" ) % "All" %
                "In Range" % "Underflow" % "Overflow" % "#Equivalent" % "Integral" % "Total"
         << std::endl
         << boost::format( " | %=9d | %=9d | %=9d | %=9d | %=11.5g | %=11.5g | %=11.5g |" ) % histo->allEntries() %
                histo->entries() % histo->binEntries( AIDA::IAxis::UNDERFLOW_BIN ) %
                histo->binEntries( AIDA::IAxis::OVERFLOW_BIN ) % histo->equivalentBinEntries() %
                histo->sumBinHeights() % histo->sumAllBinHeights()
         << std::endl
         << std::endl;
  //
  const AIDA::IAnnotation& a = histo->annotation();
  if ( 0 != a.size() ) {
    stream << " Annotation" << std::endl;
    for ( int i = 0; i < a.size(); ++i ) {
      stream << boost::format( " | %-25.25s : %-45.45s | " ) % a.key( i ) % a.value( i ) << std::endl;
    }
    stream << std::endl;
  }
  //
  return dumpText( hist, width, height, errors, stream );
}
// ============================================================================
/*  dump the text representation of the histogram
 *  @param histo the histogram
 *  @param stream the stream
 *  @param width  the maximal column width
 *  @param height (INPUT) the proposed coulmn height
 *  @param errors (INPUT) print/plot errors
 *  @param erorrs print/plot errors
 *  @author Vanya BELYAEV  Ivan.BElyaev@nikhef.nl
 *  @date 2009-09-19
 */
// ============================================================================
std::string Gaudi::Utils::Histos::histoDump( const AIDA::IHistogram1D* histo, const std::size_t width,
                                             const std::size_t height, const bool errors )
{
  std::ostringstream stream;
  histoDump_( histo, stream, width, height, errors );
  return stream.str();
}
// ============================================================================
/*  dump the text representation of the 1D-profile
 *  @param histo  (INPUT) the profile
 *  @param stream (OUTUT) the stream
 *  @param width  (INPUT) the maximal column width
 *  @param height (INPUT) the proposed coulmn height
 *  @param spread (INPUT) plot spread/error?
 *  @return the stream
 *  @author Vanya BELYAEV  Ivan.BElyaev@nikhef.nl
 *  @date 2009-09-19
 */
// ============================================================================
std::ostream& Gaudi::Utils::Histos::histoDump_( const AIDA::IProfile1D* histo, std::ostream& stream,
                                                const std::size_t width, const std::size_t height, const bool spread )
{
  stream << std::endl;
  if ( !histo ) {
    return stream;
  } // RETURN
  Histo      hist;
  StatusCode sc = _getHisto( histo, hist, spread );
  if ( sc.isFailure() ) {
    return stream;
  } // RETURN
  //
  stream << boost::format( " Histo TES   : \"%s\"" ) % path( histo ) << std::endl
         << boost::format( " Histo Title : \"%s\"" ) % histo->title() << std::endl
         << std::endl;
  //
  stream << boost::format( " Mean        : %11.5g " ) % histo->mean() << std::endl
         << boost::format( " Rms         : %11.5g " ) % histo->rms() << std::endl
         << std::endl;
  //
  stream << boost::format( " Entries     :\n | %=9s | %=9s | %=9s | %9s | %=11s | %=11s |" ) % "All" % "In Range" %
                "Underflow" % "Overflow"
                // % "#Equivalent"
                % "Integral" % "Total"
         << std::endl
         << boost::format( " | %=9d | %=9d | %=9d | %=9d | %=11.5g | %=11.5g |" ) % histo->allEntries() %
                histo->entries() % histo->binEntries( AIDA::IAxis::UNDERFLOW_BIN ) %
                histo->binEntries( AIDA::IAxis::OVERFLOW_BIN )
                // % histo -> equivalentBinEntries ()
                % histo->sumBinHeights() % histo->sumAllBinHeights()
         << std::endl
         << std::endl;
  //
  const AIDA::IAnnotation& a = histo->annotation();
  if ( 0 != a.size() ) {
    stream << " Annotation" << std::endl;
    for ( int i = 0; i < a.size(); ++i ) {
      stream << boost::format( " | %-25.25s : %-45.45s | " ) % a.key( i ) % a.value( i ) << std::endl;
    }
    stream << std::endl;
  }
  //
  return dumpText( hist, width, height, true, stream );
}
// ============================================================================
/*  dump the text representation of the 1D-profile
 *  @param histo the histogram
 *  @param stream the stream
 *  @param width  the maximal column width
 *  @param height (INPUT) the proposed coulmn height
 *  @author Vanya BELYAEV  Ivan.BElyaev@nikhef.nl
 *  @date 2009-09-19
 */
// ============================================================================
std::string Gaudi::Utils::Histos::histoDump( const AIDA::IProfile1D* histo, const std::size_t width,
                                             const std::size_t height, const bool spread )
{
  std::ostringstream stream;
  histoDump_( histo, stream, width, height, spread );
  return stream.str();
}
// ============================================================================
/*  dump the text representation of the histogram
 *  @param histo  (INPUT) the histogram
 *  @param stream (OUTUT) the stream
 *  @param width  (INPUT) the maximal column width
 *  @param errors (INPUT) print/plot errors
 *  @return the stream
 *  @author Vanya BELYAEV  Ivan.Belyaev@nikhef.nl
 *  @date 2009-09-19
 */
// ============================================================================
std::ostream& Gaudi::Utils::Histos::histoDump_( const TH1* histo, std::ostream& stream, const std::size_t width,
                                                const std::size_t height, const bool errors )
{
  const TProfile* profile = dynamic_cast<const TProfile*>( histo );
  if ( profile ) {
    return histoDump_( profile, stream, width, height );
  }
  //
  stream << std::endl;
  if ( !histo ) {
    return stream;
  } // RETURN
  Histo      hist;
  StatusCode sc = _getHisto( histo, hist );
  if ( sc.isFailure() ) {
    return stream;
  } // RETURN
  //
  stream << boost::format( " Histo Name  : \"%s\"" ) % histo->GetName() << std::endl
         << boost::format( " Histo Title : \"%s\"" ) % histo->GetTitle() << std::endl
         << std::endl;
  //
  stream << boost::format( " Mean        : %11.5g +- %-10.4g " ) % histo->GetMean() % histo->GetMeanError() << std::endl
         << boost::format( " Rms         : %11.5g +- %-10.4g " ) % histo->GetRMS() % histo->GetRMSError() << std::endl
         << boost::format( " Skewness    : %11.5g            " ) % histo->GetSkewness() << std::endl
         << boost::format( " Kurtosis    : %11.5g            " ) % histo->GetKurtosis() << std::endl
         << std::endl;
  //
  stream << boost::format( " Entries     :\n | %=11s | %=11s | %=11s | %=11s | %=11s |" ) % "All" % "Underflow" %
                "Overflow" % "#Equivalent" % "Integral"
         << std::endl
         << boost::format( " | %=11.5g | %=11.5g | %=11.5g | %=11.5g | %=11.5g |" ) % histo->GetEntries() %
                histo->GetBinContent( 0 ) % histo->GetBinContent( histo->GetNbinsX() + 1 ) %
                histo->GetEffectiveEntries() % histo->Integral()
         << std::endl
         << std::endl;
  //
  return dumpText( hist, width, height, errors, stream );
}
// ============================================================================
/*  dump the text representation of the histogram
 *  @param histo  (INPUT) the histogram
 *  @param stream (OUTUT) the stream
 *  @param width  (INPUT) the maximal column width
 *  @param errors (INPUT) print/plot errors
 *  @return the stream
 *  @author Vanya BELYAEV  Ivan.Belyaev@nikhef.nl
 *  @date 2009-09-19
 */
// ============================================================================
std::ostream& Gaudi::Utils::Histos::histoDump_( const TProfile* histo, std::ostream& stream, const std::size_t width,
                                                const std::size_t height )
{
  stream << std::endl;
  if ( !histo ) {
    return stream;
  } // RETURN
  Histo      hist;
  StatusCode sc = _getHisto( histo, hist, true );
  if ( sc.isFailure() ) {
    return stream;
  } // RETURN
  //
  stream << boost::format( " Profile Name  : \"%s\"" ) % histo->GetName() << std::endl
         << boost::format( " Profile Title : \"%s\"" ) % histo->GetTitle() << std::endl
         << std::endl;
  //
  stream << boost::format( " Mean          : %11.5g " ) % histo->GetMean() << std::endl
         << boost::format( " Rms           : %11.5g " ) % histo->GetRMS() << std::endl
         << std::endl;
  //
  stream << boost::format( " Entries       :\n | %=11s | %=11s | %=11s | %=11s |" ) % "All" % "Underflow" % "Overflow" %
                "Integral"
         << std::endl
         << boost::format( " | %=11.5g | %=11.5g | %=11.5g | %=11.5g |" ) % histo->GetEntries() %
                histo->GetBinContent( 0 ) % histo->GetBinContent( histo->GetNbinsX() + 1 ) % histo->Integral()
         << std::endl
         << std::endl;
  //
  return dumpText( hist, width, height, true, stream );
}
// ============================================================================
/*  dump the text representation of the histogram
 *  @param histo  (INPUT) the histogram
 *  @param width  (INPUT) the maximal column width
 *  @param errors (INPUT) print/plot errors
 *  @return string representation of the histogram
 *  @author Vanya BELYAEV  Ivan.Belyaev@nikhef.nl
 *  @date 2009-09-19
 */
// ============================================================================
std::string Gaudi::Utils::Histos::histoDump( const TH1* histo, const std::size_t width, const std::size_t height,
                                             const bool errors )
{
  std::ostringstream stream;
  histoDump_( histo, stream, width, height, errors );
  return stream.str();
}
// ============================================================================
/*  dump the text representation of the histogram
 *  @param histo  (INPUT) the histogram
 *  @param width  (INPUT) the maximal column width
 *  @param errors (INPUT) print/plot errors
 *  @return string representation of the histogram
 *  @author Vanya BELYAEV  Ivan.Belyaev@nikhef.nl
 *  @date 2009-09-19
 */
// ============================================================================
std::string Gaudi::Utils::Histos::histoDump( const TProfile* histo, const std::size_t width, const std::size_t height )
{
  std::ostringstream stream;
  histoDump_( histo, stream, width, height );
  return stream.str();
}
// ============================================================================

// ============================================================================
// The END
// ============================================================================