---

GenHisto1D.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiSvc/src/HistogramSvc/GenHisto1D.h,v 1.1.1.2 2001/04/18 18:32:49 tlindner Exp $
#ifndef HISTOGRAMSVC_GENHISTO1D_H
#define HISTOGRAMSVC_GENHISTO1D_H 1


// Include files
#include <string>
#include "GaudiKernel/xtoa.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IHistogram1D.h"
#include "Axis.h"

#include "HTL/Histograms.h"


//------------------------------------------------------------------------------
//
// ClassName:   GenHisto1D 
//  
// Description: Definition of general 1D histogram
//              The class is templated with the concrete 1D histogram type
//
//              It implements functions form the interface IHistogram1D
// 
//              It implements functions from IHistoBase
//              - print functions, which convert the histogram
//                into ASCII graphical representation
//              - operator<< , which calls internally the print() function
//              - write functions, which convert the histogram
//                into ASCI table (containing numbers with e.g. bin height)
//
//              HTL offers only single std::string to keep
//              the textual information about a histogram.
//              We divide it into two fields :
//              - histogram identifier - can be any string (but if using HBOOK
//                for histogram persistency, the identifier has to be a number)
//              - histogram title - any string (apears on the histogram plot)
//              The function title() of IHistogram1D returns
//              a single std::string with both fields
//
// Author:      Pavel Binko
//
//------------------------------------------------------------------------------


template <class TYPE>
class GenHisto1D : virtual public IHistogram1D, public DataObject              {

protected:


  GenHisto1D(
          const std::string& title,           // HTL   - histogram title
          const std::string& histoID,         // GAUDI - histogram identifier
          int nBinsX,                         // HTL   - X-axis
          double lowX,
          double highX,
          End_Point_Convention  )             // HTL   - end point convention

  {
    std::string temp = histoID;
    temp += '|';
    temp += title;
    m_histogram = new TYPE( temp.c_str(), nBinsX, lowX, highX );
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, nBinsX, lowX, highX );
  }

  GenHisto1D(
          const std::string& title,           // HTL   - histogram title
          int histoID,                        // GAUDI - histogram number
          int nBinsX,                         // HTL   - X-axis
          double lowX,
          double highX,
          End_Point_Convention )              // HTL   - end point convention

  {
    // Convert the number into a string
    char buffer[32];
    _itoa(histoID,buffer,10);
    std::string temp = buffer;
    temp += '|';
    temp += title;
    m_histogram = new TYPE( temp.c_str(), nBinsX, lowX, highX );
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, nBinsX, lowX, highX );
  }


  GenHisto1D(
          const std::string& title,           // HTL   - histogram title
          const std::string& histoID,         // GAUDI - histogram number
          std::vector<double> edges,          // HTL   - X-axis
          End_Point_Convention )              // HTL   - end point convention
  {
    std::string temp = histoID;
    temp += '|';
    temp += title;
    m_histogram = new TYPE( temp.c_str(), edges );
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, edges );
  }

  GenHisto1D(
          const std::string& title,           // HTL   - histogram title
          int histoID,                        // GAUDI - histogram number
          std::vector<double> edges,          // HTL   - X-axis
          End_Point_Convention )              // HTL   - end point convention
  {
    // Convert the number into a string
    char buffer[32];
    _itoa(histoID,buffer,10);
    std::string temp = buffer;
    temp += '|';
    temp += title;
    m_histogram = new TYPE( temp.c_str(), edges );
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, edges );
  }


  GenHisto1D(
          const std::string& title,           // HTL   - histogram title
          Histo1D& h,                         // concrete HTL histogram
          int nBinsX,                         // HTL   - X-axis
          double lowX,
          double highX,
          End_Point_Convention )              // HTL   - end point convention
    : m_histogram(&h)
  {
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, nBinsX, lowX, highX );
    // Set the histogram title
    setTitle( title );
  }

  GenHisto1D(
          const std::string& title,           // HTL   - histogram title
          Histo1DVar& h,                      // concrete HTL histogram
          std::vector<double>& edges,         // HTL   - X-axis
          End_Point_Convention )              // HTL   - end point convention
    : m_histogram(&h)
  {
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, edges );
    // Set the histogram title
    setTitle( title );
  }


  virtual ~GenHisto1D()                                                        {
    delete m_histogram;
    delete m_xAxis;
  }


public:





  virtual std::string title() const                                            {
    return m_histogram->name();
  }
  virtual void setTitle( std::string value )                                   {
    m_histogram->set_name( value.c_str() );
  }

//PB  virtual IAnnotation* annotation()                                         = 0;

  virtual int dimensions() const                                               {
    return m_histogram->dim();
  }

  virtual void reset()                                                         {
    m_histogram->reset();
  }



  virtual int entries() const                                                  {
    return (int) HStat::in_range_entries_count( *m_histogram );
  }

  virtual int allEntries() const                                               {
    return (int) HStat::entries_count( *m_histogram );
  }

  virtual int extraEntries() const                                             {
    return (int) HStat::extra_entries_count( *m_histogram );
  }

  virtual double equivalentBinEntries() const                                  {
    return HStat::nequival( *m_histogram );
  }



  virtual double sumBinHeights() const                                         {
    return HInfo::in_range_value( *m_histogram );
  }

  virtual double sumAllBinHeights() const                                      {
    return sumBinHeights() + sumExtraBinHeights();
  }

  virtual double sumExtraBinHeights() const                                    {
    return binHeight( UNDERFLOW_BIN ) + binHeight( OVERFLOW_BIN );
  }





  virtual void fill( double x, double weight = 1 )                             {
    m_histogram->fill( x, weight );
  }



  virtual int binEntries( int index ) const                                    {
    int i = checkIndex( index );
    if( UNDERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_UNDERFLOW ).count();
    }
    else if( OVERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_OVERFLOW ).count();
    }
    // In-range
    return m_histogram->i_bin( i ).count();
  }

  virtual double binHeight( int index ) const                                  {
    int i = checkIndex( index );
    if( UNDERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_UNDERFLOW ).value();
    }
    else if( OVERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_OVERFLOW ).value();
    }
    // In-range
    return m_histogram->i_bin( i ).value();
  }

  virtual double binError( int index ) const                                   {
    int i = checkIndex( index );
    if( UNDERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_UNDERFLOW ).error();
    }
    else if( OVERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_OVERFLOW ).error();
    }
    // In-range
    return m_histogram->i_bin( i ).error();
  }



  virtual double mean() const                                                  {
    return HStat::mean( *m_histogram );
  }

  virtual double rms() const                                                   {
    return HStat::rms( *m_histogram );
  }



  virtual double minBinHeight() const                                          {
    return HInfo::in_range_min_value( *m_histogram );
  }
  virtual int minBin() const                                                   {
    int  index = 0;
    double val = m_histogram->i_bin( index ).value();
    for( int i=1; i<m_histogram->bin_count(); i++ ) {
      if( m_histogram->i_bin( i ).value() < val ) {
        index = i;
      }
    }
    return index;
  }

  virtual double maxBinHeight() const                                          {
    return HInfo::in_range_max_value( *m_histogram );
  }
  virtual int maxBin() const                                                   {
    int  index = 0;
    double val = m_histogram->i_bin( index ).value();
    for( int i=1; i<m_histogram->bin_count(); i++ ) {
      if( m_histogram->i_bin( i ).value() > val ) {
        index = i;
      }
    }
    return index;
  }



  virtual IAxis* xAxis() const                                                 {
    return m_xAxis;
  }



  virtual int coordToIndex( double coord ) const                               {
    return xAxis()->coordToIndex( coord );
  }



  
  virtual std::ostream& print( std::ostream& s ) const                         {
    HPrinter hp( s );
    hp.print( *m_histogram );
    return s;
  }


  virtual std::ostream& write( std::ostream& s ) const                         {
    s << "1-dimensional histogram" << std::endl;
    for( int i = 0; i < m_xAxis->bins(); i++ ) {
      s << m_xAxis->binCentre(i) << " "
        << binHeight(i) << " "
        << binError(i) << std::endl;
    }
    s << std::endl;
    return s;
  }

  virtual int write( const char* file_name ) const                             {
    HistoTable1D ht( file_name );
    int status = ht.write( *m_histogram );
    return status;
  }


protected:
  

  virtual int checkIndex( int index ) const                                    {
    return m_xAxis->checkIndex( index );
  }



  TYPE*          m_histogram;

  Axis*          m_xAxis;

};


#endif    // HISTOGRAMSVC_GENHISTO1D_H

---