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; }