HVisitors.h

Go to the documentation of this file.

#ifndef __HVISITORS_H
#define __HVISITORS_H

#include "jbltools/sfh/HVisitor.h"

//root
#include <TObject.h>
#include <TH1.h>
#include <TF1.h>
#include <TLine.h>

#include <iostream>
#include <cassert>

class TPad;
class TF1;
class TVirtualPS;


class Writer: public ConstHVisitor {
  public: 
    virtual void visit (RegO& h) const {
      if (TObject *to = dynamic_cast<TObject *>(&h)) to->Write();
    };
};


class Normalizer: public ConstHVisitor {
  public: 
    Normalizer (Double_t c_ = 1,              
                bool includeOverflow_ = true  
                )
    : c (c_), includeOverflow(includeOverflow_) {}
    virtual void visit (RegO& h     
                       ) const {
      if (TH1 *th1 = dynamic_cast<TH1 *>(&h)) {
        Double_t scale = th1->GetSumOfWeights();
        if (includeOverflow) {
          int maxbin = 1;
          assert (th1->GetDimension() == 1); // not yet implemented for 2D and 3D
          maxbin = th1->GetNbinsX()+1;
          scale += th1->GetBinContent(0)+
                   th1->GetBinContent(maxbin);
        }
        if (scale > 0.) th1->Scale (c/scale);
      }
    };
  private:
    Double_t c;                 
    bool  includeOverflow;      
};


class BinWidthNormalizer: public ConstHVisitor {
  public: 
    BinWidthNormalizer (Double_t width_ = 1  
                       )
    : width (width_) {}
    virtual void visit (RegO& h     
                       ) const {
      if (TH1 *th1 = dynamic_cast<TH1 *>(&h)) {
        for (int i = 1; i <= th1->GetNbinsX(); ++i) {
          Double_t c = width/th1->GetBinWidth(i);
          th1->SetBinContent (i, c*th1->GetBinContent (i)); 
          th1->SetBinError (i, c*th1->GetBinError (i)); 
        }
      }
    };
  private:
    Double_t width;                    
};


class AttMarkerSetter: public ConstHVisitor {
  public: 
    AttMarkerSetter (Color_t tcolor_ = -1,    
                     Size_t msize_ = -1,      
                     Style_t mstyle_ = -1     
                     )
    : tcolor (tcolor_), msize (msize_), mstyle (mstyle_)
    {}
    virtual void visit (RegO& h     
                       ) const {
      if (TAttMarker *tam = dynamic_cast<TAttMarker *>(&h)) {
        if (tcolor >= 0) tam->SetMarkerColor (tcolor);
        if (msize  >= 0) tam->SetMarkerSize  (msize);
        if (mstyle >= 0) tam->SetMarkerStyle (mstyle);
      }
    }
  private:
    Color_t tcolor;       
    Size_t  msize;        
    Style_t mstyle;       
};


class AttLineSetter: public ConstHVisitor {
  public: 
    AttLineSetter (Color_t lcolor_ = -1,   
                   Style_t lstyle_ = -1,   
                   Width_t lwidth_ = -1    
                   )
    : lcolor (lcolor_), lstyle (lstyle_), lwidth (lwidth_)
    {}
    virtual void visit (RegO& h     
                       ) const {
      if (TAttLine *tal = dynamic_cast<TAttLine *>(&h)) {
        if (lcolor >= 0) tal->SetLineColor (lcolor);
        if (lstyle >= 0) tal->SetLineStyle (lstyle);
        if (lwidth >= 0) tal->SetLineWidth (lwidth);
      }
    }
    virtual void visit (TLine& h     
                       ) const {
      if (TAttLine *tal = dynamic_cast<TAttLine *>(&h)) {
        if (lcolor >= 0) tal->SetLineColor (lcolor);
        if (lstyle >= 0) tal->SetLineStyle (lstyle);
        if (lwidth >= 0) tal->SetLineWidth (lwidth);
      }
    }
  private:
    Color_t lcolor;       
    Style_t lstyle;       
    Width_t lwidth;       
};


class AttFillSetter: public ConstHVisitor {
  public: 
    AttFillSetter (Color_t fcolor_ = -1,    
                   Style_t fstyle_ = -1     
                   )
    : fcolor (fcolor_), fstyle (fstyle_)
    {}
    virtual void visit (RegO& h     
                       ) const {
      if (TAttFill *taf = dynamic_cast<TAttFill *>(&h)) {
        if (fcolor >= 0) taf->SetFillColor (fcolor);
        if (fstyle >= 0) taf->SetFillStyle (fstyle);
      }
    }
  private:
    Color_t fcolor;       
    Style_t fstyle;       
};

class ErrorEraser: public ConstHVisitor {
  public: 
    ErrorEraser (){}
    virtual void visit (RegO& h     
                       ) const {
      if (TH1 *th1 = dynamic_cast<TH1 *>(&h)) {
        for (int i = 0; i <= th1->GetNbinsX()+1; ++i) {
          th1->SetBinError (i, 0.0);
        }
      }
    }
};

class MinMaxSetter: public ConstHVisitor {
  public: 
    MinMaxSetter (Double_t min_,     
                  Double_t max_      
                  )
    : min (min_), max (max_)
    {}
    virtual void visit (RegO& h     
                       ) const {
      if (TH1 *th1 = dynamic_cast<TH1 *>(&h)) {
        th1->SetMinimum (min);
        th1->SetMaximum (max);
      }
    }
  private:
    Double_t min;         
    Double_t max;         
};


class AxisTitleAttribSetter: public ConstHVisitor {
  public: 
     AxisTitleAttribSetter(int         axis_,           
                           const char *name_   = 0,     
                           Double_t    size_   = -1,    
                           Double_t    offset_ = -999., 
                           Color_t     lcolor_ = -1,    
                           Style_t     font_   = -1)    
    : axis   (axis_),
      name   (0), 
      size   (size_), 
      offset (offset_), 
      lcolor (lcolor_),
      font   (font_)
    {
      if (name_) {
        name = new char [strlen (name_)+1];
        strcpy (name, name_); 
      }
    }
    
    virtual void visit (RegO& h     
                       ) const {
      if (TH1 *th1 = dynamic_cast<TH1 *>(&h)) {
        TAxis *ax = 0;
        switch (axis) {
          case 1: ax = th1->GetXaxis(); break;
          case 2: ax = th1->GetYaxis(); break;
          case 3: ax = th1->GetZaxis(); break;
        }
        if (ax == 0) return;
      
        if (name)           ax->SetTitle       (name);
        if (size > 0)       ax->SetTitleSize   (size);
        if (offset !=-999.) ax->SetTitleOffset (offset);
        if (lcolor > -1)    ax->SetTitleColor  (lcolor);
        if (font > -1)      ax->SetTitleFont   (font);
      }
    }
    
    ~AxisTitleAttribSetter() {
      delete[] name;
      name = 0;
    }
  private:
    int      axis;       
    char    *name;       
    Double_t size;       
    Double_t offset;     
    Color_t  lcolor;     
    Style_t  font;       
    
    AxisTitleAttribSetter (const AxisTitleAttribSetter& source);
    AxisTitleAttribSetter& operator= (const AxisTitleAttribSetter& source);
};


class AxisLabelAttribSetter: public ConstHVisitor {
  public: 
     AxisLabelAttribSetter(int         axis_,        
                           Double_t    size_,        
                           Color_t     lcolor_ = -1, 
                           Style_t     font_   = -1, 
                           Int_t       ndiv_   = -1) 
    : axis   (axis_),
      size   (size_), 
      lcolor (lcolor_),
      font   (font_),
      ndiv   (ndiv_)
    {}
    
    virtual void visit (RegO& h     
                       ) const {
      if (TH1 *th1 = dynamic_cast<TH1 *>(&h)) {
        TAxis *ax = 0;
        switch (axis) {
          case 1: ax = th1->GetXaxis(); break;
          case 2: ax = th1->GetYaxis(); break;
          case 3: ax = th1->GetZaxis(); break;
        }
        if (ax == 0) return;
      
        if (size > 0)    ax->SetLabelSize  (size);
        if (lcolor > -1) ax->SetLabelColor (lcolor);
        if (font > -1)   ax->SetLabelFont  (font);
        if (ndiv > -1)   ax->SetNdivisions (ndiv);
      }
    }
    
    ~AxisLabelAttribSetter() {}
  private:
    int      axis;       
    Double_t size;       
    Color_t  lcolor;     
    Style_t  font;       
    Int_t    ndiv;       
    
    AxisLabelAttribSetter (const AxisLabelAttribSetter& source);
    AxisLabelAttribSetter& operator= (const AxisLabelAttribSetter& source);
};
static AttLineSetter blackline (1);
static AttLineSetter redline (2);
static AttLineSetter greenline (3);
static AttLineSetter blueline (4);
static AttLineSetter yellowline (5);
static AttLineSetter magentaline (6);
static AttLineSetter cyanline (7);

static AttFillSetter blackfill (1);
static AttFillSetter redfill (2);
static AttFillSetter greenfill (3);
static AttFillSetter bluefill (4);
static AttFillSetter yellowfill (5);
static AttFillSetter magentafill (6);
static AttFillSetter cyanfill (7);

static AttFillSetter hollowfill (-1, 0);
static AttFillSetter solidfill (-1, 1001);
  
static AttMarkerSetter blackmarker (1);
static AttMarkerSetter redmarker (2);
static AttMarkerSetter greenmarker (3);
static AttMarkerSetter bluemarker (4);
static AttMarkerSetter yellowmarker (5);
static AttMarkerSetter magentamarker (6);
static AttMarkerSetter cyanmarker (7);

class AxisSetter: public ConstHVisitor {
  public: 
    AxisSetter (Int_t n_, const Float_t *x_)
    : n (n_), x (x_)
    {}
    virtual void visit (RegO& h     
                       ) const {
      if (TH1 *th1 = dynamic_cast<TH1 *>(&h)) {
        TAxis *axis = th1->GetXaxis();
        if (axis) axis->Set (n, x);
      }
    }
  private:
    Int_t n;
    const Float_t *x;
};


#endif  /* #ifndef __HVISITORS_H */

---