Book.h

Go to the documentation of this file.

#ifndef BOOK_FOR_ROOT_HISTOGRAMS
#define BOOK_FOR_ROOT_HISTOGRAMS
 
#include <map>
#include <string>
#include "poly.h"
#include "TDirectory.h"
#include "TH1.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TProfile.h"
#include "TH3D.h"
#include <boost/regex.hpp>
#include <boost/iterator/filter_iterator.hpp>
 
class Book {
  typedef const double double_t;
  typedef const unsigned long uint_t;
  typedef const std::string string_t;
  typedef std::map<std::string, TH1*> book_t;
 
  book_t book_;
  std::string title_;
  TDirectory* directory;
 
  struct match_name {
    match_name(string_t re) : expression(re) {}
    bool operator()(const book_t::const_iterator::value_type& p) { return regex_match(p.first, expression); }
 
  private:
    boost::regex expression;
  };
 
public:
  Book() : title_(""), directory(nullptr) {}
  Book(string_t t) : title_(t), directory(new TDirectory(t.c_str(), t.c_str())) {}
 
  string_t& title() const { return title_; }
  bool empty() const { return book_.empty(); }
  long size() const { return book_.size(); }
 
  TH1* book(string_t name, TH1* const hist) {
    book_[name] = hist;
    hist->SetDirectory(directory);
    if (!hist->GetSumw2N())
      hist->Sumw2();
    return hist;
  }
  TH1*& operator[](string_t name) { return book_[name]; }
  const TH1* operator[](string_t name) const {
    book_t::const_iterator it = book_.find(name);
    return it == book_.end() ? nullptr : it->second;
  }
 
  typedef boost::filter_iterator<match_name, book_t::iterator> iterator;
  typedef boost::filter_iterator<match_name, book_t::const_iterator> const_iterator;
  iterator begin(string_t re = ".*") {
    book_t::iterator b(book_.begin()), e(book_.end());
    return boost::make_filter_iterator(match_name(re), b, e);
  }
  const_iterator begin(string_t re = ".*") const {
    book_t::const_iterator b(book_.begin()), e(book_.end());
    return boost::make_filter_iterator(match_name(re), b, e);
  }
  iterator end(string_t re = ".*") {
    book_t::iterator e(book_.end());
    return boost::make_filter_iterator(match_name(re), e, e);
  }
  const_iterator end(string_t re = ".*") const {
    book_t::const_iterator e(book_.end());
    return boost::make_filter_iterator(match_name(re), e, e);
  }
  iterator find(string_t name, string_t re = ".*") {
    return boost::make_filter_iterator(match_name(re), book_.find(name), book_.end());
  }
  const_iterator find(string_t name, string_t re = ".*") const {
    return boost::make_filter_iterator(match_name(re), book_.find(name), book_.end());
  }
  std::pair<iterator, iterator> filter_range(string_t re = ".*") { return std::make_pair(begin(re), end(re)); }
  std::pair<const_iterator, const_iterator> filter_range(string_t re = ".*") const {
    return std::make_pair(begin(re), end(re));
  }
 
  void erase(string_t name) {
    book_t::iterator it = book_.find(name);
    if (it != book_.end()) {
      delete it->second;
      book_.erase(it);
    }
  }
  void erase(iterator it) {
    delete it->second;
    book_.erase(it.base());
  }
 
  void fill(double_t X, const char* name, uint_t NbinsX, double_t Xlow, double_t Xup, double_t W = 1) {
    fill(X, std::string(name), NbinsX, Xlow, Xup, W);
  }
  void fill(double_t X, const poly<std::string>& names, uint_t NbinsX, double_t Xlow, double_t Xup, double_t W = 1) {
    for (auto const& name : names) {
      book_t::const_iterator current = book_.find(name);
      if (current == book_.end())
        book(name, new TH1D(name.c_str(), "", NbinsX, Xlow, Xup))->Fill(X, W);
      else
        current->second->Fill(X, W);
    }
  }
  void fill(double_t X, double_t Y, const char* name, uint_t NbinsX, double_t Xlow, double_t Xup, double_t W = 1) {
    fill(X, Y, std::string(name), NbinsX, Xlow, Xup, W);
  }
  void fill(double_t X,
            double_t Y,
            const poly<std::string>& names,
            uint_t NbinsX,
            double_t Xlow,
            double_t Xup,
            double_t W = 1) {
    for (auto const& name : names) {
      book_t::const_iterator current = book_.find(name);
      if (current == book_.end())
        static_cast<TProfile*>(book(name, new TProfile(name.c_str(), "", NbinsX, Xlow, Xup)))->Fill(X, Y, W);
      else
        static_cast<TProfile*>(current->second)->Fill(X, Y, W);
    }
  }
  void fill(double_t X,
            double_t Y,
            const char* name,
            uint_t NbinsX,
            double_t Xlow,
            double_t Xup,
            uint_t NbinsY,
            double_t Ylow,
            double_t Yup,
            double_t W = 1) {
    fill(X, Y, std::string(name), NbinsX, Xlow, Xup, NbinsY, Ylow, Yup, W);
  }
  void fill(double_t X,
            double_t Y,
            const poly<std::string>& names,
            uint_t NbinsX,
            double_t Xlow,
            double_t Xup,
            uint_t NbinsY,
            double_t Ylow,
            double_t Yup,
            double_t W = 1) {
    for (auto const& name : names) {
      book_t::const_iterator current = book_.find(name);
      if (current == book_.end())
        static_cast<TH2*>(book(name, new TH2D(name.c_str(), "", NbinsX, Xlow, Xup, NbinsY, Ylow, Yup)))->Fill(X, Y, W);
      else
        static_cast<TH2*>(current->second)->Fill(X, Y, W);
    }
  }
  void fill(double_t X,
            double_t Y,
            double_t Z,
            const char* name,
            uint_t NbinsX,
            double_t Xlow,
            double_t Xup,
            uint_t NbinsY,
            double_t Ylow,
            double_t Yup,
            uint_t NbinsZ,
            double_t Zlow,
            double_t Zup,
            double_t W = 1) {
    fill(X, Y, Z, std::string(name), NbinsX, Xlow, Xup, NbinsY, Ylow, Yup, NbinsZ, Zlow, Zup);
  }
  void fill(double_t X,
            double_t Y,
            double_t Z,
            const poly<std::string>& names,
            uint_t NbinsX,
            double_t Xlow,
            double_t Xup,
            uint_t NbinsY,
            double_t Ylow,
            double_t Yup,
            uint_t NbinsZ,
            double_t Zlow,
            double_t Zup,
            double_t W = 1) {
    for (auto const& name : names) {
      book_t::const_iterator current = book_.find(name);
      if (current == book_.end())
        static_cast<TH3*>(
            book(name, new TH3D(name.c_str(), "", NbinsX, Xlow, Xup, NbinsY, Ylow, Yup, NbinsZ, Zlow, Zup)))
            ->Fill(X, Y, Z, W);
      else
        static_cast<TH3*>(current->second)->Fill(X, Y, Z, W);
    }
  }
};
 
#endif