---

GenHisto2D.h

Go to the documentation of this file.

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


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

#include "HTL/Histograms.h"


//------------------------------------------------------------------------------
//
// ClassName:   GenHisto2D 
//  
// Description: Definition of general 2D histogram
//              The class is templated with the concrete 2D histogram type
//
//              It implements functions form the interface IHistogram2D
// 
//              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 GenHisto2D : virtual public IHistogram2D, public DataObject              {

protected:


  GenHisto2D(
          const std::string& title,           // HTL   - histogram title
          const std::string& histoID,         // GAUDI - histogram identifier
          int nBinsX,                         // HTL   - X-axis
          double lowX,
          double highX,
          int nBinsY,                         // HTL   - Y-axis
          double lowY,
          double highY,
          End_Point_Convention epc )          // HTL   - end point convention
  {
    std::string temp = histoID;
    temp += '|';
    temp += title;
    m_histogram = new TYPE( temp.c_str(), nBinsX, lowX, highX,
                                          nBinsY, lowY, highY, epc );
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, nBinsX, lowX, highX );
    // Axis number = 1 (Y axis)
    m_yAxis     = new Axis( m_histogram, 1, nBinsY, lowY, highY );
  }

  GenHisto2D(
          const std::string& title,           // HTL   - histogram title
          int histoID,                        // GAUDI - histogram identifier
          int nBinsX,                         // HTL   - X-axis
          double lowX,
          double highX,
          int nBinsY,                         // HTL   - Y-axis
          double lowY,
          double highY,
          End_Point_Convention epc )          // 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,
                                          nBinsY, lowY, highY, epc );
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, nBinsX, lowX, highX );
    // Axis number = 1 (Y axis)
    m_yAxis     = new Axis( m_histogram, 1, nBinsY, lowY, highY );
  }



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

  GenHisto2D(
          const std::string& title,           // HTL   - histogram title
          int histoID,                        // GAUDI - histogram identifier
          std::vector<double> edgesX,         // HTL   - X-axis
          std::vector<double> edgesY,         // HTL   - Y-axis
          End_Point_Convention epc )          // 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(), edgesX, edgesY );
    // Axis number = 0 (X axis)
    m_xAxis     = new Axis( m_histogram, 0, edgesX );
    // Axis number = 1 (Y axis)
    m_yAxis     = new Axis( m_histogram, 1, edgesY );
  }



  virtual ~GenHisto2D()                                                        {
    delete m_histogram;
    delete m_xAxis;
    delete m_yAxis;
  }


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 binHeightX( UNDERFLOW_BIN                )       // W
         + binHeight ( UNDERFLOW_BIN, OVERFLOW_BIN  )       // NW
         + binHeightY(                OVERFLOW_BIN  )       // N
         + binHeight ( OVERFLOW_BIN,  OVERFLOW_BIN  )       // NE
         + binHeightX( OVERFLOW_BIN                 )       // E
         + binHeight ( OVERFLOW_BIN,  UNDERFLOW_BIN )       // SE
         + binHeightY(                UNDERFLOW_BIN )       // S
         + binHeight ( UNDERFLOW_BIN, UNDERFLOW_BIN );      // SW
  }





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



  virtual int binEntries( int indexX, int indexY ) const                       {
    int  i = checkIndexX(indexX);
    int  j = checkIndexY(indexY);
    return htlBin(i,j)->count();
  }

  virtual int binEntriesX( int indexX ) const                                  {
    int  i = checkIndexX(indexX);
    if( UNDERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_UNDERFLOW, H_IN_RANGE  ).count();   // W
    }
    else if( OVERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_OVERFLOW , H_IN_RANGE  ).count();   // E
    }
    // In-range
    I_Histo::I_Bin_Location loc(2);
    loc[0] = i;
    int sum = 0;
    for( int j=0; j<m_yAxis->bins(); j++ ) {
      loc[1] = j;
      sum += m_histogram->i_bin( loc ).count();
    }
    return sum;
  }

  virtual int binEntriesY( int indexY ) const                                  {
    int  j = checkIndexY(indexY);
    if( UNDERFLOW_BIN == j ) {
      return m_histogram->extra_bin( H_IN_RANGE , H_UNDERFLOW ).count();   // S
    }
    else if( OVERFLOW_BIN == j ) {
      return m_histogram->extra_bin( H_IN_RANGE , H_OVERFLOW  ).count();   // N
    }
    // In-range
    I_Histo::I_Bin_Location loc(2);
    loc[1] = j;
    int sum = 0;
    for( int i=0; i<m_xAxis->bins(); i++ ) {
      loc[0] = i;
      sum += m_histogram->i_bin( loc ).count();
    }
    return sum;
  }

  virtual double binHeight( int indexX, int indexY ) const                     {
    int  i = checkIndexX(indexX);
    int  j = checkIndexY(indexY);
    return htlBin(i,j)->value();
  }

  virtual double binHeightX( int indexX ) const                                {
    int  i = checkIndexX(indexX);
    if( UNDERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_UNDERFLOW, H_IN_RANGE  ).value();   // W
    }
    else if( OVERFLOW_BIN == i ) {
      return m_histogram->extra_bin( H_OVERFLOW , H_IN_RANGE  ).value();   // E
    }
    // In-range
    I_Histo::I_Bin_Location loc(2);
    loc[0] = i;
    double sum = 0.;
    for( int j=0; j<m_yAxis->bins(); j++ ) {
      loc[1] = j;
      sum += m_histogram->i_bin( loc ).value();
    }
    return sum;
  }

  virtual double binHeightY( int indexY ) const                                {
    int  j = checkIndexY(indexY);
    if( UNDERFLOW_BIN == j ) {
      return m_histogram->extra_bin( H_IN_RANGE , H_UNDERFLOW ).value();   // S
    }
    else if( OVERFLOW_BIN == j ) {
      return m_histogram->extra_bin( H_IN_RANGE , H_OVERFLOW  ).value();   // N
    }
    // In-range
    I_Histo::I_Bin_Location loc(2);
    loc[1] = j;
    double sum = 0.;
    for( int i=0; i<m_xAxis->bins(); i++ ) {
      loc[0] = i;
      sum += m_histogram->i_bin( loc ).value();
    }
    return sum;
  }

  virtual double binError( int indexX, int indexY ) const                      {
    int  i = checkIndexX(indexX);
    int  j = checkIndexY(indexY);
    return htlBin(i,j)->error();
  }

protected:
  virtual I_Bin* htlBin( int i, int j ) const                                  {
    if( UNDERFLOW_BIN != i && OVERFLOW_BIN != i
     && UNDERFLOW_BIN != j && OVERFLOW_BIN != j ) {
      I_Histo::I_Bin_Location loc(2); loc[0] = i; loc[1] = j;
      return &m_histogram->i_bin( loc );                            // In-range
    }
    else if( UNDERFLOW_BIN == i && UNDERFLOW_BIN != j && OVERFLOW_BIN != j ) {
      return &m_histogram->extra_bin( H_UNDERFLOW, H_IN_RANGE  );   // W
    }
    else if( UNDERFLOW_BIN == i && OVERFLOW_BIN == j ) {
      return &m_histogram->extra_bin( H_UNDERFLOW, H_OVERFLOW  );   // NW
    }
    else if( UNDERFLOW_BIN != i && OVERFLOW_BIN != i && OVERFLOW_BIN == j ) {
      return &m_histogram->extra_bin( H_IN_RANGE , H_OVERFLOW  );   // N
    }
    else if( OVERFLOW_BIN == i && OVERFLOW_BIN == j ) {
      return &m_histogram->extra_bin( H_OVERFLOW , H_OVERFLOW  );   // NE
    }
    else if( OVERFLOW_BIN == i && UNDERFLOW_BIN != j && OVERFLOW_BIN != j ) {
      return &m_histogram->extra_bin( H_OVERFLOW , H_IN_RANGE  );   // E
    }
    else if( OVERFLOW_BIN == i && UNDERFLOW_BIN == j ) {
      return &m_histogram->extra_bin( H_OVERFLOW , H_UNDERFLOW );   // SE
    }
    else if( UNDERFLOW_BIN != i && OVERFLOW_BIN != i && UNDERFLOW_BIN == j ) {
      return &m_histogram->extra_bin( H_IN_RANGE , H_UNDERFLOW );   // S
    }
    // UNDERFLOW_BIN == i && UNDERFLOW_BIN == j
    return &m_histogram->extra_bin( H_UNDERFLOW, H_UNDERFLOW );     // SW
  }

public:



  virtual double meanX() const                                                 {
    std::cerr << "Sorry, not yet implemented" << std::endl;
    return 0.;
  }
  virtual double meanY() const                                                 {
    std::cerr << "Sorry, not yet implemented" << std::endl;
    return 0.;
  }

  virtual double rmsX() const                                                  {
    std::cerr << "Sorry, not yet implemented" << std::endl;
    return 0.;
  }
  virtual double rmsY() const                                                  {
    std::cerr << "Sorry, not yet implemented" << std::endl;
    return 0.;
  }



  virtual double minBinHeight() const                                          {
    return HInfo::in_range_min_value( *m_histogram );
  }

  virtual int minBinX() const                                                  {
    I_Histo::I_Bin_Location minLoc(2);
    minLoc = htlMinBin();
    return minLoc[0];
  }

  virtual int minBinY() const                                                  {
    I_Histo::I_Bin_Location minLoc(2);
    minLoc = htlMinBin();
    return minLoc[1];
  }

  virtual double maxBinHeight() const                                          {
    return HInfo::in_range_max_value( *m_histogram );
  }

  virtual int maxBinX() const                                                  {
    I_Histo::I_Bin_Location maxLoc(2);
    maxLoc = htlMinBin();
    return maxLoc[0];
  }

  virtual int maxBinY() const                                                  {
    I_Histo::I_Bin_Location maxLoc(2);
    maxLoc = htlMinBin();
    return maxLoc[1];
  }

protected:

  virtual I_Histo::I_Bin_Location htlMinBin() const                            {
    I_Histo::I_Bin_Location minLoc(2);
    I_Histo::I_Bin_Location loc(2);
    loc[0] = 0;
    loc[1] = 0;
    double val = m_histogram->i_bin( loc ).value();
    for( int i=1; i<m_xAxis->bins(); i++ ) {
      for( int j=1; j<m_yAxis->bins(); j++ ) {
        loc[0] = i;
        loc[1] = j;
        if( m_histogram->i_bin( loc ).value() < val ) {
          minLoc[0] = i;
          minLoc[1] = j;
        }
      }
    }
    return minLoc;
  }

  virtual I_Histo::I_Bin_Location htlMaxBin() const                            {
    I_Histo::I_Bin_Location maxLoc(2);
    I_Histo::I_Bin_Location loc(2);
    loc[0] = 0;
    loc[1] = 0;
    double val = m_histogram->i_bin( loc ).value();
    for( int i=1; i<m_xAxis->bins(); i++ ) {
      for( int j=1; j<m_yAxis->bins(); j++ ) {
        loc[0] = i;
        loc[1] = j;
        if( m_histogram->i_bin( loc ).value() > val ) {
          maxLoc[0] = i;
          maxLoc[1] = j;
        }
      }
    }
    return maxLoc;
  }


public:


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

  virtual IAxis* yAxis() const                                                 {
    return m_yAxis;
  }



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

  virtual int coordToIndexY( double coordY ) const                             {
    return yAxis()->coordToIndex( coordY );
  }



  virtual IHistogram1D* projectionX() const                                    {
    HSlicer s;
    // Construct the new title
    std::string newTitle = title();
    int sep = newTitle.find('|');
    if ( 0 < sep ) {
      // Remove the histogram ID at the beginning of the title
      std::string temp( newTitle, sep+1, newTitle.length() );
      newTitle = temp;
    }
    // Concatenate with the projection type
    newTitle = newTitle + " ( Projection on the axis X )";
    // Create the 1D histogram with variable binning
    IHistogram1D* proj =
      new H1DVar( newTitle, *s.xProject( *m_histogram ), xAxis()->edges() );
    return proj;
  }

  virtual IHistogram1D* projectionY() const                                    {
    HSlicer s;
    // Construct the new title
    std::string newTitle = title();
    int sep = newTitle.find('|');
    if ( 0 < sep ) {
      // Remove the histogram ID at the beginning of the title
      std::string temp( newTitle, sep+1, newTitle.length() );
      newTitle = temp;
    }
    // Concatenate with the projection type
    newTitle = newTitle + " ( Projection on the axis Y )";
    // Create the 1D histogram with variable binning
    IHistogram1D* proj =
      new H1DVar( newTitle, *s.yProject( *m_histogram ), yAxis()->edges() );
    return proj;
  }



  virtual IHistogram1D* sliceX( int indexY ) const                             {
    HSlicer s;
    // Convert the index (number) into a string
    char buffer[32];
    _itoa( indexY, buffer, 10 );
    std::string indexAsString = buffer;
    // Construct the new title
    std::string newTitle = title();
    int sep = newTitle.find('|');
    if ( 0 < sep ) {
      // Remove the histogram ID at the beginning of the title
      std::string temp( newTitle, sep+1, newTitle.length() );
      newTitle = temp;
    }
    // Concatenate with the slice type
      newTitle = newTitle + " ( Slice parallel with the axis X, at the index "
                          + indexAsString
                          + " )";
    // Create the 1D histogram with variable binning
    IHistogram1D* proj =
      new H1DVar( newTitle,
                  *s.xBand( *m_histogram, indexY ),
                  xAxis()->edges() );
    return proj;
  }

  virtual IHistogram1D* sliceY( int indexX ) const                             {
    HSlicer s;
    // Convert the index (number) into a string
    char buffer[32];
    _itoa( indexX, buffer, 10 );
    std::string indexAsString = buffer;
    // Construct the new title
    std::string newTitle = title();
    int sep = newTitle.find('|');
    if ( 0 < sep ) {
      // Remove the histogram ID at the beginning of the title
      std::string temp( newTitle, sep+1, newTitle.length() );
      newTitle = temp;
    }
    // Concatenate with the slice type
    newTitle = newTitle + " ( Slice parallel with the axis Y, at the index "
                        + indexAsString
                        + " )";
    // Create the 1D histogram with variable binning
    IHistogram1D* proj =
      new H1DVar( newTitle,
                  *s.yBand( *m_histogram, indexX ),
                  yAxis()->edges() );
    return proj;
  }

  virtual IHistogram1D* sliceX( int /*indexY1*/, int /*indexY2*/ ) const       {
    std::cerr << "Sorry, not yet implemented" << std::endl;
    return (IHistogram1D*) 0;
  }

  virtual IHistogram1D* sliceY( int /*indexX1*/, int /*indexX2*/ ) const       {
    std::cerr << "Sorry, not yet implemented" << std::endl;
    return (IHistogram1D*) 0;
  }



  
  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 << "2-dimensional histogram" << std::endl;
    for( int i = 0; i < m_xAxis->bins(); i++ ) {
      for( int j = 0; j < m_yAxis->bins(); j++ ) {
        s << m_xAxis->binCentre(i) << " "
          << m_yAxis->binCentre(j) << " "
          << binHeight(i,j) << " "
          << binError(i,j) << std::endl;
      }
    }
    s << std::endl;
    return s;
  }

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


protected:
  
  virtual int calcIndex( double coord, int part ) const                        {
    Index an_index;
    Extra_Index an_extra_index;
    m_histogram->i_partition(part).map_point( coord, an_index, an_extra_index );
    if (an_extra_index == H_IN_RANGE) {
      return an_index;
    }
    return 0;
  }
  

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

  virtual int checkIndexY( int indexY ) const                                   {
    return m_yAxis->checkIndex( indexY );
  }



  TYPE*          m_histogram;
  
  Axis*          m_xAxis;

  Axis*          m_yAxis;

};


#endif    // HISTOGRAMSVC_GENHISTO2D_H

---