---

Axis.h

Go to the documentation of this file.

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


// Include files
#include "GaudiKernel/IHistogram.h"
#include "GaudiKernel/IAxis.h"

#include "HTL/Histograms.h"


//------------------------------------------------------------------------------
//
// ClassName:    Axis
//  
// Description:  Definition of the class Axis
//
//               Axis represents a binned histogram axis.
//               A 1D histogram has one axis representing the X axis,
//               a 2D histogram has two axes representing the X and Y Axis. 
//
// Authors:      Pavel Binko, Dino Ferrero Merlino, Andreas Pfeiffer
// Date:         22/03/2000
//
//------------------------------------------------------------------------------


class Axis : virtual public IAxis                                              {

public:

  Axis( I_Histo* h, int axisNumber, int nBins, double low, double high )                                   {
    m_histogram = h;
    m_axisNumber = axisNumber;
    setEdgesAndBins( nBins, low, high );
  }

  Axis( I_Histo* h, int axisNumber, const std::vector<double>& edges )                                     {
    m_histogram = h;
    m_axisNumber = axisNumber;
    setEdgesAndBins( edges );
  }

  virtual ~Axis() {}


  virtual const std::vector<double>& edges() const                             {
    return m_edges;
  }

  virtual double lowerEdge() const                                             {
    return m_edges[0];
  }
  virtual double upperEdge() const                                             {
    return m_edges[m_bins];
  }




  virtual int bins() const                                                     {
    return m_bins;
  }


  virtual double binLowerEdge( int index ) const                               {
    int i = checkIndex( index );
    if( IHistogram::UNDERFLOW_BIN == i ) {
      // Should be negative infinity
      return -999999.999999;
    }
    else if ( IHistogram::OVERFLOW_BIN == i ) {
      return m_edges[m_bins];
    }
    // In-range bin
    return m_edges[i];
  }

  virtual double binUpperEdge( int index ) const                               {
    int i = checkIndex( index );
    if( IHistogram::UNDERFLOW_BIN == i ) {
      return m_edges[0];
    }
    else if ( IHistogram::OVERFLOW_BIN == i ) {
      // Should be positive infinity
      return +999999.999999;
    }
    // In-range bin
    return m_edges[i+1];
  }


  virtual double binWidth( int index ) const                                   {
    int i = checkIndex( index );
    return m_edges[i+1] - m_edges[i];
  }


  virtual double binCentre( int index ) const                                  {
    int i = checkIndex( index );
    // Only the arithmetic bin centre supported
    if( 1 == m_histogram->dim() ) {
      // Histogram 1D
      return HInfo::bin_center( *m_histogram, i );
    }
    else if( 2 == m_histogram->dim() ) {
      // Histogram 2D
      if( 0 == m_axisNumber ) {
        // X axis
        return HInfo::bin_center( *m_histogram, m_axisNumber, i, 0 );
      }
      else if( 1 == m_axisNumber ) {
        // Y axis
        return HInfo::bin_center( *m_histogram, m_axisNumber, 0, i );
      }
      std::cout << "Other axes than X or Y are not supported" << std::endl;
    }
    std::cout << "Other histograms than 1D or 2D are not supported" << std::endl;
    return 0.;
//    // Geometrical bin centre would be
//    return ( m_edges[i] + m_edges[i+1] ) / 2;
  }



  virtual int coordToIndex( double coord ) const                               {
    // Other possible implementation of fast coord to index conversion
    // Assuming histogram with right open bins
    if( lowerEdge() > coord ) {
      return IHistogram::UNDERFLOW_BIN;
    }
    if( upperEdge() <= coord ) {
      return IHistogram::OVERFLOW_BIN;
    }
    // Inside the histogram
    int begin   = 0;
    int end     = bins() - 1;
    int centre  = 0;
    while( begin != end ) {
      centre = ( begin + end ) / 2;
      if( binUpperEdge( centre ) <= coord  ) {
        begin = centre + 1;
      }
      else {
        end = centre;
      }
    }
    return begin;
  }

  

  virtual int checkIndex( int index ) const                                    {
    if( (index >= 0) && (index < m_bins) ) {
      return index;
    }
    else if( (IHistogram::OVERFLOW_BIN != index) && ((index < 0) || (index >= m_bins)) ) {
      return IHistogram::UNDERFLOW_BIN;
    }
    // Otherwise overflow
    return IHistogram::OVERFLOW_BIN;
  }


protected:


  void setEdgesAndBins( const std::vector<double>& value )                     {
    m_edges = value;
    m_bins = m_edges.size() - 1;
  }
  void setEdgesAndBins( int nBins, double low, double high )                   {
    double siz  = ( high - low ) / nBins;
    double edge = low;
    for( int i=0; i<nBins; i++ ) {
      m_edges.push_back( edge );
      edge += siz;
    }
    m_edges.push_back( high );
    m_bins = nBins;
  }

protected:

  int                      m_bins;
  
  std::vector<double>      m_edges;

  I_Histo*                 m_histogram;

  int                      m_axisNumber;

};


#endif    // GAUDISVC_AXIS_H

---