MatrixOfHistograms.C

Go to the documentation of this file.

#include "jbltools/sfh/MatrixOfHistograms.h"
#include "jbltools/sfh/SetOfHistograms.h"
#include "jbltools/sfh/RegH1F.h"
#include "jbltools/sfh/BinningFun.h"

#include <TFile.h>
#include <TAxis.h>

#include <iostream>
#include <cassert>

using std::endl;
using std::cout;
using std::cerr;

static const char *ident="@(#)$Id: MatrixOfHistograms.C,v 1.12 2005/07/08 15:01:34 blist Exp $";

MatrixOfHistograms::MatrixOfHistograms (const char* name_,  
                                        const char* title_, 
                                        const ROListPoR& rol, 
                                        const BinningFunPoR& binning1_, 
                                        const BinningFunPoR& binning2_) 
: MatrixOfH (name_, title_, rol, binning1_, binning2_)
{
}  

MatrixOfHistograms::MatrixOfHistograms (const char* name_,  
                                        const char* title_, 
                                        Int_t nbinsx,  
                                        Axis_t xlow,  
                                        Axis_t xup,  
                                        const ROListPoR& rol, 
                                        const BinningFunPoR& binning1_, 
                                        const BinningFunPoR& binning2_) 
: MatrixOfH (name_, title_, rol, binning1_, binning2_),
  axisbinning (nbinsx, xlow, xup) 
{
  initHistos ();
}  

MatrixOfHistograms::MatrixOfHistograms (const char* name_,  
                                        const char* title_, 
                                        Int_t nbinsx,  
                                        const Double_t *xbins,  
                                        const ROListPoR& rol, 
                                        const BinningFunPoR& binning1_, 
                                        const BinningFunPoR& binning2_) 
: MatrixOfH (name_, title_, rol, binning1_, binning2_),
  axisbinning (nbinsx, xbins) 
{
  initHistos ();
}  

MatrixOfHistograms::MatrixOfHistograms (const char* name_,  
                                        const char* title_, 
                                        Int_t nbinsx,  
                                        const Float_t *xbins,  
                                        const ROListPoR& rol, 
                                        const BinningFunPoR& binning1_, 
                                        const BinningFunPoR& binning2_) 
: MatrixOfH (name_, title_, rol, binning1_, binning2_),
  axisbinning (nbinsx, xbins)
{
  initHistos ();
}  

MatrixOfHistograms::MatrixOfHistograms (const char* name_,  
                                        const char* title_, 
                                        const Binning& axisbinning_,  
                                        const ROListPoR& rol, 
                                        const BinningFunPoR& binning1_, 
                                        const BinningFunPoR& binning2_) 
: MatrixOfH (name_, title_, rol, binning1_, binning2_),
  axisbinning (axisbinning_)
{
  initHistos ();
}  

MatrixOfHistograms::MatrixOfHistograms (const char* name_, 
                                        const char* title_, 
                                        TFile& file, 
                                        const ROListPoR& rol,
                                        const BinningFunPoR& binning1_, 
                                        const BinningFunPoR& binning2_)
: MatrixOfH (name_, title_, rol, binning1_, binning2_)
{
  const BinningFun *binning1 = getBinning(1);
  const BinningFun *binning2 = getBinning(2);
  assert (binning1);
  assert (binning2);
  IndexType nbins1 = binning1->getNBins();
  IndexType nbins2 = binning2->getNBins();
  for (IndexType i = 0; i < nbins1; i++) {
    for (IndexType j = 0; j < nbins2; j++) {
      const char *hname = genBinName(i, j);
      new RegH1F (hname, file, *this);
      delete[] hname;
    }
  }
  cout << "MatrixOfHistograms::MatrixOfHistograms: name=" << getName()
       << ", title=" << getTitle() 
       << "\nnbins1=" << nbins1 << ", nbins2=" << nbins2 
       << ", entries=" << getEntries() 
       << "\n read from file " << file.GetName() << endl;
  
  if (rol.prol) rol.prol->registerObject (this);
}  


void MatrixOfHistograms::initHisto (IndexType i, IndexType j) {
  const char *htitle = genBinTitle(i, j);
  const char *hname = genBinName(i, j);
  RegH1F * h = new RegH1F (hname, htitle, axisbinning, 0);
  registerObject (getBinNumber(i, j), h);
  delete[] hname;
  delete[] htitle;
}


MatrixOfHistograms::~MatrixOfHistograms () {
}                    

  
RegH1F *MatrixOfHistograms::getHisto (IndexType i, IndexType j) {
  return dynamic_cast<RegH1F *>(getEntry(getBinNumber (i, j)));
}
  
  
RegH1F *MatrixOfHistograms::getSummary(Option_t* option, 
                                       const ROListPoR& rol) {
  bool dim2 = false;

  TString opt = option;
  opt.ToLower();
  if (opt.Contains("2")) dim2 = true;
  
  int number = 99999;
  if (opt.Contains("m")) number = 99998;
  
  const char *title = getTitle();
  if (!title) title = "?";
  const char *name = getName();
  if (!name) name = "?";
  
  int htitlen = strlen (title) + 5 + 1;
  char *htitle = new char[htitlen];
  snprintf (htitle, htitlen, "%s Summary", title);
  int hnamlen = strlen (name) + 1 + strlen ("Summary")+1;
  char *hname = new char[hnamlen];
  snprintf (hname, hnamlen, "%s%5d", hname, number);
  RegH1F *result = 0;
  
  const BinningFun *binning1 = getBinning(1);
  const BinningFun *binning2 = getBinning(2);
  assert (binning1);
  assert (binning2);
  IndexType nbins1 = binning1->getNBins();
  IndexType nbins2 = binning2->getNBins();
  
  if (dim2) {
    cerr << "MatrixOfHistograms::getSummary: 2-dim not yet implemented"
         << endl;
  } else {
    Int_t nbinsx = nbins1*nbins2;
    Axis_t xlow = -0.5;
    Axis_t xup = nbinsx-0.5;
    result = new RegH1F (hname, htitle, nbinsx, xlow, xup, rol);
    if (result == 0)  {
      cerr << "MatrixOfHistograms::getSummary: Cannot create histo!"
           << endl;
    } else {
      for (IndexType i = 0; i < nbins1; i++) {
        for (IndexType j = 0; j < nbins1; j++) {
          RegH1F *h = getHisto (i, j);
          if (h) {
            Int_t ibin = i*nbins2 + j + 1;
            Stat_t content = 0;
            Stat_t error2 = 0;
            h->getHistInfo (option, content, error2);
            result->SetBinContent (ibin, content);
//            result->SetBinError2  (ibin, error2);
// TH1 only knows SetBinError :(
            result->SetBinError  (ibin, sqrt(error2));
          }
        }
      }
    }
  }
  delete[] hname;
  delete[] htitle;
  
  return result;
}
SetOfHistograms* MatrixOfHistograms::getSet (const char* name, const char* title, int idim, 
                                             const ROListPoR& rol,
                                             int lowbin, int highbin) {
  BinningFun *binning1 = getBinning(1);
  BinningFun *binning2 = getBinning(2);
  assert (binning1);
  assert (binning2);
  
  SetOfHistograms *result = 0;
  
  IndexType low = (lowbin < 0) ? 0 : lowbin;
  IndexType high = (highbin < 0 || highbin < lowbin) ? 0 : highbin;
  
  if (idim == 1) {
    if (highbin > binning2->getNBins()-1) high = binning2->getNBins()-1;
    result = new SetOfHistograms (name, title, rol, binning1);
    for (IndexType i = 0; i < static_cast<IndexType>(binning1->getNBins()); ++i) {
      RegH1F *h = getHisto (i, low);
      assert (h);
      const char *title = result->genBinTitle (i);
      const char *name = result->genBinName (i);
      RegH1F *sumhist = new RegH1F(name, title, *h, *result);
      delete[] title;
      delete[] name;
      for (IndexType j = low+1; j <= high; ++j) {
        sumhist->Add (getHisto (i, j));
      }
    }
  } else if (idim == 2) {
    if (highbin > binning1->getNBins()-1) high = binning1->getNBins()-1;
    result = new SetOfHistograms (name, title, rol, binning2);
    for (IndexType j = 0; j < static_cast<IndexType>(binning2->getNBins()); ++j) {
      RegH1F *h = getHisto (low, j);
      assert (h);
      const char *title = result->genBinTitle (j);
      const char *name = result->genBinName (j);
      RegH1F *sumhist = new RegH1F(name, title, *h, *result);
      delete[] title;
      delete[] name;
      // Bug fix 13.5.05 BL, RW: Start at lowbin+1, as result is already a copy of 1st histogram
      for (IndexType i = low+1; i <= high; ++i) {
        sumhist->Add (getHisto (i, j));
      }
    }
  } else {
    cerr << "MatrixOfHistograms::getSet: ERROR: non-existing dimension " 
         << idim << " requested!" <<  endl;
  }
  return result;
}

SetOfHistograms *MatrixOfHistograms::getSummarySet(const char *name, const char *title, int idim,
                               Option_t* option, 
                               const ROListPoR& rol,
                               const Float_t *xbinmargins) {

  BinningFun *binning1 = getBinning(1);
  BinningFun *binning2 = getBinning(2);
  assert (binning1);
  assert (binning2);
  
  SetOfHistograms *result = 0;
  if (idim == 1) {
    int nx = binning2->getNBins();
    if (xbinmargins == 0) {
      result = new SetOfHistograms (name, title, nx, -0.5, nx-0.5, rol, binning1);
    }
    else {
      result = new SetOfHistograms (name, title, nx, xbinmargins, rol, binning1);
    }
    for (IndexType i = 0; i < static_cast<IndexType>(binning1->getNBins()); ++i) {
      RegH1F *target = result->getHisto (i);
      for (IndexType j = 0; j < static_cast<IndexType>(binning2->getNBins()); ++j) {
        RegH1F *h = getHisto (i, j);
        if (target && h) {
          Stat_t content = 0;
          Stat_t error2 = 0;
          h->getHistInfo (option, content, error2);
          target->SetBinContent (j+1, content);
//          target->SetBinError2  (j+1, error2);
          target->SetBinError  (j+1, sqrt(error2));
        }
      }
    }
  } else if (idim == 2) {
    IndexType nx = binning1->getNBins();
    if (xbinmargins == 0) {
      result = new SetOfHistograms (name, title, nx, -0.5, nx-0.5, rol, binning2);
    }
    else {
      result = new SetOfHistograms (name, title, nx, xbinmargins, rol, binning2);
    }
    for (IndexType j = 0; j < static_cast<IndexType>(binning2->getNBins()); ++j) {
      RegH1F *target = result->getHisto (j);
      for (IndexType i = 0; i < static_cast<IndexType>(binning1->getNBins()); ++i) {
        RegH1F *h = getHisto (i, j);
        if (target && h) {
          Stat_t content = 0;
          Stat_t error2 = 0;
          h->getHistInfo (option, content, error2);
          target->SetBinContent (i+1, content);
//          target->SetBinError2  (i+1, error2);
          target->SetBinError  (i+1, sqrt(error2));
        }
      }
    }
  } else {
    cerr << "MatrixOfHistograms::getSet: ERROR: non-existing dimension " 
         << idim << " requested!" <<  endl;
  }
  return result;
}

---