void ratioPlots( TCanvas* c1, TH1* h_r, TH1* h_i,
string xTitle, string yTitle, string savePath,
double fitMin=-100000, double fitMax=100000, bool doubleColFit=0 ){
double xMaximum = h_r->GetXaxis()->GetBinUpEdge(h_r->GetXaxis()->GetLast());
double xMinimum = h_r->GetXaxis()->GetBinLowEdge(h_r->GetXaxis()->GetFirst());
double yMaximum;
double yMinimum;
h_i->Sumw2();
h_r->Sumw2();
TLine* line1 = new TLine(xMinimum,1,xMaximum,1);
line1->SetLineColor(1);
line1->SetLineWidth(2);
line1->SetLineStyle(7);
TF1* fpol1 = new TF1("fpol1", "pol1", fitMin, fitMax);
fpol1->SetLineColor(2);
fpol1->SetLineWidth(3);
fpol1->SetLineStyle(7);
TH1* hRatio = (TH1*)h_r->Clone("clone_record");
hRatio->Divide(h_i);
yMaximum = hRatio->GetMaximum();
yMinimum = hRatio->GetMinimum(0);
hRatio->GetYaxis()->SetRangeUser(yMinimum/2.5,yMaximum+yMaximum/5);
hRatio->SetXTitle(xTitle.c_str());
hRatio->SetYTitle(yTitle.c_str());
hRatio->SetLineColor(9);
hRatio->SetLineWidth(2);
hRatio->SetMarkerStyle(8);
hRatio->Draw("e");
hRatio->Fit("fpol1", "L");
line1->Draw("SAME");
if(doubleColFit){
double p0=fpol1->GetParameter(0);
double p1=fpol1->GetParameter(1);
double endPoint=double(fitMax*p1)+p0;
double p1new=(endPoint-1)/(fitMax-fitMin);
char fun[100], text[100];
sprintf(fun,"x*(%f)+1",p1new);
sprintf(text,"Tangent: %f",p1new);
TF1* fnew = new TF1("fnew", fun, fitMin, fitMax);
fnew->SetLineColor(2);
fnew->SetLineWidth(3);
fnew->Draw("SAME");
TText* Title = new TText( fitMax/12, yMinimum, text);
Title->SetTextColor(2);
Title->SetTextSize(0.035);
Title->Draw("SAME");
}
c1->SaveAs(savePath.c_str());
c1->cd();
}
void MakeNsignalEff_pt15(){
setTDRStyle();
gStyle->SetPalette(1);
TH1* medium = makehist("PreSelection_medium_pt15");
TH1* tight = makehist("PreSelection_tight_pt15");
TH1* tight_dxy10= makehist("PreSelection_iso_10_10_pt15");
TH1* tight_anal = makehist("PreSelection_pt15");
TLegend* legendH = new TLegend(0.6, 0.7, 0.9, 0.9);
legendH->SetFillColor(kWhite);
legendH->SetTextSize(0.03);
medium->GetXaxis()->SetTitle("m_{N} GeV");
medium->GetYaxis()->SetTitle("ID efficiency");
medium->SetMarkerColor(kRed);
tight->SetMarkerColor(kRed);
tight_dxy10->SetMarkerColor(kRed);
tight_anal->SetMarkerColor(kRed);
medium->SetMarkerStyle(20.);
tight->SetMarkerStyle(21.);
tight_dxy10->SetMarkerStyle(22.);
tight_anal->SetMarkerStyle(23.);
legendH->AddEntry(medium, "medium ID", "p");
legendH->AddEntry(tight, "tight ID", "p");
legendH->AddEntry(tight_dxy10, "tight+ dxy ", "p");
legendH->AddEntry(tight_anal, "tight+ dxy+ iso ", "p");
medium->Draw("p");
tight->Draw("psame");
tight_dxy10->Draw("psame");
tight_anal->Draw("psame");
legendH->Draw();
TGraphAsymmErrors * g = new TGraphAsymmErrors(heff);
g->SetLineWidth(2.0);
g->SetMarkerSize(2.);
// g->Draw( "9pXsame" );
CMS_lumi( c1, 2, 11 );
c1->Update();
c1->RedrawAxis();
c1->SaveAs(("/home/jalmond/WebPlots/PreApproval/SignalPlots/SignalEff_presel_med_tight_pt15.pdf" ));
}
void DrawEmpirical(const char* filename="Empirical.root",
Bool_t fmd=true)
{
gStyle->SetOptTitle(0);
TFile* file = TFile::Open(filename, "READ");
if (!file) return;
Double_t yr = 0.3;
TCanvas* c = new TCanvas("c","c", 1000,1000);
TPad* p1 = new TPad("p1","p1",0,0,1,yr);
TPad* p2 = new TPad("p2","p2",0,yr,1,1);
c->cd(); p1->Draw();
c->cd(); p2->Draw();
gDirectory->cd("Forward");
THStack* r = DrawOne(p1, yr, false, gDirectory, "ratios");
THStack* e = DrawOne(p2, yr, true, gDirectory, "empirical");
r->SetMinimum(0.945);
r->SetMaximum(1.055);
r->GetXaxis()->SetTitle("#it{#eta}");
r->GetYaxis()->SetTitle("Ratio to mean");
e->SetMinimum(0.005);
e->GetYaxis()->SetTitle("#it{E_{c}}(#it{#eta})");
TIter nextE(e->GetHists());
TIter nextR(r->GetHists());
TH1* hist = 0;
Color_t cols[] = { kRed+2, kGreen+2, kBlue+2, kMagenta+2, 0 };
Color_t *ptr = cols;
Style_t stys[] = { 20, 21, 22, 23 };
Style_t* sty = stys;
while (*ptr) {
hist = static_cast<TH1*>(nextE());
hist->SetMarkerColor(*ptr);
hist->SetMarkerSize(2);
hist->SetMarkerStyle(*sty);
hist = static_cast<TH1*>(nextR());
hist->SetMarkerColor(*ptr);
hist->SetMarkerSize(2);
hist->SetMarkerStyle(*sty);
ptr++;
sty++;
}
TLegend* l = p2->BuildLegend(0.35, .2, .65, .8);
l->SetFillColor(0);
l->SetFillStyle(0);
l->SetBorderSize(0);
c->Modified();
c->Update();
c->cd();
c->Print("empirical.png");
}
void plotter::draw_output_stat(TH1* output_, TH1* stat_, TH1D* truth_, bool norm, TString file_name){
// std::vector<double> sys = get_sys_errors();
// TH1* output_sys = add_error_bar(output, sys);
TH1* output = (TH1*) output_->Clone("output");
TH1* stat = (TH1*) stat_->Clone("stat");
TH1D* truth = (TH1D*) truth_->Clone("truth");
TCanvas *c = new TCanvas("c","",600,600);
double ymax;
gPad->SetLeftMargin(0.15);
if(truth->GetMaximum() > output->GetMaximum()) ymax = 1.5 * truth->GetMaximum();
else ymax = 1.5 * output->GetMaximum();
TGaxis::SetMaxDigits(3);
output->SetTitle(" ");
output->GetYaxis()->SetRangeUser(0., ymax);
output->GetXaxis()->SetTitle("Leading-jet mass [GeV]");
if(norm) output->GetYaxis()->SetTitle("#frac{1}{#sigma} #frac{d#sigma}{dm_{jet}} [#frac{1}{GeV}]");
else output->GetYaxis()->SetTitle("events");
output->GetYaxis()->SetTitleOffset(1.1);
output->GetXaxis()->SetTitleOffset(0.9);
output->GetYaxis()->SetTitleSize(0.05);
output->GetXaxis()->SetTitleSize(0.05);
output->GetYaxis()->SetNdivisions(505);
output->SetLineColor(kBlack);
output->SetMarkerColor(kBlack);
output->SetMarkerStyle(8);
output->SetMarkerSize(1);
output->Draw("E1");
stat->SetLineColor(kBlack);
stat->SetMarkerColor(kBlack);
stat->SetMarkerStyle(8);
stat->SetMarkerSize(1);
gStyle->SetEndErrorSize(5);
truth->SetLineWidth(3);
truth->SetLineColor(kRed);
truth->SetLineStyle(2);
truth->Draw("HIST SAME");
stat->Draw("E1 SAME");
output->Draw("E1 SAME");
TLegend *l=new TLegend(0.5,0.65,0.85,0.85);
l->SetBorderSize(0);
l->SetFillStyle(0);
l->AddEntry(output,"data unfolded","pl");
l->AddEntry(truth,"MC particle level","pl");
l->SetTextSize(0.04);
l->Draw();
c->SaveAs(directory + file_name + ".pdf");
delete c;
}
// Make 1D comparison plots
void makeplots1D( TH1& eff, TH1& base, TH1& destination, TString name) {
gROOT->ProcessLine(".L ~/tdrstyle.C");
setTDRStyle();
TGraphAsymmErrors *g1 = new TGraphAsymmErrors();
g1->BayesDivide(&destination, &base, "");
g1->GetYaxis()->SetRangeUser(0.5, 1.05);
eff.SetLineColor(2);
eff.SetMarkerStyle(22);
eff.SetMarkerSize(1.4);
eff.SetMarkerColor(2);
//
g1->GetYaxis()->SetTitle("Efficiency");
if(name.Contains("_Eta"))
g1->GetXaxis()->SetTitle("#eta");
if(name.Contains("_Phi"))
g1->GetXaxis()->SetTitle("#phi");
if(name.Contains("_Pt"))
g1->GetXaxis()->SetTitle("p_{T} (GeV/c)");
TCanvas canvas("canvas",name,600,600);
g1->Draw("APE");
eff.Draw("same");
canvas.SaveAs(name + TString(".eps"));
canvas.SaveAs(name + TString(".gif"));
canvas.Close();
delete g1;
}
/**
SetColor/Style Histo
*/
void SetColorAndStyleHisto(TH1 & histo , EColor color){
histo.SetFillColor (color) ;
histo.SetLineColor (color) ;
histo.SetMarkerColor (color) ;
histo.SetMarkerSize (1) ;
histo.SetMarkerStyle (20) ;
}
void plotter::draw_output_pseudo(TH1* output_, TH1D* pseudotruth_, TH1D* mctruth_, bool norm, TString file_name){
TH1* output = (TH1*) output_->Clone("output");
TH1D* pseudotruth = (TH1D*) pseudotruth_->Clone("pseudotruth");
TH1D* mctruth = (TH1D*) mctruth_->Clone("mctruth");
double ymax_temp = 0;
if(pseudotruth->GetMaximum() > ymax_temp) ymax_temp = pseudotruth->GetMaximum();
if(mctruth->GetMaximum() > ymax_temp) ymax_temp = mctruth->GetMaximum();
if(output->GetMaximum() > ymax_temp) ymax_temp = output->GetMaximum();
double ymax = 1.5 * ymax_temp;
pseudotruth->SetTitle(" ");
pseudotruth->GetYaxis()->SetRangeUser(0., ymax);
pseudotruth->GetXaxis()->SetTitle("Leading-jet mass [GeV]");
if(norm) pseudotruth->GetYaxis()->SetTitle("#frac{1}{#sigma} #frac{d#sigma}{dm_{jet}} [#frac{1}{GeV}]");
else pseudotruth->GetYaxis()->SetTitle("events");
pseudotruth->GetYaxis()->SetTitleOffset(1.1);
pseudotruth->GetXaxis()->SetTitleOffset(0.9);
pseudotruth->GetYaxis()->SetTitleSize(0.05);
pseudotruth->GetXaxis()->SetTitleSize(0.05);
pseudotruth->GetYaxis()->SetNdivisions(505);
pseudotruth->SetLineWidth(4);
pseudotruth->SetLineColor(kRed);
mctruth->SetLineWidth(3);
mctruth->SetLineStyle(2);
mctruth->SetLineColor(kBlue);
output->SetLineColor(kBlack);
output->SetMarkerColor(kBlack);
output->SetMarkerStyle(8);
output->SetMarkerSize(1);
TCanvas *c= new TCanvas("Particle Level","",600,600);
gPad->SetLeftMargin(0.15);
TGaxis::SetMaxDigits(3);
pseudotruth->Draw("HIST SAME");
mctruth->Draw("HIST SAME");
output->Draw("E1 SAME");
TLegend *l;
if(mctruth->GetSize() > 20) l=new TLegend(0.2,0.6,0.4,0.85);
else l=new TLegend(0.55,0.6,0.85,0.85);
l->SetBorderSize(0);
l->SetFillStyle(0);
l->AddEntry(output,"pseudo data","pl");
l->AddEntry(pseudotruth,"pseudo data truth","pl");
l->AddEntry(mctruth,"MC truth","pl");
l->SetTextSize(0.04);
l->Draw();
gPad->RedrawAxis();
c->SaveAs(directory + file_name + ".pdf");
delete c;
}
Double_t fitgp0( char* hs ) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ){
cout << hs << " does not exist\n";
return 0;
}
h->SetMarkerStyle(21);
h->SetMarkerSize(0.8);
h->SetStats(1);
gStyle->SetOptFit(101);
gROOT->ForceStyle();
double dx = h->GetBinWidth(1);
double nmax = h->GetBinContent(h->GetMaximumBin());
double xmax = h->GetBinCenter(h->GetMaximumBin());
double nn = 7*nmax;
int nb = h->GetNbinsX();
double n1 = h->GetBinContent(1);
double n9 = h->GetBinContent(nb);
double bg = 0.5*(n1+n9);
double x1 = h->GetBinCenter(1);
double x9 = h->GetBinCenter(nb);
// create a TF1 with the range from x1 to x9 and 4 parameters
TF1 *gp0Fcn = new TF1( "gp0Fcn", gp0Fit, x1, x9, 4 );
gp0Fcn->SetParName( 0, "mean" );
gp0Fcn->SetParName( 1, "sigma" );
gp0Fcn->SetParName( 2, "area" );
gp0Fcn->SetParName( 3, "BG" );
gp0Fcn->SetNpx(500);
gp0Fcn->SetLineWidth(4);
gp0Fcn->SetLineColor(kMagenta);
gp0Fcn->SetLineColor(kGreen);
// set start values for some parameters:
gp0Fcn->SetParameter( 0, xmax ); // peak position
gp0Fcn->SetParameter( 1, 4*dx ); // width
gp0Fcn->SetParameter( 2, nn ); // N
gp0Fcn->SetParameter( 3, bg );
// N: not drawing
// Q: quiet
// R: use specified range
h->Fit( "gp0Fcn", "NQR", "ep" );
return gp0Fcn->GetParameter(1);
}
void showTauIsolation(TFile* inputFile, const TString& dqmDirectory, const TString& meName,
const char* dqmSubDirectoryTauJet, const char* dqmSubDirectoryMuon, const char* dqmSubDirectoryElectron,
TCanvas* canvas, TPostScript* ps, const char* outputFileLabel, bool useLogScale)
{
canvas->SetLogy(useLogScale);
TLegend legend(0.74, 0.71, 0.89, 0.89, "", "brNDC");
legend.SetBorderSize(0);
legend.SetFillColor(0);
TH1* meTauJet = getMonitorElement(inputFile, dqmDirectory, dqmSubDirectoryTauJet, meName);
meTauJet->SetMarkerStyle(20);
meTauJet->SetMarkerColor(kRed);
meTauJet->SetLineColor(kRed);
meTauJet->Draw("e1p");
legend.AddEntry(meTauJet, "#tau-Jet", "p");
if ( dqmSubDirectoryMuon != "" ) {
TH1* meMuon = getMonitorElement(inputFile, dqmDirectory, dqmSubDirectoryMuon, meName);
meMuon->SetMarkerStyle(21);
meMuon->SetMarkerColor(kBlue);
meMuon->SetLineColor(kBlue);
meMuon->Draw("e1psame");
legend.AddEntry(meMuon, "#mu", "p");
}
if ( dqmSubDirectoryElectron != "" ) {
TH1* meElectron = getMonitorElement(inputFile, dqmDirectory, dqmSubDirectoryElectron, meName);
meElectron->SetMarkerStyle(23);
meElectron->SetMarkerColor(kGreen);
meElectron->SetLineColor(kGreen);
meElectron->Draw("e1psame");
legend.AddEntry(meElectron, "e", "p");
}
legend.Draw();
canvas->Update();
TString outputFileName = TString("plot").Append(meTauJet->GetName()).Append("_").Append(outputFileLabel).Append(".png");
canvas->Print(outputFileName.Data());
//ps->NewPage();
}
void SetStyle(TH1& h, double size, int color, int style, int fillstyle=0, int linestyle=1){
h.SetMarkerSize(size);
h.SetMarkerColor(color);
h.SetLineColor(color);
h.SetMarkerStyle(style);
h.SetFillStyle(fillstyle);
h.SetLineStyle(linestyle);
h.GetXaxis()->SetTitleFont(42);
h.GetYaxis()->SetTitleFont(42);
h.GetXaxis()->SetTitleSize(0.048);
h.GetYaxis()->SetTitleSize(0.048);
h.GetXaxis()->CenterTitle();
h.GetYaxis()->CenterTitle();
}
void histogramStyle(TH1& hist, int color, int lineStyle, int markerStyle, float markersize, int filled)
{
hist.SetLineWidth(3);
hist.SetStats(kFALSE);
hist.SetLineColor (color);
hist.SetMarkerColor(color);
hist.SetMarkerStyle(markerStyle);
hist.SetMarkerSize(markersize);
hist.SetLineStyle(lineStyle);
if(filled==1){
hist.SetFillStyle(1001);
hist.SetFillColor(color);
}
else{
hist.SetFillStyle(0);
}
}
void Legend()
{
TLegend* leg = new TLegend(.6, .6, .9, .85);
leg->SetFillStyle(0);
TH1* dummy = new TH1F("", "", 1, 0, 1);
dummy->SetMarkerStyle(kFullCircle);
leg->AddEntry(dummy->Clone(), "Fake Data", "lep");
dummy->SetLineColor(kTotalMCColor);
leg->AddEntry(dummy->Clone(), "Total MC", "l");
dummy->SetLineColor(kNCBackgroundColor);
leg->AddEntry(dummy->Clone(), "NC", "l");
dummy->SetLineColor(kNumuBackgroundColor);
leg->AddEntry(dummy->Clone(), "#nu_{#mu} CC", "l");
dummy->SetLineColor(kBeamNueBackgroundColor);
leg->AddEntry(dummy->Clone(), "Beam #nu_{e} CC", "l");
leg->Draw();
}
void format1Dhisto(TH1& h1, double Ymax, double Ymin, double& col, double& fill, double& style, const char* titx, const char* tity ){
//void format1Dhisto(TH1& h1, string& xTitle, double Ymax, double Ymin){
//h1.SetTitle(";XXXX;XXXX");
if(Ymax!=-1 && Ymin!=-1) h1.GetYaxis()->SetRangeUser(Ymax, Ymin);
//if(Ymax==-1 && Ymin!=-1) h1.GetYaxis()->SetMinimum(Ymin);
h1.SetMarkerColor(col);
h1.SetMarkerStyle();
h1.SetMarkerColor();
h1.SetLineColor(col);
h1.SetFillColor(fill);
h1.SetFillStyle(style);
h1.GetXaxis()->SetTitle(titx);
h1.GetYaxis()->SetTitle(tity);
h1.GetXaxis()->CenterTitle();
h1.GetYaxis()->CenterTitle();
//cout<<"The title is : "<<tit<<endl;
return;
}
void boostcontrolplots( TDirectory *boostdir ) {
const Int_t nPlots = 4;
Int_t width = 900;
Int_t height = 600;
char cn[100];
const TString titName = boostdir->GetName();
sprintf( cn, "cv_%s", titName.Data() );
TCanvas *c = new TCanvas( cn, Form( "%s Control Plots", titName.Data() ),
width, height );
c->Divide(2,2);
const TString titName = boostdir->GetName();
TString hname[nPlots]={"Booster_BoostWeight","Booster_MethodWeight","Booster_ErrFraction","Booster_OrigErrFraction"};
for (Int_t i=0; i<nPlots; i++){
Int_t color = 4;
TPad * cPad = (TPad*)c->cd(i+1);
TH1 *h = (TH1*) boostdir->Get(hname[i]);
TString plotname = h->GetName();
h->SetMaximum(h->GetMaximum()*1.3);
h->SetMinimum( 0 );
h->SetMarkerColor(color);
h->SetMarkerSize( 0.7 );
h->SetMarkerStyle( 24 );
h->SetLineWidth(1);
h->SetLineColor(color);
h->Draw();
c->Update();
}
// write to file
TString fname = Form( "plots/%s_ControlPlots", titName.Data() );
TMVAGlob::imgconv( c, fname );
}
void SetAxisLabels(TH1& hist, char* xtitle, char* ytitle="",
double xoffset=1.1, double yoffset=1.4) {
TAxis* x = hist.GetXaxis();
TAxis* y = hist.GetYaxis();
x->SetTitle(xtitle);
x->SetTitleSize(0.06);
x->SetLabelSize(0.05);
x->SetTitleOffset(xoffset);
x->SetNdivisions(505);
y->SetTitle(ytitle);
y->SetTitleSize(0.06);
y->SetLabelSize(0.05);
y->SetTitleOffset(yoffset);
y->SetNoExponent();
hist.SetLineWidth(2);
hist.SetMarkerStyle(20);
std::stringstream str;
str << "Events / " << (int) lumi << " pb^{-1} ";
std::string defYtitle = str.str();
if(ytitle=="") y->SetTitle( defYtitle.c_str() );
}
void DrawTree::Project(Params& A) {
char name[128];
sprintf(name,"drawTree%d_%d",fN,_countAdd++);
A._Hname=name;
_tree->Project(name,A._varexp.c_str(),A._selection.c_str(),A._option.c_str(),A._nentries,A._firstentry);
TH1* h = (TH1*)gDirectory->Get(A._Hname.c_str());
h->SetMarkerStyle(_MarkerStyle+(_MarkerCount0++));
h->SetMarkerColor(_MarkerColor+(_MarkerCount1++));
A._TH=h;
_stack.Add(h);
cout << A._legend.c_str() << endl;
_legend->AddEntry(h,A._legend.c_str(),"P");
float axmin=h->GetXaxis()->GetXmin();
float axmax=h->GetXaxis()->GetXmax();
if (xmin>axmin)
xmin=axmin;
if (xmax<axmax)
xmax=axmax;
if (A._varexp.find(":") != string::npos) {
A._1D=false;
float aymin=h->GetYaxis()->GetXmin();
float aymax=h->GetYaxis()->GetXmax();
if (ymin>aymin)
ymin=aymin;
if (ymax<aymax)
ymax=aymax;
}
}
TH1* compRatioHistogram(const std::string& ratioHistogramName, const TH1* numerator, const TH1* denominator)
{
TH1* histogramRatio = 0;
if ( numerator->GetDimension() == denominator->GetDimension() &&
numerator->GetNbinsX() == denominator->GetNbinsX() ) {
histogramRatio = (TH1*)numerator->Clone(ratioHistogramName.data());
histogramRatio->Divide(denominator);
int nBins = histogramRatio->GetNbinsX();
for ( int iBin = 1; iBin <= nBins; ++iBin ){
double binContent = histogramRatio->GetBinContent(iBin);
histogramRatio->SetBinContent(iBin, binContent - 1.);
}
histogramRatio->SetLineColor(numerator->GetLineColor());
histogramRatio->SetLineWidth(numerator->GetLineWidth());
histogramRatio->SetMarkerColor(numerator->GetMarkerColor());
histogramRatio->SetMarkerStyle(numerator->GetMarkerStyle());
histogramRatio->SetMarkerSize(numerator->GetMarkerSize());
}
return histogramRatio;
}
void makePlot(const std::string& inputFilePath, const std::string& canvasName, const std::string& sample, int massPoint, const std::string& channel, double k,
const std::string& inputFileName, const std::string& outputFilePath, const std::string& outputFileName)
{
std::string inputFileName_full = Form("%s%s", inputFilePath.data(), inputFileName.data());
TFile* inputFile = new TFile(inputFileName_full.data());
if ( !inputFile ) {
std::cerr << "Failed to open input file = " << inputFileName_full << " !!" << std::endl;
assert(0);
}
inputFile->ls();
TCanvas* canvas = dynamic_cast<TCanvas*>(inputFile->Get(canvasName.data()));
if ( !canvas ) {
std::cerr << "Failed to load canvas = " << canvasName << " !!" << std::endl;
assert(0);
}
int idxPad = -1;
if ( massPoint == 90 ) idxPad = 1;
if ( massPoint == 125 ) idxPad = 2;
if ( massPoint == 200 ) idxPad = 3;
if ( massPoint == 300 ) idxPad = 4;
if ( massPoint == 500 ) idxPad = 5;
if ( massPoint == 800 ) idxPad = 6;
if ( !(idxPad >= 1 && idxPad <= 6) ) {
std::cerr << "Invalid sample = " << sample << " !!" << std::endl;
assert(0);
}
TVirtualPad* pad = canvas->GetPad(idxPad);
std::cout << "pad = " << pad << ": ClassName = " << pad->ClassName() << std::endl;
TCanvas* canvas_new = new TCanvas("canvas_new", "canvas_new", 900, 800);
canvas_new->SetFillColor(10);
canvas_new->SetBorderSize(2);
canvas_new->SetTopMargin(0.065);
canvas_new->SetLeftMargin(0.17);
canvas_new->SetBottomMargin(0.165);
canvas_new->SetRightMargin(0.015);
canvas_new->SetLogx(true);
canvas_new->SetLogy(true);
canvas_new->Draw();
canvas_new->cd();
//TList* pad_primitives = canvas->GetListOfPrimitives();
TList* pad_primitives = pad->GetListOfPrimitives();
TH1* histogramCA = 0;
TH1* histogramSVfit = 0;
TH1* histogramSVfitMEMkEq0 = 0;
TH1* histogramSVfitMEMkNeq0 = 0;
TIter pad_nextObj(pad_primitives);
while ( TObject* obj = pad_nextObj() ) {
std::string objName = "";
if ( dynamic_cast<TNamed*>(obj) ) objName = (dynamic_cast<TNamed*>(obj))->GetName();
std::cout << "obj = " << obj << ": name = " << objName << ", type = " << obj->ClassName() << std::endl;
TH1* tmpHistogram = dynamic_cast<TH1*>(obj);
if ( tmpHistogram ) {
std::cout << "tmpHistogram:"
<< " fillColor = " << tmpHistogram->GetFillColor() << ", fillStyle = " << tmpHistogram->GetFillStyle() << ","
<< " lineColor = " << tmpHistogram->GetLineColor() << ", lineStyle = " << tmpHistogram->GetLineStyle() << ", lineWidth = " << tmpHistogram->GetLineWidth() << ","
<< " markerColor = " << tmpHistogram->GetMarkerColor() << ", markerStyle = " << tmpHistogram->GetMarkerStyle() << ", markerSize = " << tmpHistogram->GetMarkerSize() << ","
<< " integral = " << tmpHistogram->Integral() << std::endl;
std::cout << "(mean = " << tmpHistogram->GetMean() << ", rms = " << tmpHistogram->GetRMS() << ": rms/mean = " << (tmpHistogram->GetRMS()/tmpHistogram->GetMean()) << ")" << std::endl;
if ( tmpHistogram->GetLineColor() == 416 ) histogramCA = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 600 ) histogramSVfit = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 616 ) histogramSVfitMEMkEq0 = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 632 ) histogramSVfitMEMkNeq0 = tmpHistogram;
}
}
if ( !(histogramCA && histogramSVfit && histogramSVfitMEMkEq0 && histogramSVfitMEMkNeq0) ) {
std::cerr << "Failed to load histograms !!" << std::endl;
assert(0);
}
//gStyle->SetLineStyleString(2,"40 10 10 10 10 10 10 10");
//gStyle->SetLineStyleString(3,"25 15");
//gStyle->SetLineStyleString(4,"60 25");
//int colors[4] = { kBlack, kGreen - 6, kBlue - 7, kMagenta - 7 };
int colors[4] = { 28, kGreen - 6, kBlue - 7, kBlack };
//int lineStyles[4] = { 2, 3, 4, 1 };
int lineStyles[4] = { 7, 1, 1, 1 };
//int lineWidths[4] = { 3, 3, 4, 3 };
int lineWidths[4] = { 3, 3, 1, 1 };
int markerStyles[4] = { 20, 25, 21, 24 };
int markerSizes[4] = { 2, 2, 2, 2 };
histogramCA->SetFillColor(0);
histogramCA->SetFillStyle(0);
histogramCA->SetLineColor(colors[0]);
histogramCA->SetLineStyle(lineStyles[0]);
histogramCA->SetLineWidth(lineWidths[0]);
histogramCA->SetMarkerColor(colors[0]);
histogramCA->SetMarkerStyle(markerStyles[0]);
histogramCA->SetMarkerSize(markerSizes[0]);
histogramSVfit->SetFillColor(0);
histogramSVfit->SetFillStyle(0);
histogramSVfit->SetLineColor(colors[1]);
histogramSVfit->SetLineStyle(lineStyles[1]);
histogramSVfit->SetLineWidth(lineWidths[1]);
histogramSVfit->SetMarkerColor(colors[1]);
histogramSVfit->SetMarkerStyle(markerStyles[1]);
histogramSVfit->SetMarkerSize(markerSizes[1]);
histogramSVfitMEMkEq0->SetFillColor(0);
histogramSVfitMEMkEq0->SetFillStyle(0);
histogramSVfitMEMkEq0->SetLineColor(colors[2]);
histogramSVfitMEMkEq0->SetLineStyle(lineStyles[2]);
histogramSVfitMEMkEq0->SetLineWidth(lineWidths[2]);
histogramSVfitMEMkEq0->SetMarkerColor(colors[2]);
histogramSVfitMEMkEq0->SetMarkerStyle(markerStyles[2]);
histogramSVfitMEMkEq0->SetMarkerSize(markerSizes[2]);
// CV: fix pathological bins at high mass for which dN/dm increases
int numBins = histogramSVfitMEMkEq0->GetNbinsX();
for ( int idxBin = 1; idxBin <= numBins; ++idxBin ) {
double binCenter = histogramSVfitMEMkEq0->GetBinCenter(idxBin);
if ( (channel == "#tau_{h}#tau_{h}" && massPoint == 500 && binCenter > 1500.) ||
(channel == "#tau_{h}#tau_{h}" && massPoint == 800 && binCenter > 2000.) ||
(channel == "#mu#tau_{h}" && massPoint == 500 && binCenter > 1500.) ||
(channel == "#mu#tau_{h}" && massPoint == 800 && binCenter > 2500.) ) {
histogramSVfitMEMkEq0->SetBinContent(idxBin, 0.);
}
}
histogramSVfitMEMkNeq0->SetFillColor(0);
histogramSVfitMEMkNeq0->SetFillStyle(0);
histogramSVfitMEMkNeq0->SetLineColor(colors[3]);
histogramSVfitMEMkNeq0->SetLineStyle(lineStyles[3]);
histogramSVfitMEMkNeq0->SetLineWidth(lineWidths[3]);
histogramSVfitMEMkNeq0->SetMarkerColor(colors[3]);
histogramSVfitMEMkNeq0->SetMarkerStyle(markerStyles[3]);
histogramSVfitMEMkNeq0->SetMarkerSize(markerSizes[3]);
TAxis* xAxis = histogramCA->GetXaxis();
xAxis->SetTitle("m_{#tau#tau} [GeV]");
xAxis->SetTitleOffset(1.15);
xAxis->SetTitleSize(0.070);
xAxis->SetTitleFont(42);
xAxis->SetLabelOffset(0.010);
xAxis->SetLabelSize(0.055);
xAxis->SetLabelFont(42);
xAxis->SetTickLength(0.040);
xAxis->SetNdivisions(510);
//double xMin = 20.;
//double xMax = xAxis->GetXmax();
//xAxis->SetRangeUser(xMin, xMax);
TAxis* yAxis = histogramCA->GetYaxis();
yAxis->SetTitle("dN/dm_{#tau#tau} [1/GeV]");
yAxis->SetTitleOffset(1.20);
yAxis->SetTitleSize(0.070);
yAxis->SetTitleFont(42);
yAxis->SetLabelOffset(0.010);
yAxis->SetLabelSize(0.055);
yAxis->SetLabelFont(42);
yAxis->SetTickLength(0.040);
yAxis->SetNdivisions(505);
double massPoint_double = 0.;
if ( massPoint == 90 ) massPoint_double = 91.2;
else massPoint_double = massPoint;
double dLog = (TMath::Log(5.*massPoint_double) - TMath::Log(50.))/25.; // xMin = 50, xMax = 5*massPoint, numBins = 25
double binWidth = TMath::Exp(TMath::Log(massPoint_double) + 0.5*dLog) - TMath::Exp(TMath::Log(massPoint_double) - 0.5*dLog);
double sf_binWidth = 1./binWidth;
std::cout << "massPoint = " << massPoint << ": sf_binWidth = " << sf_binWidth << std::endl;
histogramCA->SetTitle("");
histogramCA->SetStats(false);
histogramCA->SetMaximum(sf_binWidth*0.79);
histogramCA->SetMinimum(sf_binWidth*1.1e-4);
histogramCA->Draw("hist");
histogramSVfit->Draw("histsame");
//histogramSVfitMEMkEq0->Draw("histsame");
histogramSVfitMEMkEq0->Draw("epsame");
//histogramSVfitMEMkNeq0->Draw("histsame");
histogramSVfitMEMkNeq0->Draw("epsame");
histogramCA->Draw("axissame");
//TPaveText* label_sample = new TPaveText(0.21, 0.86, 0.46, 0.94, "NDC");
TPaveText* label_sample = new TPaveText(0.1700, 0.9475, 0.4600, 1.0375, "NDC");
label_sample->SetFillStyle(0);
label_sample->SetBorderSize(0);
label_sample->AddText(sample.data());
label_sample->SetTextFont(42);
label_sample->SetTextSize(0.055);
label_sample->SetTextColor(1);
label_sample->SetTextAlign(13);
label_sample->Draw();
//TLegend* legend_new = new TLegend(0.225, 0.52, 0.41, 0.82, NULL, "brNDC");
TLegend* legend_new = new TLegend(0.30, 0.30, 0.80, 0.80, NULL, "brNDC");
legend_new->SetFillColor(10);
legend_new->SetFillStyle(0);
legend_new->SetBorderSize(0);
legend_new->SetTextFont(42);
legend_new->SetTextSize(0.055);
legend_new->SetTextColor(1);
legend_new->SetMargin(0.20);
legend_new->AddEntry(histogramCA, "CA", "l");
legend_new->AddEntry(histogramSVfit, "SVfit", "l");
//legend_new->AddEntry(histogramSVfitMEMkEq0, "SVfitMEM (k=0)", "l");
legend_new->AddEntry(histogramSVfitMEMkEq0, "SVfitMEM (k=0)", "p");
//legend_new->AddEntry(histogramSVfitMEMkNeq0, Form("SVfitMEM(k=%1.0f)", k), "l");
legend_new->AddEntry(histogramSVfitMEMkNeq0, Form("SVfitMEM (k=%1.0f)", k), "p");
//legend_new->Draw();
double label_channel_y0;
if ( channel == "e#mu" ) label_channel_y0 = 0.9275;
else if ( channel == "#mu#tau_{h}" ) label_channel_y0 = 0.9400;
else if ( channel == "#tau_{h}#tau_{h}" ) label_channel_y0 = 0.9350;
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
TPaveText* label_channel = new TPaveText(0.895, label_channel_y0, 0.975, label_channel_y0 + 0.055, "NDC");
label_channel->SetFillStyle(0);
label_channel->SetBorderSize(0);
label_channel->AddText(channel.data());
label_channel->SetTextFont(62);
label_channel->SetTextSize(0.055);
label_channel->SetTextColor(1);
label_channel->SetTextAlign(31);
label_channel->Draw();
canvas_new->Update();
std::string outputFileName_full = Form("%s%s", outputFilePath.data(), outputFileName.data());
size_t idx = outputFileName_full.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName_full, 0, idx);
canvas_new->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas_new->Print(std::string(outputFileName_plot).append(".root").data());
std::string channel_string;
if ( channel == "e#mu" ) channel_string = "emu";
else if ( channel == "#mu#tau_{h}" ) channel_string = "muhad";
else if ( channel == "#tau_{h}#tau_{h}" ) channel_string = "hadhad";
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
std::string outputFileName_legend = Form("makeSVfitMEM_PerformancePlots_legend_%s.pdf", channel_string.data());
makePlot_legend(legend_new, outputFilePath, outputFileName_legend);
delete label_sample;
delete legend_new;
delete label_channel;
delete canvas_new;
delete inputFile;
}
//------------------------------------------------------------------------------
void PlotAlignmentValidation::setHistStyle( TH1& hist,const char* titleX, const char* titleY, int color)
{
std::stringstream titel_Xaxis;
std::stringstream titel_Yaxis;
TString titelXAxis=titleX;
TString titelYAxis=titleY;
if ( titelXAxis.Contains("Phi") )titel_Xaxis<<titleX<<"[rad]";
else if( titelXAxis.Contains("meanX") )titel_Xaxis<<"#LTx'_{pred}-x'_{hit}#GT[cm]";
else if( titelXAxis.Contains("meanY") )titel_Xaxis<<"#LTy'_{pred}-y'_{hit}#GT[cm]";
else if( titelXAxis.Contains("rmsX") )titel_Xaxis<<"RMS(x'_{pred}-x'_{hit})[cm]";
else if( titelXAxis.Contains("rmsY") )titel_Xaxis<<"RMS(y'_{pred}-y'_{hit})[cm]";
else if( titelXAxis.Contains("meanNormX") )titel_Xaxis<<"#LTx'_{pred}-x'_{hit}/#sigma#GT";
else if( titelXAxis.Contains("meanNormY") )titel_Xaxis<<"#LTy'_{pred}-y'_{hit}/#sigma#GT";
else if( titelXAxis.Contains("rmsNormX") )titel_Xaxis<<"RMS(x'_{pred}-x'_{hit}/#sigma)";
else if( titelXAxis.Contains("rmsNormY") )titel_Xaxis<<"RMS(y'_{pred}-y'_{hit}/#sigma)";
else if( titelXAxis.Contains("meanLocalX") )titel_Xaxis<<"#LTx_{pred}-x_{hit}#GT[cm]";
else if( titelXAxis.Contains("rmsLocalX") )titel_Xaxis<<"RMS(x_{pred}-x_{hit})[cm]";
else if( titelXAxis.Contains("meanNormLocalX") )titel_Xaxis<<"#LTx_{pred}-x_{hit}/#sigma#GT[cm]";
else if( titelXAxis.Contains("rmsNormLocalX") )titel_Xaxis<<"RMS(x_{pred}-x_{hit}/#sigma)[cm]";
else if( titelXAxis.Contains("medianX") )titel_Xaxis<<"median(x'_{pred}-x'_{hit})[cm]";
else if( titelXAxis.Contains("medianY") )titel_Xaxis<<"median(y'_{pred}-y'_{hit})[cm]";
else titel_Xaxis<<titleX<<"[cm]";
if (hist.IsA()->InheritsFrom( TH1F::Class() ) )hist.SetLineColor(color);
if (hist.IsA()->InheritsFrom( TProfile::Class() ) ) {
hist.SetMarkerStyle(20);
hist.SetMarkerSize(0.8);
hist.SetMarkerColor(color);
}
hist.GetXaxis()->SetTitle( (titel_Xaxis.str()).c_str() );
hist.GetXaxis()->SetTitleSize ( 0.05 );
hist.GetXaxis()->SetTitleColor ( 1 );
hist.GetXaxis()->SetTitleOffset( 1.2 );
hist.GetXaxis()->SetTitleFont ( 62 );
hist.GetXaxis()->SetLabelSize ( 0.05 );
hist.GetXaxis()->SetLabelFont ( 62 );
//hist.GetXaxis()->CenterTitle ( );
hist.GetXaxis()->SetNdivisions ( 505 );
if /*( titelYAxis.Contains("meanX") )titel_Yaxis<<"#LTx'_{pred}-x'_{hit}#GT[cm]";
else if ( titelYAxis.Contains("rmsX") )titel_Yaxis<<"RMS(x'_{pred}-x'_{hit})[cm]";
else if( titelYAxis.Contains("meanNormX") )titel_Yaxis<<"#LTx'_{pred}-x'_{hit}/#sigma#GT";
else if( titelYAxis.Contains("rmsNormX") )titel_Yaxis<<"RMS(x_'{pred}-x'_{hit}/#sigma)";
else if( titelYAxis.Contains("meanLocalX") )titel_Yaxis<<"#LTx_{pred}-x_{hit}#GT[cm]";
else if( titelYAxis.Contains("rmsLocalX") )titel_Yaxis<<"RMS(x_{pred}-x_{hit})[cm]";
else if*/ ( (titelYAxis.Contains("layer") && titelYAxis.Contains("subDetId"))
|| titelYAxis.Contains("#modules") )titel_Yaxis<<"#modules";
else if ( (titelYAxis.Contains("ring") && titelYAxis.Contains("subDetId"))
|| titelYAxis.Contains("#modules") )titel_Yaxis<<"#modules";
else titel_Yaxis<<titleY<<"[cm]";
hist.GetYaxis()->SetTitle( (titel_Yaxis.str()).c_str() );
//hist.SetMinimum(1);
hist.GetYaxis()->SetTitleSize ( 0.05 );
hist.GetYaxis()->SetTitleColor ( 1 );
if ( hist.IsA()->InheritsFrom( TH2::Class() ) ) hist.GetYaxis()->SetTitleOffset( 0.95 );
else hist.GetYaxis()->SetTitleOffset( 1.2 );
hist.GetYaxis()->SetTitleFont ( 62 );
hist.GetYaxis()->SetLabelSize ( 0.03 );
hist.GetYaxis()->SetLabelFont ( 62 );
}
void plotter::draw_output_mass(TH1* output_, TH1* stat_, std::vector<TH1D*> mtop_templates_, std::vector<bool> show, bool norm, TString file_name){
TH1* output = (TH1*) output_->Clone("output");
TH1* stat = (TH1*) stat_->Clone("stat");
std::vector<TH1D*> mtop_templates;
for(unsigned int i = 0; i < mtop_templates_.size(); i++){
mtop_templates.push_back((TH1D*) mtop_templates_[i]->Clone(""));
}
TCanvas *c = new TCanvas("c","",600,600);
gPad->SetLeftMargin(0.15);
double max = output->GetMaximum();
for(unsigned int i = 0; i < mtop_templates.size(); i++){
if(show[i]){
double max_temp = mtop_templates[i]->GetMaximum();
if(max_temp > max) max = max_temp;
}
}
double ymax = 1.5 * max;
TGaxis::SetMaxDigits(3);
output->SetTitle(" ");
output->GetYaxis()->SetRangeUser(0., ymax);
output->GetXaxis()->SetTitle("Leading-jet mass [GeV]");
if(norm) output->GetYaxis()->SetTitle("#frac{1}{#sigma} #frac{d#sigma}{dm_{jet}} [#frac{1}{GeV}]");
else output->GetYaxis()->SetTitle("events");
output->GetYaxis()->SetTitleOffset(1.1);
output->GetXaxis()->SetTitleOffset(0.9);
output->GetYaxis()->SetTitleSize(0.05);
output->GetXaxis()->SetTitleSize(0.05);
output->GetYaxis()->SetNdivisions(505);
output->SetLineColor(kBlack);
output->SetMarkerColor(kBlack);
output->SetMarkerStyle(8);
output->SetMarkerSize(1);
output->Draw("E1 SAME");
stat->SetLineColor(kBlack);
stat->SetMarkerColor(kBlack);
stat->SetMarkerStyle(8);
stat->SetMarkerSize(1);
gStyle->SetEndErrorSize(5);
mtop_templates[0]->SetLineColor(kRed);
mtop_templates[1]->SetLineColor(kRed);
mtop_templates[2]->SetLineColor(kRed);
mtop_templates[3]->SetLineColor(13);
mtop_templates[4]->SetLineColor(kAzure+7);
mtop_templates[5]->SetLineColor(kAzure+7);
mtop_templates[6]->SetLineColor(kAzure+7);
for(unsigned int i = 0; i < mtop_templates.size(); i++){
mtop_templates[i]->SetLineWidth(3);
if(show[i]) mtop_templates[i]->Draw("HIST SAME");
}
stat->Draw("E1 SAME");
output->Draw("E1 SAME"); // draw again to set markers in front
TLegend *l=new TLegend(0.56,0.65,0.78,0.85);
l->SetBorderSize(0);
l->SetFillStyle(0);
l->AddEntry(output,"data unfolded","pl");
if(show[0]) l->AddEntry(mtop_templates[0],"m_{top}^{MC} = 166.5 GeV","pl");
if(show[1]) l->AddEntry(mtop_templates[1],"m_{top}^{MC} = 169.5 GeV","pl");
if(show[2]) l->AddEntry(mtop_templates[2],"m_{top}^{MC} = 171.5 GeV","pl");
if(show[3]) l->AddEntry(mtop_templates[3],"m_{top}^{MC} = 172.5 GeV","pl");
if(show[4]) l->AddEntry(mtop_templates[4],"m_{top}^{MC} = 173.5 GeV","pl");
if(show[5]) l->AddEntry(mtop_templates[5],"m_{top}^{MC} = 175.5 GeV","pl");
if(show[6]) l->AddEntry(mtop_templates[6],"m_{top}^{MC} = 178.5 GeV","pl");
l->SetTextSize(0.04);
l->Draw();
c->SaveAs(directory + file_name + ".pdf");
delete c;
}
TH1 *
UnfoldMe_MB2(const Char_t *data, const Char_t *mc, const Char_t *anatag, Int_t bin, Bool_t useMBcorr , Bool_t usecorrfit , Bool_t ismc , Float_t smooth , Int_t iter , Int_t regul , Float_t weight , Bool_t bayesian , Int_t nloop )
{
// MF comments:
// usedMBcorr: changes the matrix used for unfonding, from effMatrix to bin matrix (I think this is just to use mult dependent v s mb correction_)
// usecorrfit: if I understand correctly, fits the response matrix and uses fit to extrapolate it
TFile *fdt =0;
if (ismc)
fdt = TFile::Open(data);
else
fdt = TFile::Open(data);
TFile *fmc = TFile::Open(mc);
TList *ldt = (TList *)fdt->Get(Form("%s", anatag));
TList *lmc = (TList *)fmc->Get(Form("%s", anatag));
TH2 *hmatdt = (TH2 *)ldt->FindObject(Form(responseMatrix, bin));
TH2 *hmatmc = 0;
if (useMBcorr){
hmatmc = (TH2 *)lmc->FindObject("effMatrix");
std::cout << "USING MB" << std::endl;
}
else {
hmatmc = (TH2 *)lmc->FindObject(Form(responseMatrix, bin));
}
TH1 *hdata = hmatdt->ProjectionY("hdata");
// TH1 *hdata = hmatdt->ProjectionY("htrue"); // For truth Only Calculations
hdata->Sumw2();
hdata->SetBinContent(1, 0.);
hdata->SetBinError(1, 0.);
// hdata->Scale(1. / hdata->Integral());
hdata->SetMarkerStyle(25);
TH1 *htrue = hmatdt->ProjectionX("htrue");
htrue->Sumw2();
// htrue->Scale(1. / htrue->Integral());
htrue->SetMarkerStyle(7);
htrue->SetMarkerColor(2);
htrue->SetBinContent(1, 0.);
htrue->SetBinError(1, 0.);
TH2 *hcorr = (TH2 *)hmatmc->Clone("hcorr");
TH1 *hinit = (TH1 *)hdata->Clone("hinit");
TH1 *hresu = (TH1 *)hdata->Clone("hresu");
TH1 *hbias = (TH1 *)hdata->Clone("hbias");
hresu->SetMarkerStyle(20);
hresu->SetMarkerColor(4);
hresu->Reset();
TH1 *hnum = hcorr->ProjectionY("hnum");
TH1 *hden = hcorr->ProjectionY("hden");
TH1 *heff = hcorr->ProjectionY("heff");
hnum->Reset();
hnum->Sumw2();
hden->Reset();
hden->Sumw2();
heff->Reset();
for (Int_t i = 0; i < heff->GetNbinsX(); i++) {
Float_t int1 = hcorr->Integral(i + 1, i + 1, 0, -1);
if (int1 <= 0.) continue;
Float_t int2 = hcorr->Integral(i + 1, i + 1, 2, -1);
hnum->SetBinContent(i + 1, int2);
hnum->SetBinError(i + 1, TMath::Sqrt(int2));
hden->SetBinContent(i + 1, int1);
hden->SetBinError(i + 1, TMath::Sqrt(int1));
}
TCanvas *cEfficiency = new TCanvas("cEfficiency", "cEfficiency");
cEfficiency->SetLogx();
cEfficiency->SetLogy();
heff->Divide(hnum, hden, 1., 1., "B");
heff->Draw();
#if 0
for (Int_t ii = 0; ii < heff->GetNbinsX(); ii++) {
heff->SetBinContent(ii + 1, 1.);
heff->SetBinError(ii + 1, 0.);
}
#endif
for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) {
hcorr->SetBinContent(i + 1, 1, 0.);
hcorr->SetBinError(i + 1, 1, 0.);
}
for (Int_t i = 0; i < hcorr->GetNbinsY(); i++) {
hcorr->SetBinContent(1, i + 1, 0.);
hcorr->SetBinError(1, i + 1, 0.);
}
TH2 *hcorrfit = ReturnCorrFromFit(hcorr);
// Docs from AliUnfolding
//Int_t AliUnfolding::Unfold(TH2* correlation, TH1* efficiency, TH1* measured, TH1* initialConditions, TH1* result, Bool_t check)
// unfolds with unfolding method fgMethodType
//
// parameters:
// correlation: response matrix as measured vs. generated
// efficiency: (optional) efficiency that is applied on the unfolded spectrum, i.e. it has to be in unfolded variables. If 0 no efficiency is applied.
// measured: the measured spectrum
// initialConditions: (optional) initial conditions for the unfolding. if 0 the measured spectrum is used as initial conditions.
// result: target for the unfolded result
// check: depends on the unfolding method, see comments in specific functions
for (Int_t iloop = 0; iloop < nloop; iloop++) {
if (bayesian) {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kBayesian);
AliUnfolding::SetBayesianParameters(smooth, iter);
} else {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kChi2Minimization);
AliUnfolding::SetChi2Regularization(AliUnfolding::RegularizationType(regul), weight);
}
AliUnfolding::SetSkip0BinInChi2(kTRUE);
AliUnfolding::SetSkipBinsBegin(1);
AliUnfolding::SetNbins(150, 150);
AliUnfolding::Unfold(usecorrfit ? hcorrfit : hcorr, heff, hdata, hinit, hresu);
hinit = (TH1 *)hresu->Clone(Form("hinit_%d", iloop));
}
printf("hdata->Integral(2, -1) = %f\n", hdata->Integral(2, -1));
printf("hresu->Integral(2, -1) = %f\n", hresu->Integral(2, -1));
TCanvas *cUnfolded = new TCanvas ("cUnfolded", "cUnfolded", 400, 800);
cUnfolded->Divide(1, 2);
cUnfolded->cd(1)->SetLogx();
cUnfolded->cd(1)->SetLogy();
hdata->Draw();
hresu->Draw("same");
htrue->Draw("same");
cUnfolded->cd(2)->SetLogx();
cUnfolded->cd(2)->DrawFrame(1., 0, 300., 10);
TH1 *hrat = (TH1 *)hresu->Clone("hrat");
hrat->Divide(htrue);
hrat->Draw("same");
TH1 *htrig = (TH1 *)hresu->Clone("htrig");
htrig->Multiply(heff);
Float_t dndeta_resu = 0.;
Float_t integr_resu = 0.;
Float_t dndeta_trig = 0.;
Float_t integr_trig = 0.;
for (Int_t i = 1; i < hresu->GetNbinsX(); i++) {
dndeta_resu += hresu->GetBinContent(i + 1) * hresu->GetBinLowEdge(i + 1);
integr_resu += hresu->GetBinContent(i + 1);
dndeta_trig += htrig->GetBinContent(i + 1) * htrig->GetBinLowEdge(i + 1);
integr_trig += htrig->GetBinContent(i + 1);
}
cUnfolded->SaveAs("unfold_efficiency.pdf");
integr_eff = integr_trig / integr_resu;
integr_eff_err = TMath::Sqrt(integr_eff * (1. - integr_eff) / integr_resu);
dndeta_eff = dndeta_trig / dndeta_resu;
dndeta_eff_err = TMath::Sqrt(dndeta_eff * (1. - dndeta_eff) / dndeta_resu);
printf("INEL > 0 efficiency: %.3f +- %.3f\n", integr_eff, integr_eff_err);
printf("dN/dEta correction: %.3f +- %.3f\n", dndeta_eff, dndeta_eff_err);
return hresu;
}
void makePlot(TCanvas* canvas, const std::string& outputFileName, TTree* testTree, const std::string& varName,
unsigned numBinsX, double xMin, double xMax)
{
std::cout << "creating histogramTauIdPassed..." << std::endl;
TString histogramTauIdPassedName = TString("histogramTauIdPassed").Append("_").Append(varName.data());
TH1* histogramTauIdPassed = fillHistogram(testTree, varName, "type==1", "",
histogramTauIdPassedName.Data(), numBinsX, xMin, xMax);
std::cout << "--> histogramTauIdPassed = " << histogramTauIdPassed << ":"
<< " integral = " << histogramTauIdPassed->Integral() << std::endl;
std::cout << "creating histogramTauIdFailed..." << std::endl;
TString histogramTauIdFailedName = TString("histogramTauIdFailed").Append("_").Append(varName.data());
TH1* histogramTauIdFailed = fillHistogram(testTree, varName, "type==0", "",
histogramTauIdFailedName.Data(), numBinsX, xMin, xMax);
std::cout << "--> histogramTauIdFailed = " << histogramTauIdFailed
<< " integral = " << histogramTauIdFailed->Integral() << std::endl;
std::cout << "creating histogramTauIdDenominator..." << std::endl;
TString histogramTauIdDenominatorName = TString("histogramTauIdDenominator").Append("_").Append(varName.data());
TH1* histogramTauIdDenominator = new TH1F(histogramTauIdDenominatorName.Data(),
histogramTauIdDenominatorName.Data(), numBinsX, xMin, xMax);
histogramTauIdDenominator->Add(histogramTauIdPassed);
histogramTauIdDenominator->Add(histogramTauIdFailed);
std::cout << "--> histogramTauIdDenominator = " << histogramTauIdDenominator
<< " integral = " << histogramTauIdDenominator->Integral() << std::endl;
std::cout << "creating histogramFakeRate..." << std::endl;
TString histogramFakeRateName = TString("histogramFakeRate").Append("_").Append(varName.data());
TH1* histogramFakeRate = new TH1F(histogramFakeRateName.Data(),
histogramFakeRateName.Data(), numBinsX, xMin, xMax);
histogramFakeRate->Add(histogramTauIdPassed);
histogramFakeRate->Divide(histogramTauIdDenominator);
std::cout << "--> histogramFakeRate = " << histogramFakeRate
<< " integral = " << histogramFakeRate->Integral() << std::endl;
std::cout << "creating histogramFakeRateWeighted..." << std::endl;
TString histogramFakeRateWeightedName = TString("histogramFakeRateWeighted").Append("_").Append(varName.data());
TH1* histogramFakeRateWeighted = fillHistogram(testTree, varName, "", "MVA_KNN",
histogramFakeRateWeightedName.Data(), numBinsX, xMin, xMax);
histogramFakeRateWeighted->Divide(histogramTauIdDenominator);
std::cout << "--> histogramFakeRateWeighted = " << histogramFakeRateWeighted
<< " entries = " << histogramFakeRateWeighted->GetEntries() << ","
<< " integral = " << histogramFakeRateWeighted->Integral() << std::endl;
// Scale the weighted fake rate histogram
histogramFakeRate->SetTitle(varName.data());
histogramFakeRate->SetStats(false);
histogramFakeRate->SetMinimum(1.e-4);
histogramFakeRate->SetMaximum(1.e+1);
histogramFakeRate->SetLineColor(2);
histogramFakeRate->SetLineWidth(2);
histogramFakeRate->SetMarkerStyle(20);
histogramFakeRate->SetMarkerColor(2);
histogramFakeRate->SetMarkerSize(1);
histogramFakeRate->Draw("e1p");
histogramFakeRateWeighted->SetLineColor(4);
histogramFakeRateWeighted->SetLineWidth(2);
histogramFakeRateWeighted->SetMarkerStyle(24);
histogramFakeRateWeighted->SetMarkerColor(4);
histogramFakeRateWeighted->SetMarkerSize(1);
histogramFakeRateWeighted->Draw("e1psame");
TLegend legend(0.11, 0.73, 0.31, 0.89);
legend.SetBorderSize(0);
legend.SetFillColor(0);
legend.AddEntry(histogramFakeRate, "Tau id. discr.", "p");
legend.AddEntry(histogramFakeRateWeighted, "Fake-Rate weight", "p");
legend.Draw();
canvas->Update();
canvas->Print(outputFileName.data());
}
void plotter::draw_delta_comparison( TH1* total_, TH1* stat_, std::vector<TH1*> MODEL_DELTA, std::vector<TString> UncertNames, TString category, TString file_name){
TH1* total = (TH1*) total_->Clone();
TH1* stat = (TH1*) stat_->Clone();
std::vector<TH1*> delta;
for(unsigned int i=0; i<MODEL_DELTA.size(); i++){
delta.push_back( (TH1*) MODEL_DELTA[i]->Clone() );
}
TCanvas *c= new TCanvas("c","",600,600);
gPad->SetLeftMargin(0.15);
total->SetTitle("");
total->GetXaxis()->SetTitle("Leading-jet mass [GeV]");
total->GetYaxis()->SetTitle("relative uncertainty [%]");
total->GetYaxis()->SetTitleOffset(1.5);
total->GetYaxis()->SetNdivisions(505);
total->GetYaxis()->SetRangeUser(0, 100);
total->SetFillColor(13);
total->SetFillStyle(3144);
total->SetLineColor(13);
total->SetMarkerStyle(-1);
total->Draw("HIST");
stat->SetLineColor(kBlack);
stat->SetLineWidth(4);
stat->SetMarkerStyle(0);
stat->Draw("B SAME");
Color_t col[] = {kRed-4, kAzure+7, kGreen, 798, kBlue, kOrange-3, kMagenta, kYellow, kAzure, 14, kRed+5, kGreen-8};
int i=0;
for(auto hist: delta){
gPad->SetLeftMargin(0.15);
hist->SetLineColor(col[i]);
hist->SetLineWidth(4);
hist->SetMarkerStyle(0);
hist->Draw("B SAME");
i++;
}
// LEGEND
TLegend *leg = new TLegend(0.4,0.6,0.88,0.88);
leg->SetFillStyle(0);
leg->SetNColumns(2);
if(category == "exp") leg->AddEntry(total, "stat #oplus exp. sys", "f");
else if(category == "model") leg->AddEntry(total, "stat #oplus model sys", "f");
leg->AddEntry(stat, "stat", "l");
for(unsigned int i=0; i<delta.size(); i++){
if (UncertNames[i] == "mass") leg->AddEntry(delta[i],"choice of m_{t}","l");
else if (UncertNames[i] == "stat") leg->AddEntry(delta[i],"statistics","l");
else if (UncertNames[i] == "b-tagging") leg->AddEntry(delta[i],"b tagging","l");
else if (UncertNames[i] == "pile-up") leg->AddEntry(delta[i],"pileup","l");
else if (UncertNames[i] == "jec") leg->AddEntry(delta[i],"jet energy scale","l");
else if (UncertNames[i] == "jer") leg->AddEntry(delta[i],"jet energy resolution","l");
else if (UncertNames[i] == "cor") leg->AddEntry(delta[i],"XCone jet correction","l");
else if (UncertNames[i] == "MuTrigger") leg->AddEntry(delta[i],"muon trigger","l");
else if (UncertNames[i] == "MuID") leg->AddEntry(delta[i],"muon ID","l");
else if (UncertNames[i] == "ElTrigger") leg->AddEntry(delta[i],"electron trigger","l");
else if (UncertNames[i] == "ElID") leg->AddEntry(delta[i],"electron ID","l");
else if (UncertNames[i] == "ElReco") leg->AddEntry(delta[i],"electron reconstruction","l");
else if (UncertNames[i] == "hdamp") leg->AddEntry(delta[i],"h_{damp}","l");
else leg->AddEntry(delta[i],UncertNames[i],"l");
}
leg->Draw();
gPad->RedrawAxis();
c->SaveAs(directory + file_name + ".pdf");
delete c;
}
void check1SLimits(
const char* workDir, // workDir: usual tag where to look for files in Output
const char* lFileName="cLimits_683_NominalABCD_Asym_2SPL_woSyst.csv", // file name to save limits results
bool dosyst = false,
int mode = 1, // mode=0 -> pass, mode=1 -> prompt, mode=2 -> nonprompt
const char* workDirFail=""
)
{
TString slFileName(lFileName);
if ( dosyst && !slFileName.Contains("wSys") )
{
cout << "Comparison requires systematics but limits file does not contain them" << endl;
return;
}
// list of files
set<anabin> thebins = allbins();
const char* ppp = "../Fitter";
// systematic uncertainties for fit
map<anabin, syst> syst_All;
if ( dosyst )
{
if (mode==0) syst_All = readSyst_all_pass("",ppp,workDir);
if (mode==1) syst_All = readSyst_all_prompt("",ppp,workDir,workDirFail);
if (mode==2) syst_All = readSyst_all_nonprompt("",ppp,workDir,workDirFail);
}
// bin edges
float ptmin, ptmax, ymin, ymax, centmin, centmax;
// histo for 1sigma limits checks
TH1* hCL = new TH1D("hOneSigmaCLComparison","",thebins.size(),0,thebins.size());
hCL->GetYaxis()->SetTitle("CL_{1#sigma}/#sigma");
hCL->GetYaxis()->SetTitleOffset(1.15);
hCL->SetStats(0);
hCL->SetDirectory(0);
hCL->SetMarkerColor(1);
hCL->SetMarkerStyle(20);
hCL->SetMarkerSize(1);
hCL->SetLineColor(1);
TLine* l1 = new TLine(0.,1.,hCL->GetXaxis()->GetXmax(),1.);
l1->SetLineWidth(3);
hCL->GetListOfFunctions()->Add(l1);
map<anabin,limits> maplim = readLimits(Form("csv/%s",slFileName.Data()));
int cnt=1;
for (set<anabin>::const_iterator it=thebins.begin(); it!=thebins.end(); it++)
{
cout << "Checking 1 sigma limits for analysis bin " << cnt << endl;
anabin thebin = *it;
ptmin = thebin.ptbin().low();
ptmax = thebin.ptbin().high();
ymin = thebin.rapbin().low();
ymax = thebin.rapbin().high();
centmin = thebin.centbin().low();
centmax = thebin.centbin().high();
double sigmaDoubleR = 0;
double doubleR = 0;
if (mode==0) {
doubleR = doubleratio_pass_nominal(workDir,thebin,ppp);
sigmaDoubleR = doubleratio_pass_stat(workDir,thebin,ppp);
}
if (mode==1) {
doubleR = doubleratio_prompt_nominal(workDir,workDirFail,thebin,ppp);
sigmaDoubleR = doubleratio_prompt_stat(workDir,workDirFail,thebin,ppp);
}
if (mode==2) {
doubleR = doubleratio_nonprompt_nominal(workDir,workDirFail,thebin,ppp);
sigmaDoubleR = doubleratio_nonprompt_stat(workDir,workDirFail,thebin,ppp);
}
double systAll=0;
if ( dosyst )
{
systAll = syst_All[thebin].value_dR;
sigmaDoubleR = sqrt(pow(sigmaDoubleR,2)+pow(systAll,2));
}
limits lim = maplim[thebin];
TString binName(Form("Pt[%.1f,%.1f]-Y[%.1f,%.1f]-C[%.1f,%.1f]",ptmin,ptmax,ymin,ymax,centmin,centmax));
double comp = -1.;
if ( sigmaDoubleR != 0 ) comp = (lim.val.second-lim.val.first)/(2.*sigmaDoubleR);
hCL->SetBinContent(cnt,comp);
hCL->GetXaxis()->SetBinLabel(cnt,binName.Data());
cnt++;
} // loop on the files
TFile* fSave = new TFile("oneSigmaCLComparison.root","RECREATE");
TCanvas* c = new TCanvas("cOneSigmaCLComparison","",90,116,1265,535);
c->Range(-3.690909,-0.01066472,33.30606,0.01252061);
c->SetFillColor(0);
c->SetBorderMode(0);
c->SetBorderSize(2);
c->SetRightMargin(0.1163896);
c->SetTopMargin(0.03732809);
c->SetBottomMargin(0.1630648);
c->SetFrameBorderMode(0);
c->SetFrameBorderMode(0);
gPad->SetGridx();
gPad->SetGridy();
hCL->Draw("p");
c->Write("cOneSigmaCLComparison", TObject::kOverwrite | TObject::kSingleKey);
fSave->Close(); delete fSave;
}
TH1 *
UnfoldMe(Char_t *data, Char_t *mc, Char_t *anatag, Int_t bin, Bool_t useMBcorr = kTRUE, Bool_t usecorrfit = kFALSE, Bool_t ismc = kFALSE, Float_t smooth = 0.001, Int_t iter = 50, Int_t regul = AliUnfolding::kPowerLaw, Float_t weight = 100., Bool_t bayesian = kTRUE, Int_t nloop = 1)
{
if (ismc)
TFile *fdt = TFile::Open(data);
else
TFile *fdt = TFile::Open(data);
TFile *fmc = TFile::Open(mc);
TList *ldt = (TList *)fdt->Get(Form("clist_%s", anatag));
TList *lmc = (TList *)fmc->Get(Form("clist_%s", anatag));
TH2 *hmatdt = (TH2 *)ldt->FindObject(Form("b%d_corrMatrix", bin));
if (useMBcorr)
TH2 *hmatmc = (TH2 *)lmc->FindObject("effMatrix");
else
TH2 *hmatmc = (TH2 *)lmc->FindObject(Form("b%d_corrMatrix", bin));
TH1 *hdata = hmatdt->ProjectionY("hdata");
hdata->Sumw2();
hdata->SetBinContent(1, 0.);
hdata->SetBinError(1, 0.);
// hdata->Scale(1. / hdata->Integral());
hdata->SetMarkerStyle(25);
TH1 *htrue = hmatdt->ProjectionX("htrue");
htrue->Sumw2();
// htrue->Scale(1. / htrue->Integral());
htrue->SetMarkerStyle(7);
htrue->SetMarkerColor(2);
htrue->SetBinContent(1, 0.);
htrue->SetBinError(1, 0.);
TH2 *hcorr = (TH2 *)hmatmc->Clone("hcorr");
TH1 *hinit = (TH1 *)hdata->Clone("hinit");
TH1 *hresu = (TH1 *)hdata->Clone("hresu");
TH1 *hbias = (TH1 *)hdata->Clone("hbias");
hresu->SetMarkerStyle(20);
hresu->SetMarkerColor(4);
hresu->Reset();
TH1 *hnum = hcorr->ProjectionY("hnum");
TH1 *hden = hcorr->ProjectionY("hden");
TH1 *heff = hcorr->ProjectionY("heff");
hnum->Reset();
hnum->Sumw2();
hden->Reset();
hden->Sumw2();
heff->Reset();
for (Int_t i = 0; i < heff->GetNbinsX(); i++) {
Float_t int1 = hcorr->Integral(i + 1, i + 1, 0, -1);
if (int1 <= 0.) continue;
Float_t int2 = hcorr->Integral(i + 1, i + 1, 2, -1);
hnum->SetBinContent(i + 1, int2);
hnum->SetBinError(i + 1, TMath::Sqrt(int2));
hden->SetBinContent(i + 1, int1);
hden->SetBinError(i + 1, TMath::Sqrt(int1));
}
new TCanvas("cEfficiency");
heff->Divide(hnum, hden, 1., 1., "B");
heff->Draw();
#if 0
for (Int_t ii = 0; ii < heff->GetNbinsX(); ii++) {
heff->SetBinContent(ii + 1, 1.);
heff->SetBinError(ii + 1, 0.);
}
#endif
for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) {
hcorr->SetBinContent(i + 1, 1, 0.);
hcorr->SetBinError(i + 1, 1, 0.);
}
for (Int_t i = 0; i < hcorr->GetNbinsY(); i++) {
hcorr->SetBinContent(1, i + 1, 0.);
hcorr->SetBinError(1, i + 1, 0.);
}
TH2 *hcorrfit = ReturnCorrFromFit(hcorr);
for (Int_t iloop = 0; iloop < nloop; iloop++) {
if (bayesian) {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kBayesian);
AliUnfolding::SetBayesianParameters(smooth, iter);
} else {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kChi2Minimization);
AliUnfolding::SetChi2Regularization(regul, weight);
}
AliUnfolding::SetSkip0BinInChi2(kTRUE);
AliUnfolding::SetSkipBinsBegin(1);
AliUnfolding::SetNbins(150, 150);
AliUnfolding::Unfold(usecorrfit ? hcorrfit : hcorr, heff, hdata, hinit, hresu);
hinit = (TH1 *)hresu->Clone(Form("hinit_%d", iloop));
}
printf("hdata->Integral(2, -1) = %f\n", hdata->Integral(2, -1));
printf("hresu->Integral(2, -1) = %f\n", hresu->Integral(2, -1));
TCanvas *cUnfolded = new TCanvas ("cUnfolded", "", 400, 800);
cUnfolded->Divide(1, 2);
cUnfolded->cd(1)->SetLogx();
cUnfolded->cd(1)->SetLogy();
hdata->Draw();
hresu->Draw("same");
htrue->Draw("same");
cUnfolded->cd(2)->SetLogx();
cUnfolded->cd(2)->DrawFrame(1., 0.75, 300., 1.25);
TH1 *hrat = (TH1 *)hresu->Clone("hrat");
hrat->Divide(htrue);
hrat->Draw("same");
TH1 *htrig = (TH1 *)hresu->Clone("htrig");
htrig->Multiply(heff);
Float_t dndeta_resu = 0.;
Float_t integr_resu = 0.;
Float_t dndeta_trig = 0.;
Float_t integr_trig = 0.;
for (Int_t i = 1; i < hresu->GetNbinsX(); i++) {
dndeta_resu += hresu->GetBinContent(i + 1) * hresu->GetBinLowEdge(i + 1);
integr_resu += hresu->GetBinContent(i + 1);
dndeta_trig += htrig->GetBinContent(i + 1) * htrig->GetBinLowEdge(i + 1);
integr_trig += htrig->GetBinContent(i + 1);
}
// dndeta_resu /= integr_resu;
// dndeta_trig /= integr_trig;
integr_eff = integr_trig / integr_resu;
integr_eff_err = TMath::Sqrt(integr_eff * (1. - integr_eff) / integr_resu);
dndeta_eff = dndeta_trig / dndeta_resu;
dndeta_eff_err = TMath::Sqrt(dndeta_eff * (1. - dndeta_eff) / dndeta_resu);
printf("INEL > 0 efficiency: %.3f +- %.3f\n", integr_eff, integr_eff_err);
printf("dN/dEta correction: %.3f +- %.3f\n", dndeta_eff, dndeta_eff_err);
return hresu;
}
void dNdEta_ThreeMethods_FullTrackingRebinned_DividedByMidRapidValue() {
//=========Macro generated from canvas: MyCanvas/MyCanvas
//========= (Thu Dec 10 11:52:00 2009) by ROOT version5.22/00d
gROOT->Reset();
gROOT->ProcessLine(".x rootlogon.C");
gStyle->SetTitleYOffset(1.4);
TCanvas *MyCanvas = new TCanvas("MyCanvas", "Final result",1,360,550,600);
TH1 *corr_result_all = new TH1D("corr_result_all","",14,-3.5,3.5);
corr_result_all->GetXaxis()->SetRange(2,13);
// ========================= Cluster Counting =======================
corr_result_all->SetBinContent(4,4.043821); // -2.0 to -1.5
corr_result_all->SetBinContent(5,3.821537); // -1.5 to -1.0
corr_result_all->SetBinContent(6,3.611029); // -1.0 to -0.5
corr_result_all->SetBinContent(7,3.501129); // -0.5 to 0.0
corr_result_all->SetBinContent(8,3.51732);
corr_result_all->SetBinContent(9,3.632249);
corr_result_all->SetBinContent(10,3.747706);
corr_result_all->SetBinContent(11,4.01596);
corr_result_all->SetBinError(4,0.177928124);
corr_result_all->SetBinError(5,0.168147628);
corr_result_all->SetBinError(6,0.158885276);
corr_result_all->SetBinError(7,0.154049676);
corr_result_all->SetBinError(8,0.15476208);
corr_result_all->SetBinError(9,0.159818956);
corr_result_all->SetBinError(10,0.164899064);
corr_result_all->SetBinError(11,0.17670224);
/*
corr_result_all->SetBinContent(4,3.954); // -2.0 to -1.5
corr_result_all->SetBinContent(5,3.770); // -1.5 to -1.0
corr_result_all->SetBinContent(6,3.607); // -1.0 to -0.5
corr_result_all->SetBinContent(7,3.548); // -0.5 to 0.0
corr_result_all->SetBinContent(8,3.567);
corr_result_all->SetBinContent(9,3.681);
corr_result_all->SetBinContent(10,3.791);
corr_result_all->SetBinContent(11,4.025);
corr_result_all->SetBinError(4,0.1779);
corr_result_all->SetBinError(5,0.1697);
corr_result_all->SetBinError(6,0.1623);
corr_result_all->SetBinError(7,0.1597);
corr_result_all->SetBinError(8,0.1605);
corr_result_all->SetBinError(9,0.1657);
corr_result_all->SetBinError(10,0.1706);
corr_result_all->SetBinError(11,0.1811);
*/
corr_result_all->SetMarkerStyle(20);
//corr_result_all->SetMarkerSize(1.5); // use rootlogon size
corr_result_all->SetMarkerColor(kRed);
corr_result_all->SetLineColor(2);
corr_result_all->GetYaxis()->SetTitle("dN_{ch}/d#eta/dN_{ch,mid}/d#eta");
corr_result_all->GetXaxis()->SetTitle("#eta");
corr_result_all->GetXaxis()->CenterTitle();
corr_result_all->GetYaxis()->CenterTitle();
corr_result_all->GetXaxis()->SetNdivisions(405);
//corr_result_all->GetYaxis()->SetNdivisions(1005);
corr_result_all->GetYaxis()->SetNdivisions(506);
Float_t midrapid = 0.5*(corr_result_all->GetBinContent(7)+corr_result_all->GetBinContent(8));
cout<<"mid rapid value = "<<midrapid<<endl;
corr_result_all->Scale(1/midrapid);
corr_result_all->SetMinimum(0.95);
corr_result_all->SetMaximum(1.3);
corr_result_all->Draw("pz");
// ======= YJ Tracklet three layer combination averaged (updated with dead modules..) ======
// 1 2 3 4 5 6 7 8 9 10 11 12
Double_t xAxis5[13] = {-3, -2.5, -2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3};
TH1 *hMeasuredFinal = new TH1D("hMeasuredFinal","",12, xAxis5);
hMeasuredFinal->SetBinContent(3,3.7459);
hMeasuredFinal->SetBinContent(4,3.65462);
hMeasuredFinal->SetBinContent(5,3.55475);
hMeasuredFinal->SetBinContent(6,3.45008);
hMeasuredFinal->SetBinContent(7,3.44329);
hMeasuredFinal->SetBinContent(8,3.5244);
hMeasuredFinal->SetBinContent(9,3.59575);
hMeasuredFinal->SetBinContent(10,3.6612);
hMeasuredFinal->SetBinError(3,0.142344);
hMeasuredFinal->SetBinError(4,0.138876);
hMeasuredFinal->SetBinError(5,0.13508);
hMeasuredFinal->SetBinError(6,0.131103);
hMeasuredFinal->SetBinError(7,0.130845);
hMeasuredFinal->SetBinError(8,0.133927);
hMeasuredFinal->SetBinError(9,0.136638);
hMeasuredFinal->SetBinError(10,0.139126);
hMeasuredFinal->SetMarkerColor(kBlue);
hMeasuredFinal->SetLineColor(4);
hMeasuredFinal->SetMarkerStyle(21);
//hMeasuredFinal->SetMarkerSize(1.5); // use rootlogon size
midrapid = 0.5*(hMeasuredFinal->GetBinContent(6)+hMeasuredFinal->GetBinContent(7));
cout<<"mid rapid value = "<<midrapid<<endl;
hMeasuredFinal->Scale(1/midrapid);
hMeasuredFinal->Draw("pzsame");
/// ==================================================== Ferenc's dN/dEta (rebinned)
Double_t xAxis6[13] = {-3, -2.5, -2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3};
TH1 *hMeasuredFinal2 = new TH1D("hMeasuredFinal2","",12, xAxis6);
// Hight Stat
hMeasuredFinal2->SetBinContent(2,3.65413);
hMeasuredFinal2->SetBinContent(3,3.68883);
hMeasuredFinal2->SetBinContent(4,3.73805);
hMeasuredFinal2->SetBinContent(5,3.62817);
hMeasuredFinal2->SetBinContent(6,3.52704);
hMeasuredFinal2->SetBinContent(7,3.47443);
hMeasuredFinal2->SetBinContent(8,3.63319);
hMeasuredFinal2->SetBinContent(9,3.7577);
hMeasuredFinal2->SetBinContent(10,3.67975);
hMeasuredFinal2->SetBinContent(11,3.65413);
// Systematic error of 3.1% --> to 2.4%
hMeasuredFinal2->SetBinError(2,0.08769912);
hMeasuredFinal2->SetBinError(3,0.08853192);
hMeasuredFinal2->SetBinError(4,0.0897132);
hMeasuredFinal2->SetBinError(5,0.08707608);
hMeasuredFinal2->SetBinError(6,0.08464896);
hMeasuredFinal2->SetBinError(7,0.08338632);
hMeasuredFinal2->SetBinError(8,0.08719656);
hMeasuredFinal2->SetBinError(9,0.0901848);
hMeasuredFinal2->SetBinError(10,0.088314);
hMeasuredFinal2->SetBinError(11,0.08769912);
/*
// Systematic error of 3.1% --> to 2.3%
hMeasuredFinal2->SetBinError(2,0.084045);
hMeasuredFinal2->SetBinError(3,0.0848431);
hMeasuredFinal2->SetBinError(4,0.0859752);
hMeasuredFinal2->SetBinError(5,0.0834479);
hMeasuredFinal2->SetBinError(6,0.0811219);
hMeasuredFinal2->SetBinError(7,0.0799119);
hMeasuredFinal2->SetBinError(8,0.0835634);
hMeasuredFinal2->SetBinError(9,0.0864271);
hMeasuredFinal2->SetBinError(10,0.0846342);
hMeasuredFinal2->SetBinError(11,0.084045);
*/
hMeasuredFinal2->SetMarkerColor(kBlack);
hMeasuredFinal2->SetLineColor(1);
hMeasuredFinal2->SetMarkerStyle(22);
//hMeasuredFinal2->SetMarkerSize(1.5); use root logon size
midrapid = 0.5*(hMeasuredFinal2->GetBinContent(6)+hMeasuredFinal2->GetBinContent(7));
cout<<"mid rapid value = "<<midrapid<<endl;
hMeasuredFinal2->Scale(1/midrapid);
hMeasuredFinal2->Draw("pzsame");
// ================== 2.36 TeV
// ========================= Cluster Counting =======================
TH1 *corr_result_all236 = new TH1D("corr_result_all236","",14,-3.5,3.5);
corr_result_all236->GetXaxis()->SetRange(2,13);
corr_result_all236->SetBinContent(4,5.203552);
corr_result_all236->SetBinContent(5,4.913457);
corr_result_all236->SetBinContent(6,4.710017);
corr_result_all236->SetBinContent(7,4.44485);
corr_result_all236->SetBinContent(8,4.448675);
corr_result_all236->SetBinContent(9,4.659581);
corr_result_all236->SetBinContent(10,4.856712);
corr_result_all236->SetBinContent(11,5.065867);
corr_result_all236->SetBinError(4,0.23416);
corr_result_all236->SetBinError(5,0.221106);
corr_result_all236->SetBinError(6,0.211951);
corr_result_all236->SetBinError(7,0.200018);
corr_result_all236->SetBinError(8,0.20019);
corr_result_all236->SetBinError(9,0.209681);
corr_result_all236->SetBinError(10,0.218552);
corr_result_all236->SetBinError(11,0.227964);
corr_result_all236->SetMarkerColor(kRed);
corr_result_all236->SetLineColor(2);
corr_result_all236->SetMarkerStyle(24);
midrapid = 0.5*(corr_result_all236->GetBinContent(7)+corr_result_all236->GetBinContent(8));
cout<<"mid rapid value = "<<midrapid<<endl;
corr_result_all236->Scale(1./midrapid);
corr_result_all236->Draw("pzsame");
/// ==================================================== Yenjie 2.36 TeV
// 1 2 3 4 5 6 7 8 9 10 11 12
TH1 *hTracklet236 = new TH1D("hTracklet236","",12, xAxis5);
hTracklet236->SetBinContent(3,4.73663);
hTracklet236->SetBinContent(4,4.69978);
hTracklet236->SetBinContent(5,4.61061);
hTracklet236->SetBinContent(6,4.40814);
hTracklet236->SetBinContent(7,4.38437);
hTracklet236->SetBinContent(8,4.51905);
hTracklet236->SetBinContent(9,4.6502);
hTracklet236->SetBinContent(10,4.80977);
// 4.8 % Systematic Error
hTracklet236->SetBinError(3,0.179992);
hTracklet236->SetBinError(4,0.178592);
hTracklet236->SetBinError(5,0.175203);
hTracklet236->SetBinError(6,0.167509);
hTracklet236->SetBinError(7,0.166606);
hTracklet236->SetBinError(8,0.171724);
hTracklet236->SetBinError(9,0.176707);
hTracklet236->SetBinError(10,0.182771);
hTracklet236->SetMarkerColor(4);
hTracklet236->SetLineColor(4);
hTracklet236->SetMarkerStyle(kOpenSquare);
//hTracklet236->SetMarkerSize(1.5); // use rootlogon size
midrapid = 0.5*(hTracklet236->GetBinContent(6)+hTracklet236->GetBinContent(7));
cout<<"mid rapid value = "<<midrapid<<endl;
hTracklet236->Scale(1./midrapid);
hTracklet236->Draw("pzsame");
/// ==================================================== Ferenc's dN/dEta (rebinned)
Double_t xAxis7[13] = {-3, -2.5, -2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3};
TH1 *hMeasuredFinal2236 = new TH1D("hMeasuredFinal2","",12, xAxis7);
hMeasuredFinal2236->SetBinContent(2,4.9689);
hMeasuredFinal2236->SetBinContent(3,4.93581);
hMeasuredFinal2236->SetBinContent(4,4.67197);
hMeasuredFinal2236->SetBinContent(5,4.70044);
hMeasuredFinal2236->SetBinContent(6,4.52142);
hMeasuredFinal2236->SetBinContent(7,4.55674);
hMeasuredFinal2236->SetBinContent(8,4.61255);
hMeasuredFinal2236->SetBinContent(9,4.67611);
hMeasuredFinal2236->SetBinContent(10,4.87402);
hMeasuredFinal2236->SetBinContent(11,4.96891);
// Systematic error of 3.1% --> 2.3%
hMeasuredFinal2236->SetBinError(2,0.114285);
hMeasuredFinal2236->SetBinError(3,0.113524);
hMeasuredFinal2236->SetBinError(4,0.107455);
hMeasuredFinal2236->SetBinError(5,0.10811);
hMeasuredFinal2236->SetBinError(6,0.103993);
hMeasuredFinal2236->SetBinError(7,0.104805);
hMeasuredFinal2236->SetBinError(8,0.106089);
hMeasuredFinal2236->SetBinError(9,0.107551);
hMeasuredFinal2236->SetBinError(10,0.112102);
hMeasuredFinal2236->SetBinError(11,0.114285);
hMeasuredFinal2236->SetMarkerColor(kBlack);
hMeasuredFinal2236->SetLineColor(1);
hMeasuredFinal2236->SetMarkerStyle(26);
//hMeasuredFinal2->SetMarkerSize(1.5); use root logon size
midrapid = 0.5*(hMeasuredFinal2236->GetBinContent(6)+hMeasuredFinal2236->GetBinContent(7));
cout<<"mid rapid value = "<<midrapid<<endl;
hMeasuredFinal2236->Scale(1./midrapid);
//hMeasuredFinal2236->Scale(1/4.53908);
hMeasuredFinal2236->Draw("pzsame");
/// ==================================================== UA5 Data
TH1F* hEta_UA5_NSD = new TH1F("hEta_UA5_NSD",";#eta;dN/d#eta",50,-3,3);
// positive eta
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(0.125),3.48);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(0.375),3.38);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(0.625),3.52);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(0.875),3.68);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(1.125),3.71);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(1.375),3.86);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(1.625),3.76);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(1.875),3.66);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(2.125),3.72);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(2.375),3.69);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(2.625),3.56);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(2.875),3.41);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(3.125),3.15);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(0.125),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(0.375),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(0.625),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(0.875),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(1.125),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(1.375),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(1.625),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(1.875),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(2.125),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(2.375),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(2.625),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(2.875),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(3.125),0.07);
//negative eta
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-0.125),3.48);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-0.375),3.38);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-0.625),3.52);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-0.875),3.68);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-1.125),3.71);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-1.375),3.86);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-1.625),3.76);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-1.875),3.66);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-2.125),3.72);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-2.375),3.69);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-2.625),3.56);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-2.875),3.41);
hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-3.125),3.15);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-0.125),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-0.375),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-0.625),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-0.875),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-1.125),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-1.375),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-1.625),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-1.875),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-2.125),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-2.375),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-2.625),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-2.875),0.07);
hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-3.125),0.07);
hEta_UA5_NSD->SetMarkerStyle(25);
hEta_UA5_NSD->SetMarkerSize(1.0);
//hEta_UA5_NSD->Draw("psame");
//TLegend *leg = new TLegend(0.20,0.27,0.53,0.47,NULL,"brNDC");
//TLegend *leg = new TLegend(0.20,0.35,0.53,0.47,NULL,"brNDC");
Float_t ywidth = 0.045*4;
//TLegend *leg = new TLegend(0.27,0.26,0.70,0.26+ywidth,NULL,"brNDC");
//TLegend *leg = new TLegend(0.39,0.21,0.82,0.21+ywidth,NULL,"brNDC");
TLegend *leg = new TLegend(0.45,0.753,0.892,0.93,NULL,"brNDC");
//leg->SetNColumns(2);
leg->SetBorderSize(0);
leg->SetMargin(0.5);
leg->SetTextFont(62);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetTextSize(0.03);
leg->SetHeader(" 2.36 TeV");
leg->AddEntry(corr_result_all236,"Hit counting","P");
leg->AddEntry(hTracklet236,"Tracklet","P");
leg->AddEntry(hMeasuredFinal2236,"Global tracking","P");
//cout<<"Number of column "<<leg->GetNColumns()<<endl;
/*
leg->AddEntry(corr_result_all236,"","P");
leg->AddEntry(hTracklet236,"","P");
leg->AddEntry(hMeasuredFinal2236,"","P");
*/
//TLegend *leg2 = new TLegend(0.20,0.22,0.53,0.35,NULL,"brNDC");
//TLegend *leg2 = new TLegend(0.50,0.26,0.93,0.47,NULL,"brNDC");
//TLegend *leg2 = new TLegend(0.39,0.26,0.82,0.26+ywidth,NULL,"brNDC");
//TLegend *leg2 = new TLegend(0.27,0.21,0.70,0.21+ywidth,NULL,"brNDC");
TLegend *leg2 = new TLegend(0.35,0.75,0.782,0.932,NULL,"brNDC");
leg2->SetMargin(0.37);
leg2->SetBorderSize(0);
leg2->SetTextFont(62);
leg2->SetLineColor(1);
leg2->SetLineStyle(1);
leg2->SetLineWidth(1);
leg2->SetFillColor(0);
//leg2->SetFillStyle(1001);
leg2->SetFillStyle(0);
leg2->SetTextSize(0.03);
leg2->SetHeader(" 0.9 TeV");
leg2->AddEntry(corr_result_all,"","P");
leg2->AddEntry(hMeasuredFinal,"","P");
leg2->AddEntry(hMeasuredFinal2,"","P");
leg->Draw();
leg2->Draw();
printFinalCanvases(MyCanvas,"dNdeta_ThreeMethods_Divided",0,2);
}
// input: - Input file (result from TMVA)
// - use of TMVA plotting TStyle
void mvas( TString fin = "TMVA.root", HistType htype = MVAType, Bool_t useTMVAStyle = kTRUE )
{
// set style and remove existing canvas'
TMVAGlob::Initialize( useTMVAStyle );
// switches
const Bool_t Save_Images = kTRUE;
// checks if file with name "fin" is already open, and if not opens one
TFile* file = TMVAGlob::OpenFile( fin );
// define Canvas layout here!
Int_t xPad = 1; // no of plots in x
Int_t yPad = 1; // no of plots in y
Int_t noPad = xPad * yPad ;
const Int_t width = 600; // size of canvas
// this defines how many canvases we need
TCanvas *c = 0;
// counter variables
Int_t countCanvas = 0;
// search for the right histograms in full list of keys
TIter next(file->GetListOfKeys());
TKey *key(0);
while ((key = (TKey*)next())) {
if (!TString(key->GetName()).BeginsWith("Method_")) continue;
if( ! gROOT->GetClass(key->GetClassName())->InheritsFrom("TDirectory") ) continue;
TString methodName;
TMVAGlob::GetMethodName(methodName,key);
TDirectory* mDir = (TDirectory*)key->ReadObj();
TIter keyIt(mDir->GetListOfKeys());
TKey *titkey;
while ((titkey = (TKey*)keyIt())) {
if (!gROOT->GetClass(titkey->GetClassName())->InheritsFrom("TDirectory")) continue;
TDirectory *titDir = (TDirectory *)titkey->ReadObj();
TString methodTitle;
TMVAGlob::GetMethodTitle(methodTitle,titDir);
cout << "--- Found directory for method: " << methodName << "::" << methodTitle << flush;
TString hname = "MVA_" + methodTitle;
if (htype == ProbaType ) hname += "_Proba";
else if (htype == RarityType ) hname += "_Rarity";
TH1* sig = dynamic_cast<TH1*>(titDir->Get( hname + "_S" ));
TH1* bgd = dynamic_cast<TH1*>(titDir->Get( hname + "_B" ));
if (sig==0 || bgd==0) {
if (htype == MVAType)
cout << "mva distribution not available (this is normal for Cut classifier)" << endl;
else if(htype == ProbaType)
cout << "probability distribution not available (this is normal for Cut classifier)" << endl;
else if(htype == RarityType)
cout << "rarity distribution not available (this is normal for Cut classifier)" << endl;
else if(htype == CompareType)
cout << "overtraining check not available (this is normal for Cut classifier)" << endl;
else cout << endl;
}
else {
cout << endl;
// chop off useless stuff
sig->SetTitle( Form("TMVA response for classifier: %s", methodTitle.Data()) );
if (htype == ProbaType)
sig->SetTitle( Form("TMVA probability for classifier: %s", methodTitle.Data()) );
else if (htype == RarityType)
sig->SetTitle( Form("TMVA Rarity for classifier: %s", methodTitle.Data()) );
else if (htype == CompareType)
sig->SetTitle( Form("TMVA overtraining check for classifier: %s", methodTitle.Data()) );
// create new canvas
TString ctitle = ((htype == MVAType) ?
Form("TMVA response %s",methodTitle.Data()) :
(htype == ProbaType) ?
Form("TMVA probability %s",methodTitle.Data()) :
(htype == CompareType) ?
Form("TMVA comparison %s",methodTitle.Data()) :
Form("TMVA Rarity %s",methodTitle.Data()));
TString cname = ((htype == MVAType) ?
Form("output_%s",methodTitle.Data()) :
(htype == ProbaType) ?
Form("probability_%s",methodTitle.Data()) :
(htype == CompareType) ?
Form("comparison_%s",methodTitle.Data()) :
Form("rarity_%s",methodTitle.Data()));
c = new TCanvas( Form("canvas%d", countCanvas+1), ctitle,
countCanvas*50+200, countCanvas*20, width, (Int_t)width*0.78 );
// set the histogram style
TMVAGlob::SetSignalAndBackgroundStyle( sig, bgd );
// normalise both signal and background
TMVAGlob::NormalizeHists( sig, bgd );
// frame limits (choose judicuous x range)
Float_t nrms = 4;
cout << "--- Mean and RMS (S): " << sig->GetMean() << ", " << sig->GetRMS() << endl;
cout << "--- Mean and RMS (B): " << bgd->GetMean() << ", " << bgd->GetRMS() << endl;
Float_t xmin = TMath::Max( TMath::Min(sig->GetMean() - nrms*sig->GetRMS(),
bgd->GetMean() - nrms*bgd->GetRMS() ),
sig->GetXaxis()->GetXmin() );
Float_t xmax = TMath::Min( TMath::Max(sig->GetMean() + nrms*sig->GetRMS(),
bgd->GetMean() + nrms*bgd->GetRMS() ),
sig->GetXaxis()->GetXmax() );
Float_t ymin = 0;
Float_t maxMult = (htype == CompareType) ? 1.3 : 1.2;
Float_t ymax = TMath::Max( sig->GetMaximum(), bgd->GetMaximum() )*maxMult;
// build a frame
Int_t nb = 500;
TString hFrameName(TString("frame") + methodTitle);
TObject *o = gROOT->FindObject(hFrameName);
if(o) delete o;
TH2F* frame = new TH2F( hFrameName, sig->GetTitle(),
nb, xmin, xmax, nb, ymin, ymax );
frame->GetXaxis()->SetTitle( methodTitle + ((htype == MVAType || htype == CompareType) ? " response" : "") );
if (htype == ProbaType ) frame->GetXaxis()->SetTitle( "Signal probability" );
else if (htype == RarityType ) frame->GetXaxis()->SetTitle( "Signal rarity" );
frame->GetYaxis()->SetTitle("Normalized");
TMVAGlob::SetFrameStyle( frame );
// eventually: draw the frame
frame->Draw();
c->GetPad(0)->SetLeftMargin( 0.105 );
frame->GetYaxis()->SetTitleOffset( 1.2 );
// Draw legend
TLegend *legend= new TLegend( c->GetLeftMargin(), 1 - c->GetTopMargin() - 0.12,
c->GetLeftMargin() + (htype == CompareType ? 0.40 : 0.3), 1 - c->GetTopMargin() );
legend->SetFillStyle( 1 );
legend->AddEntry(sig,TString("Signal") + ((htype == CompareType) ? " (test sample)" : ""), "F");
legend->AddEntry(bgd,TString("Background") + ((htype == CompareType) ? " (test sample)" : ""), "F");
legend->SetBorderSize(1);
legend->SetMargin( (htype == CompareType ? 0.2 : 0.3) );
legend->Draw("same");
// overlay signal and background histograms
sig->Draw("samehist");
bgd->Draw("samehist");
if (htype == CompareType) {
// if overtraining check, load additional histograms
TH1* sigOv = 0;
TH1* bgdOv = 0;
TString ovname = hname += "_Train";
sigOv = dynamic_cast<TH1*>(titDir->Get( ovname + "_S" ));
bgdOv = dynamic_cast<TH1*>(titDir->Get( ovname + "_B" ));
if (sigOv == 0 || bgdOv == 0) {
cout << "+++ Problem in \"mvas.C\": overtraining check histograms do not exist" << endl;
}
else {
cout << "--- Found comparison histograms for overtraining check" << endl;
TLegend *legend2= new TLegend( 1 - c->GetRightMargin() - 0.42, 1 - c->GetTopMargin() - 0.12,
1 - c->GetRightMargin(), 1 - c->GetTopMargin() );
legend2->SetFillStyle( 1 );
legend2->SetBorderSize(1);
legend2->AddEntry(sigOv,"Signal (training sample)","P");
legend2->AddEntry(bgdOv,"Background (training sample)","P");
legend2->SetMargin( 0.1 );
legend2->Draw("same");
}
Int_t col = sig->GetLineColor();
sigOv->SetMarkerColor( col );
sigOv->SetMarkerSize( 0.7 );
sigOv->SetMarkerStyle( 20 );
sigOv->SetLineWidth( 1 );
sigOv->SetLineColor( col );
sigOv->Draw("e1same");
col = bgd->GetLineColor();
bgdOv->SetMarkerColor( col );
bgdOv->SetMarkerSize( 0.7 );
bgdOv->SetMarkerStyle( 20 );
bgdOv->SetLineWidth( 1 );
bgdOv->SetLineColor( col );
bgdOv->Draw("e1same");
ymax = TMath::Max( ymax, TMath::Max( sigOv->GetMaximum(), bgdOv->GetMaximum() )*maxMult );
frame->GetYaxis()->SetLimits( 0, ymax );
// for better visibility, plot thinner lines
sig->SetLineWidth( 1 );
bgd->SetLineWidth( 1 );
// perform K-S test
cout << "--- Perform Kolmogorov-Smirnov tests" << endl;
Double_t kolS = sig->KolmogorovTest( sigOv );
Double_t kolB = bgd->KolmogorovTest( bgdOv );
cout << "--- Goodness of signal (background) consistency: " << kolS << " (" << kolB << ")" << endl;
TString probatext = Form( "Kolmogorov-Smirnov test: signal (background) probability = %5.3g (%5.3g)", kolS, kolB );
TText* tt = new TText( 0.12, 0.74, probatext );
tt->SetNDC(); tt->SetTextSize( 0.032 ); tt->AppendPad();
}
// redraw axes
frame->Draw("sameaxis");
// text for overflows
Int_t nbin = sig->GetNbinsX();
Double_t dxu = sig->GetBinWidth(0);
Double_t dxo = sig->GetBinWidth(nbin+1);
TString uoflow = Form( "U/O-flow (S,B): (%.1f, %.1f)%% / (%.1f, %.1f)%%",
sig->GetBinContent(0)*dxu*100, bgd->GetBinContent(0)*dxu*100,
sig->GetBinContent(nbin+1)*dxo*100, bgd->GetBinContent(nbin+1)*dxo*100 );
TText* t = new TText( 0.975, 0.115, uoflow );
t->SetNDC();
t->SetTextSize( 0.030 );
t->SetTextAngle( 90 );
t->AppendPad();
// update canvas
c->Update();
// save canvas to file
TMVAGlob::plot_logo(1.058);
if (Save_Images) {
if (htype == MVAType) TMVAGlob::imgconv( c, Form("plots/mva_%s", methodTitle.Data()) );
else if (htype == ProbaType) TMVAGlob::imgconv( c, Form("plots/proba_%s", methodTitle.Data()) );
else if (htype == CompareType) TMVAGlob::imgconv( c, Form("plots/overtrain_%s", methodTitle.Data()) );
else TMVAGlob::imgconv( c, Form("plots/rarity_%s", methodTitle.Data()) );
}
countCanvas++;
}
}
}
}
void QAtracklets(const Char_t *fdata, const Char_t *fmc)
{
style();
TFile *fdtin = TFile::Open(fdata);
TList *ldtin = (TList *)fdtin->Get("clist");
TH2 *hdtin = (TH2 *)ldtin->FindObject("etaphiTracklets");
TH1 *pdtin = (TH1 *)hdtin->ProjectionY("pdtin_tracklets");
pdtin->SetMarkerStyle(20);
pdtin->SetMarkerSize(1.);
pdtin->SetMarkerColor(kAzure-3);
hdtin->Scale(1. / hdtin->GetEntries());
pdtin->Scale(1. / hdtin->GetEntries());
TFile *fmcin = TFile::Open(fmc);
TList *lmcin = (TList *)fmcin->Get("clist");
if(!lmcin) {
std::cout << "NOLIST" << std::endl;
}
lmcin->ls();
TH2 *hmcin = (TH2 *)lmcin->FindObject("etaphiTracklets");
if(!hmcin) {
std::cout << "NO H!! etaphiTracklets" << std::endl;
}
TH1 *pmcin = (TH1 *)hmcin->ProjectionY("pmcin_tracklets");
pmcin->SetLineColor(kRed+1);
pmcin->SetFillStyle(1001);
pmcin->SetFillColorAlpha(kRed+1, 0.1);
hmcin->Scale(1. / hmcin->GetEntries());
pmcin->Scale(1. / hmcin->GetEntries());
/*
pdtin->Scale(pmcin->Integral(pmcin->FindBin(0. + 0.001),
pmcin->FindBin(1. - 0.001))
/ pdtin->Integral(pdtin->FindBin(0. + 0.001),
pdtin->FindBin(1. - 0.001)));
*/
TCanvas *cData = new TCanvas("cTrackletData", "cTrackletData", 800, 800);
// cData->SetLogz();
TH1 * hfr = cData->DrawFrame(-2.5, 0., 2.5, 2. * TMath::Pi());
hfr->SetTitle(";#eta;#varphi");
hdtin->Draw("same,col");
cData->SaveAs(canvasPrefix+"trackletData.pdf");
TCanvas *cMC = new TCanvas("cTrackletMC", "cTrackletMC", 800, 800);
// cMC->SetLogz();
hfr = cMC->DrawFrame(-2.5, 0., 2.5, 2. * TMath::Pi());
hfr->SetTitle(";#eta;#varphi");
hmcin->Draw("same,col");
cMC->SaveAs(canvasPrefix+"trackletMC.pdf");
TCanvas *cPhi = new TCanvas("cTrackletPhi", "cTrackletPhi", 800, 800);
// cPhi->SetLogy();
hfr = cPhi->DrawFrame(0., 0., 2. * TMath::Pi(), 0.01);
hfr->SetTitle(";#varphi;");
pdtin->DrawCopy("same");
pmcin->DrawCopy("same,histo");
TLegend *legend = new TLegend(0.20, 0.18+0.63, 0.50, 0.30+0.63);
legend->SetFillColor(0);
legend->SetBorderSize(0);
legend->SetTextFont(42);
legend->SetTextSize(0.04);
legend->AddEntry(pdtin, "data", "pl");
legend->AddEntry(pmcin, "Monte Carlo", "l");
legend->Draw("same");
cPhi->SaveAs(canvasPrefix+"trackletPhi.pdf");
TCanvas *cPhir = new TCanvas("cTrackletPhir", "cTrackletPhir", 800, 800);
// cPhi->SetLogy();
hfr = cPhir->DrawFrame(0., 0.5, 2. * TMath::Pi(), 1.5);
hfr->SetTitle(";#varphi;data / Monte Carlo");
pdtin->Divide(pmcin);
pdtin->Draw("same");
cPhir->SaveAs(canvasPrefix+"trackletPhir.pdf");
}
histoBook* histoBook::set( string opt, vector<string> params ){
//cout << "Setting : " << opt << endl;
//for ( int i = 0; i < params.size(); i++ ){
// cout << params[ i ] << " ";
//}
//cout << endl;
// force the param name to lowercase
transform(opt.begin(), opt.end(), opt.begin(), ::tolower);
TH1* h = get( styling );
if ( h ){
if ( "title" == opt ){
h->SetTitle( cParam(params, 0) );
} else if ( "x" == opt ){
h->GetXaxis()->SetTitle( cParam(params, 0) );
} else if ( "y" == opt ){
h->GetYaxis()->SetTitle( cParam(params, 0) );
} else if ( "legend" == opt ){
legend->AddEntry( h, cParam(params, 0), cParam(params, 1, "lpf") );
legend->Draw();
} else if ( "draw" == opt ){
drawOption = cParam(params, 0);
} else if ( "linecolor" == opt ){
int c = color( cParam( params, 0) );
if ( c < 0 )
c = (int) dParam( params, 0);
h->SetLineColor( c );
} else if ( "fillcolor" == opt ){
int c = color( cParam( params, 0) );
if ( c < 0 )
c = (int) dParam( params, 0);
h->SetFillColor( c );
} else if ( "linewidth" == opt ){
h->SetLineWidth( dParam( params, 0) );
} else if ( "domain" == opt ){
double min = dParam( params, 0);
double max = dParam( params, 1);
h->GetXaxis()->SetRangeUser( min, max );
} else if ( "dynamicdomain" == opt ){
double thresh = dParam( params, 0);
int min = (int)dParam( params, 1);
int max = (int)dParam( params, 2);
int axis = (int)dParam( params, 3); // 1 = x, 2 = y
if ( 1 != axis && 2 != axis )
axis = 1;
if ( thresh >= 0) {
if ( -1 >= min )
min = h->FindFirstBinAbove( thresh, axis );
if ( -1 >= max )
max = h->FindLastBinAbove( thresh, axis );
}
if ( 1 == axis )
h->GetXaxis()->SetRange( min, max );
else if ( 2 == axis )
h->GetYaxis()->SetRange( min, max );
} else if ( "range" == opt ){
double min = dParam( params, 0);
double max = dParam( params, 1);
h->GetYaxis()->SetRangeUser( min, max );
} else if ( "markercolor" == opt ) {
int c = color( cParam( params, 0) );
if ( c < 0 )
c = (int) dParam( params, 0);
h->SetMarkerColor( c );
} else if ( "markerstyle" == opt ) {
h->SetMarkerStyle( (int)dParam( params, 0) );
} else if ( "legend" == opt ){
// p1 - alignmentX
// p2 - alignmentY
// p3 - width
// p4 - height
// make sure option is valid
double p1 = dParam( params, 0);
double p2 = dParam( params, 1);
if ( !(legendAlignment::center == p1 || legendAlignment::left == p1 || legendAlignment::right == p1) )
p1 = legendAlignment::best;
if ( !(legendAlignment::center == p2 || legendAlignment::top == p2 || legendAlignment::bottom == p2) )
p2 = legendAlignment::best;
placeLegend( p1, p2, dParam( params, 3), dParam( params, 3) );
} else if ( "numberofticks" == opt ){
// p1 - # of primary divisions
// p2 - # of secondary divisions
// p3 - axis : 0 or 1 = x, 2 = y
double p1 = dParam( params, 0);
double p2 = dParam( params, 1);
double p3 = dParam( params, 2);
if ( p2 == -1 )
p2 = 0;
if ( 2 == (int)p3 )
h->GetYaxis()->SetNdivisions( (int) p1, (int) p2, 0, true );
else
h->GetXaxis()->SetNdivisions( (int) p1, (int) p2, 0, true );
} else if ( "logy" == opt ){
gPad->SetLogy( (int)dParam( params, 0 ) );
} else if ( "logx" == opt ){
gPad->SetLogx( (int)dParam( params, 0 ) );
} else if ( "logz" == opt ){
gPad->SetLogz( (int)dParam( params, 0 ) );
}
}
return this;
}
//void makeHist(const int sample, const int dataset=1)
void makeHist(const string title="")
{
vector<Hist> hist2print;
TPaveText *tx = new TPaveText(.05,.1,.95,.8);
// tx->AddText("Using Deafult JERs for all jets");
// tx->AddText("Using b-Jet JERs");
/* string title("QCD MG:");
//if (sample==1) title += "NJet(70/50/30>=2/4/5), #slash{E}_{T}>175, Triplet>1, 80<TopMass<270, TOP+0.5*BJET>500, MT2>300, #Delta#Phi(.5,.5,.3), BJets>=1";
if (sample==1) title += "All Stop cuts applied (use default JERs for all jets)";
else if (sample==2) title += "All Stop cuts applied + Inverted #Delta#Phi (use default JERs for all jets)";
else if (sample==3) title += "All Stop cuts applied (use b-Jet JERs)";
else if (sample==4) title += "All Stop cuts applied + Inverted #Delta#Phi (use b-Jet JERs)";
else if (sample==5) title += "No cuts applied";
*/
unsigned bitMaskArray[] = {0,1,2,3,129,130,131,195,257,258,269,323};
vector<unsigned> vBitMaskArray(bitMaskArray, bitMaskArray + sizeof(bitMaskArray) / sizeof(unsigned));
stringstream unclmet_title;
unclmet_title << title << "Unclutered MET";
hist2print.push_back(Hist("met",title,2,0.0, 400.0,1));
hist2print.push_back(Hist("unclmet",unclmet_title.str().c_str(),2,0.0, 100.0,1));
hist2print.push_back(Hist("mht",title,2,0.0, 400.0,1));
hist2print.push_back(Hist("ht",title,2,0,2000,1));
hist2print.push_back(Hist("njet30eta5p0",title,1,0,15,1));
hist2print.push_back(Hist("nbjets",title,1,0,10,1));
// hist2print.push_back(Hist("bjetPt",title,2));
hist2print.push_back(Hist("M123",title,2));
// hist2print.push_back(Hist("M23overM123",title));
hist2print.push_back(Hist("MT2",title,2));
hist2print.push_back(Hist("MTb",title,4));
hist2print.push_back(Hist("MTt",title,4));
hist2print.push_back(Hist("MTb_p_MTt",title,2,400,1000,1));
//hist2print.push_back(Hist("jet1_pt",title,2));
//hist2print.push_back("bjetPt");
// hist2print.push_back(Hist("bjetMass",title,2,0,200));
// hist2print.push_back(Hist("dphimin",title,4));
TFile *outRootFile = new TFile("Merged.root");
/*TPad *c1=0, *c2=0;
TCanvas *c = GetCanvas(c1, c2);
if (c ==NULL|| c1 == 0 ||c2 == 0)
{
cout << " A drawing pad is null !"<< endl;
cout << "c = " << c << endl;
cout << "c1 = " << c1 << endl;
cout << "c2 = " << c2 << endl;
assert(false);
}*/
TCanvas *c = new TCanvas("c1");
c->Range(0,0,1,1);
c->SetBorderSize(2);
c->SetFrameFillColor(0);
// ------------>Primitives in pad: c1_1
TPad *c1_1 = new TPad("c1_1", "c1_1",0.01,0.30,0.99,0.99);
c1_1->Draw();
c1_1->cd();
c1_1->SetBorderSize(2);
c1_1->SetTickx(1);
c1_1->SetTicky(1);
c1_1->SetTopMargin(0.1);
c1_1->SetBottomMargin(0.0);
//c1_1->SetFrameFillColor(3);
//c1_1->SetLogy();
c->cd();
// ------------>Primitives in pad: c1_2
TPad *c1_2 = new TPad("c1_2", "c1_2",0.01,0.01,0.99,0.30);
c1_2->Draw();
c1_2->cd();
c1_2->SetBorderSize(2);
c1_2->SetTickx(1);
c1_2->SetTicky(1);
c1_2->SetTopMargin(0.0);
c1_2->SetBottomMargin(0.24);
c1_2->SetFrameFillColor(0);
c1_2->SetGridx();
c1_2->SetGridy();
c->cd();
gStyle->SetOptStat(0);
gPad->Print("samples.eps[");
for (unsigned i=0;i<vBitMaskArray.size(); ++i)
{
unsigned mask = vBitMaskArray.at(i);
for (unsigned ihist=0; ihist < hist2print.size(); ++ihist)
{
stringstream path, reco_hist_name, gen_hist_name, smear_hist_name;
stringstream reco_hist, gen_hist, smear_hist;
stringstream folder;
folder << "Hist/Mask"<< mask << "HT0to8000MHT0to8000/";
//cout << "folder = " << folder.str() << endl;
/* if ((hist2print.at(ihist).Name()).find("Jet"))
{
reco_hist_name << folder.str() << "reco" << hist2print.at(ihist).Name() << "_copy";
reco_hist << folder.str() << "reco" << hist2print.at(ihist).Name();
smear_hist_name << folder.str() << "smeared" << hist2print.at(ihist).Name() << "_copy";
smear_hist << folder.str() << "smeared" << hist2print.at(ihist).Name();
gen_hist_name << folder.str() << "gen" << hist2print.at(ihist).Name() << "_copy";
gen_hist << folder.str() << "gen" << hist2print.at(ihist).Name();
} else
*/ {
reco_hist_name << folder.str() << "reco_" << hist2print.at(ihist).Name() << "_copy";
reco_hist << folder.str() << "reco_" << hist2print.at(ihist).Name();
smear_hist_name << folder.str() << "smeared_" << hist2print.at(ihist).Name() << "_copy";
smear_hist << folder.str() << "smeared_" << hist2print.at(ihist).Name();
gen_hist_name << folder.str() << "gen_" << hist2print.at(ihist).Name() << "_copy";
gen_hist << folder.str() << "gen_" << hist2print.at(ihist).Name();
}
TH1* hreco = (TH1*) (outRootFile->Get(reco_hist.str().c_str()));
if (hreco == NULL) { cout << "hreco = " << reco_hist.str() << " was not found!" << endl; assert(false); }
hreco->SetDirectory(0);
TH1* hsmear = (TH1*) (outRootFile->Get(smear_hist.str().c_str()));
if (hsmear == NULL) { cout << "hsmear = " << smear_hist.str() << " was not found!" << endl; assert(false); }
hsmear->SetDirectory(0);
TH1* hgen = (TH1*) (outRootFile->Get(gen_hist.str().c_str()));
//->Clone(gen_hist_name.str().c_str()));
if (hgen == NULL) { cout << "hgen = " << gen_hist.str() << " was not found!" << endl; assert(false); }
hgen->SetDirectory(0);
hreco->Sumw2();
hsmear->Sumw2();
hgen->Sumw2();
const int rebin = hist2print.at(ihist).Rebin();
const string title = hist2print.at(ihist).Title();
const double xmin = hist2print.at(ihist).Xmin();
const double xmax = hist2print.at(ihist).Xmax();
if (rebin>1)
{
hreco->Rebin(rebin);
hsmear->Rebin(rebin);
hgen->Rebin(rebin);
}
if (title.length()>0)
{
hreco->SetTitle(title.c_str());
hsmear->SetTitle(title.c_str());
hgen->SetTitle(title.c_str());
}
if (xmin != LargeNegNum || xmax != LargeNegNum)
{
hreco->GetXaxis()->SetRangeUser(xmin,xmax);
hsmear->GetXaxis()->SetRangeUser(xmin,xmax);
hgen->GetXaxis()->SetRangeUser(xmin,xmax);
}
const double reco_max_y = hreco->GetBinContent(hreco->GetMaximumBin());
const double smear_max_y = hsmear->GetBinContent(hsmear->GetMaximumBin());
const double y_max = max(reco_max_y, smear_max_y);
double y_min = 9999.0;
for (unsigned bin=1; bin<hreco->GetNbinsX(); ++bin)
{
const double v1 = hreco->GetBinContent(bin);
const double v2 = hsmear->GetBinContent(bin);
const double minv = min(v1,v2);
if (minv != 0 && minv < y_min) y_min = minv;
}
cout << hreco->GetName() << "->ymin/max = " << y_min << "(" << y_min/2.0 << ")/" << y_max << "(" << y_max*2.0 << ")" << endl;
hreco->GetYaxis()->SetRangeUser(y_min/2.0, y_max*2.0);
hsmear->GetYaxis()->SetRangeUser(y_min/2.0, y_max*2.0);
hgen->SetLineColor(kBlue);
hgen->SetMarkerColor(kBlue);
hgen->SetMarkerStyle(24);
hgen->SetLineWidth(2);
hsmear->SetLineColor(kRed);
hsmear->SetMarkerColor(kRed);
hsmear->SetMarkerStyle(24);
hsmear->SetLineWidth(2);
hreco->SetLineWidth(2);
hreco->SetMarkerStyle(kDot);
hreco->SetLineColor(kBlack);
hreco->SetMarkerColor(kBlack);
//hreco->GetXaxis()->SetRangeUser(0,300);
//hsmear->GetXaxis()->SetRangeUser(0,300);
hreco->GetYaxis()->CenterTitle(1);
hreco->SetLabelFont(42,"XYZ");
hreco->SetTitleFont(42,"XYZ");
hreco->GetYaxis()->SetTitleOffset(0.8);
hreco->SetLabelSize(0.05,"XYZ");
hreco->SetTitleSize(0.06,"XYZ");
TH1 *hsmeartoreco_ratio = (TH1*) (hsmear->Clone("hsmear_copy"));
hsmeartoreco_ratio->Divide(hreco);
hsmeartoreco_ratio->SetTitle("");
hsmeartoreco_ratio->GetYaxis()->SetTitle("Smear/Reco");
hsmeartoreco_ratio->GetYaxis()->SetRangeUser(0,2.);
hsmeartoreco_ratio->GetYaxis()->SetTitleOffset(0.4);
hsmeartoreco_ratio->GetXaxis()->SetTitleOffset(0.9);
hsmeartoreco_ratio->GetYaxis()->CenterTitle(1);
hsmeartoreco_ratio->GetXaxis()->CenterTitle(1);
hsmeartoreco_ratio->SetLabelSize(0.125,"XYZ");
hsmeartoreco_ratio->SetTitleSize(0.125,"XYZ");
// hsmeartoreco_ratio->SetLabelFont(labelfont,"XYZ");
// hsmeartoreco_ratio->SetTitleFont(titlefont,"XYZ");
hsmeartoreco_ratio->GetXaxis()->SetTickLength(0.07);
stringstream recoleg,smearleg, genleg;
const double sum_reco = hreco->Integral(1, hreco->GetNbinsX()+1);
const double sum_smear = hsmear->Integral(1, hsmear->GetNbinsX()+1);
const double sum_gen = hgen->Integral(1, hgen->GetNbinsX()+1);
const double err_reco = StatErr(hreco);
const double err_smear = StatErr(hsmear);
cout << setprecision(1) << fixed;
recoleg << "Reco (" << sum_reco << "#pm" << err_reco << ")";
smearleg << "Smear (" << sum_smear << "#pm" << err_smear << ")";
genleg << "Gen (" << sum_gen << ")";
cout << smear_hist_name.str() << "::reco/smear = " << sum_reco << "/" << sum_smear << endl;
TLegend *l2 = new TLegend(0.6,0.6,0.9,0.9);
l2->AddEntry(hreco, recoleg.str().c_str());
//l2->AddEntry(hgen, genleg.str().c_str());
l2->AddEntry(hsmear, smearleg.str().c_str());
c1_1->cd();
gPad->SetLogy(hist2print.at(ihist).LogY());
hreco->DrawCopy();
//hgen->DrawCopy("same");
hsmear->DrawCopy("same");
l2->Draw();
//tx->Draw();
c1_2->cd();
hsmeartoreco_ratio->DrawCopy();
c->cd();
gPad->Print("samples.eps");
}
}
gPad->Print("samples.eps]");
}
