ana::Binning Class Reference

Represent the binning of a Spectrum's x-axis. More...

#include <Binning.h>

Public Member Functions
int	NBins () const
double	Min () const
double	Max () const
int	FindBin (float x) const
bool	IsSimple () const
const std::vector< double > &	Edges () const
const std::vector< std::string > &	Labels () const
void	SaveTo (TDirectory *dir) const
int	ID () const
bool	operator== (const Binning &rhs) const
bool	operator< (const Binning &rhs) const

Static Public Member Functions
static Binning	Simple (int n, double lo, double hi, const std::vector< std::string > &labels={})
static Binning	LogUniform (int n, double lo, double hi)
static Binning	Custom (const std::vector< double > &edges)
static Binning	FromTAxis (const TAxis *ax)
static std::unique_ptr< Binning >	LoadFrom (TDirectory *dir)
static int	MaxID ()

Protected Member Functions
	Binning ()

Static Protected Member Functions
static Binning	SimpleHelper (int n, double lo, double hi, const std::vector< std::string > &labels={})
static Binning	CustomHelper (const std::vector< double > &edges)
static std::map< Binning, int > &	IDMap ()

Protected Attributes
std::vector< double >	fEdges
std::vector< std::string >	fLabels
int	fNBins
double	fMin
double	fMax
bool	fIsSimple
int	fID

Static Protected Attributes
static int	fgNextID = 0
	The next ID that hasn't yet been assigned. More...

Detailed Description

Represent the binning of a Spectrum's x-axis.

May be "Simple" (equally spaced) or "Custom" (arbitrary binning)

Definition at line 18 of file Binning.h.

Constructor & Destructor Documentation

ana::Binning::Binning ( )

protected

Definition at line 13 of file Binning.cxx.

    : fID(-1)
  {
  }

Member Function Documentation

Binning ana::Binning::Custom ( const std::vector< double > &  edges )

static

Definition at line 83 of file Binning.cxx.

  {
    Binning bins = CustomHelper(edges);

    auto it = IDMap().find(bins);
    if(it == IDMap().end()){
      bins.fID = fgNextID++;
      IDMap().emplace(bins, bins.fID);
    }
    else{
      bins.fID = it->second;
    }

    return bins;
  }

Binning ana::Binning::CustomHelper ( const std::vector< double > &  edges )

staticprotected

Definition at line 68 of file Binning.cxx.

  {
    assert(edges.size() > 1);

    Binning bins;
    bins.fEdges = edges;
    bins.fNBins = edges.size()-1;
    bins.fMin = edges.front();
    bins.fMax = edges.back();
    bins.fIsSimple = false;

    return bins;
  }

const std::vector<double>& ana::Binning::Edges ( ) const

inline

Definition at line 32 of file Binning.h.

    {
      return fEdges;
    }

int ana::Binning::FindBin

(

float

x

)

const

Definition at line 100 of file Binning.cxx.

  {
    // Treat anything outside [fMin, fMax) at Underflow / Overflow
    if (x <  fMin) return 0;               // Underflow
    if (x >= fMax) return fEdges.size();   // Overflow

    // Follow ROOT convention, first bin of histogram is bin 1

    if (this->IsSimple()){
      double binwidth = (fMax - fMin) / fNBins;
      int bin = (x - fMin) / binwidth + 1;
      return bin;
    }

    int bin =
      std::lower_bound(fEdges.begin(), fEdges.end(), x) - fEdges.begin();
    if (x == fEdges[bin]) bin++;
    assert(bin >= 0 && bin < (int)fEdges.size());
    return bin;
  }

Binning ana::Binning::FromTAxis ( const TAxis *  ax )

static

Definition at line 122 of file Binning.cxx.

  {
    Binning bins;

    // Evenly spaced binning
    if(!ax->GetXbins()->GetArray()){
      bins = SimpleHelper(ax->GetNbins(), ax->GetXmin(), ax->GetXmax());
    }
    else{
      std::vector<double> edges(ax->GetNbins()+1);
      ax->GetLowEdge(&edges.front());
      edges[ax->GetNbins()] = ax->GetBinUpEdge(ax->GetNbins());

      bins = Binning::Custom(edges);
    }

    auto it = IDMap().find(bins);
    if(it != IDMap().end()){
      bins.fID = it->second;
    }
    else{
      bins.fID = fgNextID++;
      IDMap().emplace(bins, bins.fID);
    }

    return bins;
  }

int ana::Binning::ID ( ) const

inline

Definition at line 42 of file Binning.h.

{return fID;}

std::map< Binning, int > & ana::Binning::IDMap ( )

staticprotected

Definition at line 290 of file Binning.cxx.

  {
    static std::map<Binning, int> ret;
    return ret;
  }

bool ana::Binning::IsSimple ( ) const

inline

Definition at line 31 of file Binning.h.

{return fIsSimple;}

const std::vector<std::string>& ana::Binning::Labels ( ) const

inline

Definition at line 37 of file Binning.h.

{return fLabels;}

std::unique_ptr< Binning > ana::Binning::LoadFrom ( TDirectory *  dir )

static

Definition at line 229 of file Binning.cxx.

  {
    TObjString* tag = (TObjString*)dir->Get("type");
    assert(tag);
    assert(tag->GetString() == "Binning");

    TVectorD* vMinMax = (TVectorD*)dir->Get("nminmax");
    assert(vMinMax);

    Binning ret;

    const TVectorD* issimple = (TVectorD*)dir->Get("issimple");
    if((*issimple)[0]){
      ret = Binning::Simple((*vMinMax)[0],
                            (*vMinMax)[1],
                            (*vMinMax)[2]);
    }
    else{
      const TVectorD* vEdges = (TVectorD*)dir->Get("edges");
      std::vector<double> edges(vEdges->GetNrows());
      for(int i = 0; i < vEdges->GetNrows(); ++i) edges[i] = (*vEdges)[i];

      ret = Binning::Custom(edges);
    }

    for(unsigned int i = 0; ; ++i){
      TObjString* s = (TObjString*)dir->Get(TString::Format("label%d", i).Data());
      if(!s) break;
      ret.fLabels.push_back(s->GetString().Data());
    }

    return std::make_unique<Binning>(ret);
  }

Binning ana::Binning::LogUniform ( int  n, double  lo, double  hi  )

static

Definition at line 56 of file Binning.cxx.

  {
    std::vector<double> edges(n+1);
    const double logSpacing = exp( (log(hi) - log(lo)) / n );
    for (int i = 0; i <= n; ++i) {
      if (i == 0) edges[i] = lo;
      else        edges[i] = logSpacing*edges[i-1];
    }
    return Custom(edges);
  }

double ana::Binning::Max ( ) const

inline

Definition at line 29 of file Binning.h.

{return fMax;}

static int ana::Binning::MaxID ( )

inlinestatic

Definition at line 43 of file Binning.h.

{return fgNextID-1;}

double ana::Binning::Min ( ) const

inline

Definition at line 28 of file Binning.h.

{return fMin;}

int ana::Binning::NBins ( ) const

inline

Definition at line 27 of file Binning.h.

{return fNBins;}

bool ana::Binning::operator<

(

const Binning &

rhs

)

const

Definition at line 278 of file Binning.cxx.

  {
    if(fIsSimple != rhs.fIsSimple) return fIsSimple < rhs.fIsSimple;
    if(fIsSimple){
      return std::make_tuple(fNBins, fMin, fMax) < std::make_tuple(rhs.fNBins, rhs.fMin, rhs.fMax);
    }
    else{
      return fEdges < rhs.fEdges;
    }
  }

bool ana::Binning::operator==

(

const Binning &

rhs

)

const

Definition at line 264 of file Binning.cxx.

  {
    // NB don't look at ID here or in < because we use these in the maps below
    // that are used to find the IDs in the first place
    if(fIsSimple != rhs.fIsSimple) return false;
    if(fIsSimple){
      return fNBins == rhs.fNBins && fMin == rhs.fMin && fMax == rhs.fMax;
    }
    else{
      return fEdges == rhs.fEdges;
    }
  }

void ana::Binning::SaveTo

(

TDirectory *

dir

)

const

Definition at line 197 of file Binning.cxx.

  {
    TDirectory* tmp = gDirectory;
    dir->cd();

    TObjString("Binning").Write("type");

    TVectorD nminmax(3);

    nminmax[0] = fNBins;
    nminmax[1] = fMin;
    nminmax[2] = fMax;

    nminmax.Write("nminmax");

    TVectorD issimple(1);
    issimple[0] = fIsSimple;
    issimple.Write("issimple");

    TVectorD edges(fEdges.size());
    for(unsigned int i = 0; i < fEdges.size(); ++i)
      edges[i] = fEdges[i];

    edges.Write("edges");

    for(unsigned int i = 0; i < fLabels.size(); ++i)
      TObjString(fLabels[i].c_str()).Write(TString::Format("label%d", i).Data());

    tmp->cd();
  }

Binning ana::Binning::Simple ( int  n, double  lo, double  hi, const std::vector< std::string > &  labels = {}  )

static

Definition at line 38 of file Binning.cxx.

  {
    Binning bins = SimpleHelper(n, lo, hi, labels);

    auto it = IDMap().find(bins);
    if(it == IDMap().end()){
      bins.fID = fgNextID++;
      IDMap().emplace(bins, bins.fID);
    }
    else{
      bins.fID = it->second;
    }

    return bins;
  }

Binning ana::Binning::SimpleHelper ( int  n, double  lo, double  hi, const std::vector< std::string > &  labels = {}  )

staticprotected

Definition at line 19 of file Binning.cxx.

  {
    assert(labels.empty() || int(labels.size()) == n);

    Binning bins;
    bins.fNBins = n;
    bins.fMin = lo;
    bins.fMax = hi;
    bins.fEdges.resize(n+1);
    for (int i = 0; i <= n; i++)
      bins.fEdges[i] = lo + i*(hi-lo)/n;
    bins.fLabels = labels;
    bins.fIsSimple = true;

    return bins;
  }

Member Data Documentation

std::vector<double> ana::Binning::fEdges

protected

Definition at line 55 of file Binning.h.

int ana::Binning::fgNextID = 0

staticprotected

The next ID that hasn't yet been assigned.

Definition at line 63 of file Binning.h.

int ana::Binning::fID

protected

Definition at line 61 of file Binning.h.

bool ana::Binning::fIsSimple

protected

Definition at line 59 of file Binning.h.

std::vector<std::string> ana::Binning::fLabels

protected

Definition at line 56 of file Binning.h.

double ana::Binning::fMax

protected

Definition at line 58 of file Binning.h.

double ana::Binning::fMin

protected

Definition at line 58 of file Binning.h.

int ana::Binning::fNBins

protected

Definition at line 57 of file Binning.h.

---

The documentation for this class was generated from the following files:

• Binning.h
• Binning.cxx