SetOfH.C

Go to the documentation of this file.

#include "jbltools/sfh/SetOfH.h"
#include "jbltools/sfh/BinningFun.h"
#include "jbltools/sfh/RegH1F.h"

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

#include <iostream>
#include <cmath>
#include <cassert>

static const char *ident="@(#)$Id: SetOfH.C,v 1.8 2005/09/06 11:27:25 blist Exp $";

SetOfH::SetOfH (const char* name_, 
                const char* title_, 
                const ROListPoR& hhl, 
                const BinningFunPoR& binning1_,
                Option_t* option_) 
: name (0), title (0),
  binning1 (binning1_.pbf), binning2 (0), binning3 (0), option (0)
{
  init (name_, title_, option_);
  if (hhl.prol) hhl.prol->registerObject (this);
}  

SetOfH::SetOfH (const char* name_, 
                const char* title_, 
                const ROListPoR& hhl, 
                const BinningFunPoR& binning1_,
                const BinningFunPoR& binning2_,
                Option_t* option_) 
: name (0), title (0),
  binning1 (binning1_.pbf), binning2 (binning2_.pbf), binning3 (0), option (0)
{
  init (name_, title_, option_);
  if (hhl.prol) hhl.prol->registerObject (this);
}  

void SetOfH::init (const char* name_, const char* title_, Option_t *option_) {
  if (!name_) name_ = "?";
  if (!title_) title_ = "?";
  if (name_) {
    name = new char[strlen (name_)+1];
    strcpy (name, name_);
  }
  if (title_) {
    title = new char[strlen (title_)+1];
    strcpy (title, title_);
  }
  if (option_) {
    option = new char[strlen (option_)+1];
    strcpy (option, option_);
  }
}


void SetOfH::initHistos () {
  IndexType nbins = binning1 ? binning1->getNBins() : 0;
  for (IndexType i = 0; i < nbins; i++) {
    this->initHisto(i);
  }
}



TH1 *SetOfH::getHisto (unsigned int i) {
  if (i >= getEntries()) return 0;
  return dynamic_cast<TH1 *>(getEntry(i));
}

const char *SetOfH::genBinTitle (IndexType i) const {
    if (binning1==0) return 0;
    const char *bintitle = binning1->getBinTitle(i);
    if (!bintitle) {
      char *bt = new char[10];
      snprintf (bt, 10, "%lld", i);
      bintitle = bt;
    }
    size_t size = strlen (title) + 1 + strlen (bintitle) + 1;
    char *htitle = new char[size];
    snprintf (htitle, size, "%s %s", title, bintitle);
    delete[] bintitle;
    return htitle;
}

const char *SetOfH::genBinName (IndexType i) const {
    if (binning1==0) return 0;
    const char *binname = binning1->getBinName(i);
    if (!binname) {
      char *bn = new char[10];
      snprintf (bn, 10, "%lld", i);
      binname = bn;
    }
    size_t size = strlen (name) + strlen (binname) + 1;
    char *hname = new char[size];
    snprintf (hname, size, "%s%s", name, binname);
    delete[] binname;
    return hname;
}

SetOfH::~SetOfH () {
  // cout << "~SetOfH(): deleting " << title << endl;
  delete[] name;
  name = 0;
  delete[] title;
  title = 0;
  delete[] option;
  option = 0;
}                    

void SetOfH::Divide(TF1* f1, Double_t c1) {
  for (iterator i = begin(); i != end(); ++i) {
    if (TH1 *h = dynamic_cast<TH1 *>(getEntry(i))) h->Divide(f1, c1);
  }
}

void SetOfH::Divide(const TH1 *h1) {
  for (iterator i = begin(); i != end(); ++i) {
    if (TH1 *h = dynamic_cast<TH1 *>(getEntry(i))) h->Divide(h1);
  }
}

void SetOfH::Divide(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2, Option_t* option) {
  for (iterator i = begin(); i != end(); ++i) {
    if (TH1 *h = dynamic_cast<TH1 *>(getEntry(i))) h->Divide(h1, h2, c1, c2, option);
  }
}
             
void SetOfH::Divide(const SetOfH *soh) {
  if (soh == 0) return;
  if (getEntries() != soh->getEntries()) {
    std::cerr << "SetOfH::Divide(const SetOfH *): number of histograms differ for " 
              << getName() << " and " << soh->getName() << std::endl; 
  }
  
  for (iterator i = begin(); i != end(); ++i) {
    TH1 *h = dynamic_cast<TH1 *>(getEntry(i));
    TH1 *h1 = dynamic_cast<TH1 *>(soh->getEntry(getIndex(i)));
    if (h && h1) h->Divide (h1);
    else if (h || h1) std::cerr << "SetOfH::Divide(const SetOfH&): histo missing for index " << getIndex(i)
                << " in set " << (h ? soh : this)->getName() << std::endl;
  }
}

void SetOfH::Divide(const SetOfH *soh1, const SetOfH *soh2, 
                    Double_t c1, Double_t c2, Option_t* option) {
  if (soh1 == 0 || soh2 == 0) return;
  if (getEntries() != soh1->getEntries() || getEntries() != soh2->getEntries()) {
    std::cerr << "SetOfH::Divide(...): number of histograms differ for " 
              << getName() << " and " << soh1->getName() << " and " << soh2->getName() << std::endl; 
  }
  for (iterator i = begin(); i != end(); ++i) {
    TH1 *h = dynamic_cast<TH1 *>(getEntry(i));
    TH1 *h1 = dynamic_cast<TH1 *>(soh1->getEntry(getIndex(i)));
    TH1 *h2 = dynamic_cast<TH1 *>(soh2->getEntry(getIndex(i)));
    if (h && h1 && h2) h->Divide (h1, h2, c1, c2, option);
    else if (h || h1 || h2) 
      std::cerr << "SetOfH::Divide(const SetOfH *, const SetOfH *, ...): histo missing for index " << getIndex(i)
                << " in set " << (h ? (h1 ? soh2 : soh1) : this)->getName() << std::endl;
  }
}


void SetOfH::Divide(const SetOfH *soh1, const SetOfH *soh2, 
                    const SetOfH *soh3, Double_t c1, Double_t c2) {
  if (soh1 == 0 || soh2 == 0 || soh3 == 0) return;
  if (getEntries() != soh1->getEntries() || 
      getEntries() != soh2->getEntries() || 
      getEntries() != soh3->getEntries()) {
    std::cerr << "SetOfHistograms::Divide(...): number of histograms differ for " 
              << getName() << " and " << soh1->getName() << " and " << soh2->getName() 
              << " and " << soh3->getName() << std::endl;  
  }
  for (iterator i = begin(); i != end(); ++i) {
    RegH1F *h = dynamic_cast<RegH1F *>(getEntry(i));
    TH1 *h1 = dynamic_cast<TH1 *>(soh1->getEntry(getIndex(i)));
    TH1 *h2 = dynamic_cast<TH1 *>(soh2->getEntry(getIndex(i)));
    TH1 *h3 = dynamic_cast<TH1 *>(soh3->getEntry(getIndex(i)));
    if (h && h1 && h2 && h3) h->Divide (h1, h2, h3, c1, c2);
    else if (h || h1 || h2 || h3) 
      std::cerr << "SetOfH::Divide(const SetOfH *, const SetOfH *, ...): histo missing for index " << getIndex(i)
                << " in set " << (h ? (h1 ? (h2 ? soh3 : soh2) : soh1) : this)->getName() << std::endl;
  }
}
  
void SetOfH::Multiply(TF1 *f1, Double_t c1) {
  for (iterator i = begin(); i != end(); ++i) {
    if (TH1 *h = dynamic_cast<TH1 *>(getEntry(i))) h->Multiply(f1, c1);
  }
}

void SetOfH::Multiply(const TH1 *h1) {
  for (iterator i = begin(); i != end(); ++i) {
    if (TH1 *h = dynamic_cast<TH1 *>(getEntry(i))) h->Multiply(h1);
  }
}

void SetOfH::Multiply(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2, Option_t* option) {
  for (iterator i = begin(); i != end(); ++i) {
    if (TH1 *h = dynamic_cast<TH1 *>(getEntry(i))) h->Multiply(h1, h2, c1, c2, option);
  }
}
             
void SetOfH::Multiply(const SetOfH *soh) {
  if (soh == 0) return;
  if (getEntries() != soh->getEntries()) {
    std::cerr << "SetOfH::Multiply(const SetOfH *): number of histograms differ for " 
              << getName() << " and " << soh->getName() << std::endl;
  }
  
  for (iterator i = begin(); i != end(); ++i) {
    TH1 *h = dynamic_cast<TH1 *>(getEntry(i));
    TH1 *h1 = dynamic_cast<TH1 *>(soh->getEntry(getIndex(i)));
    if (h && h1) h->Multiply (h1);
    else if (h || h1) 
      std::cerr << "SetOfH::Multiply(const SetOfH *): histo missing for index " << getIndex(i)
                << " in set " << (h ? soh : this)->getName() << std::endl;
  }
}

void SetOfH::Multiply(const SetOfH *soh1, 
                      const SetOfH *soh2, 
                      Double_t c1, Double_t c2, 
                      Option_t* option) {
  if (soh1 == 0 || soh2 == 0) return;                             
  if (getEntries() != soh1->getEntries() || getEntries() != soh2->getEntries()) {
    std::cerr << "SetOfH::Multiply(const SetOfH *, const SetOfH *, ...): number of histograms differ for " 
              << getName() << " and " << soh1->getName() << " and " << soh2->getName() << std::endl;
  }
  for (iterator i = begin(); i != end(); ++i) {
    TH1 *h = dynamic_cast<TH1 *>(getEntry(i));
    TH1 *h1 = dynamic_cast<TH1 *>(soh1->getEntry(getIndex(i)));
    TH1 *h2 = dynamic_cast<TH1 *>(soh2->getEntry(getIndex(i)));
    if (h && h1 && h2) h->Multiply (h1, h2, c1, c2, option);
    else if (h || h1 || h2) 
      std::cerr << "SetOfH::Multiply(const SetOfH *, const SetOfH *, ...): histo missing for index " << getIndex(i)
                << " in set " << (h ? (h1 ? soh2 : soh1) : this)->getName() << std::endl;
  }
}
  
void SetOfH::Add(const SetOfH *soh, Double_t c1) {
  if (soh == 0) return;
  if (getEntries() != soh->getEntries()) {
    std::cerr << "SetOfH::Add(const SetOfH *): number of histograms differ!" 
              << std::endl;
  }
  
  for (iterator i = begin(); i != end(); ++i) {
    TH1 *h = dynamic_cast<TH1 *>(getEntry(i));
    TH1 *h1 = dynamic_cast<TH1 *>(soh->getEntry(getIndex(i)));
    if (h && h1) h->Add (h1, c1);
    else if (h || h1) 
      std::cerr << "SetOfH::Add(const SetOfH *): histo missing for index " << getIndex(i)
                << " in set " << (h ? soh : this)->getName() << std::endl;
  }
}
  

  

---