SFH2F.C

Go to the documentation of this file.

#include "jbltools/sfh/SFH2F.h"

#include "jbltools/sfh/FloatFunBase.h"
#include "jbltools/sfh/BaseCutBase.h"
#include "jbltools/sfh/FillIterator.h"

#include <iostream>

static const char *ident="@(#)$Id: SFH2F.C,v 1.13 2005/08/23 12:05:44 blist Exp $";

SFH2F::SFH2F (const char* name, const char* title, 
              Int_t nbinsx, Axis_t xlow, Axis_t xup,
              Int_t nbinsy, Axis_t ylow, Axis_t yup, 
              const ROListPoR& hhl, 
              const FloatFunPoR& xfun_, 
              const FloatFunPoR& yfun_, 
              const BaseCutPoR& cut_, 
              const FloatFunPoR& wfun_, 
              const FillIteratorPoR& iter_) 
: RegH2F (name, title, nbinsx, xlow, xup, nbinsy, ylow, yup, hhl), 
  xfun(xfun_.pff), yfun(yfun_.pff), cut(cut_.pbc), wfun(wfun_.pff), iter(iter_.pfi)
{
  checkIterators(name);
}
  
  
SFH2F::SFH2F (const char* name, const char* title, 
              Int_t nbinsx, const Double_t* xbins,
              Int_t nbinsy, Axis_t ylow, Axis_t yup, 
              const ROListPoR& hhl, 
              const FloatFunPoR& xfun_, 
              const FloatFunPoR& yfun_, 
              const BaseCutPoR& cut_, 
              const FloatFunPoR& wfun_, 
              const FillIteratorPoR& iter_) 
: RegH2F (name, title, nbinsx, xbins, nbinsy, ylow, yup, hhl), 
  xfun(xfun_.pff), yfun(yfun_.pff), cut(cut_.pbc), wfun(wfun_.pff), iter(iter_.pfi)
{
  checkIterators(name);
}
  
  
SFH2F::SFH2F (const char* name, const char* title, 
              Int_t nbinsx, Axis_t xlow, Axis_t xup,
              Int_t nbinsy, const Double_t* ybins, 
              const ROListPoR& hhl, 
              const FloatFunPoR& xfun_, 
              const FloatFunPoR& yfun_, 
              const BaseCutPoR& cut_, 
              const FloatFunPoR& wfun_, 
              const FillIteratorPoR& iter_) 
: RegH2F (name, title, nbinsx, xlow, xup, nbinsy, ybins, hhl), 
  xfun(xfun_.pff), yfun(yfun_.pff), cut(cut_.pbc), wfun(wfun_.pff), iter(iter_.pfi)
{
  checkIterators(name);
}
  
  
SFH2F::SFH2F (const char* name, const char* title, 
              Int_t nbinsx, const Double_t* xbins,
              Int_t nbinsy, const Double_t* ybins, 
              const ROListPoR& hhl, 
              const FloatFunPoR& xfun_, 
              const FloatFunPoR& yfun_, 
              const BaseCutPoR& cut_, 
              const FloatFunPoR& wfun_, 
              const FillIteratorPoR& iter_) 
: RegH2F (name, title, nbinsx, xbins, nbinsy, ybins, hhl), 
   xfun(xfun_.pff), yfun(yfun_.pff), cut(cut_.pbc), wfun(wfun_.pff), iter(iter_.pfi)
{
  checkIterators(name);
}

SFH2F::SFH2F (const char* name, const char* title, 
              Int_t nbinsx, const Float_t* xbins,
              Int_t nbinsy, const Float_t* ybins, 
              const ROListPoR& hhl, 
              const FloatFunPoR& xfun_, 
              const FloatFunPoR& yfun_, 
              const BaseCutPoR& cut_, 
              const FloatFunPoR& wfun_, 
              const FillIteratorPoR& iter_) 
: RegH2F (name, title, nbinsx, xbins, nbinsy, ybins, hhl), 
  xfun(xfun_.pff), yfun(yfun_.pff), cut(cut_.pbc), wfun(wfun_.pff), iter(iter_.pfi)
{
  checkIterators(name);
}

SFH2F::SFH2F (const char* name, const char* title, 
              const Binning& xbinning,         
              const Binning& ybinning,         
              const ROListPoR& hhl, 
              const FloatFunPoR& xfun_, 
              const FloatFunPoR& yfun_, 
              const BaseCutPoR& cut_, 
              const FloatFunPoR& wfun_, 
              const FillIteratorPoR& iter_) 
: RegH2F (name, title, xbinning, ybinning, hhl), 
  xfun(xfun_.pff), yfun(yfun_.pff), cut(cut_.pbc), wfun(wfun_.pff), iter(iter_.pfi) 
{
  checkIterators(name);
}


SFH2F::~SFH2F() 
{}

void SFH2F::Fill() {
  if (!xfun) return;
  if (!iter || iter->reset()) {
    do {
      if (!cut || (*cut)()) {
        Float_FF w = wfun ? (*wfun)() : 1.;
        this->TH2F::Fill ((*xfun)(), (*yfun)(), w);
      } 
    } while (iter && iter->next());  
  }
}

template<class Fun1, class Fun2>
void SFH2F::checkTwoIterators(const char *name, 
                              const char *fun1name, Fun1 *fun1, 
                              const char *fun2name, Fun2 *fun2) {
  if (fun1 && fun1->getIterator() && 
      fun2  && fun2->getIterator() &&
      fun1->getIterator() != fun2->getIterator()) {
    std::cerr << "SFH2F: Iterators of " << fun1name
              << " and " << fun2name
              << " are different for histogram "
              << name << "!" << std::endl;
  }
  assert (!fun1 || !fun1->getIterator() || !fun2  || !fun2->getIterator()  || fun1->getIterator() == fun2->getIterator());
}                       
template<class Fun>
void SFH2F::checkOneIterator (const char *name, 
                              const char *funname, 
                                    Fun  *fun) {
  if (fun && fun->getIterator()) {
    if (iter) {
      if (fun->getIterator() != iter) {
        std::cerr << "SFH2F: Iterator '" 
                  << fun->getIterator()->getName() 
                  << "' of " << funname 
                  << " '" << fun->getName() << "'"
                  << " and iter '" << iter->getName() 
                  << "'are different for histogram "
                  << name << "!\n";
      }
    }
    else {
#if(DEBUG>=2)      
      std::cerr << "SFH2F: Iterator '" 
                << fun->getIterator()->getName() << "' of " 
                << funname
                << " '" << fun->getName() << "'"
                << " used as iterator for histogram "
                << name << ".\n";
#endif
      iter = const_cast<FillIterator *>(fun->getIterator());
    }
  }
  assert (!fun || !fun->getIterator() || fun->getIterator() == iter);
}                       

void SFH2F::checkIterators(const char *name) {
  checkTwoIterators (name, "xfun", xfun, "yfun",    yfun);
  checkTwoIterators (name, "xfun", xfun, "cut",     cut);
  checkTwoIterators (name, "xfun", xfun, "wfun",    wfun);
  checkTwoIterators (name, "yfun", yfun, "cut",     cut);
  checkTwoIterators (name, "yfun", yfun, "wfun",    wfun);
  checkTwoIterators (name, "wfun", wfun, "cut",     cut);

  checkOneIterator (name, "xfun",    xfun);
  checkOneIterator (name, "yfun",    yfun);
  checkOneIterator (name, "wfun",    wfun);
  checkOneIterator (name, "cut",     cut);
}

---