/Users/jmonk/Physics/ForIA/ForIA/D3PD/RootHistogrammer.hh

Go to the documentation of this file.

#ifndef FORIA_ROOTHISTOGRAMMER_HH
#define FORIA_ROOTHISTOGRAMMER_HH

#include "ForIA/IHistogrammer.hh"

#include "boost/lexical_cast.hpp"
#include "boost/unordered_map.hpp"

#include <map>
#include <string>
#include <set>

class TH1;
class TH1D;
class TProfile;
class TH2D;
class TH3D;
class TDirectory;

namespace ForIA {
 
  using std::map;
  using std::string;
  using std::pair;
  using std::set;
  
  class BinError: public std::runtime_error{

  public:
    BinError(double min, double max): std::runtime_error
    ("bin minimum " + boost::lexical_cast<string>(min) + 
     " is above maximum " + boost::lexical_cast<string>(max)){
      
    }
    
  };
  
  class Directory {
    
  public:
    
    Directory(const string &name);
    
    void addHistogram(const string &name, TH1D *histo, bool divideBinWidths);
    void addProfile(const string &name, TProfile *prof);
    void addHistogram(const string &name, TH2D *histo, bool divideBinWidths);
    void addHistogram(const string &name, TH3D *histo, bool divideBinWidths);
    
    TH1D *histogram(const string &name);
    TProfile *profile(const string &name);
    TH2D *histogram2D(const string &name);    
    TH3D *histogram3D(const string &name);
    
    pair<string, Directory*> addDirectory(string path);
    
    const string &name()const;
    
    bool write(TDirectory *dir) const;
    
    typedef boost::unordered_map<string, TH1D*>::iterator iterator;
    typedef boost::unordered_map<string, TH1D*>::const_iterator const_iterator;
    
    iterator begin(){return m_histos.begin();};
    iterator end(){return m_histos.end();};
    
    typedef boost::unordered_map<string, TH2D*>::iterator iterator2D;
    typedef boost::unordered_map<string, TH2D*>::const_iterator const_iterator2D;
    
    iterator2D begin2D(){return m_2dHistos.begin();}
    iterator2D end2D(){return m_2dHistos.end();}

    typedef boost::unordered_map<string, TH3D*>::iterator iterator3D;
    typedef boost::unordered_map<string, TH3D*>::const_iterator const_iterator3D;
    
    iterator3D begin3D(){return m_3dHistos.begin();}
    iterator3D end3D(){return m_3dHistos.end();}
    
    bool doDivideBinWidths(const TH1 *histo)const;
        
  private:
    
    
    string &stripSlash(string &path);
    
    string m_name;
    
    boost::unordered_map<string, TH1D*> m_histos;
    boost::unordered_map<string, TProfile*> m_profile1Ds;
    boost::unordered_map<string, TH2D*> m_2dHistos;
    boost::unordered_map<string, TH3D*> m_3dHistos;
    map<string, Directory> m_dirs;
    set<const TH1*> m_noDivideBinWidths;
    
  };
  
  class RootHistogrammer : public IHistogrammer {
    
  public:
    
    RootHistogrammer(const string &rootFileName="ForIA");
    
    const string & outputName()const;
    
    void bookHistogram1D(const string &path, const string &name, const string &title, int nBins, double xMin, double xMax, bool divideBinWidths);
    void bookHistogram1D(const string &path, const string &name, const string &title, const vector<double> &bins, bool divideBinWidths);
    
    void bookProfile1D(const string &path, const string &name, const string &title, int nBins, double xMin, double xMax);
    
    void bookHistogram2D(const string &path, const string &name, const string &title, 
                         int nBinsX, double xMin, double xMax,
                         int nBinsY, double yMin, double yMax,
                         bool divideBinWidths);
    
    void bookHistogram2D(const string &path, const string &name, const string &title,
                         const vector<double> &xbins, const vector<double> &ybins,
                         bool divideBinWidths);
    
    void bookHistogram3D(const string &path, const string &name, const string &title, 
                         int nBinsX, double xMin, double xMax,
                         int nBinsY, double yMin, double yMax,
                         int nBinsZ, double zMin, double zMax,
                         bool divideBinWidths);
    
    void fillHistogram1D(const string &path, const string &name, double value, double weight);
    
    void fillProfile1D(const string &path, const string &name,  double xVal, double yVal, double weight);
    
    void fillHistogram2D(const string &path, const string &name, double xVal, double yVal, double weight);

    void fillHistogram3D(const string &path, const string &name, double xVal, double yVal, double zVal, double weight);
    
    void finalise();
    
    void normaliseHistogram1D(const string &path, const string &name, double norm=1.);
    
    void scaleHistogram1D(const string &path, const string  &name, double scale=1.);
    
    void normaliseHistogram2D(const string &path, const string &name, double norm=1.);
    
    void scaleHistogram2D(const string &path, const string  &name, double scale=1.);
    
    void showHistograms(std::ostream &out) const;
    
  private:
    
    template <class T> void addHisto(const string &path, const string &name, T *histo, bool divideBinWidths){
     
      boost::unordered_map<string, Directory*>::iterator dir = m_directories.find(path);
      
      if(dir == m_directories.end()){
        
        pair<string, Directory*> newDir = m_rootDir.addDirectory(path);
        
        newDir.second->addHistogram(name, histo, divideBinWidths);
        
        m_directories.insert(newDir);
      }else{
        dir->second->addHistogram(name, histo, divideBinWidths);
      }
            
      return;
    }
    
    template<class T> void addProfile(const string &path, const string &name, T *prof){
     
      boost::unordered_map<string, Directory*>::iterator dir = m_directories.find(path);
      
      if(dir == m_directories.end()){
       
        pair<string, Directory*> newDir = m_rootDir.addDirectory(path);
        
        newDir.second->addProfile(name, prof);
        
        m_directories.insert(newDir);
      }else{
        dir->second->addProfile(name, prof);
      }
      
      return;
    }
    
    string m_rootFileName;
    boost::unordered_map<string, Directory*> m_directories;
    Directory m_rootDir;
    
  };
}
#endif