ROList.C

Go to the documentation of this file.

#include "jbltools/sfh/ROList.h"
#include "jbltools/sfh/HVisitors.h"

#include <TVirtualPS.h>
#include <TPad.h>
#include <TNamed.h>

#include <iostream>
#include <cassert>
#include <string>

static const char *ident="@(#)$Id: ROList.C,v 1.15 2006/05/15 13:28:19 zimmerto Exp $";

ROList::ROList ()
{}

ROList::ROList (const ROListPoR& mother)
{
  // std::cout << "ROList::ROList (const ROListPoR& mother)\n";
#if(DEBUG>=3)
  if (mother.prol) std::cerr << "... registering with mother\n";
#endif
  if (mother.prol) mother.prol->registerObject (this);
}

int ROList::registerObject (RegO* h) {
  theMap [getHighestEntry()] = h;
#if(DEBUG>=3)
  if (TNamed *tn = dynamic_cast<TNamed *>(h)) {
    std::cout << "ROList::registerObject: Have registered object "
              << tn->GetName() << std::endl;
    
  }
#endif
  return getEntries();
}

int ROList::registerObject (IndexType n, RegO* h) {
  theMap [n] = h;
#if(DEBUG>=3)
  if (TNamed *tn = dynamic_cast<TNamed *>(h)) {
    std::cout << "ROList::registerObject: Have registered object "
              << tn->GetName() << std::endl;
    
  }
#endif
  return getEntries();
}

ROList::~ROList () {
  for (iterator iter = begin(); iter != end(); ++iter) {
    delete iter->second;
    iter->second = 0;
  } 
}

void ROList::Write () {
  visit (Writer());
}

ROList& ROList::visit (HVisitor& v) {
  for (iterator iter = begin(); iter != end(); ++iter) {
    if (iter->second) {
      if (ROList *rol = dynamic_cast<ROList *>(iter->second)) {
        rol->visit (v);
      }
      else {
        if (iter->second) v.visit(*(iter->second));
      }
    }
  }
  return *this;
}

ROList&  ROList::visit (const ConstHVisitor& v) {
  for (iterator iter = begin(); iter != end(); ++iter) {
    if (iter->second) {
      if (ROList *rol = dynamic_cast<ROList *>(iter->second)) {
        rol->visit (v);
      }
      else {
        if (iter->second) v.visit(*(iter->second));
      }
    }
  }
  return *this;
}

int ROList::Draw (TPad *pad, TVirtualPS *ps,
                   Option_t *option,
                   bool across,
                   Int_t nx, Int_t ny,
                   Float_t xmargin, Float_t ymargin, 
                   Int_t color,
                   Int_t log, bool recursive, int izone) {
  if (!pad) {
    std::cerr << "HasHistogramList::Draw: No pad, no Draw()!\n";
    return 0;
  }      
  assert (pad);  
  
  // std::cout << "ROList::Draw: drawing " << getEntries() << " histos\n";                 
                             
  // loop over all histograms
  IndexType n = nx*ny;
  IndexType i = izone;
  for (iterator iter = begin(); iter != end(); ++iter, ++i) {
    // std::cout << "ROList::Draw: drawing #" << i << "\n";                 
    if (i % n == 0) {
      if (i!=0 && ps) ps->NewPage();
      i = 0;
 
      pad->Clear();
      pad->Divide (nx, ny, xmargin, ymargin, color);
    }
    if (across) {
      pad->cd (i+1);
    }
    else {
      int ix = i / ny;
      int iy = i % ny;
      pad->cd (iy*nx + ix + 1);
    }
    if (log & LOGY) gPad->SetLogy();
    if (log & LOGX) gPad->SetLogx();
    
    if (ROList *rol = dynamic_cast<ROList *>(iter->second)) {
      i = rol->Draw (pad, ps, option, across, nx, ny, xmargin,  ymargin, color, log, i);
    } else {
      if (TH1 *th1=dynamic_cast<TH1 *>(iter->second))th1->Draw(option);
      if (((i+1) % n == 0) || (i+1) == getEntries()) {
        pad->Update();
        // std::cout << "ROList::Draw: Calling pad->Update()\n"; 
      }                
    }
  }
  // std::cout << "ROList::Draw: finished\n";  
  return i;               
} 
  
int ROList::Draw (TPad *pad, TVirtualPS *ps,
                      Option_t *option,
                      bool across,
                      Int_t nx, Int_t ny,
                      Int_t log, bool recursive, int izone) {
  return Draw (pad, ps, option, across, nx, ny, 0.01, 0.01, 0, log, recursive, izone);
}

void ROList::DrawCutFlow (TPad *pad, TVirtualPS *ps,
                          Option_t *option,
                          Option_t *sameoption,
                          bool across,
                          Int_t nx, Int_t ny,
                          Float_t xmargin, Float_t ymargin, 
                          Int_t color,
                          Int_t log, bool recursive, bool backward) {
  if (!pad) {
    std::cerr << "HasHistogramList::DrawCutFlow: No pad, no Draw()!\n";
    return;
  }      
  assert (pad);  
  
  if (!option) option = "";
  if (!sameoption) sameoption = " same";
  
  std::cout << "ROList::Draw: drawing " << getEntries() << " histos\n";                 
  std::cout << "nx/ny = " << nx << " " << ny << "\n";                 
  std::cout << "log = " << log << "\n";                 
                             
  // loop over all histograms
  IndexType n = nx*ny;
  IndexType i = 0;
  iterator last = 0;
  for (iterator iter = begin(); iter != end(); ++iter, ++i) {
    iterator next = iter;
    ++next;
    // std::cout << "ROList::DrawCutFlow: drawing #" << i << "\n";                 
    if (i % n == 0) {
      i = 0;
      if (ps) ps->NewPage();
 
      pad->Clear();
      pad->Divide (nx, ny, xmargin, ymargin, color);
    }
    if (across) {
      pad->cd (i+1);
    }
    else {
      int ix = i / ny;
      int iy = i % ny;
      pad->cd (iy*nx + ix + 1);
    }
    if (log & LOGY) gPad->SetLogy();
    if (log & LOGX) gPad->SetLogx();
    
    if (ROList *rol = dynamic_cast<ROList *>(iter->second)) {
      if (recursive) {
        rol->DrawCutFlow (pad, ps, option, sameoption, across, nx, ny, xmargin, ymargin, color, log, recursive, backward);
        i = 0;
      }
    } else {
      if (TH1 *th1     = dynamic_cast<TH1 *>(iter->second)) {
        TH1 *th1other = 0;
        if (backward) {
          th1other = (iter != begin()) ? dynamic_cast<TH1 *>(last->second) : 0;
        } else {
          th1other = (next != end()) ? dynamic_cast<TH1 *>(next->second) : 0;
        }
        float maxi = th1->GetMaximum();
        if (th1other && th1other->GetMaximum() > maxi) {
          maxi = th1other->GetMaximum();
          th1->SetMaximum(1.1*maxi);
          th1->Draw (option);
          th1->SetMaximum(-1111);   // Default value = "no maximum"
        }
        else th1->Draw (option);
        if (th1other) {
          Color_t oldcolor = th1other->GetLineColor();
          th1other->SetLineColor(2);
          th1other->DrawCopy (sameoption);
          th1other->SetLineColor(oldcolor);
        }
      }
      if (((i+1) % n == 0) || (i+1) == getEntries()) {
        pad->Update();
        // std::cout << "ROList::Draw: Calling pad->Update()\n"; 
      }                
    }
    last = iter;
  }
  // std::cout << "ROList::Draw: finished\n";                 
} 
  
void ROList::DrawCutFlow (TPad *pad, TVirtualPS *ps,
                      Option_t *option,
                      Option_t *sameoption,
                      bool across,
                      Int_t nx, Int_t ny,
                      Int_t log, bool recursive, bool backward) {
  DrawCutFlow (pad, ps, option, sameoption, across, nx, ny, 0.01, 0.01, 0, log, recursive, backward);
}

// DrawFunc by Ronnie Weber
int ROList::DrawFunc (TPad *pad, TVirtualPS *ps,
                      Option_t *option,
                      const char *fname,
                      bool across,
                      Int_t nx, Int_t ny,
                      Float_t xmargin, Float_t ymargin,
                      Int_t color,
                      Int_t log, bool recursive, int izone) {
  if (!pad) {
    std::cerr << "HasHistogramList::Draw: No pad, no Draw()!\n";
    return 0;
  }      
  assert (pad);  
  
  // std::cout << "ROList::Draw: drawing " << getEntries() << " histos\n";                 
                             
  // loop over all histograms
  IndexType n = nx*ny;
  IndexType i = izone;
  for (iterator iter = begin(); iter != end(); ++iter, ++i) {
    // std::cout << "ROList::Draw: drawing #" << i << "\n";                 
    if (i % n == 0) {
      if (i!=0 && ps) ps->NewPage();
      i = 0;
 
      pad->Clear();
      pad->Divide (nx, ny, xmargin, ymargin, color);
    }
    if (across) {
      pad->cd (i+1);
    }
    else {
      int ix = i / ny;
      int iy = i % ny;
      pad->cd (iy*nx + ix + 1);
    }
    if (log & LOGY) gPad->SetLogy();
    if (log & LOGX) gPad->SetLogx();
    
    if (ROList *rol = dynamic_cast<ROList *>(iter->second)) {
      i = rol->DrawFunc (pad, ps, option, fname, across, nx, ny, xmargin,  ymargin, color, log, i);
    } else {
      if (TH1 *th1=dynamic_cast<TH1 *>(iter->second)){
        if(TF1 *f = th1->GetFunction(fname)) {
          std::cout << "ROList::DrawFunc: temp. enabling function " << fname
                    << " for drawing of " << th1->GetName() << "\n";
          f->SetBit(BIT(9), 0);
        } else {
          std::cout << "ROList::DrawFunc: ERROR - could not find function " << fname
                    << " for drawing of " << th1->GetName() << "\n";
        }
        th1->DrawCopy(option);
        if(TF1 *f = th1->GetFunction(fname)) {
          f->SetBit(BIT(9), 1);
        }
      }
      if (((i+1) % n == 0) || (i+1) == getEntries()) {
        pad->Update();
        // std::cout << "ROList::Draw: Calling pad->Update()\n"; 
      }                
    }
  }
  // std::cout << "ROList::Draw: finished\n";  
  return i;               
} 
  
int ROList::DrawFunc (TPad *pad, TVirtualPS *ps,
                      Option_t *option,
                      const char *fname,
                      bool across,
                      Int_t nx, Int_t ny,
                      Int_t log, bool recursive, int izone) {
  return DrawFunc (pad, ps, option, fname, across, nx, ny, 0.01, 0.01, 0, log, recursive, izone);
}

---