Collaboration diagram for inlib::histo::axis< TC >:

Public Types
enum	{ UNDERFLOW_BIN = -2, OVERFLOW_BIN = -1 }
typedef unsigned int	bn_t
Public Member Functions
bool	is_fixed_binning () const
TC	lower_edge () const
TC	upper_edge () const
bn_t	bins () const
const std::vector< TC > &	edges () const
TC	bin_width (int aBin) const
TC	bin_lower_edge (int aBin) const
TC	bin_upper_edge (int aBin) const
TC	bin_center (int aBin) const
int	coord_to_index (TC aValue) const
bool	coord_to_absolute_index (TC aValue, bn_t &a_index) const
bool	in_range_to_absolute_index (int a_in, bn_t &a_out) const
bool	configure (const std::vector< TC > &aEdges)
bool	configure (bn_t aNumber, TC aMin, TC aMax)
bool	is_compatible (const axis &a_axis) const
	axis ()
virtual	~axis ()
	axis (const axis &a_axis)
axis &	operator= (const axis &a_axis)
Public Attributes
bn_t	m_offset
bn_t	m_number_of_bins
TC	m_minimum_value
TC	m_maximum_value
bool	m_fixed
TC	m_bin_width
std::vector< TC >	m_edges

Detailed Description

template<class TC>
class inlib::histo::axis< TC >

Definition at line 16 of file axis.

Member Typedef Documentation

template<class TC>

typedef unsigned int inlib::histo::axis< TC >::bn_t

Definition at line 18 of file axis.

Member Enumeration Documentation

template<class TC>

anonymous enum

Enumerator:

UNDERFLOW_BIN
OVERFLOW_BIN

Definition at line 20 of file axis.

{ UNDERFLOW_BIN = -2, OVERFLOW_BIN = -1 }; //AIDA casing.

Constructor & Destructor Documentation

template<class TC>

inlib::histo::axis< TC >::axis ( ) [inline]

Definition at line 212 of file axis.

  :m_offset(0)
  ,m_number_of_bins(0)
  ,m_minimum_value(0)
  ,m_maximum_value(0)
  ,m_fixed(true)
  ,m_bin_width(0)
  {}

template<class TC>

virtual inlib::histo::axis< TC >::~axis ( ) [inline, virtual]

Definition at line 221 of file axis.

{}

template<class TC>

inlib::histo::axis< TC >::axis ( const axis< TC > & a_axis ) [inline]

Definition at line 223 of file axis.

  :m_offset(a_axis.m_offset)
  ,m_number_of_bins(a_axis.m_number_of_bins)
  ,m_minimum_value(a_axis.m_minimum_value)
  ,m_maximum_value(a_axis.m_maximum_value)
  ,m_fixed(a_axis.m_fixed)
  ,m_bin_width(a_axis.m_bin_width)
  ,m_edges(a_axis.m_edges)
  {}

Member Function Documentation

template<class TC>

TC inlib::histo::axis< TC >::bin_center ( int aBin ) const [inline]

Definition at line 76 of file axis.

                                {
    if(aBin==UNDERFLOW_BIN) {
      return 0; //FIXME : -INF
    } else if(aBin==OVERFLOW_BIN) {
      return 0; //FIXME : +INF
    } else if(aBin<0) {
      return 0; //FIXME : -INF
    } else if(aBin>=(int)m_number_of_bins) {
      return 0; //FIXME : +INF
    } else {
      if(m_fixed) {
        return (m_minimum_value + (aBin + 0.5) * m_bin_width);
      } else {
        return (m_edges[aBin] + m_edges[aBin+1])/2.;
      }
    }
  }

template<class TC>

TC inlib::histo::axis< TC >::bin_lower_edge ( int aBin ) const [inline]

Definition at line 44 of file axis.

                                    {
    if(aBin==UNDERFLOW_BIN) {
      return 0; //FIXME return -DBL_MAX;
    } else if(aBin==OVERFLOW_BIN) {
      return 0; //FIXME return bin_upper_edge(m_number_of_bins-1);
    } else if((aBin<0) ||(aBin>=(int)m_number_of_bins)) {
      return 0;
    } else {
      if(m_fixed) {
        return (m_minimum_value + aBin * m_bin_width);
      } else {
        return m_edges[aBin];
      }
    }
  }

template<class TC>

TC inlib::histo::axis< TC >::bin_upper_edge ( int aBin ) const [inline]

Definition at line 60 of file axis.

                                    {
    if(aBin==UNDERFLOW_BIN) {
      return 0; //FIXME bin_lower_edge(0)
    } else if(aBin==OVERFLOW_BIN) {
      return 0; //FIXME return DBL_MAX;
    } else if((aBin<0) ||(aBin>=(int)m_number_of_bins)) {
      return 0;
    } else {
      if(m_fixed) {
        return (m_minimum_value + (aBin + 1) * m_bin_width);
      } else {
        return m_edges[aBin+1];
      }
    }
  }

template<class TC>

TC inlib::histo::axis< TC >::bin_width ( int aBin ) const [inline]

Definition at line 28 of file axis.

                               {
    if(aBin==UNDERFLOW_BIN) {
      return 0; //FIXME return DBL_MAX;
    } else if(aBin==OVERFLOW_BIN) {
      return 0; //FIXME return DBL_MAX;
    } else if((aBin<0) ||(aBin>=(int)m_number_of_bins)) {
      return 0;
    } else {
      if(m_fixed) {
        return m_bin_width;
      } else {
        return (m_edges[aBin+1]-m_edges[aBin]);
      }
    }
  }

template<class TC>

bn_t inlib::histo::axis< TC >::bins ( ) const [inline]

Definition at line 25 of file axis.

{return m_number_of_bins;}

template<class TC>

bool inlib::histo::axis< TC >::configure ( const std::vector< TC > & aEdges ) [inline]

Definition at line 161 of file axis.

                                              {
    // init :
    m_number_of_bins = 0;
    m_minimum_value = 0;
    m_maximum_value = 0;
    m_fixed = true;
    m_bin_width = 0;
    m_edges.clear();
    // setup :
    if(aEdges.size()<=1) return false;
    bn_t number = aEdges.size()-1;
    for(bn_t index=0;index<number;index++) {
      if((aEdges[index]>=aEdges[index+1])) {
        return false;
      }
    }
    m_edges = aEdges;
    m_number_of_bins = number;
    m_minimum_value = aEdges[0];
    m_maximum_value = aEdges[m_number_of_bins];
    m_fixed = false;
    return true;
  }

template<class TC>

bool inlib::histo::axis< TC >::configure	(	bn_t	aNumber,
		TC	aMin,
		TC	aMax
	)		`[inline]`

Definition at line 185 of file axis.

                                               {
    // init :
    m_number_of_bins = 0;
    m_minimum_value = 0;
    m_maximum_value = 0;
    m_fixed = true;
    m_bin_width = 0;
    m_edges.clear();
    // setup :
    if(aNumber<=0) return false;
    if(aMax<=aMin) return false;
    m_number_of_bins = aNumber;
    m_minimum_value = aMin;
    m_maximum_value = aMax;
    m_bin_width = (aMax - aMin)/ aNumber;
    m_fixed = true;
    return true;
  }

template<class TC>

bool inlib::histo::axis< TC >::coord_to_absolute_index	(	TC	aValue,
		bn_t &	a_index
	)		const `[inline]`

Definition at line 114 of file axis.

                                                              {
    if( aValue <  m_minimum_value) {
      a_index = 0;
      return true;
    } else if( aValue >= m_maximum_value) {
      a_index = m_number_of_bins+1;
      return true; 
    } else {
      if(m_fixed) {
        a_index = (bn_t)((aValue - m_minimum_value)/m_bin_width)+1;
        return true;
      } else {
        for(bn_t index=0;index<m_number_of_bins;index++) {
          if((m_edges[index]<=aValue)&&(aValue<m_edges[index+1])) {
            a_index = index+1;
            return true;
          }
        }
        // Should never pass here...
        a_index = 0;
        return false;
      }
    }
  }

template<class TC>

int inlib::histo::axis< TC >::coord_to_index ( TC aValue ) const [inline]

Definition at line 94 of file axis.

                                      {
    if( aValue <  m_minimum_value) {
      return UNDERFLOW_BIN;
    } else if( aValue >= m_maximum_value) {
      return OVERFLOW_BIN;
    } else {
      if(m_fixed) {
        return (int)((aValue - m_minimum_value)/m_bin_width);
      } else {
        for(bn_t index=0;index<m_number_of_bins;index++) {
          if((m_edges[index]<=aValue)&&(aValue<m_edges[index+1])) {
            return index;
          }
        }
        // Should never pass here...
        return UNDERFLOW_BIN;
      }
    }
  }

template<class TC>

const std::vector<TC>& inlib::histo::axis< TC >::edges ( ) const [inline]

Definition at line 26 of file axis.

{return m_edges;}

template<class TC>

bool inlib::histo::axis< TC >::in_range_to_absolute_index	(	int	a_in,
		bn_t &	a_out
	)		const `[inline]`

Definition at line 139 of file axis.

                                                              {
    // a_in is given in in-range indexing :
    //  - [0,n-1] for in-range bins
    //  - UNDERFLOW_BIN for the iaxis underflow bin
    //  - OVERFLOW_BIN for the iaxis overflow bin
    // Return the absolute indexing in [0,n+1].
    if(a_in==UNDERFLOW_BIN) {
      a_out = 0;
      return true;
    } else if(a_in==OVERFLOW_BIN) {
      a_out = m_number_of_bins+1;
      return true;
    } else if((a_in>=0)&&(a_in<(int)m_number_of_bins)){
      a_out = a_in + 1;
      return true;
    } else {
      return false;
    }
  }

template<class TC>

bool inlib::histo::axis< TC >::is_compatible ( const axis< TC > & a_axis ) const [inline]

Definition at line 204 of file axis.

                                               {
    if(m_number_of_bins!=a_axis.m_number_of_bins) return false;
    if(m_minimum_value!=a_axis.m_minimum_value) return false;
    if(m_maximum_value!=a_axis.m_maximum_value) return false;
    return true;
  }

template<class TC>

bool inlib::histo::axis< TC >::is_fixed_binning ( ) const [inline]

Definition at line 22 of file axis.

{return m_fixed;}

template<class TC>

TC inlib::histo::axis< TC >::lower_edge ( ) const [inline]

Definition at line 23 of file axis.

{return m_minimum_value;}

template<class TC>

axis& inlib::histo::axis< TC >::operator= ( const axis< TC > & a_axis ) [inline]

Definition at line 233 of file axis.

                                      {
    m_offset = a_axis.m_offset;
    m_number_of_bins = a_axis.m_number_of_bins;
    m_minimum_value = a_axis.m_minimum_value;
    m_maximum_value = a_axis.m_maximum_value;
    m_fixed = a_axis.m_fixed;
    m_bin_width = a_axis.m_bin_width;
    m_edges = a_axis.m_edges;
    return *this;
  }