Overlayer.h

Go to the documentation of this file.

#ifndef OVERLAYER_H
#define OVERLAYER_H

#include "TFile.h"
#include "TH1.h"
#include "TCanvas.h"
#include "TLegend.h"
#include <iostream>
#include <sstream>
#include "round_string.h"

class Overlayer {
public:
 Overlayer(std::string filename, std::string datadir, std::string simdir, Color_t color)
  : file_(new TFile(filename.c_str(),"READ")),
    dataLocation_(datadir),
    simLocation_(simdir),
    color_(color)
{ clear(); }

  Overlayer& clear();
  Overlayer& find(std::string);
  Overlayer& xlabel(std::string s) { xlabel_=s; return *this;}
  Overlayer& ylabel(std::string s) { ylabel_=s; return *this;}
  Overlayer& logy(bool state=true) { logy_=state; return *this;}
  Overlayer& withLegend(bool state=true);
  Overlayer& legendLeft(bool state=true) { left_=state; return *this;}
  void print(std::string);
private:
  std::string getStats(const TH1* const) const;

  TFile* const file_;
  const std::string dataLocation_,simLocation_;
  const Color_t color_;
  std::string histName_,xlabel_,ylabel_,title_;
  TH1* data_;
  TH1* sim_;
  bool logy_,left_;
  TLegend* legend_;
};

Overlayer& Overlayer::
clear() {
  std::cout << "clear" << std::endl;
  data_=sim_=0;
  xlabel_=ylabel_=histName_=title_="";
  logy_=false;
  legend_=0;
  left_=false;
  return *this;
}

Overlayer& Overlayer::
find(std::string name) {
  std::cout << "find " << name << "\t" << std::flush;
  histName_=name; 
  data_ = (TH1*) file_->GetDirectory(dataLocation_.c_str())->FindObjectAny(name.c_str());
  sim_ = (TH1*) file_->GetDirectory(simLocation_.c_str())->FindObjectAny(name.c_str());
  return *this;
}

Overlayer& Overlayer::withLegend(bool state) {
  std::cout << "legend: " << (state?"true\t":"false\t") << std::flush;
  if(!state) {legend_=0; return *this;}
  
  std::string data_stats = getStats(data_);
  std::string sim_stats = getStats(sim_);
  unsigned maxlength = std::max( std::max( dataLocation_.size(), simLocation_.size()), 
                 std::max( data_stats.size(), sim_stats.size()) );

  if(left_) legend_ = new TLegend(0,0.75,maxlength*0.015,1.0);
  else legend_ = new TLegend(1.0-maxlength*0.015,0.75,1.0,1.0); 

  legend_->SetFillColor(kWhite);
  legend_->AddEntry(data_,("#splitline{"+dataLocation_+"}{"+ data_stats + "}").c_str() );
  legend_->AddEntry(sim_,("#splitline{"+simLocation_+"}{"+ sim_stats + "}").c_str() );
  return *this;
}

std::string Overlayer::
getStats(const TH1* const hist) const {
  stringstream ss;
  ss << "N: " << hist->GetEntries() << ", "
     << "#mu: " << round_string()(std::make_pair(hist->GetMean(),hist->GetMeanError())) << ", "
     << "#sigma: " << round_string()(std::make_pair(hist->GetRMS(),hist->GetRMSError()));
  return ss.str().c_str();
}

void Overlayer::
print(std::string suffix) {
  std::cout << "print\t" << std::flush;

  sim_->GetXaxis()->SetLabelSize(0.05);  sim_->GetXaxis()->SetTitleSize(0.05);
  sim_->GetYaxis()->SetLabelSize(0.05);  sim_->GetYaxis()->SetTitleSize(0.05);
  sim_->SetTitle((title_+";"+xlabel_+";"+ylabel_).c_str());
  sim_->Scale(data_->Integral()/sim_->Integral());  
  sim_->SetMinimum( (logy_?0.1:0) );
  sim_->SetMaximum( (logy_?2:1.1) * std::max( sim_->GetBinContent(sim_->GetMaximumBin()) + sim_->GetBinError(sim_->GetMaximumBin()) ,
                          data_->GetBinContent(data_->GetMaximumBin()) + data_->GetBinError(data_->GetMaximumBin()) ) );

  sim_->SetFillColor(color_);
  TH1* sim_errors = (TH1*) sim_->Clone((histName_+"_clone").c_str());
  sim_->SetLineColor(kRed);
  sim_errors->SetFillColor(kRed);
  sim_errors->SetFillStyle(3244);
  data_->SetMarkerStyle(20);
  
  TCanvas c("c","",800,600);
  if(logy_) c.SetLogy();

  sim_->Draw("hist");
  sim_errors->Draw("e2same");
  data_->Draw("same");
  if(legend_) legend_->Draw();

  c.Print((histName_+suffix).c_str());  
}

#endif