Binning.C

Go to the documentation of this file.

#include "jbltools/sfh/Binning.h"

#include <TAxis.h>

#include <cmath>
#include <cassert>

static const char *ident="@(#)$Id: Binning.C,v 1.9 2005/09/29 08:56:40 boehmej Exp $";

Binning::Binning ()
: nbins(0), binedges(0), equidistant (true) 
{}

Binning::Binning (int nbins_, Axis_t xlow, Axis_t xhigh)
: nbins(nbins_), binedges(0), equidistant (true) 
{
  assert (xhigh > xlow);
  assert (nbins >= 1);
  binedges = new Axis_t[2];
  binedges[0] = xlow;
  binedges[1] = xhigh;
}

Binning::Binning (int nbins_, const float binedges_[])
: nbins(nbins_), binedges(0), equidistant (false) 
{
  assert (binedges_);
  binedges = new Axis_t[nbins+1];
  // C macho style:
  for (Axis_t *be=binedges; be != binedges+nbins+1;) *(be++) = *(binedges_++);
}

Binning::Binning (int nbins_, const double binedges_[])
: nbins(nbins_), binedges(0), equidistant (false) 
{
  assert (binedges_);
  binedges = new Axis_t[nbins+1];
  // C macho style:
  for (Axis_t *be=binedges; be != binedges+nbins+1;) *(be++) = *(binedges_++);
}

Binning::Binning (const TAxis& axis)
: nbins(0), binedges(0), equidistant (true)  {
  assert (&axis);
  nbins = axis.GetNbins();
  const TArrayD *xbins = axis.GetXbins();
  if (!xbins || xbins->GetSize() == 0) {
    // equidistant binning
    equidistant = true;
    binedges = new Axis_t[2];
    binedges[0] = axis.GetXmin();
    binedges[1] = axis.GetXmax();
  }
  else {
    // non-equidistant binning
    assert (xbins->GetSize() == nbins+1);
    binedges = new Axis_t[nbins+1];
    const Double_t *array = xbins->GetArray();
    assert (array);
    // C macho style:
    for (Axis_t *be=binedges; be != binedges+nbins+1;) *(be++) = *(array++);
  }
}

Binning::Binning (const Binning& rhs)
: nbins(rhs.nbins), binedges(0), equidistant (rhs.equidistant) {
  assert (rhs.binedges);
  binedges = new Axis_t[nbins+1];
  // C macho style:
  Axis_t *binedges_ = rhs.binedges;
  for (Axis_t *be=binedges; be != binedges+nbins+1;) *(be++) = *(binedges_++);
} 

Binning& Binning::operator= (const Binning& rhs)
{
  if (this != &rhs) {
    delete[] binedges;
    nbins = rhs.nbins;
    equidistant = rhs.equidistant;
    binedges = new Axis_t[nbins+1];
    assert (rhs.binedges);
    // C macho style:
    Axis_t *binedges_ = rhs.binedges;
    for (Axis_t *be=binedges; be != binedges+nbins+1;) *(be++) = *(binedges_++);
  }
  return *this;
} 

int Binning::getBin(Axis_t x) const {
  if (!binedges) return -1;
  if (equidistant) {
    // assume binedges[0] and binedges[1] to be lower and upper limit
    if (x < binedges[0] || x >= binedges[1]) return -1;
    return static_cast<int> (std::floor(nbins*(x-binedges[0])/(binedges[1]-binedges[0])));
  }
  else {
    if (x < binedges[0] || x >= binedges[nbins]) return -1;
    for (int i = 1; i < nbins+1; ++i) 
      if (binedges[i] > x) return i-1;
  }
  return -1;    // should never happen!            
}   

int Binning::getNBins() const {
  return nbins;
}
Axis_t Binning::getLowerBinEdge(int i) const {
  if (!binedges || i < 0 || i > nbins-1) return 0;
  if (equidistant) return binedges[0]+i*(binedges[1]-binedges[0])/nbins;
  return binedges[i];
}

Axis_t Binning::getUpperBinEdge(int i) const {
  if (!binedges || i < 0 || i > nbins-1) return 0;
  if (equidistant) return binedges[0]+(i+1)*(binedges[1]-binedges[0])/nbins;
  return binedges[i+1];
}

Axis_t Binning::getLowerEdge() const {
  if (!binedges) return 0;
  return binedges[0];
}

Axis_t Binning::getUpperEdge() const {
  if (!binedges) return 0;
  return (equidistant) ? binedges[1] : binedges [nbins];
}

const Axis_t *Binning::getEdges() const {
  return binedges;
}

bool Binning::isEquidistant() const {
  return equidistant;
}

bool Binning::hasBinLabels() const {
  return false;
}
    
const char *Binning::getBinLabel(int i) const {
  return "";
}
    
Binning::~Binning() {
  delete[] binedges;
  binedges = 0;
}

---