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);
}
drawGraph( TGraph* gr, const Char_t* ytitle = 0 )
{
gr->Draw( "AP*" );
TH1* h = gr->GetHistogram( );
std::cout << gr->GetMean( ) << std::endl;
gr->Fit( "pol0", "Q", "SAME" );
TF1* fit = gr->GetFunction( "pol0" );
Double_t chi2 = fit->GetChisquare( );
Double_t par0 = fit->GetParameter( 0 );
Double_t err = fit->GetParError( 0 );
TLatex* l = new TLatex;
l->SetNDC( );
l->DrawLatex( 0.85, 0.80, Form( "#splitline{Entries = %i}{RMS = %2.3f}",
gr->GetN(), gr->GetMean(2)) );
TLatex* l2 = new TLatex;
l2->SetNDC( );
l2->DrawLatex( 0.85, 0.7, Form("#splitline{fit = %2.3f#pm%2.3f}{#chi^{2} = %2.3f}",
par0, chi2, err) );
// TLegend* leg = new TLegend( 0.8, 0.9, 0.95, 0.95 );
// leg->SetFillColor( kWhite );
// leg->SetBorderSize( 0 );
// leg->AddEntry( "gr", "CPU+AFAR+MBED+ATWD+AMPS", "P" );
// leg->Draw( );
if( h != 0 )
{
h->GetXaxis()->SetTimeFormat("%m/%d %H:%M");
h->GetXaxis()->SetNdivisions( 10, 10, 0 );
h->GetXaxis()->SetTimeDisplay( 1 );
h->GetXaxis()->SetTitle("Date / Time (UTC)");
h->GetXaxis()->SetLabelSize( 0.06 );
h->GetYaxis()->SetLabelSize(0.07);
h->GetYaxis()->SetTitleSize(0.06);
h->GetXaxis()->SetTitleSize(0.055);
h->GetYaxis()->SetTitleOffset( 0.9 );
h->GetXaxis()->SetTitleOffset( 0.9 );
h->SetMarkerSize( 5 );
if( ytitle != 0 )
{
h->GetYaxis()->SetTitle(ytitle);
}
}
if( gPad != 0 )
{
gPad->Update();
}
}
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 plotCut2DSignal()
{
string canvas_title = "Cut 2D Signal";
TCanvas *canvas = new TCanvas(canvas_title.c_str(), canvas_title.c_str());
canvas->SetWindowSize(1200, 640);
canvas->Divide(3, 2);
canvas_title = "DeltaR Signal";
TCanvas *canvas_dr = new TCanvas(canvas_title.c_str(), canvas_title.c_str());
canvas_dr->SetWindowSize(1200, 640);
canvas_dr->Divide(3, 2);
canvas_title = "pTrel Signal";
TCanvas *canvas_ptrel = new TCanvas(canvas_title.c_str(), canvas_title.c_str());
canvas_ptrel->SetWindowSize(1200, 640);
canvas_ptrel->Divide(3, 2);
for(int i = 0; SIGNAL_CHANNELS > i; ++i)
{
int id = BACKGROUND_CHANNELS + i;
TH1 *hist = get("dr_vs_ptrel", input_s1[id], id);
if (!hist)
continue;
canvas->cd(i + 1);
style(hist, id);
hist->SetMarkerSize(0.1);
hist->Draw("scat");
TLegend *legend = createLegend(toString(id));
legend->Draw();
canvas_ptrel->cd(i + 1);
TH2 *hist2d = dynamic_cast<TH2 *>(hist);
TH1 *ptrel = dynamic_cast<TH1 *>(hist2d->ProjectionX()->Clone());
style(ptrel, id);
ptrel->Draw();
legend->Draw();
canvas_dr->cd(i + 1);
TH2 *hist2d = dynamic_cast<TH2 *>(hist);
TH1 *dr = dynamic_cast<TH1 *>(hist2d->ProjectionY()->Clone());
style(dr, id);
dr->Draw();
legend->Draw();
}
}
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 makePlot_legend(TLegend* legend, const std::string& outputFilePath, const std::string& outputFileName)
{
TCanvas* canvas_legend = new TCanvas("canvas_legend", "canvas_legend", 900, 800);
canvas_legend->SetFillColor(10);
canvas_legend->SetBorderSize(2);
canvas_legend->Draw();
canvas_legend->cd();
legend->SetX1NDC(0.30);
legend->SetY1NDC(0.30);
legend->SetX2NDC(0.80);
legend->SetY2NDC(0.80);
legend->SetTextSize(0.070);
legend->SetMargin(0.20);
TList* legend_primitives = legend->GetListOfPrimitives();
TIter legend_nextObj(legend_primitives);
while ( TObject* obj = legend_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;
TLegendEntry* legendEntry = dynamic_cast<TLegendEntry*>(obj);
if ( legendEntry ) {
TH1* histogram = dynamic_cast<TH1*>(legendEntry->GetObject());
if ( histogram ) {
histogram->SetLineWidth(2*histogram->GetLineWidth());
histogram->SetMarkerSize(3);
}
}
}
legend->Draw();
canvas_legend->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_legend->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas_legend->Print(std::string(outputFileName_plot).append(".root").data());
delete canvas_legend;
}
void format1Dhisto(TH1& h1, double Ymax, double Ymin, double& col, double& Mstyle, 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(Ymin, Ymax);
//if(Ymax==-1 && Ymin!=-1) h1.GetYaxis()->SetMinimum(Ymin);
h1.SetMarkerColor(col);
h1.SetMarkerStyle(Mstyle);
h1.SetLineColor(col);
h1.SetFillColor(fill);
h1.SetFillStyle(style);
h1.SetMarkerSize(0.8);
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 );
}
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 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;
}
// 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 diffrac(){
gROOT->Reset();
//gROOT->ProcessLine(".x rootlogon.C");
//=========Macro generated from canvas: cEvtSel/EvtSel
//========= (Wed Apr 14 17:19:02 2010) by ROOT version5.22/00d
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",550,600);
/*
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",0,22,550,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
cEvtSel->Range(-32.99367,-0.009375,158.1456,0.053125);
cEvtSel->SetFillColor(0);
cEvtSel->SetBorderMode(0);
cEvtSel->SetBorderSize(0);
cEvtSel->SetTickx(1);
cEvtSel->SetTicky(1);
cEvtSel->SetLeftMargin(0.17);
cEvtSel->SetRightMargin(0.04);
cEvtSel->SetTopMargin(0.05);
cEvtSel->SetBottomMargin(0.15);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
*/
//TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,60.5,1,0,0.06);
TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,150.5,1,0,0.05);
hFrame2->SetDirectory(0);
hFrame2->SetStats(0);
hFrame2->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame2->GetXaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetTitle("Fraction of events");
hFrame2->GetYaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetTitleOffset(1.5);
hFrame2->Draw("");
hFrame2->GetXaxis()->SetNdivisions(312);
hFrame2->GetYaxis()->SetNdivisions(305);
/*
TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,150.5,1,0,0.05);
hFrame2->SetDirectory(0);
hFrame2->SetStats(0);
hFrame2->SetFillColor(1);
hFrame2->SetFillStyle(0);
hFrame2->SetLineStyle(0);
hFrame2->SetMarkerStyle(20);
hFrame2->SetMarkerSize(1.5);
hFrame2->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame2->GetXaxis()->CenterTitle(true);
hFrame2->GetXaxis()->SetNdivisions(312);
hFrame2->GetXaxis()->SetLabelFont(42);
hFrame2->GetXaxis()->SetLabelOffset(0.01);
hFrame2->GetXaxis()->SetLabelSize(0.045);
hFrame2->GetXaxis()->SetTitleSize(0.055);
hFrame2->GetXaxis()->SetTitleFont(42);
hFrame2->GetYaxis()->SetTitle("Fraction of events");
hFrame2->GetYaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetLabelFont(42);
hFrame2->GetYaxis()->SetLabelOffset(0.01);
hFrame2->GetYaxis()->SetLabelSize(0.045);
hFrame2->GetYaxis()->SetTitleSize(0.055);
hFrame2->GetYaxis()->SetTitleOffset(1.5);
hFrame2->GetYaxis()->SetTitleFont(42);
hFrame2->GetZaxis()->SetLabelFont(42);
hFrame2->GetZaxis()->SetLabelSize(0.045);
hFrame2->GetZaxis()->SetTitleFont(42);
hFrame2->Draw("");
*/
TH1 *diffrac = new TH1D("diffrac","diffrac",200,0,200);
diffrac->SetBinContent(1,0.0004697663);
diffrac->SetBinContent(2,0.008010118);
diffrac->SetBinContent(3,0.0127921);
diffrac->SetBinContent(4,0.01698988);
diffrac->SetBinContent(5,0.02012166);
diffrac->SetBinContent(6,0.022341);
diffrac->SetBinContent(7,0.02315105);
diffrac->SetBinContent(8,0.02518068);
diffrac->SetBinContent(9,0.02668032);
diffrac->SetBinContent(10,0.02875512);
diffrac->SetBinContent(11,0.03089617);
diffrac->SetBinContent(12,0.0324741);
diffrac->SetBinContent(13,0.03311853);
diffrac->SetBinContent(14,0.03265478);
diffrac->SetBinContent(15,0.03213081);
diffrac->SetBinContent(16,0.03054987);
diffrac->SetBinContent(17,0.0283245);
diffrac->SetBinContent(18,0.02640026);
diffrac->SetBinContent(19,0.02394001);
diffrac->SetBinContent(20,0.02234401);
diffrac->SetBinContent(21,0.02026921);
diffrac->SetBinContent(22,0.01865213);
diffrac->SetBinContent(23,0.01720369);
diffrac->SetBinContent(24,0.01639665);
diffrac->SetBinContent(25,0.01546013);
diffrac->SetBinContent(26,0.01423151);
diffrac->SetBinContent(27,0.01359311);
diffrac->SetBinContent(28,0.01247892);
diffrac->SetBinContent(29,0.01204529);
diffrac->SetBinContent(30,0.01130752);
diffrac->SetBinContent(31,0.01089798);
diffrac->SetBinContent(32,0.01070826);
diffrac->SetBinContent(33,0.009497711);
diffrac->SetBinContent(34,0.009579017);
diffrac->SetBinContent(35,0.008805107);
diffrac->SetBinContent(36,0.008741869);
diffrac->SetBinContent(37,0.008522043);
diffrac->SetBinContent(38,0.00790171);
diffrac->SetBinContent(39,0.007799325);
diffrac->SetBinContent(40,0.007486148);
diffrac->SetBinContent(41,0.006838714);
diffrac->SetBinContent(42,0.006947121);
diffrac->SetBinContent(43,0.006504457);
diffrac->SetBinContent(44,0.0063298);
diffrac->SetBinContent(45,0.006122019);
diffrac->SetBinContent(46,0.006061792);
diffrac->SetBinContent(47,0.005823898);
diffrac->SetBinContent(48,0.005661286);
diffrac->SetBinContent(49,0.005543845);
diffrac->SetBinContent(50,0.005363166);
diffrac->SetBinContent(51,0.005215611);
diffrac->SetBinContent(52,0.00503192);
diffrac->SetBinContent(53,0.004800048);
diffrac->SetBinContent(54,0.004839195);
diffrac->SetBinContent(55,0.004583233);
diffrac->SetBinContent(56,0.004544086);
diffrac->SetBinContent(57,0.004471814);
diffrac->SetBinContent(58,0.004146591);
diffrac->SetBinContent(59,0.004267044);
diffrac->SetBinContent(60,0.003990002);
diffrac->SetBinContent(61,0.004083353);
diffrac->SetBinContent(62,0.003806312);
diffrac->SetBinContent(63,0.003782221);
diffrac->SetBinContent(64,0.003812334);
diffrac->SetBinContent(65,0.003472055);
diffrac->SetBinContent(66,0.00366478);
diffrac->SetBinContent(67,0.003195013);
diffrac->SetBinContent(68,0.003285353);
diffrac->SetBinContent(69,0.00323416);
diffrac->SetBinContent(70,0.0031649);
diffrac->SetBinContent(71,0.003110696);
diffrac->SetBinContent(72,0.003170923);
diffrac->SetBinContent(73,0.002966153);
diffrac->SetBinContent(74,0.002957119);
diffrac->SetBinContent(75,0.002905926);
diffrac->SetBinContent(76,0.002954107);
diffrac->SetBinContent(77,0.002785473);
diffrac->SetBinContent(78,0.002836666);
diffrac->SetBinContent(79,0.002725247);
diffrac->SetBinContent(80,0.002728258);
diffrac->SetBinContent(81,0.002568658);
diffrac->SetBinContent(82,0.002288605);
diffrac->SetBinContent(83,0.002499398);
diffrac->SetBinContent(84,0.002445194);
diffrac->SetBinContent(85,0.002378945);
diffrac->SetBinContent(86,0.00227656);
diffrac->SetBinContent(87,0.002418092);
diffrac->SetBinContent(88,0.002351843);
diffrac->SetBinContent(89,0.002381956);
diffrac->SetBinContent(90,0.002189232);
diffrac->SetBinContent(91,0.002222356);
diffrac->SetBinContent(92,0.002198265);
diffrac->SetBinContent(93,0.002219345);
diffrac->SetBinContent(94,0.002198265);
diffrac->SetBinContent(95,0.002089858);
diffrac->SetBinContent(96,0.001996507);
diffrac->SetBinContent(97,0.001972416);
diffrac->SetBinContent(98,0.001903156);
diffrac->SetBinContent(99,0.001818839);
diffrac->SetBinContent(100,0.001876054);
diffrac->SetBinContent(101,0.001864009);
diffrac->SetBinContent(102,0.001767646);
diffrac->SetBinContent(103,0.001879065);
diffrac->SetBinContent(104,0.001894122);
diffrac->SetBinContent(105,0.001695375);
diffrac->SetBinContent(106,0.001674295);
diffrac->SetBinContent(107,0.001611058);
diffrac->SetBinContent(108,0.001556854);
diffrac->SetBinContent(109,0.001620092);
diffrac->SetBinContent(110,0.001556854);
diffrac->SetBinContent(111,0.001568899);
diffrac->SetBinContent(112,0.001475548);
diffrac->SetBinContent(113,0.001376174);
diffrac->SetBinContent(114,0.001448446);
diffrac->SetBinContent(115,0.001520718);
diffrac->SetBinContent(116,0.001261744);
diffrac->SetBinContent(117,0.001448446);
diffrac->SetBinContent(118,0.001282823);
diffrac->SetBinContent(119,0.001219586);
diffrac->SetBinContent(120,0.001201518);
diffrac->SetBinContent(121,0.001237654);
diffrac->SetBinContent(122,0.001141291);
diffrac->SetBinContent(123,0.001195495);
diffrac->SetBinContent(124,0.001150325);
diffrac->SetBinContent(125,0.001195495);
diffrac->SetBinContent(126,0.0009816912);
diffrac->SetBinContent(127,0.001135269);
diffrac->SetBinContent(128,0.00100277);
diffrac->SetBinContent(129,0.001005782);
diffrac->SetBinContent(130,0.0009003854);
diffrac->SetBinContent(131,0.0008823175);
diffrac->SetBinContent(132,0.0009576006);
diffrac->SetBinContent(133,0.0008732835);
diffrac->SetBinContent(134,0.0008220911);
diffrac->SetBinContent(135,0.000831125);
diffrac->SetBinContent(136,0.0007437967);
diffrac->SetBinContent(137,0.000662491);
diffrac->SetBinContent(138,0.0007046495);
diffrac->SetBinContent(139,0.0007287401);
diffrac->SetBinContent(140,0.0007407854);
diffrac->SetBinContent(141,0.0006263551);
diffrac->SetBinContent(142,0.0006745363);
diffrac->SetBinContent(143,0.000653457);
diffrac->SetBinContent(144,0.0006082872);
diffrac->SetBinContent(145,0.0005420381);
diffrac->SetBinContent(146,0.0005631173);
diffrac->SetBinContent(147,0.0005059022);
diffrac->SetBinContent(148,0.0005781739);
diffrac->SetBinContent(149,0.0005239701);
diffrac->SetBinContent(150,0.0004547097);
diffrac->SetBinContent(151,0.0004697663);
diffrac->SetBinContent(152,0.0004547097);
diffrac->SetBinContent(153,0.0004396531);
diffrac->SetBinContent(154,0.0004697663);
diffrac->SetBinContent(155,0.0003884606);
diffrac->SetBinContent(156,0.0003613587);
diffrac->SetBinContent(157,0.0003523247);
diffrac->SetBinContent(158,0.0003703927);
diffrac->SetBinContent(159,0.0003794266);
diffrac->SetBinContent(160,0.0003041436);
diffrac->SetBinContent(161,0.0003192002);
diffrac->SetBinContent(162,0.000280053);
diffrac->SetBinContent(163,0.0002770417);
diffrac->SetBinContent(164,0.0002228379);
diffrac->SetBinContent(165,0.0002529511);
diffrac->SetBinContent(166,0.0002469285);
diffrac->SetBinContent(167,0.0002318718);
diffrac->SetBinContent(168,0.0003041436);
diffrac->SetBinContent(169,0.0002198265);
diffrac->SetBinContent(170,0.0002499398);
diffrac->SetBinContent(171,0.0001565888);
diffrac->SetBinContent(172,0.0001656227);
diffrac->SetBinContent(173,0.0001535775);
diffrac->SetBinContent(174,0.0001626114);
diffrac->SetBinContent(175,0.0001987473);
diffrac->SetBinContent(176,0.0001445435);
diffrac->SetBinContent(177,0.0001174416);
diffrac->SetBinContent(178,0.0001445435);
diffrac->SetBinContent(179,0.0001415322);
diffrac->SetBinContent(180,0.0001445435);
diffrac->SetBinContent(181,0.0001264755);
diffrac->SetBinContent(182,6.62491e-05);
diffrac->SetBinContent(183,7.227174e-05);
diffrac->SetBinContent(184,0.0001053963);
diffrac->SetBinContent(185,9.033968e-05);
diffrac->SetBinContent(186,8.732835e-05);
diffrac->SetBinContent(187,6.022645e-05);
diffrac->SetBinContent(188,9.3351e-05);
diffrac->SetBinContent(189,8.732835e-05);
diffrac->SetBinContent(190,8.431703e-05);
diffrac->SetBinContent(191,9.033968e-05);
diffrac->SetBinContent(192,4.215852e-05);
diffrac->SetBinContent(193,6.62491e-05);
diffrac->SetBinContent(194,7.528306e-05);
diffrac->SetBinContent(195,4.215852e-05);
diffrac->SetBinContent(196,4.516984e-05);
diffrac->SetBinContent(197,3.613587e-05);
diffrac->SetBinContent(198,6.022645e-05);
diffrac->SetBinContent(199,4.516984e-05);
diffrac->SetBinContent(200,3.011323e-05);
diffrac->SetBinContent(201,0.000457721);
diffrac->SetBinError(1,3.761141e-05);
diffrac->SetBinError(2,0.0001553095);
diffrac->SetBinError(3,0.000196268);
diffrac->SetBinError(4,0.0002261902);
diffrac->SetBinError(5,0.0002461561);
diffrac->SetBinError(6,0.0002593761);
diffrac->SetBinError(7,0.0002640365);
diffrac->SetBinError(8,0.0002753673);
diffrac->SetBinError(9,0.0002834485);
diffrac->SetBinError(10,0.0002942634);
diffrac->SetBinError(11,0.0003050219);
diffrac->SetBinError(12,0.0003127139);
diffrac->SetBinError(13,0.0003158015);
diffrac->SetBinError(14,0.0003135827);
diffrac->SetBinError(15,0.0003110566);
diffrac->SetBinError(16,0.0003033076);
diffrac->SetBinError(17,0.0002920517);
diffrac->SetBinError(18,0.0002819569);
diffrac->SetBinError(19,0.0002684979);
diffrac->SetBinError(20,0.0002593936);
diffrac->SetBinError(21,0.0002470569);
diffrac->SetBinError(22,0.000236997);
diffrac->SetBinError(23,0.000227609);
diffrac->SetBinError(24,0.0002222062);
diffrac->SetBinError(25,0.0002157671);
diffrac->SetBinError(26,0.0002070161);
diffrac->SetBinError(27,0.0002023196);
diffrac->SetBinError(28,0.0001938506);
diffrac->SetBinError(29,0.0001904528);
diffrac->SetBinError(30,0.000184528);
diffrac->SetBinError(31,0.0001811555);
diffrac->SetBinError(32,0.0001795718);
diffrac->SetBinError(33,0.0001691173);
diffrac->SetBinError(34,0.0001698397);
diffrac->SetBinError(35,0.0001628343);
diffrac->SetBinError(36,0.0001622485);
diffrac->SetBinError(37,0.0001601956);
diffrac->SetBinError(38,0.000154255);
diffrac->SetBinError(39,0.0001532524);
diffrac->SetBinError(40,0.000150144);
diffrac->SetBinError(41,0.0001435046);
diffrac->SetBinError(42,0.0001446376);
diffrac->SetBinError(43,0.0001399536);
diffrac->SetBinError(44,0.0001380618);
diffrac->SetBinError(45,0.0001357769);
diffrac->SetBinError(46,0.0001351074);
diffrac->SetBinError(47,0.0001324297);
diffrac->SetBinError(48,0.0001305678);
diffrac->SetBinError(49,0.0001292064);
diffrac->SetBinError(50,0.0001270835);
diffrac->SetBinError(51,0.0001253231);
diffrac->SetBinError(52,0.0001230964);
diffrac->SetBinError(53,0.0001202268);
diffrac->SetBinError(54,0.0001207161);
diffrac->SetBinError(55,0.0001174802);
diffrac->SetBinError(56,0.0001169774);
diffrac->SetBinError(57,0.0001160434);
diffrac->SetBinError(58,0.000111744);
diffrac->SetBinError(59,0.0001133554);
diffrac->SetBinError(60,0.0001096138);
diffrac->SetBinError(61,0.0001108887);
diffrac->SetBinError(62,0.0001070609);
diffrac->SetBinError(63,0.0001067215);
diffrac->SetBinError(64,0.0001071455);
diffrac->SetBinError(65,0.000102252);
diffrac->SetBinError(66,0.0001050516);
diffrac->SetBinError(67,9.808779e-05);
diffrac->SetBinError(68,9.946486e-05);
diffrac->SetBinError(69,9.868688e-05);
diffrac->SetBinError(70,9.762446e-05);
diffrac->SetBinError(71,9.678486e-05);
diffrac->SetBinError(72,9.77173e-05);
diffrac->SetBinError(73,9.450948e-05);
diffrac->SetBinError(74,9.436545e-05);
diffrac->SetBinError(75,9.354508e-05);
diffrac->SetBinError(76,9.431739e-05);
diffrac->SetBinError(77,9.15858e-05);
diffrac->SetBinError(78,9.242357e-05);
diffrac->SetBinError(79,9.059027e-05);
diffrac->SetBinError(80,9.064031e-05);
diffrac->SetBinError(81,8.794918e-05);
diffrac->SetBinError(82,8.301643e-05);
diffrac->SetBinError(83,8.675536e-05);
diffrac->SetBinError(84,8.580948e-05);
diffrac->SetBinError(85,8.463906e-05);
diffrac->SetBinError(86,8.279768e-05);
diffrac->SetBinError(87,8.533261e-05);
diffrac->SetBinError(88,8.415556e-05);
diffrac->SetBinError(89,8.469261e-05);
diffrac->SetBinError(90,8.11941e-05);
diffrac->SetBinError(91,8.180606e-05);
diffrac->SetBinError(92,8.136146e-05);
diffrac->SetBinError(93,8.175061e-05);
diffrac->SetBinError(94,8.136146e-05);
diffrac->SetBinError(95,7.932992e-05);
diffrac->SetBinError(96,7.75379e-05);
diffrac->SetBinError(97,7.706868e-05);
diffrac->SetBinError(98,7.570348e-05);
diffrac->SetBinError(99,7.40075e-05);
diffrac->SetBinError(100,7.516251e-05);
diffrac->SetBinError(101,7.492083e-05);
diffrac->SetBinError(102,7.295857e-05);
diffrac->SetBinError(103,7.522281e-05);
diffrac->SetBinError(104,7.552359e-05);
diffrac->SetBinError(105,7.145152e-05);
diffrac->SetBinError(106,7.100594e-05);
diffrac->SetBinError(107,6.965209e-05);
diffrac->SetBinError(108,6.847035e-05);
diffrac->SetBinError(109,6.984711e-05);
diffrac->SetBinError(110,6.847035e-05);
diffrac->SetBinError(111,6.873472e-05);
diffrac->SetBinError(112,6.665847e-05);
diffrac->SetBinError(113,6.437472e-05);
diffrac->SetBinError(114,6.604346e-05);
diffrac->SetBinError(115,6.767106e-05);
diffrac->SetBinError(116,6.164024e-05);
diffrac->SetBinError(117,6.604346e-05);
diffrac->SetBinError(118,6.2153e-05);
diffrac->SetBinError(119,6.06017e-05);
diffrac->SetBinError(120,6.015112e-05);
diffrac->SetBinError(121,6.104895e-05);
diffrac->SetBinError(122,5.862419e-05);
diffrac->SetBinError(123,6.000018e-05);
diffrac->SetBinError(124,5.885576e-05);
diffrac->SetBinError(125,6.000018e-05);
diffrac->SetBinError(126,5.437084e-05);
diffrac->SetBinError(127,5.846931e-05);
diffrac->SetBinError(128,5.495148e-05);
diffrac->SetBinError(129,5.503393e-05);
diffrac->SetBinError(130,5.207063e-05);
diffrac->SetBinError(131,5.154554e-05);
diffrac->SetBinError(132,5.369957e-05);
diffrac->SetBinError(133,5.128098e-05);
diffrac->SetBinError(134,4.975521e-05);
diffrac->SetBinError(135,5.002785e-05);
diffrac->SetBinError(136,4.732665e-05);
diffrac->SetBinError(137,4.466513e-05);
diffrac->SetBinError(138,4.606438e-05);
diffrac->SetBinError(139,4.684519e-05);
diffrac->SetBinError(140,4.723075e-05);
diffrac->SetBinError(141,4.342991e-05);
diffrac->SetBinError(142,4.506935e-05);
diffrac->SetBinError(143,4.435955e-05);
diffrac->SetBinError(144,4.279894e-05);
diffrac->SetBinError(145,4.040113e-05);
diffrac->SetBinError(146,4.117922e-05);
diffrac->SetBinError(147,3.90312e-05);
diffrac->SetBinError(148,4.172611e-05);
diffrac->SetBinError(149,3.972207e-05);
diffrac->SetBinError(150,3.700375e-05);
diffrac->SetBinError(151,3.761141e-05);
diffrac->SetBinError(152,3.700375e-05);
diffrac->SetBinError(153,3.638595e-05);
diffrac->SetBinError(154,3.761141e-05);
diffrac->SetBinError(155,3.420205e-05);
diffrac->SetBinError(156,3.298739e-05);
diffrac->SetBinError(157,3.257243e-05);
diffrac->SetBinError(158,3.339718e-05);
diffrac->SetBinError(159,3.380201e-05);
diffrac->SetBinError(160,3.026342e-05);
diffrac->SetBinError(161,3.100346e-05);
diffrac->SetBinError(162,2.904014e-05);
diffrac->SetBinError(163,2.888359e-05);
diffrac->SetBinError(164,2.590438e-05);
diffrac->SetBinError(165,2.759923e-05);
diffrac->SetBinError(166,2.726869e-05);
diffrac->SetBinError(167,2.642425e-05);
diffrac->SetBinError(168,3.026342e-05);
diffrac->SetBinError(169,2.572875e-05);
diffrac->SetBinError(170,2.743445e-05);
diffrac->SetBinError(171,2.171496e-05);
diffrac->SetBinError(172,2.233257e-05);
diffrac->SetBinError(173,2.150514e-05);
diffrac->SetBinError(174,2.212861e-05);
diffrac->SetBinError(175,2.44641e-05);
diffrac->SetBinError(176,2.086305e-05);
diffrac->SetBinError(177,1.88057e-05);
diffrac->SetBinError(178,2.086305e-05);
diffrac->SetBinError(179,2.064459e-05);
diffrac->SetBinError(180,2.086305e-05);
diffrac->SetBinError(181,1.95156e-05);
diffrac->SetBinError(182,1.412435e-05);
diffrac->SetBinError(183,1.475241e-05);
diffrac->SetBinError(184,1.781522e-05);
diffrac->SetBinError(185,1.649369e-05);
diffrac->SetBinError(186,1.621647e-05);
diffrac->SetBinError(187,1.346704e-05);
diffrac->SetBinError(188,1.676633e-05);
diffrac->SetBinError(189,1.621647e-05);
diffrac->SetBinError(190,1.593442e-05);
diffrac->SetBinError(191,1.649369e-05);
diffrac->SetBinError(192,1.126734e-05);
diffrac->SetBinError(193,1.412435e-05);
diffrac->SetBinError(194,1.505661e-05);
diffrac->SetBinError(195,1.126734e-05);
diffrac->SetBinError(196,1.16628e-05);
diffrac->SetBinError(197,1.043153e-05);
diffrac->SetBinError(198,1.346704e-05);
diffrac->SetBinError(199,1.16628e-05);
diffrac->SetBinError(200,9.522638e-06);
diffrac->SetBinError(201,3.712608e-05);
diffrac->SetEntries(332232);
diffrac->SetDirectory(0);
diffrac->SetFillColor(1);
diffrac->SetFillStyle(0);
diffrac->SetLineStyle(0);
diffrac->SetLineWidth(2);
diffrac->SetMarkerStyle(20);
diffrac->SetMarkerSize(1.5);
diffrac->GetXaxis()->SetTitle("M");
diffrac->GetXaxis()->SetLabelFont(42);
diffrac->GetXaxis()->SetLabelOffset(0.01);
diffrac->GetXaxis()->SetLabelSize(0.045);
diffrac->GetXaxis()->SetTitleSize(0.055);
diffrac->GetXaxis()->SetTitleFont(42);
diffrac->GetYaxis()->SetTitle("Fraction of events");
diffrac->GetYaxis()->SetLabelFont(42);
diffrac->GetYaxis()->SetLabelOffset(0.01);
diffrac->GetYaxis()->SetLabelSize(0.045);
diffrac->GetYaxis()->SetTitleSize(0.055);
diffrac->GetYaxis()->SetTitleOffset(1.6);
diffrac->GetYaxis()->SetTitleFont(42);
diffrac->GetZaxis()->SetLabelFont(42);
diffrac->GetZaxis()->SetLabelSize(0.045);
diffrac->GetZaxis()->SetTitleFont(42);
diffrac->Draw("hist same");
TH1 *diffrac = new TH1D("diffrac","diffrac",200,0,200);
diffrac->SetBinContent(1,0.0001535956);
diffrac->SetBinContent(2,0.002138746);
diffrac->SetBinContent(3,0.003918136);
diffrac->SetBinContent(4,0.006984252);
diffrac->SetBinContent(5,0.01149359);
diffrac->SetBinContent(6,0.01725487);
diffrac->SetBinContent(7,0.02335522);
diffrac->SetBinContent(8,0.02994824);
diffrac->SetBinContent(9,0.03493575);
diffrac->SetBinContent(10,0.03668616);
diffrac->SetBinContent(11,0.03929439);
diffrac->SetBinContent(12,0.03968852);
diffrac->SetBinContent(13,0.03844526);
diffrac->SetBinContent(14,0.0360341);
diffrac->SetBinContent(15,0.03434745);
diffrac->SetBinContent(16,0.03306942);
diffrac->SetBinContent(17,0.03029311);
diffrac->SetBinContent(18,0.02782978);
diffrac->SetBinContent(19,0.02716903);
diffrac->SetBinContent(20,0.02540413);
diffrac->SetBinContent(21,0.02289154);
diffrac->SetBinContent(22,0.02272345);
diffrac->SetBinContent(23,0.02145412);
diffrac->SetBinContent(24,0.02181927);
diffrac->SetBinContent(25,0.02003698);
diffrac->SetBinContent(26,0.01887487);
diffrac->SetBinContent(27,0.01739977);
diffrac->SetBinContent(28,0.01641734);
diffrac->SetBinContent(29,0.01567544);
diffrac->SetBinContent(30,0.01542621);
diffrac->SetBinContent(31,0.01473069);
diffrac->SetBinContent(32,0.01400618);
diffrac->SetBinContent(33,0.01286146);
diffrac->SetBinContent(34,0.01269917);
diffrac->SetBinContent(35,0.0127919);
diffrac->SetBinContent(36,0.01181527);
diffrac->SetBinContent(37,0.01151387);
diffrac->SetBinContent(38,0.01042421);
diffrac->SetBinContent(39,0.01025613);
diffrac->SetBinContent(40,0.009320064);
diffrac->SetBinContent(41,0.009027363);
diffrac->SetBinContent(42,0.008412981);
diffrac->SetBinContent(43,0.00834053);
diffrac->SetBinContent(44,0.007647901);
diffrac->SetBinContent(45,0.007917418);
diffrac->SetBinContent(46,0.007523286);
diffrac->SetBinContent(47,0.006679959);
diffrac->SetBinContent(48,0.006526363);
diffrac->SetBinContent(49,0.006004718);
diffrac->SetBinContent(50,0.005914879);
diffrac->SetBinContent(51,0.006233662);
diffrac->SetBinContent(52,0.006123537);
diffrac->SetBinContent(53,0.005494665);
diffrac->SetBinContent(54,0.005019388);
diffrac->SetBinContent(55,0.004778851);
diffrac->SetBinContent(56,0.004686114);
diffrac->SetBinContent(57,0.004355739);
diffrac->SetBinContent(58,0.004112304);
diffrac->SetBinContent(59,0.004112304);
diffrac->SetBinContent(60,0.004187653);
diffrac->SetBinContent(61,0.003448656);
diffrac->SetBinContent(62,0.003593557);
diffrac->SetBinContent(63,0.003376205);
diffrac->SetBinContent(64,0.003054524);
diffrac->SetBinContent(65,0.002628513);
diffrac->SetBinContent(66,0.003097994);
diffrac->SetBinContent(67,0.002509694);
diffrac->SetBinContent(68,0.002495204);
diffrac->SetBinContent(69,0.002547368);
diffrac->SetBinContent(70,0.002153236);
diffrac->SetBinContent(71,0.002222789);
diffrac->SetBinContent(72,0.001904006);
diffrac->SetBinContent(73,0.002008335);
diffrac->SetBinContent(74,0.001762002);
diffrac->SetBinContent(75,0.001617101);
diffrac->SetBinContent(76,0.001834453);
diffrac->SetBinContent(77,0.001770696);
diffrac->SetBinContent(78,0.001463505);
diffrac->SetBinContent(79,0.001312808);
diffrac->SetBinContent(80,0.001193988);
diffrac->SetBinContent(81,0.001240357);
diffrac->SetBinContent(82,0.001307011);
diffrac->SetBinContent(83,0.001101251);
diffrac->SetBinContent(84,0.001008514);
diffrac->SetBinContent(85,0.0008838991);
diffrac->SetBinContent(86,0.0009969223);
diffrac->SetBinContent(87,0.0008896952);
diffrac->SetBinContent(88,0.001011412);
diffrac->SetBinContent(89,0.0008867972);
diffrac->SetBinContent(90,0.0007563858);
diffrac->SetBinContent(91,0.000681037);
diffrac->SetBinContent(92,0.0005911981);
diffrac->SetBinContent(93,0.0007360996);
diffrac->SetBinContent(94,0.0006259745);
diffrac->SetBinContent(95,0.0004955631);
diffrac->SetBinContent(96,0.000486869);
diffrac->SetBinContent(97,0.0004462966);
diffrac->SetBinContent(98,0.0003970301);
diffrac->SetBinContent(99,0.0003448656);
diffrac->SetBinContent(100,0.0002782109);
diffrac->SetBinContent(101,0.0003042931);
diffrac->SetBinContent(102,0.0002550266);
diffrac->SetBinContent(103,0.0003361715);
diffrac->SetBinContent(104,0.0001854739);
diffrac->SetBinContent(105,0.0003158853);
diffrac->SetBinContent(106,0.0002144542);
diffrac->SetBinContent(107,0.0001767798);
diffrac->SetBinContent(108,0.0001477995);
diffrac->SetBinContent(109,0.0001506976);
diffrac->SetBinContent(110,0.0001362074);
diffrac->SetBinContent(111,0.0002463325);
diffrac->SetBinContent(112,0.0001391054);
diffrac->SetBinContent(113,0.0002173522);
diffrac->SetBinContent(114,9.853302e-05);
diffrac->SetBinContent(115,0.0001420035);
diffrac->SetBinContent(116,0.0001159212);
diffrac->SetBinContent(117,8.983893e-05);
diffrac->SetBinContent(118,6.085863e-05);
diffrac->SetBinContent(119,6.375666e-05);
diffrac->SetBinContent(120,6.375666e-05);
diffrac->SetBinContent(121,5.79606e-05);
diffrac->SetBinContent(122,6.665469e-05);
diffrac->SetBinContent(123,4.926651e-05);
diffrac->SetBinContent(124,4.347045e-05);
diffrac->SetBinContent(125,4.636848e-05);
diffrac->SetBinContent(126,5.216454e-05);
diffrac->SetBinContent(127,3.477636e-05);
diffrac->SetBinContent(128,3.767439e-05);
diffrac->SetBinContent(129,2.318424e-05);
diffrac->SetBinContent(130,2.028621e-05);
diffrac->SetBinContent(131,3.187833e-05);
diffrac->SetBinContent(132,2.608227e-05);
diffrac->SetBinContent(133,3.477636e-05);
diffrac->SetBinContent(134,1.738818e-05);
diffrac->SetBinContent(135,1.738818e-05);
diffrac->SetBinContent(136,8.69409e-06);
diffrac->SetBinContent(137,1.449015e-05);
diffrac->SetBinContent(138,1.449015e-05);
diffrac->SetBinContent(139,2.89803e-06);
diffrac->SetBinContent(140,5.79606e-06);
diffrac->SetBinContent(141,8.69409e-06);
diffrac->SetBinContent(142,1.159212e-05);
diffrac->SetBinContent(143,2.89803e-06);
diffrac->SetBinContent(144,1.159212e-05);
diffrac->SetBinContent(145,2.89803e-06);
diffrac->SetBinContent(146,2.89803e-06);
diffrac->SetBinContent(147,5.79606e-06);
diffrac->SetBinContent(149,8.69409e-06);
diffrac->SetBinContent(151,5.79606e-06);
diffrac->SetBinContent(152,8.69409e-06);
diffrac->SetBinContent(154,2.89803e-06);
diffrac->SetBinContent(155,2.89803e-06);
diffrac->SetBinContent(157,5.79606e-06);
diffrac->SetBinContent(170,2.89803e-06);
diffrac->SetBinContent(173,5.79606e-06);
diffrac->SetBinContent(178,2.89803e-06);
diffrac->SetBinError(1,2.109798e-05);
diffrac->SetBinError(2,7.872833e-05);
diffrac->SetBinError(3,0.0001065593);
diffrac->SetBinError(4,0.0001422694);
diffrac->SetBinError(5,0.0001825069);
diffrac->SetBinError(6,0.0002236183);
diffrac->SetBinError(7,0.0002601617);
diffrac->SetBinError(8,0.000294603);
diffrac->SetBinError(9,0.00031819);
diffrac->SetBinError(10,0.0003260638);
diffrac->SetBinError(11,0.0003374556);
diffrac->SetBinError(12,0.0003391438);
diffrac->SetBinError(13,0.0003337896);
diffrac->SetBinError(14,0.0003231531);
diffrac->SetBinError(15,0.0003154995);
diffrac->SetBinError(16,0.0003095742);
diffrac->SetBinError(17,0.0002962943);
diffrac->SetBinError(18,0.0002839921);
diffrac->SetBinError(19,0.0002806005);
diffrac->SetBinError(20,0.0002713336);
diffrac->SetBinError(21,0.0002575662);
diffrac->SetBinError(22,0.0002566189);
diffrac->SetBinError(23,0.0002493485);
diffrac->SetBinError(24,0.0002514615);
diffrac->SetBinError(25,0.0002409725);
diffrac->SetBinError(26,0.0002338802);
diffrac->SetBinError(27,0.0002245552);
diffrac->SetBinError(28,0.0002181237);
diffrac->SetBinError(29,0.0002131382);
diffrac->SetBinError(30,0.0002114371);
diffrac->SetBinError(31,0.0002066155);
diffrac->SetBinError(32,0.0002014704);
diffrac->SetBinError(33,0.0001930619);
diffrac->SetBinError(34,0.0001918399);
diffrac->SetBinError(35,0.0001925391);
diffrac->SetBinError(36,0.0001850432);
diffrac->SetBinError(37,0.0001826679);
diffrac->SetBinError(38,0.0001738093);
diffrac->SetBinError(39,0.0001724023);
diffrac->SetBinError(40,0.0001643467);
diffrac->SetBinError(41,0.0001617454);
diffrac->SetBinError(42,0.0001561444);
diffrac->SetBinError(43,0.0001554706);
diffrac->SetBinError(44,0.0001488753);
diffrac->SetBinError(45,0.0001514758);
diffrac->SetBinError(46,0.0001476574);
diffrac->SetBinError(47,0.0001391356);
diffrac->SetBinError(48,0.0001375267);
diffrac->SetBinError(49,0.0001319161);
diffrac->SetBinError(50,0.0001309255);
diffrac->SetBinError(51,0.0001344074);
diffrac->SetBinError(52,0.0001332148);
diffrac->SetBinError(53,0.0001261892);
diffrac->SetBinError(54,0.0001206082);
diffrac->SetBinError(55,0.0001176829);
diffrac->SetBinError(56,0.0001165354);
diffrac->SetBinError(57,0.0001123524);
diffrac->SetBinError(58,0.0001091677);
diffrac->SetBinError(59,0.0001091677);
diffrac->SetBinError(60,0.0001101633);
diffrac->SetBinError(61,9.997153e-05);
diffrac->SetBinError(62,0.0001020502);
diffrac->SetBinError(63,9.891584e-05);
diffrac->SetBinError(64,9.40856e-05);
diffrac->SetBinError(65,8.727835e-05);
diffrac->SetBinError(66,9.475273e-05);
diffrac->SetBinError(67,8.528287e-05);
diffrac->SetBinError(68,8.503632e-05);
diffrac->SetBinError(69,8.59206e-05);
diffrac->SetBinError(70,7.899458e-05);
diffrac->SetBinError(71,8.026026e-05);
diffrac->SetBinError(72,7.428234e-05);
diffrac->SetBinError(73,7.629033e-05);
diffrac->SetBinError(74,7.145862e-05);
diffrac->SetBinError(75,6.845733e-05);
diffrac->SetBinError(76,7.291296e-05);
diffrac->SetBinError(77,7.16347e-05);
diffrac->SetBinError(78,6.512512e-05);
diffrac->SetBinError(79,6.168108e-05);
diffrac->SetBinError(80,5.882358e-05);
diffrac->SetBinError(81,5.995491e-05);
diffrac->SetBinError(82,6.154477e-05);
diffrac->SetBinError(83,5.6493e-05);
diffrac->SetBinError(84,5.406205e-05);
diffrac->SetBinError(85,5.061192e-05);
diffrac->SetBinError(86,5.375045e-05);
diffrac->SetBinError(87,5.077759e-05);
diffrac->SetBinError(88,5.413967e-05);
diffrac->SetBinError(89,5.069482e-05);
diffrac->SetBinError(90,4.681911e-05);
diffrac->SetBinError(91,4.442596e-05);
diffrac->SetBinError(92,4.139215e-05);
diffrac->SetBinError(93,4.6187e-05);
diffrac->SetBinError(94,4.259217e-05);
diffrac->SetBinError(95,3.789666e-05);
diffrac->SetBinError(96,3.756276e-05);
diffrac->SetBinError(97,3.596361e-05);
diffrac->SetBinError(98,3.392057e-05);
diffrac->SetBinError(99,3.161377e-05);
diffrac->SetBinError(100,2.839478e-05);
diffrac->SetBinError(101,2.969597e-05);
diffrac->SetBinError(102,2.718593e-05);
diffrac->SetBinError(103,3.121274e-05);
diffrac->SetBinError(104,2.318424e-05);
diffrac->SetBinError(105,3.025632e-05);
diffrac->SetBinError(106,2.49298e-05);
diffrac->SetBinError(107,2.263434e-05);
diffrac->SetBinError(108,2.069607e-05);
diffrac->SetBinError(109,2.089799e-05);
diffrac->SetBinError(110,1.986789e-05);
diffrac->SetBinError(111,2.671852e-05);
diffrac->SetBinError(112,2.007814e-05);
diffrac->SetBinError(113,2.509768e-05);
diffrac->SetBinError(114,1.689827e-05);
diffrac->SetBinError(115,2.028621e-05);
diffrac->SetBinError(116,1.832875e-05);
diffrac->SetBinError(117,1.613555e-05);
diffrac->SetBinError(118,1.328044e-05);
diffrac->SetBinError(119,1.359297e-05);
diffrac->SetBinError(120,1.359297e-05);
diffrac->SetBinError(121,1.296038e-05);
diffrac->SetBinError(122,1.389846e-05);
diffrac->SetBinError(123,1.194888e-05);
diffrac->SetBinError(124,1.122402e-05);
diffrac->SetBinError(125,1.159212e-05);
diffrac->SetBinError(126,1.22953e-05);
diffrac->SetBinError(127,1.003907e-05);
diffrac->SetBinError(128,1.0449e-05);
diffrac->SetBinError(129,8.196866e-06);
diffrac->SetBinError(130,7.667466e-06);
diffrac->SetBinError(131,9.611678e-06);
diffrac->SetBinError(132,8.69409e-06);
diffrac->SetBinError(133,1.003907e-05);
diffrac->SetBinError(134,7.098695e-06);
diffrac->SetBinError(135,7.098695e-06);
diffrac->SetBinError(136,5.019535e-06);
diffrac->SetBinError(137,6.480192e-06);
diffrac->SetBinError(138,6.480192e-06);
diffrac->SetBinError(139,2.89803e-06);
diffrac->SetBinError(140,4.098433e-06);
diffrac->SetBinError(141,5.019535e-06);
diffrac->SetBinError(142,5.79606e-06);
diffrac->SetBinError(143,2.89803e-06);
diffrac->SetBinError(144,5.79606e-06);
diffrac->SetBinError(145,2.89803e-06);
diffrac->SetBinError(146,2.89803e-06);
diffrac->SetBinError(147,4.098433e-06);
diffrac->SetBinError(149,5.019535e-06);
diffrac->SetBinError(151,4.098433e-06);
diffrac->SetBinError(152,5.019535e-06);
diffrac->SetBinError(154,2.89803e-06);
diffrac->SetBinError(155,2.89803e-06);
diffrac->SetBinError(157,4.098433e-06);
diffrac->SetBinError(170,2.89803e-06);
diffrac->SetBinError(173,4.098433e-06);
diffrac->SetBinError(178,2.89803e-06);
diffrac->SetEntries(345062);
diffrac->SetDirectory(0);
diffrac->SetFillColor(1);
diffrac->SetFillStyle(0);
diffrac->SetLineStyle(2);
diffrac->SetLineWidth(3);
diffrac->SetMarkerStyle(20);
diffrac->GetXaxis()->SetTitle("M");
diffrac->GetXaxis()->SetLabelFont(42);
diffrac->GetXaxis()->SetLabelOffset(0.01);
diffrac->GetXaxis()->SetLabelSize(0.045);
diffrac->GetXaxis()->SetTitleSize(0.055);
diffrac->GetXaxis()->SetTitleFont(42);
diffrac->GetYaxis()->SetTitle("Fraction of events");
diffrac->GetYaxis()->SetLabelFont(42);
diffrac->GetYaxis()->SetLabelOffset(0.01);
diffrac->GetYaxis()->SetLabelSize(0.045);
diffrac->GetYaxis()->SetTitleSize(0.055);
diffrac->GetYaxis()->SetTitleOffset(1.6);
diffrac->GetYaxis()->SetTitleFont(42);
diffrac->GetZaxis()->SetLabelFont(42);
diffrac->GetZaxis()->SetLabelSize(0.045);
diffrac->GetZaxis()->SetTitleFont(42);
diffrac->Draw("p same");
TLegend *leg = new TLegend(0.61,0.67,0.91,0.87,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(62);
leg->SetTextSize(0.035);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(2);
leg->SetFillColor(19);
leg->SetFillStyle(0);
TLegendEntry *entry=leg->AddEntry("diffrac","PYTHIA 7 TeV","l");
entry->SetLineColor(1);
entry->SetLineWidth(2);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
//entry=leg->AddEntry("diffrac","(Atlas tune)","");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry=leg->AddEntry("diffrac","PHOJET 7 TeV","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
leg->Draw();
printFinalCanvases(cEvtSel,"diffrac");
/*
TLatex * tex = new TLatex(0.85,0.9,"CMS");
tex->SetNDC();
tex->SetTextSize(0.04);
tex->SetLineWidth(2);
tex->Draw();
cEvtSel->Modified();
cEvtSel->cd();
cEvtSel->SetSelected(cEvtSel);
*/
}
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;
}
void makeStack(TString myVar, TString myCut, TString myName, TString myAxisNameX, TString myAxisNameY,
vector<const Sample*>& listOfSignals, vector<const Sample*>& listOfSamples, vector<const Sample*> listOfDatasets,
TString inFileName,
bool isBlind, bool isLog, bool drawSignal, bool drawLegend,
int nBins, float xLow, float xHigh,
float* xlowVec)
{
// prepare the input file
TFile* infile = new TFile(inFileName, "READ");
infile -> cd();
// prepare the stack
THStack *hs = new THStack("hs","");
// prepare the histos pointers
TH1F* hist[20];
// prepare the tree pointers
TTree* tree[20];
// prepare the legend
TLegend* leg = new TLegend(.7485,.7225,.9597,.9604);
leg->SetFillColor(0);
// prepare the colors
Int_t col[20] = {46,2,12,5,3,4,9,7,47,49,49,50,51,52,53,54,55,56,57,58};
// prepare the cut
if (isBlind) myCut += "*(phoMetDeltaPhi < 2.9)";
// prepare the Y axis lable
if (xlowVec != 0) myAxisNameY = "Events/" + myAxisNameY;
else {
float binWidth = (xHigh-xLow)/nBins;
TString tempString;
tempString.Form("%.2f ",binWidth);
myAxisNameY = "Events/" + tempString + myAxisNameY;
}
// prepare the legend strings
vector<TString> theLegends;
// loop through the datasets and produce the plots
TH1F* hdata;
TH1F* hsignal;
//prepare data and signal histos
if (xlowVec != 0) hdata = new TH1F("hdata","",nBins,xlowVec);
else hdata = new TH1F("hdata","",nBins,xLow,xHigh);
if (xlowVec != 0) hsignal = new TH1F("hsignal","",nBins,xlowVec);
else hsignal = new TH1F("hsignal","",nBins,xLow,xHigh);
TTree* treedata[20];
for (UInt_t iDatas=0; iDatas < listOfDatasets.size(); iDatas++) {
//get the tree
treedata[iDatas] = (TTree*) infile -> Get(listOfDatasets.at(iDatas)->Name()->Data());
//fill the histogram
if ( iDatas == 0 ) treedata[iDatas] -> Draw(myVar + " >> hdata","evt_weight*kf_weight*pu_weight" + myCut);
else treedata[iDatas] -> Draw(myVar + " >>+ hdata","evt_weight*kf_weight*pu_weight" + myCut);
if ( isBlind && iDatas == 0 ) leg -> AddEntry(hdata, "DATA (19.8 fb^{-1})", "pl");
}//end loop on datasets
if (xlowVec != 0) {
for (int iBin = 1; iBin <= nBins; iBin++) hdata->SetBinError (iBin,hdata->GetBinError(iBin)/hdata->GetBinWidth(iBin));
for (int iBin = 1; iBin <= nBins; iBin++) hdata->SetBinContent(iBin,hdata->GetBinContent(iBin)/hdata->GetBinWidth(iBin));
}
TTree* treesignal[20];
for (UInt_t iSignal=0; iSignal < listOfSignals.size(); iSignal++) {
//get the tree
treesignal[iSignal] = (TTree*) infile -> Get(listOfSignals.at(iSignal)->Name()->Data());
//fill the histogram
TString thisScale = Form("%f *", *(listOfSignals.at(iSignal)->Scale()));
if ( iSignal == 0 ) treesignal[iSignal] -> Draw(myVar + " >> hsignal",thisScale + "evt_weight*kf_weight*pu_weight" + myCut);
else treesignal[iSignal] -> Draw(myVar + " >>+ hsignal",thisScale + "evt_weight*kf_weight*pu_weight" + myCut);
if ( drawSignal && iSignal == 0 ) leg -> AddEntry(hsignal, "Signal", "l");
}//end loop on signals
if (xlowVec != 0) {
for (int iBin = 1; iBin <= nBins; iBin++) hsignal->SetBinError (iBin,hsignal->GetBinError(iBin)/hsignal->GetBinWidth(iBin));
for (int iBin = 1; iBin <= nBins; iBin++) hsignal->SetBinContent(iBin,hsignal->GetBinContent(iBin)/hsignal->GetBinWidth(iBin));
}
hsignal -> SetLineColor(49);
hsignal -> SetLineWidth(4.0);
int theHistCounter = 0;
// loop through the samples and produce the plots
for (UInt_t iSample=0; iSample < listOfSamples.size(); iSample++) {
//determine if the histo is first of the series
bool isFirstOfSerie = (*listOfSamples.at(iSample)->Legend()).CompareTo(" ");
bool isLastOfSerie = false;
if (iSample == listOfSamples.size() - 1) isLastOfSerie = true;
if (iSample < listOfSamples.size() - 1 && (*listOfSamples.at(iSample+1)->Legend()).CompareTo(" ") != 0) isLastOfSerie = true;
//get the tree
tree[iSample] = (TTree*) infile -> Get(listOfSamples.at(iSample)->Name()->Data());
//if sample first of the list create a new histogram
if (isFirstOfSerie) {
TString thisHistName = "h_" + *(listOfSamples.at(iSample)->Name());
//variable bin histo
if (xlowVec != 0) hist[theHistCounter] = new TH1F(thisHistName,thisHistName,nBins,xlowVec);
//fixed bin histo
else hist[theHistCounter] = new TH1F(thisHistName,thisHistName,nBins,xLow,xHigh);
hist[theHistCounter] -> Sumw2();
hist[theHistCounter] -> SetFillColor(col[theHistCounter]);
hist[theHistCounter] -> SetFillStyle(1001);
theLegends.push_back(*listOfSamples.at(iSample)->Legend());
}
//fill the histogram
TString thisScale = Form("%f *", *(listOfSamples.at(iSample)->Scale()));
if (isFirstOfSerie) tree[iSample] -> Draw(myVar + " >> " + TString(hist[theHistCounter] -> GetName()),thisScale + "evt_weight*kf_weight*pu_weight" + myCut);
else tree[iSample] -> Draw(myVar + " >>+ " + TString(hist[theHistCounter] -> GetName()),thisScale + "evt_weight*kf_weight*pu_weight" + myCut);
//add the histogram to the stack if the last of the series:
//either last sample or ~ sample followed by non ~ sample
if (isLastOfSerie) {
if (xlowVec != 0) {
for (int iBin = 1; iBin <= nBins; iBin++) hist[theHistCounter]->SetBinError (iBin,hist[theHistCounter]->GetBinError(iBin)/hist[theHistCounter]->GetBinWidth(iBin));
for (int iBin = 1; iBin <= nBins; iBin++) hist[theHistCounter]->SetBinContent(iBin,hist[theHistCounter]->GetBinContent(iBin)/hist[theHistCounter]->GetBinWidth(iBin));
}
hs -> Add(hist[theHistCounter]);
theHistCounter++;
}
}//end loop on samples
//Fix the legend
for (int iHisto = theHistCounter-1; iHisto >= 0; iHisto--) {
leg -> AddEntry(hist[iHisto], theLegends[iHisto], "f");
}
//get the maximum to properly set the frame
float theMax = hdata -> GetBinContent(hdata -> GetMaximumBin()) + hdata -> GetBinError(hdata -> GetMaximumBin());
TH1* theMCSum = (TH1*) hs->GetStack()->Last();
float theMaxMC = theMCSum->GetBinContent(theMCSum->GetMaximumBin()) + theMCSum->GetBinError(theMCSum->GetMaximumBin());
if (theMaxMC > theMax) theMax = theMaxMC;
//prepare the ratio band and plot
TH1* theMCRatioBand = makeRatioBand(theMCSum);
TH1* theRatioPlot = makeRatioPlot(hdata,theMCSum);
TCanvas* can = new TCanvas();
can -> SetLogy(isLog);
TPad *pad1 = new TPad("pad1","top pad",0,0.30,1,1);
pad1->SetBottomMargin(0.02);
pad1->SetLeftMargin(0.13);
pad1->Draw();
TPad *pad2 = new TPad("pad2","bottom pad",0,0.0,1,0.30);
pad2->SetTopMargin(0.02);
pad2->SetLeftMargin(0.13);
pad2->SetBottomMargin(0.4);
pad2->SetGridy();
pad2->Draw();
pad1->cd();
hs->Draw("hist");
hdata->Draw("same,pe");
if (drawSignal) hsignal->Draw("same,hist");
if (drawLegend) leg->Draw("same");
//hs->GetXaxis()->SetTitle(myAxisNameX);
hs->GetYaxis()->SetTitle(myAxisNameY);
hs->GetXaxis()->SetLabelSize(0.04);
hs->GetYaxis()->SetLabelSize(0.04);
hs->GetXaxis()->SetLabelOffset(0.025);
hs->GetYaxis()->SetLabelOffset(0.035);
//hs->GetXaxis()->SetTitleOffset(1.1);
hs->GetYaxis()->SetTitleOffset(1.1);
hs->SetMaximum(theMax);
if (isLog) hs->SetMinimum(0.01);
pad2->cd();
theMCRatioBand->GetXaxis()->SetTitle(myAxisNameX);
theMCRatioBand->GetXaxis()->SetTitleSize(0.16);
theMCRatioBand->GetXaxis()->SetTitleOffset(1.1);
theMCRatioBand->GetXaxis()->SetLabelSize(0.12);
theMCRatioBand->GetXaxis()->SetLabelOffset(0.07);
theMCRatioBand->GetYaxis()->SetTitle("Data/MC");
theMCRatioBand->GetYaxis()->SetTitleSize(0.10);
theMCRatioBand->GetYaxis()->SetTitleOffset(0.6);
theMCRatioBand->GetYaxis()->SetLabelSize(0.06);
theMCRatioBand->GetYaxis()->SetLabelOffset(0.03);
theMCRatioBand->SetFillStyle(3001);
theMCRatioBand->SetFillColor(kBlue);
theMCRatioBand->SetLineWidth(1);
theMCRatioBand->SetLineColor(kBlack);
theMCRatioBand->SetMarkerSize(0.1);
theMCRatioBand->SetMaximum(4.);
theMCRatioBand->SetMinimum(0.);
theMCRatioBand->Draw("E2");
TLine *line = new TLine(xLow,1,xHigh,1);
line->SetLineColor(kBlack);
line->Draw("same");
theRatioPlot->Draw("same,pe");
can->cd();
can->Modified();
can -> SaveAs(myName + ".pdf","pdf");
//cleanup the memory allocation
delete theMCSum;
delete hs;
delete leg;
delete hdata;
delete pad1;
delete pad2;
delete can;
delete theMCRatioBand;
delete theRatioPlot;
infile -> Close();
delete infile;
return;
}
//
//----------------------------------------------------------------------
//
int fittp0( char* hs ) {
TH1 *h = (TH1*)gDirectory->Get(hs);
if( h == NULL ){
cout << hs << " does not exist\n";
}
else{
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);
cout << hs << ": " << x1 << " - " << x9 << endl;
// create a TF1 with the range from x1 to x9 and 5 parameters
TF1 *tp0Fcn = new TF1( "tp0Fcn", tp0Fit, x1, x9, 5 );
tp0Fcn->SetParName( 0, "mean" );
tp0Fcn->SetParName( 1, "sigma" );
tp0Fcn->SetParName( 2, "nu" );
tp0Fcn->SetParName( 3, "area" );
tp0Fcn->SetParName( 4, "BG" );
tp0Fcn->SetNpx(500);
tp0Fcn->SetLineWidth(4);
tp0Fcn->SetLineColor(kMagenta);
tp0Fcn->SetLineColor(kGreen);
// set start values for some parameters:
cout << hs << " " << dx << ", " << nn << ", " << xmax << endl;
tp0Fcn->SetParameter( 0, xmax ); // peak position
tp0Fcn->SetParameter( 1, 4*dx ); // width
tp0Fcn->SetParameter( 2, 2.2 ); // nu
tp0Fcn->SetParameter( 3, nn ); // N
tp0Fcn->SetParameter( 4, bg );
h->Fit( "tp0Fcn", "R", "ep" );
// h->Fit("tp0Fcn","V+","ep");
h->Draw("histepsame"); // data again on top
}
}
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 trigeff(){
gROOT->Reset();
//=========Macro generated from canvas: cEvtSel/EvtSel
//========= (Wed Apr 14 17:19:34 2010) by ROOT version5.22/00d
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",550,600);
/*
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",0,22,550,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
cEvtSel->Range(-13.62658,-0.215625,63.58861,1.221875);
cEvtSel->SetFillColor(0);
cEvtSel->SetBorderMode(0);
cEvtSel->SetBorderSize(0);
cEvtSel->SetTickx(1);
cEvtSel->SetTicky(1);
cEvtSel->SetLeftMargin(0.17);
cEvtSel->SetRightMargin(0.04);
cEvtSel->SetTopMargin(0.05);
cEvtSel->SetBottomMargin(0.15);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
*/
TH1 *hFrame1 = new TH2D("hFrame1","",1,-0.5,60.5,1,0,1.15);
hFrame1->SetDirectory(0);
hFrame1->SetStats(0);
hFrame1->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame1->GetXaxis()->CenterTitle(true);
hFrame1->GetYaxis()->SetTitle("Selection efficiency");
hFrame1->GetYaxis()->CenterTitle(true);
hFrame1->Draw("");
hFrame1->GetXaxis()->SetNdivisions(312);
/*
TH1 *hFrame1 = new TH2D("hFrame1","",1,-0.5,60.5,1,0,1.15);
hFrame1->SetDirectory(0);
hFrame1->SetStats(0);
hFrame1->SetFillColor(1);
hFrame1->SetFillStyle(0);
hFrame1->SetLineStyle(0);
hFrame1->SetMarkerStyle(20);
hFrame1->SetMarkerSize(1.5);
hFrame1->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame1->GetXaxis()->CenterTitle(true);
hFrame1->GetXaxis()->SetNdivisions(312);
hFrame1->GetXaxis()->SetLabelFont(42);
hFrame1->GetXaxis()->SetLabelOffset(0.01);
hFrame1->GetXaxis()->SetLabelSize(0.045);
hFrame1->GetXaxis()->SetTitleSize(0.055);
hFrame1->GetXaxis()->SetTitleFont(42);
hFrame1->GetYaxis()->SetTitle("Selection efficiency");
hFrame1->GetYaxis()->CenterTitle(true);
hFrame1->GetYaxis()->SetLabelFont(42);
hFrame1->GetYaxis()->SetLabelOffset(0.01);
hFrame1->GetYaxis()->SetLabelSize(0.045);
hFrame1->GetYaxis()->SetTitleSize(0.055);
hFrame1->GetYaxis()->SetTitleOffset(1.6);
hFrame1->GetYaxis()->SetTitleFont(42);
hFrame1->GetZaxis()->SetLabelFont(42);
hFrame1->GetZaxis()->SetLabelSize(0.045);
hFrame1->GetZaxis()->SetTitleFont(42);
hFrame1->Draw("");
*/
TH1 *trigeff = new TH1D("trigeff","trigeff",200,0,200);
trigeff->SetBinContent(1,0.007879584);
trigeff->SetBinContent(2,0.3524112);
trigeff->SetBinContent(3,0.5050529);
trigeff->SetBinContent(4,0.5978595);
trigeff->SetBinContent(5,0.6587795);
trigeff->SetBinContent(6,0.7034895);
trigeff->SetBinContent(7,0.7451056);
trigeff->SetBinContent(8,0.7911818);
trigeff->SetBinContent(9,0.8363224);
trigeff->SetBinContent(10,0.873251);
trigeff->SetBinContent(11,0.9012649);
trigeff->SetBinContent(12,0.9177872);
trigeff->SetBinContent(13,0.9395182);
trigeff->SetBinContent(14,0.9502278);
trigeff->SetBinContent(15,0.9600504);
trigeff->SetBinContent(16,0.9667429);
trigeff->SetBinContent(17,0.9722969);
trigeff->SetBinContent(18,0.977478);
trigeff->SetBinContent(19,0.9801504);
trigeff->SetBinContent(20,0.9840849);
trigeff->SetBinContent(21,0.9843521);
trigeff->SetBinContent(22,0.9856779);
trigeff->SetBinContent(23,0.9894354);
trigeff->SetBinContent(24,0.9892805);
trigeff->SetBinContent(25,0.9913111);
trigeff->SetBinContent(26,0.9934833);
trigeff->SetBinContent(27,0.9907814);
trigeff->SetBinContent(28,0.9928126);
trigeff->SetBinContent(29,0.990099);
trigeff->SetBinContent(30,0.9918119);
trigeff->SetBinContent(31,0.994504);
trigeff->SetBinContent(32,0.9938513);
trigeff->SetBinContent(33,0.993073);
trigeff->SetBinContent(34,0.9965539);
trigeff->SetBinContent(35,0.9955737);
trigeff->SetBinContent(36,0.9952005);
trigeff->SetBinContent(37,0.9940288);
trigeff->SetBinContent(38,0.9946929);
trigeff->SetBinContent(39,0.9973046);
trigeff->SetBinContent(40,0.9959936);
trigeff->SetBinContent(41,0.9964897);
trigeff->SetBinContent(42,0.9943966);
trigeff->SetBinContent(43,0.9940175);
trigeff->SetBinContent(44,0.9947941);
trigeff->SetBinContent(45,0.9960804);
trigeff->SetBinContent(46,0.9970282);
trigeff->SetBinContent(47,0.9963936);
trigeff->SetBinContent(48,0.9968187);
trigeff->SetBinContent(49,0.9956733);
trigeff->SetBinContent(50,0.996085);
trigeff->SetBinContent(51,0.9988466);
trigeff->SetBinContent(52,0.9982079);
trigeff->SetBinContent(53,0.99625);
trigeff->SetBinContent(54,0.9962802);
trigeff->SetBinContent(55,0.9980328);
trigeff->SetBinContent(56,0.9960396);
trigeff->SetBinContent(57,0.9993271);
trigeff->SetBinContent(58,0.9978261);
trigeff->SetBinContent(59,0.9950843);
trigeff->SetBinContent(60,0.9992459);
trigeff->SetBinContent(61,0.9977925);
trigeff->SetBinContent(62,0.9960599);
trigeff->SetBinContent(63,0.9952456);
trigeff->SetBinContent(64,0.9960661);
trigeff->SetBinContent(65,0.9965428);
trigeff->SetBinContent(66,0.995094);
trigeff->SetBinContent(67,0.9962441);
trigeff->SetBinContent(68,0.9990842);
trigeff->SetBinContent(69,0.9981413);
trigeff->SetBinContent(70,0.9981007);
trigeff->SetBinContent(71,0.9980676);
trigeff->SetBinContent(72,0.9990512);
trigeff->SetBinContent(73,0.9969636);
trigeff->SetBinContent(74,0.9959432);
trigeff->SetBinContent(75,0.9969008);
trigeff->SetBinContent(76,0.994929);
trigeff->SetBinContent(77,0.9978425);
trigeff->SetBinContent(78,0.9989396);
trigeff->SetBinContent(79,0.9955996);
trigeff->SetBinContent(80,0.9988975);
trigeff->SetBinContent(81,0.998829);
trigeff->SetBinContent(82,0.9960682);
trigeff->SetBinContent(83,0.9963986);
trigeff->SetBinContent(84,0.995098);
trigeff->SetBinContent(85,0.9962169);
trigeff->SetBinContent(86,0.9973615);
trigeff->SetBinContent(87,0.9987562);
trigeff->SetBinContent(88,0.9987212);
trigeff->SetBinContent(89,0.9987374);
trigeff->SetBinContent(90,0.9986264);
trigeff->SetBinContent(91,0.9972973);
trigeff->SetBinContent(92,1);
trigeff->SetBinContent(93,0.9959459);
trigeff->SetBinContent(94,0.9945504);
trigeff->SetBinContent(95,0.9985612);
trigeff->SetBinContent(96,1);
trigeff->SetBinContent(97,1);
trigeff->SetBinContent(98,0.9968454);
trigeff->SetBinContent(99,0.9983471);
trigeff->SetBinContent(100,0.9968);
trigeff->SetBinContent(101,0.9983871);
trigeff->SetBinContent(102,0.9966044);
trigeff->SetBinContent(103,0.9984);
trigeff->SetBinContent(104,1);
trigeff->SetBinContent(105,0.9946996);
trigeff->SetBinContent(106,0.9946333);
trigeff->SetBinContent(107,0.9981343);
trigeff->SetBinContent(108,1);
trigeff->SetBinContent(109,0.9962963);
trigeff->SetBinContent(110,0.9923225);
trigeff->SetBinContent(111,1);
trigeff->SetBinContent(112,0.9979633);
trigeff->SetBinContent(113,0.9978166);
trigeff->SetBinContent(114,1);
trigeff->SetBinContent(115,0.9980237);
trigeff->SetBinContent(116,0.9952494);
trigeff->SetBinContent(117,0.9979253);
trigeff->SetBinContent(118,1);
trigeff->SetBinContent(119,1);
trigeff->SetBinContent(120,0.9950125);
trigeff->SetBinContent(121,0.9975728);
trigeff->SetBinContent(122,0.9921466);
trigeff->SetBinContent(123,0.9974874);
trigeff->SetBinContent(124,1);
trigeff->SetBinContent(125,0.9974874);
trigeff->SetBinContent(126,0.9969419);
trigeff->SetBinContent(127,0.994723);
trigeff->SetBinContent(128,0.9940299);
trigeff->SetBinContent(129,1);
trigeff->SetBinContent(130,0.9966667);
trigeff->SetBinContent(131,1);
trigeff->SetBinContent(132,1);
trigeff->SetBinContent(133,0.9931507);
trigeff->SetBinContent(134,0.9963504);
trigeff->SetBinContent(135,1);
trigeff->SetBinContent(136,0.9959677);
trigeff->SetBinContent(137,1);
trigeff->SetBinContent(138,1);
trigeff->SetBinContent(139,1);
trigeff->SetBinContent(140,0.9959514);
trigeff->SetBinContent(141,1);
trigeff->SetBinContent(142,0.9955556);
trigeff->SetBinContent(143,1);
trigeff->SetBinContent(144,1);
trigeff->SetBinContent(145,1);
trigeff->SetBinContent(146,0.989418);
trigeff->SetBinContent(147,0.9940828);
trigeff->SetBinContent(148,1);
trigeff->SetBinContent(149,0.9942857);
trigeff->SetBinContent(150,1);
trigeff->SetBinContent(151,1);
trigeff->SetBinContent(152,1);
trigeff->SetBinContent(153,1);
trigeff->SetBinContent(154,1);
trigeff->SetBinContent(155,0.9923077);
trigeff->SetBinContent(156,1);
trigeff->SetBinContent(157,1);
trigeff->SetBinContent(158,1);
trigeff->SetBinContent(159,1);
trigeff->SetBinContent(160,0.9901961);
trigeff->SetBinContent(161,1);
trigeff->SetBinContent(162,1);
trigeff->SetBinContent(163,1);
trigeff->SetBinContent(164,1);
trigeff->SetBinContent(165,0.9767442);
trigeff->SetBinContent(166,1);
trigeff->SetBinContent(167,1);
trigeff->SetBinContent(168,1);
trigeff->SetBinContent(169,1);
trigeff->SetBinContent(170,1);
trigeff->SetBinContent(171,1);
trigeff->SetBinContent(172,1);
trigeff->SetBinContent(173,0.9807692);
trigeff->SetBinContent(174,1);
trigeff->SetBinContent(175,0.9850746);
trigeff->SetBinContent(176,1);
trigeff->SetBinContent(177,1);
trigeff->SetBinContent(178,1);
trigeff->SetBinContent(179,1);
trigeff->SetBinContent(180,1);
trigeff->SetBinContent(181,1);
trigeff->SetBinContent(182,1);
trigeff->SetBinContent(183,1);
trigeff->SetBinContent(184,1);
trigeff->SetBinContent(185,1);
trigeff->SetBinContent(186,1);
trigeff->SetBinContent(187,1);
trigeff->SetBinContent(188,1);
trigeff->SetBinContent(189,1);
trigeff->SetBinContent(190,1);
trigeff->SetBinContent(191,1);
trigeff->SetBinContent(192,1);
trigeff->SetBinContent(193,1);
trigeff->SetBinContent(194,1);
trigeff->SetBinContent(195,0.9333333);
trigeff->SetBinContent(196,1);
trigeff->SetBinContent(197,0.9230769);
trigeff->SetBinContent(198,1);
trigeff->SetBinContent(199,1);
trigeff->SetBinContent(200,1);
trigeff->SetBinContent(201,1);
trigeff->SetBinError(1,0.0006283812);
trigeff->SetBinError(2,0.005498682);
trigeff->SetBinError(3,0.0054516);
trigeff->SetBinError(4,0.005047444);
trigeff->SetBinError(5,0.004707652);
trigeff->SetBinError(6,0.004447388);
trigeff->SetBinError(7,0.004290336);
trigeff->SetBinError(8,0.003953715);
trigeff->SetBinError(9,0.003594607);
trigeff->SetBinError(10,0.003181503);
trigeff->SetBinError(11,0.002795854);
trigeff->SetBinError(12,0.002534088);
trigeff->SetBinError(13,0.002203234);
trigeff->SetBinError(14,0.002035759);
trigeff->SetBinError(15,0.001857668);
trigeff->SetBinError(16,0.001750359);
trigeff->SetBinError(17,0.001668633);
trigeff->SetBinError(18,0.001566698);
trigeff->SetBinError(19,0.001548763);
trigeff->SetBinError(20,0.001441238);
trigeff->SetBinError(21,0.001500853);
trigeff->SetBinError(22,0.001498831);
trigeff->SetBinError(23,0.001345494);
trigeff->SetBinError(24,0.001388057);
trigeff->SetBinError(25,0.001289631);
trigeff->SetBinError(26,0.001166616);
trigeff->SetBinError(27,0.001415891);
trigeff->SetBinError(28,0.0013075);
trigeff->SetBinError(29,0.001557715);
trigeff->SetBinError(30,0.001464586);
trigeff->SetBinError(31,0.001225565);
trigeff->SetBinError(32,0.001306868);
trigeff->SetBinError(33,0.001471707);
trigeff->SetBinError(34,0.001037251);
trigeff->SetBinError(35,0.001224911);
trigeff->SetBinError(36,0.001279626);
trigeff->SetBinError(37,0.001443898);
trigeff->SetBinError(38,0.0014146);
trigeff->SetBinError(39,0.001017398);
trigeff->SetBinError(40,0.001264398);
trigeff->SetBinError(41,0.001238902);
trigeff->SetBinError(42,0.001549757);
trigeff->SetBinError(43,0.00165428);
trigeff->SetBinError(44,0.001565537);
trigeff->SetBinError(45,0.001383086);
trigeff->SetBinError(46,0.001211415);
trigeff->SetBinError(47,0.001360627);
trigeff->SetBinError(48,0.001296707);
trigeff->SetBinError(49,0.001526394);
trigeff->SetBinError(50,0.001476827);
trigeff->SetBinError(51,0.0008151083);
trigeff->SetBinError(52,0.00103375);
trigeff->SetBinError(53,0.001528058);
trigeff->SetBinError(54,0.001515765);
trigeff->SetBinError(55,0.001134653);
trigeff->SetBinError(56,0.00161362);
trigeff->SetBinError(57,0.000672721);
trigeff->SetBinError(58,0.001253744);
trigeff->SetBinError(59,0.001853399);
trigeff->SetBinError(60,0.0007538634);
trigeff->SetBinError(61,0.001273096);
trigeff->SetBinError(62,0.001758596);
trigeff->SetBinError(63,0.001936339);
trigeff->SetBinError(64,0.001755834);
trigeff->SetBinError(65,0.001725618);
trigeff->SetBinError(66,0.001997934);
trigeff->SetBinError(67,0.001874404);
trigeff->SetBinError(68,0.0009153315);
trigeff->SetBinError(69,0.001313103);
trigeff->SetBinError(70,0.001341757);
trigeff->SetBinError(71,0.001365069);
trigeff->SetBinError(72,0.0009483164);
trigeff->SetBinError(73,0.001750424);
trigeff->SetBinError(74,0.002024279);
trigeff->SetBinError(75,0.001786534);
trigeff->SetBinError(76,0.00226206);
trigeff->SetBinError(77,0.001523934);
trigeff->SetBinError(78,0.001059883);
trigeff->SetBinError(79,0.002195374);
trigeff->SetBinError(80,0.001101928);
trigeff->SetBinError(81,0.001170274);
trigeff->SetBinError(82,0.002265586);
trigeff->SetBinError(83,0.002075545);
trigeff->SetBinError(84,0.002444966);
trigeff->SetBinError(85,0.00218004);
trigeff->SetBinError(86,0.001863254);
trigeff->SetBinError(87,0.001243007);
trigeff->SetBinError(88,0.001277954);
trigeff->SetBinError(89,0.001261829);
trigeff->SetBinError(90,0.001372683);
trigeff->SetBinError(91,0.001908515);
trigeff->SetBinError(93,0.00233586);
trigeff->SetBinError(94,0.002717361);
trigeff->SetBinError(95,0.001437813);
trigeff->SetBinError(98,0.0022271);
trigeff->SetBinError(99,0.001651526);
trigeff->SetBinError(100,0.002259118);
trigeff->SetBinError(101,0.001611602);
trigeff->SetBinError(102,0.002396962);
trigeff->SetBinError(103,0.001598719);
trigeff->SetBinError(105,0.00305204);
trigeff->SetBinError(106,0.003090155);
trigeff->SetBinError(107,0.00186393);
trigeff->SetBinError(109,0.00261406);
trigeff->SetBinError(110,0.003824007);
trigeff->SetBinError(112,0.002034585);
trigeff->SetBinError(113,0.002181021);
trigeff->SetBinError(115,0.001974331);
trigeff->SetBinError(116,0.003351189);
trigeff->SetBinError(117,0.002072536);
trigeff->SetBinError(120,0.003517911);
trigeff->SetBinError(121,0.002424237);
trigeff->SetBinError(122,0.004516325);
trigeff->SetBinError(123,0.002509404);
trigeff->SetBinError(125,0.002509404);
trigeff->SetBinError(126,0.003053424);
trigeff->SetBinError(127,0.003721576);
trigeff->SetBinError(128,0.004208913);
trigeff->SetBinError(130,0.003327773);
trigeff->SetBinError(133,0.004826582);
trigeff->SetBinError(134,0.003642969);
trigeff->SetBinError(136,0.00402412);
trigeff->SetBinError(140,0.004040379);
trigeff->SetBinError(142,0.004434557);
trigeff->SetBinError(146,0.007442916);
trigeff->SetBinError(147,0.005899627);
trigeff->SetBinError(149,0.005697936);
trigeff->SetBinError(155,0.007662665);
trigeff->SetBinError(160,0.009755745);
trigeff->SetBinError(165,0.01625201);
trigeff->SetBinError(173,0.01904496);
trigeff->SetBinError(175,0.01481357);
trigeff->SetBinError(195,0.06440612);
trigeff->SetBinError(197,0.0739053);
trigeff->SetEntries(385140);
trigeff->SetDirectory(0);
trigeff->SetFillColor(1);
trigeff->SetFillStyle(0);
trigeff->SetLineStyle(0);
trigeff->SetLineWidth(2);
trigeff->SetMarkerStyle(20);
trigeff->SetMarkerSize(1.5);
trigeff->GetXaxis()->SetTitle("M");
trigeff->GetXaxis()->SetLabelFont(42);
trigeff->GetXaxis()->SetLabelOffset(0.01);
trigeff->GetXaxis()->SetLabelSize(0.045);
trigeff->GetXaxis()->SetTitleSize(0.055);
trigeff->GetXaxis()->SetTitleFont(42);
trigeff->GetYaxis()->SetTitle("Selection efficiency");
trigeff->GetYaxis()->SetLabelFont(42);
trigeff->GetYaxis()->SetLabelOffset(0.01);
trigeff->GetYaxis()->SetLabelSize(0.045);
trigeff->GetYaxis()->SetTitleSize(0.055);
trigeff->GetYaxis()->SetTitleOffset(1.6);
trigeff->GetYaxis()->SetTitleFont(42);
trigeff->GetZaxis()->SetLabelFont(42);
trigeff->GetZaxis()->SetLabelSize(0.045);
trigeff->GetZaxis()->SetTitleFont(42);
trigeff->Draw("hist same");
TH1 *trigeff = new TH1D("trigeff","trigeff",200,0,200);
trigeff->SetBinContent(1,0.009007478);
trigeff->SetBinContent(2,0.2935561);
trigeff->SetBinContent(3,0.4702609);
trigeff->SetBinContent(4,0.6518799);
trigeff->SetBinContent(5,0.7428357);
trigeff->SetBinContent(6,0.8347119);
trigeff->SetBinContent(7,0.8777911);
trigeff->SetBinContent(8,0.904666);
trigeff->SetBinContent(9,0.9195271);
trigeff->SetBinContent(10,0.9292373);
trigeff->SetBinContent(11,0.9375605);
trigeff->SetBinContent(12,0.9489987);
trigeff->SetBinContent(13,0.9535653);
trigeff->SetBinContent(14,0.9493052);
trigeff->SetBinContent(15,0.9572732);
trigeff->SetBinContent(16,0.9589076);
trigeff->SetBinContent(17,0.9627003);
trigeff->SetBinContent(18,0.9629964);
trigeff->SetBinContent(19,0.9683917);
trigeff->SetBinContent(20,0.9674429);
trigeff->SetBinContent(21,0.9771153);
trigeff->SetBinContent(22,0.9762201);
trigeff->SetBinContent(23,0.9766491);
trigeff->SetBinContent(24,0.9828982);
trigeff->SetBinContent(25,0.9802921);
trigeff->SetBinContent(26,0.9826494);
trigeff->SetBinContent(27,0.9759428);
trigeff->SetBinContent(28,0.9843614);
trigeff->SetBinContent(29,0.9879452);
trigeff->SetBinContent(30,0.9855582);
trigeff->SetBinContent(31,0.9875656);
trigeff->SetBinContent(32,0.9883436);
trigeff->SetBinContent(33,0.9886389);
trigeff->SetBinContent(34,0.9900587);
trigeff->SetBinContent(35,0.9925793);
trigeff->SetBinContent(36,0.9926954);
trigeff->SetBinContent(37,0.9905261);
trigeff->SetBinContent(38,0.993372);
trigeff->SetBinContent(39,0.9899301);
trigeff->SetBinContent(40,0.9913687);
trigeff->SetBinContent(41,0.9920382);
trigeff->SetBinContent(42,0.9901091);
trigeff->SetBinContent(43,0.9941278);
trigeff->SetBinContent(44,0.9865421);
trigeff->SetBinContent(45,0.9902138);
trigeff->SetBinContent(46,0.9965451);
trigeff->SetBinContent(47,0.9961106);
trigeff->SetBinContent(48,0.9951392);
trigeff->SetBinContent(49,0.9951969);
trigeff->SetBinContent(50,0.9960957);
trigeff->SetBinContent(51,0.9981439);
trigeff->SetBinContent(52,0.9962282);
trigeff->SetBinContent(53,0.9973698);
trigeff->SetBinContent(54,0.9976959);
trigeff->SetBinContent(55,0.9933735);
trigeff->SetBinContent(56,0.9956897);
trigeff->SetBinContent(57,0.9953642);
trigeff->SetBinContent(58,0.9902303);
trigeff->SetBinContent(59,0.9985925);
trigeff->SetBinContent(60,0.9986178);
trigeff->SetBinContent(61,0.9991604);
trigeff->SetBinContent(62,0.9983897);
trigeff->SetBinContent(63,0.9940273);
trigeff->SetBinContent(64,0.9952786);
trigeff->SetBinContent(65,0.9977998);
trigeff->SetBinContent(66,0.9972015);
trigeff->SetBinContent(67,0.9908467);
trigeff->SetBinContent(68,1);
trigeff->SetBinContent(69,0.9988636);
trigeff->SetBinContent(70,0.9933155);
trigeff->SetBinContent(71,0.9986979);
trigeff->SetBinContent(72,0.9969651);
trigeff->SetBinContent(73,0.9971223);
trigeff->SetBinContent(74,0.9967213);
trigeff->SetBinContent(75,0.9982111);
trigeff->SetBinContent(76,0.9968504);
trigeff->SetBinContent(77,0.9967374);
trigeff->SetBinContent(78,0.9980237);
trigeff->SetBinContent(79,0.9977974);
trigeff->SetBinContent(80,1);
trigeff->SetBinContent(81,0.997669);
trigeff->SetBinContent(82,0.9977876);
trigeff->SetBinContent(83,0.9921671);
trigeff->SetBinContent(84,0.9942857);
trigeff->SetBinContent(85,1);
trigeff->SetBinContent(86,1);
trigeff->SetBinContent(87,0.9967532);
trigeff->SetBinContent(88,1);
trigeff->SetBinContent(89,0.9967427);
trigeff->SetBinContent(90,0.9961832);
trigeff->SetBinContent(91,1);
trigeff->SetBinContent(92,1);
trigeff->SetBinContent(93,1);
trigeff->SetBinContent(94,1);
trigeff->SetBinContent(95,1);
trigeff->SetBinContent(96,0.9940828);
trigeff->SetBinContent(97,1);
trigeff->SetBinContent(98,0.9927536);
trigeff->SetBinContent(99,1);
trigeff->SetBinContent(100,0.9896907);
trigeff->SetBinContent(101,0.990566);
trigeff->SetBinContent(102,0.988764);
trigeff->SetBinContent(103,1);
trigeff->SetBinContent(104,1);
trigeff->SetBinContent(105,1);
trigeff->SetBinContent(106,1);
trigeff->SetBinContent(107,1);
trigeff->SetBinContent(108,1);
trigeff->SetBinContent(109,1);
trigeff->SetBinContent(110,1);
trigeff->SetBinContent(111,1);
trigeff->SetBinContent(112,1);
trigeff->SetBinContent(113,1);
trigeff->SetBinContent(114,1);
trigeff->SetBinContent(115,1);
trigeff->SetBinContent(116,1);
trigeff->SetBinContent(117,1);
trigeff->SetBinContent(118,1);
trigeff->SetBinContent(119,1);
trigeff->SetBinContent(120,1);
trigeff->SetBinContent(121,1);
trigeff->SetBinContent(122,1);
trigeff->SetBinContent(123,1);
trigeff->SetBinContent(124,1);
trigeff->SetBinContent(125,1);
trigeff->SetBinContent(126,1);
trigeff->SetBinContent(127,1);
trigeff->SetBinContent(128,1);
trigeff->SetBinContent(129,1);
trigeff->SetBinContent(130,1);
trigeff->SetBinContent(131,1);
trigeff->SetBinContent(132,1);
trigeff->SetBinContent(133,1);
trigeff->SetBinContent(134,1);
trigeff->SetBinContent(135,1);
trigeff->SetBinContent(136,1);
trigeff->SetBinContent(137,1);
trigeff->SetBinContent(138,1);
trigeff->SetBinContent(139,1);
trigeff->SetBinContent(140,1);
trigeff->SetBinContent(141,1);
trigeff->SetBinContent(142,1);
trigeff->SetBinContent(143,1);
trigeff->SetBinContent(144,1);
trigeff->SetBinContent(145,1);
trigeff->SetBinContent(146,1);
trigeff->SetBinContent(147,1);
trigeff->SetBinContent(149,1);
trigeff->SetBinContent(151,1);
trigeff->SetBinContent(152,1);
trigeff->SetBinContent(154,1);
trigeff->SetBinContent(155,1);
trigeff->SetBinContent(157,1);
trigeff->SetBinContent(170,1);
trigeff->SetBinContent(173,1);
trigeff->SetBinContent(178,1);
trigeff->SetBinError(1,0.001231687);
trigeff->SetBinError(2,0.009082424);
trigeff->SetBinError(3,0.009308539);
trigeff->SetBinError(4,0.007834723);
trigeff->SetBinError(5,0.00598166);
trigeff->SetBinError(6,0.004397977);
trigeff->SetBinError(7,0.003418236);
trigeff->SetBinError(8,0.002747754);
trigeff->SetBinError(9,0.002375778);
trigeff->SetBinError(10,0.002196995);
trigeff->SetBinError(11,0.002011941);
trigeff->SetBinError(12,0.001831367);
trigeff->SetBinError(13,0.001784029);
trigeff->SetBinError(14,0.001916823);
trigeff->SetBinError(15,0.001817566);
trigeff->SetBinError(16,0.001819683);
trigeff->SetBinError(17,0.001818542);
trigeff->SetBinError(18,0.001890354);
trigeff->SetBinError(19,0.00177814);
trigeff->SetBinError(20,0.001864436);
trigeff->SetBinError(21,0.001663154);
trigeff->SetBinError(22,0.00170007);
trigeff->SetBinError(23,0.00173455);
trigeff->SetBinError(24,0.001481362);
trigeff->SetBinError(25,0.001655051);
trigeff->SetBinError(26,0.001603857);
trigeff->SetBinError(27,0.00195356);
trigeff->SetBinError(28,0.00163551);
trigeff->SetBinError(29,0.001474872);
trigeff->SetBinError(30,0.001623358);
trigeff->SetBinError(31,0.00154461);
trigeff->SetBinError(32,0.001534909);
trigeff->SetBinError(33,0.00158181);
trigeff->SetBinError(34,0.001491233);
trigeff->SetBinError(35,0.001286982);
trigeff->SetBinError(36,0.001328752);
trigeff->SetBinError(37,0.00152958);
trigeff->SetBinError(38,0.001348444);
trigeff->SetBinError(39,0.00166985);
trigeff->SetBinError(40,0.001624111);
trigeff->SetBinError(41,0.001586005);
trigeff->SetBinError(42,0.001827581);
trigeff->SetBinError(43,0.001420028);
trigeff->SetBinError(44,0.002227847);
trigeff->SetBinError(45,0.001874108);
trigeff->SetBinError(46,0.00114964);
trigeff->SetBinError(47,0.001293933);
trigeff->SetBinError(48,0.001462021);
trigeff->SetBinError(49,0.001515213);
trigeff->SetBinError(50,0.001377697);
trigeff->SetBinError(51,0.0009272125);
trigeff->SetBinError(52,0.001331017);
trigeff->SetBinError(53,0.001174711);
trigeff->SetBinError(54,0.001150746);
trigeff->SetBinError(55,0.001991336);
trigeff->SetBinError(56,0.001625642);
trigeff->SetBinError(57,0.001748087);
trigeff->SetBinError(58,0.00259828);
trigeff->SetBinError(59,0.0009945236);
trigeff->SetBinError(60,0.0009766661);
trigeff->SetBinError(61,0.000839278);
trigeff->SetBinError(62,0.001137741);
trigeff->SetBinError(63,0.002250715);
trigeff->SetBinError(64,0.0021065);
trigeff->SetBinError(65,0.001554078);
trigeff->SetBinError(66,0.001613457);
trigeff->SetBinError(67,0.003221342);
trigeff->SetBinError(69,0.001135718);
trigeff->SetBinError(70,0.002979388);
trigeff->SetBinError(71,0.001301235);
trigeff->SetBinError(72,0.00214274);
trigeff->SetBinError(73,0.00203191);
trigeff->SetBinError(74,0.002314579);
trigeff->SetBinError(75,0.001787308);
trigeff->SetBinError(76,0.002223598);
trigeff->SetBinError(77,0.00230327);
trigeff->SetBinError(78,0.001974331);
trigeff->SetBinError(79,0.002200216);
trigeff->SetBinError(81,0.002328284);
trigeff->SetBinError(82,0.002209941);
trigeff->SetBinError(83,0.00450458);
trigeff->SetBinError(84,0.004029049);
trigeff->SetBinError(87,0.003241478);
trigeff->SetBinError(89,0.00325202);
trigeff->SetBinError(90,0.003809503);
trigeff->SetBinError(96,0.005899627);
trigeff->SetBinError(98,0.007220074);
trigeff->SetBinError(100,0.010256);
trigeff->SetBinError(101,0.009389357);
trigeff->SetBinError(102,0.01117265);
trigeff->SetEntries(369636);
trigeff->SetDirectory(0);
trigeff->SetFillColor(1);
trigeff->SetFillStyle(0);
trigeff->SetLineStyle(2);
trigeff->SetLineWidth(3);
trigeff->SetMarkerStyle(20);
trigeff->GetXaxis()->SetTitle("M");
trigeff->GetXaxis()->SetLabelFont(42);
trigeff->GetXaxis()->SetLabelOffset(0.01);
trigeff->GetXaxis()->SetLabelSize(0.045);
trigeff->GetXaxis()->SetTitleSize(0.055);
trigeff->GetXaxis()->SetTitleFont(42);
trigeff->GetYaxis()->SetTitle("Selection efficiency");
trigeff->GetYaxis()->SetLabelFont(42);
trigeff->GetYaxis()->SetLabelOffset(0.01);
trigeff->GetYaxis()->SetLabelSize(0.045);
trigeff->GetYaxis()->SetTitleSize(0.055);
trigeff->GetYaxis()->SetTitleOffset(1.6);
trigeff->GetYaxis()->SetTitleFont(42);
trigeff->GetZaxis()->SetLabelFont(42);
trigeff->GetZaxis()->SetLabelSize(0.045);
trigeff->GetZaxis()->SetTitleFont(42);
trigeff->Draw("p same");
TLegend *leg = new TLegend(0.57,0.22,1,0.42,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(62);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(19);
leg->SetFillStyle(0);
TLegendEntry *entry=leg->AddEntry("trigeff","PYTHIA 7 TeV","l");
entry->SetLineColor(1);
entry->SetLineWidth(2);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
//entry=leg->AddEntry("trigeff","(Atlas tune)","");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry=leg->AddEntry("trigeff","PHOJET 7 TeV","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
leg->Draw();
printFinalCanvases(cEvtSel,"trigeff");
/*
TLatex * tex = new TLatex(0.85,0.9,"CMS");
tex->SetNDC();
tex->SetTextSize(0.04);
tex->SetLineWidth(2);
tex->Draw();
cEvtSel->Modified();
cEvtSel->cd();
cEvtSel->SetSelected(cEvtSel);
*/
}
//------------------------------------------------------------------------------
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 likelihoodrefs( TDirectory *lhdir ) {
Bool_t newCanvas = kTRUE;
const UInt_t maxCanvas = 200;
TCanvas** c = new TCanvas*[maxCanvas];
Int_t width = 670;
Int_t height = 380;
// avoid duplicated printing
std::vector<std::string> hasBeenUsed;
const TString titName = lhdir->GetName();
UInt_t ic = -1;
TIter next(lhdir->GetListOfKeys());
TKey *key;
while ((key = TMVAGlob::NextKey(next,"TH1"))) { // loop over all TH1
TH1 *h = (TH1*)key->ReadObj();
TH1F *b( 0 );
TString hname( h->GetName() );
// avoid duplicated plotting
Bool_t found = kFALSE;
for (UInt_t j = 0; j < hasBeenUsed.size(); j++) {
if (hasBeenUsed[j] == hname.Data()) found = kTRUE;
}
if (!found) {
// draw original plots
if (hname.EndsWith("_sig_nice")) {
if (newCanvas) {
char cn[20];
sprintf( cn, "cv%d_%s", ic+1, titName.Data() );
++ic;
TString n = hname;
c[ic] = new TCanvas( cn, Form( "%s reference for variable: %s",
titName.Data(),(n.ReplaceAll("_sig","")).Data() ),
ic*50+50, ic*20, width, height );
c[ic]->Divide(2,1);
newCanvas = kFALSE;
}
// signal
Int_t color = 4;
TPad * cPad = (TPad*)c[ic]->cd(1);
TString plotname = hname;
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);
color++;
h->Draw("e1");
Double_t hSscale = 1.0/(h->GetSumOfWeights()*h->GetBinWidth(1));
TLegend *legS= new TLegend( cPad->GetLeftMargin(),
1-cPad->GetTopMargin()-.14,
cPad->GetLeftMargin()+.77,
1-cPad->GetTopMargin() );
legS->SetBorderSize(1);
legS->AddEntry(h,"Input data (signal)","p");
// background
TString bname( hname );
b = (TH1F*)lhdir->Get( bname.ReplaceAll("_sig","_bgd") );
cPad = (TPad*)c[ic]->cd(2);
color = 2;
b->SetMaximum(b->GetMaximum()*1.3);
b->SetMinimum( 0 );
b->SetLineWidth(1);
b->SetLineColor(color);
b->SetMarkerColor(color);
b->SetMarkerSize( 0.7 );
b->SetMarkerStyle( 24 );
b->Draw("e1");
Double_t hBscale = 1.0/(b->GetSumOfWeights()*b->GetBinWidth(1));
TLegend *legB= new TLegend( cPad->GetLeftMargin(),
1-cPad->GetTopMargin()-.14,
cPad->GetLeftMargin()+.77,
1-cPad->GetTopMargin() );
legB->SetBorderSize(1);
legB->AddEntry(b,"Input data (backgr.)","p");
// register
hasBeenUsed.push_back( bname.Data() );
// the PDFs --------------
// check for splines
h = 0;
b = 0;
TString pname = hname; pname.ReplaceAll("_nice","");
for (int i=0; i<= 5; i++) {
TString hspline = pname + Form( "_smoothed_hist_from_spline%i", i );
h = (TH1F*)lhdir->Get( hspline );
if (h) {
b = (TH1F*)lhdir->Get( hspline.ReplaceAll("_sig","_bgd") );
break;
}
}
// check for KDE
if (h == 0 && b == 0) {
TString hspline = pname +"_smoothed_hist_from_KDE";
h = (TH1F*)lhdir->Get( hspline );
if (h) {
b = (TH1F*)lhdir->Get( hspline.ReplaceAll("_sig","_bgd") );
}
}
// found something ?
if (h == 0 || b == 0) {
cout << "--- likelihoodrefs.C: did not find spline for histogram: " << pname.Data() << endl;
}
else {
Double_t pSscale = 1.0/(h->GetSumOfWeights()*h->GetBinWidth(1));
h->Scale( pSscale/hSscale );
color = 4;
c[ic]->cd(1);
h->SetLineWidth(2);
h->SetLineColor(color);
legS->AddEntry(h,"Estimated PDF (norm. signal)","l");
h->Draw("histsame");
legS->Draw();
Double_t pBscale = 1.0/(b->GetSumOfWeights()*b->GetBinWidth(1));
b->Scale( pBscale/hBscale );
color = 2;
c[ic]->cd(2);
b->SetLineColor(color);
b->SetLineWidth(2);
legB->AddEntry(b,"Estimated PDF (norm. backgr.)","l");
b->Draw("histsame");
// draw the legends
legB->Draw();
hasBeenUsed.push_back( pname.Data() );
}
c[ic]->Update();
// write to file
TString fname = Form( "root_mva/plots/%s_refs_c%i", titName.Data(), ic+1 );
TMVAGlob::imgconv( c[ic], fname );
// c[ic]->Update();
newCanvas = kTRUE;
hasBeenUsed.push_back( hname.Data() );
}
}
}
}
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");
}
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());
}
int ratio5() {
// Constants and arrays
Int_t multi = 2;
const Int_t n_at = 3;
Int_t at[n_at] = { 500, 510, 550 };
//for ( int ii = 0; ii < n_at; ++ii ) { at[ii] = 500 + ii * 10; }
TString eq = "Gt";
const Int_t n = 4;
float pt[n] = { 50., 40., 30., 20. };
Int_t colour[n] = { 1, 2, 3, 4 };
const Int_t m = 2;
Int_t style[m] = { kOpenSquare, kFullSquare };
const Int_t ngr = 1000;
double x3[ngr];
double r[ngr];
int count = 0;
// General style
gStyle->SetOptStat(0);
// // Canvas for RECO curves
// TCanvas* reco_canvas = new TCanvas("Reco");
// reco_canvas->SetFillColor(0);
// reco_canvas->SetLineColor(0);
// reco_canvas->SetLogy();
// TLegend* reco_legend = new TLegend( 0.5, 0.7, 0.88, 0.88, NULL, "brNDC" );
// reco_legend->SetFillColor(0);
// reco_legend->SetLineColor(0);
// bool empty = true;
// double reco_max = 1.e-15.;
// double reco_min = 1.e15;
// Loop through pt bins
for ( Int_t i = 0; i < 1; ++i ) {
std::stringstream pt_can;
pt_can << "PtBin" << pt[i];
// Canvas for Pt bin
TCanvas* pt_canvas = new TCanvas(TString(pt_can.str()),"");
pt_canvas->SetFillColor(0);
pt_canvas->SetLineColor(0);
pt_canvas->SetLogy();
TLegend* pt_legend = new TLegend( 0.82, 0.5, 0.98, 0.9, NULL, "brNDC" );
pt_legend->SetFillColor(0);
pt_legend->SetLineColor(0);
bool empty = true;
double pt_max = 1.e-15.;
double pt_min = 1.e15;
std::vector<TH1*> pt_ratio;
pt_canvas->SetRightMargin(0.2);
// Open files
std::stringstream ss;
ss << "results/4/Reco" << pt[i] << "_QCDPythia6.root";
TString name(ss.str());
TFile* file = new TFile(name);
if ( file->IsZombie() || !(file->IsOpen()) ) { continue; }
file->cd();
// Loop through AlphaT thresolds
for ( Int_t iat = 0; iat < n_at; ++iat ) {
// Loop through RECO and GEN
for ( Int_t j = 0; j < m; ++j ) {
// Define names of histos to open
std::stringstream pre;
std::stringstream post;
if ( j == 0 ) {
pre << "Ratio" << at[iat] << "/GenHt" << eq << "PreAlphaT" << at[iat] << "_" << multi;
post << "Ratio" << at[iat] << "/GenHt" << eq << "PostAlphaT" << at[iat] << "_" << multi;
std::cout << pre.str() << std::endl;
std::cout << post.str() << std::endl;
} else if ( j == 1 ) {
pre << "Ratio" << at[iat] << "/Ht" << eq << "PreAlphaT" << at[iat] << "_" << multi;
post << "Ratio" << at[iat] << "/Ht" << eq << "PostAlphaT" << at[iat] << "_" << multi;
std::cout << pre.str() << std::endl;
std::cout << post.str() << std::endl;
}
// Create ratio histo
TH1* denominator = his( (TH1*)file->Get(TString(pre.str())), 45, 200., 650. );
TH1* numerator = his( (TH1*)file->Get(TString(post.str())), 45, 200., 650. );
int rebin = 5;
numerator->Rebin(rebin);
denominator->Rebin(rebin);
TH1* ratio = (TH1*)numerator->Clone();
ratio->Divide(denominator);
//ratio->Divide(numerator,denominator,1.,1.,"b"); //@@ poisson errors
ratio->SetMarkerStyle(style[j]);
ratio->SetMarkerSize(1.2);
ratio->SetMarkerColor(iat+1);//colour[iat]);
ratio->SetBarOffset(0.1*i);
//ratio->GetXaxis()->SetRangeUser(100.,550.);
ratio->GetYaxis()->SetRangeUser(1.e-7,1.e-1);
ratio->GetXaxis()->SetTitle("HT_{reco} [GeV]");
ratio->GetYaxis()->SetTitle("R(#alpha_{T})");
if ( ratio->GetMaximum() > 0. &&
ratio->GetMaximum() > pt_max ) {
pt_max = ratio->GetMaximum();
}
if ( ratio->GetMinimum() > 0. &&
ratio->GetMinimum() < pt_min ) {
pt_min = ratio->GetMinimum();
}
pt_ratio.push_back(ratio);
if ( empty ) { ratio->Draw(""); empty = false; }
else { ratio->Draw("same"); }
//ratio->GetYaxis()->SetRangeUser(pt_min/1.1,pt_max*1.1);
// Text for legend
std::stringstream pt_leg;
if ( j == 0 ) { pt_leg << "#alpha_{T} = " << at[iat]/1000. << ", GEN"; }
else if ( j == 1 ) { pt_leg << "#alpha_{T} = " << at[iat]/1000. << ", RECO"; }
pt_legend->AddEntry( ratio, TString(pt_leg.str()), "lep" );
// // Draw histos on canvas for RECO only
// if ( j == 1 ) {
// reco_canvas->cd();
// if ( i == 0 ) ratio->Draw("");
// else ratio->Draw("same");
// std::stringstream reco_leg;
// reco_leg << "p_{T}^{min} = " << pt[i];
// reco_legend->AddEntry( ratio, TString(reco_leg.str()), "lep" );
// }
}
}
// if (0) {
// int nbins = ratio->GetNbinsX();
// int bin_width = ratio->GetBinWidth(1);
// double lower = 0.;
// double upper = 1400.;
// int bin_lower = int( ( lower - ratio->GetBinLowEdge(1) ) / bin_width );
// for ( Int_t ii = bin_lower; ii < ratio->GetNbinsX()-1; ++ii ) {
// if ( ratio->GetBinContent(ii) > 0. ) {
// lower = ratio->GetBinCenter(ii);
// break;
// }
// }
// int bin_upper = int( ( upper - ratio->GetBinLowEdge(1) ) / bin_width );
// for ( Int_t ii = bin_upper; ii > 0; --ii ) {
// if ( ratio->GetBinContent(ii) > 0. ) {
// upper = ratio->GetBinCenter(ii);
// break;
// }
// }
// if (0) {
// std::cout << " bin_width: " << bin_width
// << " bin_lower: " << bin_lower
// << " bin_upper: " << bin_upper
// << " lower: " << lower
// << " upper: " << upper
// << std::endl;
// }
// TF1* fit = new TF1(sample[i],"expo",lower,upper);
// fit->SetLineColor(colour[i]);
// fit->SetLineWidth(1);
// ratio->Fit(sample[i],"QR","same");
// }
pt_canvas->cd();
// for ( Int_t iii = 0; iii < pt_ratio.size(); ++iii ) {
// TH1* ratio = pt_ratio[iii];
// if ( !ratio ) { continue; }
// if ( ii == 0 ) { ratio->Draw(""); }
// else { ratio->Draw("same"); }
// ratio->GetYaxis()->SetRangeUser(pt_min/1.1,pt_max*1.1);
// }
pt_legend->Draw("same");
pt_canvas->Update();
pt_canvas->SaveAs(TString(pt_can.str()+".png"));
// pt_canvas->SaveAs(TString(pt_can.str()+".C"));
}
// reco_canvas->cd();
// reco_legend->Draw("same");
// reco_canvas->Update();
// reco_canvas->SaveAs(TString("Reco.png"));
// reco_canvas->SaveAs(TString("Reco.C"));
// TCanvas* c2 = new TCanvas("C2");
// c2->SetLogy();
// c2->SetFillColor(0);
// gStyle->SetOptStat(0);
// if ( count > 0 ) {
// TGraph* graph = new TGraph(count,x3,r);
// graph->Draw("a*");
// }
}
/**
* Process a single eta bin
*
* @param measured Input collection of measured data
* @param corrections Input collection of correction data
* @param method Unfolding method to use
* @param regParam Regularisation parameter
* @param out Output directory.
*
* @return Stack of histograms or null
*/
THStack* ProcessBin(TCollection* measured,
TCollection* corrections,
UInt_t method,
Double_t regParam,
TDirectory* out)
{
Printf(" Processing %s ...", measured->GetName());
// Try to get the data
TH1* inRaw = GetH1(measured, "rawDist");
TH1* inTruth = GetH1(corrections, "truth");
TH1* inTruthA = GetH1(corrections, "truthAccepted");
TH1* inTrgVtx = GetH1(corrections, "triggerVertex");
TH2* inResp = GetH2(corrections, "response");
if (!inRaw || !inTruth || !inTruthA || !inTrgVtx || !inResp)
return 0;
// Make output directory
TDirectory* dir = out->mkdir(measured->GetName());
dir->cd();
// Copy the input to the output
TH1* outRaw = static_cast<TH1*>(inRaw ->Clone("measured"));
TH1* outTruth = static_cast<TH1*>(inTruth ->Clone("truth"));
TH1* outTruthA = static_cast<TH1*>(inTruthA ->Clone("truthAccepted"));
TH1* outTrgVtx = static_cast<TH1*>(inTrgVtx ->Clone("triggerVertex"));
TH2* outResp = static_cast<TH2*>(inResp ->Clone("response"));
// Make our response matrix
RooUnfoldResponse matrix(0, 0, inResp);
// Store regularization parameter
Double_t r = regParam;
RooUnfold::Algorithm algo = (RooUnfold::Algorithm)method;
RooUnfold* unfolder = RooUnfold::New(algo, &matrix, inRaw, r);
unfolder->SetVerbose(0);
// Do the unfolding and get the result
TH1* res = unfolder->Hreco();
res->SetDirectory(0);
// Make a copy to store on the output
TH1* outUnfold = static_cast<TH1*>(res->Clone("unfolded"));
TString tit(outUnfold->GetTitle());
tit.ReplaceAll("Unfold Reponse matrix", "Unfolded P(#it{N}_{ch})");
outUnfold->SetTitle(tit);
// Clone the unfolded results and divide by the trigger/vertex
// bias correction
TH1* outCorr = static_cast<TH1*>(outUnfold->Clone("corrected"));
outCorr->Divide(inTrgVtx);
tit.ReplaceAll("Unfolded", "Corrected");
outCorr->SetTitle(tit);
// Now normalize the output to integral=1
TH1* hists[] = { outRaw, outUnfold, outCorr, 0 };
TH1** phist = hists;
while (*phist) {
TH1* h = *phist;
if (h) {
Double_t intg = h->Integral(1, h->GetXaxis()->GetXmax());
h->Scale(1. / intg, "width");
}
phist++;
}
// And make ratios
TH1* ratioTrue = static_cast<TH1*>(outCorr->Clone("ratioCorrTruth"));
tit = ratioTrue->GetTitle();
tit.ReplaceAll("Corrected", "Corrected/MC 'truth'");
ratioTrue->SetTitle(tit);
ratioTrue->Divide(outTruth);
ratioTrue->SetYTitle("P_{corrected}(#it{N}_{ch})/P_{truth}(#it{N}_{ch})");
TH1* ratioAcc = static_cast<TH1*>(outUnfold->Clone("ratioUnfAcc"));
tit = ratioAcc->GetTitle();
tit.ReplaceAll("Unfolded", "Unfolded/MC selected");
ratioAcc->SetTitle(tit);
ratioAcc->Divide(outTruthA);
ratioAcc->SetYTitle("P_{unfolded}(#it{N}_{ch})/P_{MC}(#it{N}_{ch})");
// Make a stack
tit = measured->GetName();
tit.ReplaceAll("m", "-");
tit.ReplaceAll("p", "+");
tit.ReplaceAll("d", ".");
tit.ReplaceAll("_", "<#it{#eta}<");
THStack* stack = new THStack("all", tit);
stack->Add(outTruth, "E2");
stack->Add(outTruthA, "E2");
stack->Add(outRaw, "E1");
stack->Add(outUnfold, "E1");
stack->Add(outCorr, "E1");
dir->Add(stack);
// Rest of the function is devoted to making the output look nice
outRaw ->SetDirectory(dir);
outTruth ->SetDirectory(dir);
outTruthA->SetDirectory(dir);
outTrgVtx->SetDirectory(dir);
outResp ->SetDirectory(dir);
outUnfold->SetDirectory(dir);
outCorr ->SetDirectory(dir);
outRaw ->SetMarkerStyle(20); // Measured is closed
outTruth ->SetMarkerStyle(24); // MC is open
outTruthA->SetMarkerStyle(24); // MC is open
outTrgVtx->SetMarkerStyle(20); // Derived is closed
outUnfold->SetMarkerStyle(20); // Derived is closed
outCorr ->SetMarkerStyle(20); // Derived is closed
outRaw ->SetMarkerSize(0.9);
outTruth ->SetMarkerSize(1.6);
outTruthA->SetMarkerSize(1.4);
outTrgVtx->SetMarkerSize(1.0);
outUnfold->SetMarkerSize(0.9);
outCorr ->SetMarkerSize(1.0);
outRaw ->SetMarkerColor(kColorMeasured);
outTruth ->SetMarkerColor(kColorTruth);
outTruthA->SetMarkerColor(kColorAccepted);
outTrgVtx->SetMarkerColor(kColorTrgVtx);
outUnfold->SetMarkerColor(kColorUnfolded);
outCorr ->SetMarkerColor(kColorCorrected);
outRaw ->SetFillColor(kColorError);
outTruth ->SetFillColor(kColorError);
outTruthA->SetFillColor(kColorError);
outTrgVtx->SetFillColor(kColorError);
outUnfold->SetFillColor(kColorError);
outCorr ->SetFillColor(kColorError);
outRaw ->SetFillStyle(0);
outTruth ->SetFillStyle(1001);
outTruthA->SetFillStyle(1001);
outTrgVtx->SetFillStyle(0);
outUnfold->SetFillStyle(0);
outCorr ->SetFillStyle(0);
outRaw ->SetLineColor(kBlack);
outTruth ->SetLineColor(kBlack);
outTruthA->SetLineColor(kBlack);
outTrgVtx->SetLineColor(kBlack);
outUnfold->SetLineColor(kBlack);
outCorr ->SetLineColor(kBlack);
// Legend
TLegend* l = StackLegend(stack);
l->AddEntry(outRaw, "Raw", "lp");
l->AddEntry(outTruth, "MC 'truth'", "fp");
l->AddEntry(outTruthA, "MC 'truth' accepted", "fp");
l->AddEntry(outUnfold, "Unfolded", "lp");
l->AddEntry(outCorr, "Corrected", "lp");
return stack;
}
/**
* Add the bin histograms to our summary stacks
*
* @param bin Bin stack
* @param i Current off-set in the stacks
* @param measured All measured @f$ P(N_{ch})@f$
* @param truth All MC truth @f$ P(N_{ch})@f$
* @param accepted All MC accepted @f$ P(N_{ch})@f$
* @param unfolded All unfolded @f$ P(N_{ch})@f$
* @param corrected All corrected @f$ P(N_{ch})@f$
* @param result The result in this bin
*/
void Bin2Stack(const THStack* bin, Int_t i,
THStack* measured,
THStack* truth,
THStack* accepted,
THStack* unfolded,
THStack* corrected,
TH1*& result)
{
Int_t open, closed;
Double_t factor;
Float_t size;
BinAttributes(i, open, closed, size, factor);
TIter next(bin->GetHists());
TH1* h = 0;
while ((h = static_cast<TH1*>(next()))) {
THStack* tmp = 0;
Int_t col = h->GetMarkerColor();
Int_t sty = 0;
switch (col) {
case kColorMeasured: tmp = measured; sty = closed; break;
case kColorTruth: tmp = truth; sty = open; break;
case kColorAccepted: tmp = accepted; sty = open; break;
case kColorUnfolded: tmp = unfolded; sty = closed; break;
case kColorCorrected: tmp = corrected; sty = closed; break;
default: continue;
}
// Now clone, and add to the appropriate stack
TH1* cln = static_cast<TH1*>(h->Clone(h->GetName()));
cln->SetDirectory(0);
cln->SetMarkerStyle(sty);
cln->SetMarkerSize(size);
cln->Scale(factor); // Scale by 10^i
if (col == kColorCorrected) result = cln;
// Make sure we do not get the old legend
TObject* tst = cln->FindObject("legend");
if (tst) cln->GetListOfFunctions()->Remove(tst);
tmp->Add(cln, next.GetOption());
}
// Add entries to our stacks
TString txt = bin->GetTitle();
if (i == 0) txt.Append(" (#times1)");
else if (i == 1) txt.Append(" (#times10)");
else txt.Append(Form(" (#times10^{%d})", i));
THStack* stacks[] = { measured, truth, accepted, unfolded, corrected, 0 };
THStack** pstack = stacks;
while (*pstack) {
TLegend* leg = StackLegend(*pstack);
pstack++;
if (!leg) continue;
TObject* dummy = 0;
TLegendEntry* e = leg->AddEntry(dummy, txt, "p");
e->SetMarkerStyle(closed);
e->SetMarkerSize(1.2*size);
e->SetMarkerColor(kBlack);
e->SetFillColor(0);
e->SetFillStyle(0);
e->SetLineColor(kBlack);
}
}
void plotter::draw_output_data(TH1* output_, TH1* stat_, std::vector<TH1D*> truth_, std::vector<TString> legnames, bool norm, TString file_name){
TH1* output = (TH1*) output_->Clone("output");
TH1* stat = (TH1*) stat_->Clone("stat");
std::vector<TH1D*> truth;
for(auto t: truth_){
truth.push_back( (TH1D*) t->Clone() );
}
double max = output->GetMaximum();
for(auto t: truth){
if(t->GetMaximum() > max) max = t->GetMaximum();
}
double ymax = 1.5 * max;
TCanvas *c = new TCanvas("c","",600,600);
gPad->SetLeftMargin(0.15);
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("#frac{d#sigma}{dm_{jet}} [#frac{fb}{GeV}]");
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);
Color_t color[] = {kRed-4, kAzure+7, kGreen, 798};
Int_t style[] = {1, 2, 9, 7};
for(unsigned int i=0; i<truth.size(); i++){
truth[i]->SetLineWidth(3);
truth[i]->SetLineColor(color[i]);
truth[i]->SetLineStyle(style[i]);
truth[i]->Draw("HIST SAME");
}
stat->Draw("E1 SAME");
output->Draw("E1 SAME");
TLegend *l=new TLegend(0.55,0.67,0.85,0.87);
l->SetBorderSize(0);
l->SetFillStyle(0);
l->AddEntry(output,"data unfolded","pl");
for(unsigned int i=0; i<truth.size(); i++){
l->AddEntry(truth[i],legnames[i],"l");
}
l->SetTextSize(0.03);
l->Draw();
c->SaveAs(directory + file_name + ".pdf");
delete c;
}
