void ratioPlots( TCanvas* c1, TH1* h_r, TH1* h_i, string xTitle, string yTitle, string savePath, double fitMin=-100000, double fitMax=100000, bool doubleColFit=0 ){ double xMaximum = h_r->GetXaxis()->GetBinUpEdge(h_r->GetXaxis()->GetLast()); double xMinimum = h_r->GetXaxis()->GetBinLowEdge(h_r->GetXaxis()->GetFirst()); double yMaximum; double yMinimum; h_i->Sumw2(); h_r->Sumw2(); TLine* line1 = new TLine(xMinimum,1,xMaximum,1); line1->SetLineColor(1); line1->SetLineWidth(2); line1->SetLineStyle(7); TF1* fpol1 = new TF1("fpol1", "pol1", fitMin, fitMax); fpol1->SetLineColor(2); fpol1->SetLineWidth(3); fpol1->SetLineStyle(7); TH1* hRatio = (TH1*)h_r->Clone("clone_record"); hRatio->Divide(h_i); yMaximum = hRatio->GetMaximum(); yMinimum = hRatio->GetMinimum(0); hRatio->GetYaxis()->SetRangeUser(yMinimum/2.5,yMaximum+yMaximum/5); hRatio->SetXTitle(xTitle.c_str()); hRatio->SetYTitle(yTitle.c_str()); hRatio->SetLineColor(9); hRatio->SetLineWidth(2); hRatio->SetMarkerStyle(8); hRatio->Draw("e"); hRatio->Fit("fpol1", "L"); line1->Draw("SAME"); if(doubleColFit){ double p0=fpol1->GetParameter(0); double p1=fpol1->GetParameter(1); double endPoint=double(fitMax*p1)+p0; double p1new=(endPoint-1)/(fitMax-fitMin); char fun[100], text[100]; sprintf(fun,"x*(%f)+1",p1new); sprintf(text,"Tangent: %f",p1new); TF1* fnew = new TF1("fnew", fun, fitMin, fitMax); fnew->SetLineColor(2); fnew->SetLineWidth(3); fnew->Draw("SAME"); TText* Title = new TText( fitMax/12, yMinimum, text); Title->SetTextColor(2); Title->SetTextSize(0.035); Title->Draw("SAME"); } c1->SaveAs(savePath.c_str()); c1->cd(); }
//____________________________________________________________________ TH1* One(TDirectory* newDir, TDirectory* oldDir, Double_t c1, Double_t c2) { TString name; name.Form("cent%03dd%02d_%03dd%02d", Int_t(c1), Int_t(c1*100)%100, Int_t(c2), Int_t(c2*100)%100); TDirectory* newSubDir = GetD(newDir, name); TDirectory* oldSubDir = GetD(oldDir, name); if (!newSubDir || !oldSubDir) return 0; Int_t newDim = 0; if (TString(newDir->GetName()).Contains("etaipz")) newDim = 3; else if (TString(newDir->GetName()).Contains("eta")) newDim = 2; else if (TString(newDir->GetName()).Contains("const")) newDim = 1; Int_t oldDim = 0; if (TString(oldDir->GetName()).Contains("etaipz")) oldDim = 3; else if (TString(oldDir->GetName()).Contains("eta")) oldDim = 2; else if (TString(oldDir->GetName()).Contains("const")) oldDim = 1; TDirectory* newSubSubDir = GetD(newSubDir, Form("results%dd",newDim)); TDirectory* oldSubSubDir = GetD(oldSubDir, Form("results%dd",oldDim)); if (!newSubSubDir || !oldSubSubDir) return 0; TH1* newRes = GetH1(newSubSubDir, "result"); TH1* oldRes = GetH1(oldSubSubDir, "result"); if (!newRes || !oldRes) return 0; TH1* ratio = static_cast<TH1*>(newRes->Clone(name)); ratio->SetDirectory(0); ratio->SetTitle(Form("%5.1f - %5.1f%%", c1, c2)); ratio->SetYTitle("New / Old"); ratio->Divide(oldRes); fMin = TMath::Min(fMin, ratio->GetMinimum()); fMax = TMath::Max(fMax, ratio->GetMaximum()); Printf("Calculated %s/%s", newDir->GetName(), oldDir->GetName()); if (!fLegend) return ratio; TLegendEntry* e = fLegend->AddEntry("", Form("%3.0f - %3.0f%%", c1, c2), "f"); e->SetFillStyle(1001); e->SetFillColor(ratio->GetMarkerColor()); return ratio; }
int main(int ac, char *av[]) { gROOT->SetStyle("Plain"); try { typedef funct::FunctExpression Expr; typedef fit::HistoChiSquare<funct::FunctExpression> ExprChi2; typedef fit::MultiHistoChiSquare<ExprChi2, ExprChi2, ExprChi2, ExprChi2, ExprChi2> ChiSquared; double fMin, fMax; string ext; po::options_description desc("Allowed options"); desc.add_options() ("help,h", "produce help message") ("input-file,i", po::value< vector<string> >(), "input file") ("min,m", po::value<double>(&fMin)->default_value(60), "minimum value for fit range") ("max,M", po::value<double>(&fMax)->default_value(120), "maximum value for fit range") ("plot-format,p", po::value<string>(&ext)->default_value("eps"), "output plot format"); po::positional_options_description p; p.add("input-file", -1); po::variables_map vm; po::store(po::command_line_parser(ac, av). options(desc).positional(p).run(), vm); po::notify(vm); if (vm.count("help")) { cout << "Usage: options_description [options]\n"; cout << desc; return 0; } fit::RootMinuitCommands<ChiSquared> commands("zFitToyMc.txt"); cout << "minuit command file completed" << endl; const unsigned int rebinMuMuNoIso = 2,rebinMuMu = 1, rebinMuMu1HLT = 1, rebinMuMu2HLT = 1, rebinMuTk = 2, rebinMuSa = 10; // assume that the bin size is 1 GeV!!! funct::Constant rebinMuMuNoIsoConst(rebinMuMuNoIso), rebinMuMuConst(rebinMuMu), rebinMuMu1HLTConst(rebinMuMu1HLT), rebinMuMu2HLTConst(rebinMuMu2HLT), rebinMuTkConst(rebinMuTk), rebinMuSaConst(rebinMuSa); if (vm.count("input-file")) { cout << "Input files are: " << vm["input-file"].as< vector<string> >() << "\n"; vector<string> v_file = vm["input-file"].as< vector<string> >(); for(vector<string>::const_iterator it = v_file.begin(); it != v_file.end(); ++it) { TFile * root_file = new TFile(it->c_str(), "read"); TH1 * histoZMuMuNoIso = getHisto(root_file, "nonIsolatedZToMuMuPlots/zMass_noIso",rebinMuMuNoIso); TH1 * histoZMuMu = getHisto(root_file, "goodZToMuMuPlots/zMass_golden",rebinMuMu); TH1 * histoZMuMu1HLT = getHisto(root_file, "goodZToMuMu1HLTPlots/zMass_1hlt", rebinMuMu1HLT); TH1 * histoZMuMu2HLT = getHisto(root_file, "goodZToMuMu2HLTPlots/zMass_2hlt", rebinMuMu2HLT); TH1 * histoZMuTk = getHisto(root_file, "goodZToMuMuOneTrackPlots/zMass_tk", rebinMuTk); TH1 * histoZMuSa = getHisto(root_file, "goodZToMuMuOneStandAloneMuonPlots/zMass_sa", rebinMuSa); TH1 * histoZMuSaFromMuMu = getHisto(root_file, "zmumuSaMassHistogram/zMass_safromGolden", rebinMuSa); cout << ">>> histogram loaded\n"; string f_string = *it; replace(f_string.begin(), f_string.end(), '.', '_'); replace(f_string.begin(), f_string.end(), '/', '_'); string plot_string = f_string + "." + ext; cout << ">>> Input files loaded\n"; const char * kYieldZMuMu = "YieldZMuMu"; const char * kEfficiencyTk = "EfficiencyTk"; const char * kEfficiencySa = "EfficiencySa"; const char * kEfficiencyIso = "EfficiencyIso"; const char * kEfficiencyHLT = "EfficiencyHLT"; const char * kYieldBkgZMuTk = "YieldBkgZMuTk"; const char * kYieldBkgZMuSa = "YieldBkgZMuSa"; const char * kYieldBkgZMuMuNotIso = "YieldBkgZMuMuNotIso"; const char * kAlpha = "Alpha"; const char * kBeta = "Beta"; const char * kLambda = "Lambda"; const char * kA0 = "A0"; const char * kA1 = "A1"; const char * kA2 = "A2"; const char * kB0 = "B0"; const char * kB1 = "B1"; const char * kB2 = "B2"; funct::Parameter yieldZMuMu(kYieldZMuMu, commands.par(kYieldZMuMu)); funct::Parameter effTk(kEfficiencyTk, commands.par(kEfficiencyTk)); funct::Parameter effSa(kEfficiencySa, commands.par(kEfficiencySa)); funct::Parameter effIso(kEfficiencyIso, commands.par(kEfficiencyIso)); funct::Parameter effHLT(kEfficiencyHLT, commands.par(kEfficiencyHLT)); funct::Parameter yieldBkgZMuTk(kYieldBkgZMuTk, commands.par(kYieldBkgZMuTk)); funct::Parameter yieldBkgZMuSa(kYieldBkgZMuSa, commands.par(kYieldBkgZMuSa)); funct::Parameter yieldBkgZMuMuNotIso(kYieldBkgZMuMuNotIso, commands.par(kYieldBkgZMuMuNotIso)); funct::Parameter alpha(kAlpha, commands.par(kAlpha)); funct::Parameter beta(kBeta, commands.par(kBeta)); funct::Parameter lambda(kLambda, commands.par(kLambda)); funct::Parameter a0(kA0, commands.par(kA0)); funct::Parameter a1(kA1, commands.par(kA1)); funct::Parameter a2(kA2, commands.par(kA2)); funct::Parameter b0(kB0, commands.par(kB0)); funct::Parameter b1(kB1, commands.par(kB1)); funct::Parameter b2(kB2, commands.par(kB2)); funct::Constant cFMin(fMin), cFMax(fMax); // count ZMuMu Yield double nZMuMu = 0, nZMuMu1HLT = 0, nZMuMu2HLT = 0; { unsigned int nBins = histoZMuMu->GetNbinsX(); double xMin = histoZMuMu->GetXaxis()->GetXmin(); double xMax = histoZMuMu->GetXaxis()->GetXmax(); double deltaX =(xMax - xMin) / nBins; for(unsigned int i = 0; i < nBins; ++i) { double x = xMin + (i +.5) * deltaX; if(x > fMin && x < fMax){ nZMuMu += histoZMuMu->GetBinContent(i+1); nZMuMu1HLT += histoZMuMu1HLT->GetBinContent(i+1); nZMuMu2HLT += histoZMuMu2HLT->GetBinContent(i+1); } } } // aggiungi 1HLT 2HLT cout << ">>> count of ZMuMu yield in the range [" << fMin << ", " << fMax << "]: " << nZMuMu << endl; cout << ">>> count of ZMuMu (1HLT) yield in the range [" << fMin << ", " << fMax << "]: " << nZMuMu1HLT << endl; cout << ">>> count of ZMuMu (2HLT) yield in the range [" << fMin << ", " << fMax << "]: " << nZMuMu2HLT << endl; funct::RootHistoPdf zPdfMuMuNonIso(*histoZMuMu, fMin, fMax);//imposto le pdf a quella di ZMuMu funct::RootHistoPdf zPdfMuTk = zPdfMuMuNonIso; funct::RootHistoPdf zPdfMuMu1HLT = zPdfMuMuNonIso; funct::RootHistoPdf zPdfMuMu2HLT = zPdfMuMuNonIso; funct::RootHistoPdf zPdfMuSa(*histoZMuSaFromMuMu, fMin, fMax); zPdfMuMuNonIso.rebin(rebinMuMuNoIso/rebinMuMu); zPdfMuTk.rebin(rebinMuTk/rebinMuMu); zPdfMuMu1HLT.rebin(rebinMuMu1HLT/rebinMuMu); zPdfMuMu2HLT.rebin(rebinMuMu2HLT/rebinMuMu); funct::Numerical<2> _2; funct::Numerical<1> _1; //Efficiency term Expr zMuMuEff1HLTTerm = _2 * (effTk ^ _2) * (effSa ^ _2) * (effIso ^ _2) * effHLT * (_1 - effHLT); Expr zMuMuEff2HLTTerm = (effTk ^ _2) * (effSa ^ _2) * (effIso ^ _2) * (effHLT ^ _2) ; Expr zMuMuNoIsoEffTerm = (effTk ^ _2) * (effSa ^ _2) * (_1 - (effIso ^ _2)) * (_1 - ((_1 - effHLT)^_2)); Expr zMuTkEffTerm = _2 * (effTk ^ _2) * effSa * (_1 - effSa) * (effIso ^ _2) * effHLT; Expr zMuSaEffTerm = _2 * (effSa ^ _2) * effTk * (_1 - effTk) * (effIso ^ _2) * effHLT; Expr zMuMu1HLT = rebinMuMu1HLTConst * zMuMuEff1HLTTerm * yieldZMuMu; Expr zMuMu2HLT = rebinMuMu2HLTConst * zMuMuEff2HLTTerm * yieldZMuMu; Expr zMuTkBkg = yieldBkgZMuTk * funct::Exponential(lambda)* funct::Polynomial<2>(a0, a1, a2); Expr zMuTkBkgScaled = rebinMuTkConst * zMuTkBkg; Expr zMuTk = rebinMuTkConst * (zMuTkEffTerm * yieldZMuMu * zPdfMuTk + zMuTkBkg); Expr zMuMuNoIsoBkg = yieldBkgZMuMuNotIso * funct::Exponential(alpha)* funct::Polynomial<2>(b0, b1, b2); Expr zMuMuNoIsoBkgScaled = rebinMuMuNoIsoConst * zMuMuNoIsoBkg; Expr zMuMuNoIso = rebinMuMuNoIsoConst * (zMuMuNoIsoEffTerm * yieldZMuMu * zPdfMuMuNonIso + zMuMuNoIsoBkg); Expr zMuSa = rebinMuSaConst * (zMuSaEffTerm * yieldZMuMu * zPdfMuSa); // + (yieldBkgZMuSa * funct::Exponential(beta) )); TH1D histoZCount1HLT("histoZCount1HLT", "", 1, fMin, fMax); histoZCount1HLT.Fill(100, nZMuMu1HLT); TH1D histoZCount2HLT("histoZCount2HLT", "", 1, fMin, fMax); histoZCount2HLT.Fill(100, nZMuMu2HLT); ChiSquared chi2(zMuMu1HLT, & histoZCount1HLT, zMuMu2HLT, & histoZCount2HLT, zMuTk, histoZMuTk, zMuSa, histoZMuSa, zMuMuNoIso,histoZMuMuNoIso, fMin, fMax); fit::RootMinuit<ChiSquared> minuit(chi2, true); commands.add(minuit, yieldZMuMu); commands.add(minuit, effTk); commands.add(minuit, effSa); commands.add(minuit, effIso); commands.add(minuit, effHLT); commands.add(minuit, yieldBkgZMuTk); commands.add(minuit, yieldBkgZMuSa); commands.add(minuit, yieldBkgZMuMuNotIso); commands.add(minuit, lambda); commands.add(minuit, alpha); commands.add(minuit, beta); commands.add(minuit, a0); commands.add(minuit, a1); commands.add(minuit, a2); commands.add(minuit, b0); commands.add(minuit, b1); commands.add(minuit, b2); commands.run(minuit); const unsigned int nPar = 17;//WARNIG: this must be updated manually for now ROOT::Math::SMatrix<double, nPar, nPar, ROOT::Math::MatRepSym<double, nPar> > err; minuit.getErrorMatrix(err); std::cout << "error matrix:" << std::endl; for(unsigned int i = 0; i < nPar; ++i) { for(unsigned int j = 0; j < nPar; ++j) { std::cout << err(i, j) << "\t"; } std::cout << std::endl; } minuit.printFitResults(); ofstream myfile; myfile.open ("fitResult.txt", ios::out | ios::app); myfile<<"\n"; double Y = minuit.getParameterError("YieldZMuMu"); double dY = minuit.getParameterError("YieldZMuMu", Y); double tk_eff = minuit.getParameterError("EfficiencyTk"); double dtk_eff = minuit.getParameterError("EfficiencyTk", tk_eff); double sa_eff = minuit.getParameterError("EfficiencySa"); double dsa_eff = minuit.getParameterError("EfficiencySa", sa_eff); double iso_eff = minuit.getParameterError("EfficiencyIso"); double diso_eff = minuit.getParameterError("EfficiencyIso", iso_eff); double hlt_eff = minuit.getParameterError("EfficiencyHLT"); double dhlt_eff = minuit.getParameterError("EfficiencyHLT",hlt_eff); myfile<< Y <<" "<< dY <<" "<< tk_eff <<" "<< dtk_eff <<" "<< sa_eff << " " << dsa_eff << " " << iso_eff <<" " << diso_eff<< " " << hlt_eff << " " << dhlt_eff << " " <<chi2()/(chi2.numberOfBins()- minuit.numberOfFreeParameters()); myfile.close(); //Plot double s; s = 0; for(int i = 1; i <= histoZMuMuNoIso->GetNbinsX(); ++i) s += histoZMuMuNoIso->GetBinContent(i); histoZMuMuNoIso->SetEntries(s); s = 0; for(int i = 1; i <= histoZMuMu->GetNbinsX(); ++i) s += histoZMuMu->GetBinContent(i); histoZMuMu->SetEntries(s); s = 0; for(int i = 1; i <= histoZMuMu1HLT->GetNbinsX(); ++i) s += histoZMuMu1HLT->GetBinContent(i); histoZMuMu1HLT->SetEntries(s); s = 0; for(int i = 1; i <= histoZMuMu2HLT->GetNbinsX(); ++i) s += histoZMuMu2HLT->GetBinContent(i); histoZMuMu2HLT->SetEntries(s); s = 0; for(int i = 1; i <= histoZMuTk->GetNbinsX(); ++i) s += histoZMuTk->GetBinContent(i); histoZMuTk->SetEntries(s); s = 0; for(int i = 1; i <= histoZMuSa->GetNbinsX(); ++i) s += histoZMuSa->GetBinContent(i); histoZMuSa->SetEntries(s); string ZMuMu1HLTPlot = "ZMuMu1HLTFit_" + plot_string; root::plot<Expr>(ZMuMu1HLTPlot.c_str(), *histoZMuMu1HLT, zMuMu1HLT, fMin, fMax, effTk, effSa, effIso, effHLT, yieldZMuMu, kRed, 2, kDashed, 100, "Z -> #mu #mu mass", "#mu #mu invariant mass (GeV/c^{2})", "Events"); string ZMuMu2HLTPlot = "ZMuMu2HLTFit_" + plot_string; root::plot<Expr>(ZMuMu2HLTPlot.c_str(), *histoZMuMu2HLT, zMuMu2HLT, fMin, fMax, effTk, effSa, effIso, effHLT, yieldZMuMu, kRed, 2, kDashed, 100, "Z -> #mu #mu mass", "#mu #mu invariant mass (GeV/c^{2})", "Events"); string ZMuMuNoIsoPlot = "ZMuMuNoIsoFit_" + plot_string; root::plot<Expr>(ZMuMuNoIsoPlot.c_str(), *histoZMuMuNoIso, zMuMuNoIso, fMin, fMax, effTk, effSa, effIso, effHLT, yieldZMuMu, kRed, 2, kDashed, 100, "Z -> #mu #mu Not Iso mass", "#mu #mu invariant mass (GeV/c^{2})", "Events"); string ZMuTkPlot = "ZMuTkFit_X_" + plot_string; root::plot<Expr>(ZMuTkPlot.c_str(), *histoZMuTk, zMuTk, fMin, fMax, effTk, effSa, effIso, effHLT, yieldZMuMu, yieldBkgZMuTk, lambda, a0, a1, a2, kRed, 2, kDashed, 100, "Z -> #mu + (unmatched) track mass", "#mu #mu invariant mass (GeV/c^{2})", "Events"); ZMuTkPlot = "ZMuTkFit_" + plot_string; TF1 funZMuTk = root::tf1_t<sig_tag, Expr>("ZMuTkFunction", zMuTk, fMin, fMax, effTk, effSa, effIso, effHLT, yieldZMuMu, yieldBkgZMuTk, lambda, a0, a1, a2); funZMuTk.SetLineColor(kRed); funZMuTk.SetLineWidth(2); funZMuTk.SetLineStyle(kDashed); funZMuTk.SetNpx(10000); TF1 funZMuTkBkg = root::tf1_t<bkg_tag, Expr>("ZMuTkBack", zMuTkBkgScaled, fMin, fMax, yieldBkgZMuTk, lambda, a0, a1, a2); funZMuTkBkg.SetLineColor(kGreen); funZMuTkBkg.SetLineWidth(2); funZMuTkBkg.SetLineStyle(kDashed); funZMuTkBkg.SetNpx(10000); histoZMuTk->SetTitle("Z -> #mu + (unmatched) track mass"); histoZMuTk->SetXTitle("#mu + (unmatched) track invariant mass (GeV/c^{2})"); histoZMuTk->SetYTitle("Events"); TCanvas *canvas = new TCanvas("canvas"); histoZMuTk->Draw("e"); funZMuTkBkg.Draw("same"); funZMuTk.Draw("same"); canvas->SaveAs(ZMuTkPlot.c_str()); canvas->SetLogy(); string logZMuTkPlot = "log_" + ZMuTkPlot; canvas->SaveAs(logZMuTkPlot.c_str()); string ZMuSaPlot = "ZMuSaFit_" + plot_string; root::plot<Expr>(ZMuSaPlot.c_str(), *histoZMuSa, zMuSa, fMin, fMax, effSa, effTk, effIso, yieldZMuMu, yieldBkgZMuSa, kRed, 2, kDashed, 10000, "Z -> #mu + (unmatched) standalone mass", "#mu + (unmatched) standalone invariant mass (GeV/c^{2})", "Events"); } } } catch(std::exception& e) { cerr << "error: " << e.what() << "\n"; return 1; } catch(...) { cerr << "Exception of unknown type!\n"; } return 0; }
TCanvas* DrawKs(const char* filename) { TFile* file = TFile::Open(filename, "READ"); if (!file) { Warning("DrawKs", "File %s couldn't be opened", filename); return 0; } TH1* cent = static_cast<TH1*>(file->Get("cent")); if (!cent) { Warning("DrawKs", "Failed to find cent in %s", file->GetName()); return 0; } TString t(filename); t.ReplaceAll("results/", ""); t.ReplaceAll("combine_",""); t.ReplaceAll("_0x3.root", ""); TString nm(filename); nm.ReplaceAll(".root", ""); nm.ReplaceAll("results/", "plots/"); nm.ReplaceAll("combine", "ks"); if (t.Contains("none")) t.ReplaceAll("none", "No weights"); else t.Append(" weights"); Int_t cW = 1200; Int_t cH = 800; TCanvas* c = new TCanvas(nm,t,cW, cH); c->SetTopMargin(0.07); c->SetRightMargin(0.20); c->SetTicks(); TLegend* l = new TLegend(1-c->GetRightMargin(), c->GetBottomMargin(), .99, 1-c->GetTopMargin()); l->SetFillStyle(0); l->SetBorderSize(0); THStack* s = new THStack("ks", ""); Int_t nCent = cent->GetXaxis()->GetNbins(); for (Int_t i = 1; i <= nCent; i++) { Double_t c1 = cent->GetXaxis()->GetBinLowEdge(i); Double_t c2 = cent->GetXaxis()->GetBinUpEdge(i); TH1* h = GetCentK(file, c1, c2, nCent-i+1-2, l); if (!h) continue; s->Add(h); } s->Draw("nostack"); TH1* f = s->GetHistogram(); if (f) { f->SetXTitle("#eta"); f->SetYTitle("#it{k}(#eta)"); } TLatex* tit = new TLatex(0.55, 0.99, t); tit->SetTextFont(42); tit->SetTextAlign(23); tit->SetTextSize(0.03); tit->SetNDC(); tit->Draw(); l->SetBorderSize(0); l->Draw(); c->Modified(); c->Update(); c->cd(); return c; }
/** * 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; }
void HwwNoteFigs(TString filename = "../histo_tmva_new-ntuples-1_160_0.root", int mass = 170, int ReBin = 4, int ysel = 0) { TFile* infile = new TFile(filename.Data(),"READ"); setTDRStyle(0); //BDTD dists TCanvas* c1 = new TCanvas("c1","c1",0,-200,500,500); TH1F* histoBg = histo4->Clone(); histoBg->Add(histo3); histoBg->Add(histo2); histoBg->Add(histo1); TH1F* histo_4 = histo4->Clone(); histo3->Add(histo_4); TH1F* histo_3 = histo3->Clone(); histo2->Add(histo_3); TH1F* histo_2 = histo2->Clone(); histo1->Add(histo_2); histo1->Rebin(ReBin); histo1->SetFillColor(kBlue); histo1->SetFillStyle(1001); histo1->SetLineStyle(0); histo1->SetLineWidth(0); histo2->Rebin(ReBin); histo2->SetFillColor(kMagenta); histo2->SetFillStyle(1001); histo2->SetLineStyle(0); histo2->SetLineWidth(0); histo3->Rebin(ReBin); histo3->SetFillColor(kGreen); histo3->SetFillStyle(1001); histo3->SetLineStyle(0); histo3->SetLineWidth(0); histo4->Rebin(ReBin); histo4->SetFillColor(kCyan); histo4->SetFillStyle(1001); histo4->SetLineStyle(0); histo4->SetLineWidth(0); char YTitle[300]; sprintf(YTitle,"events / bin"); char XTitle[300]; sprintf(XTitle,"BDT Output"); histo0->SetYTitle(YTitle); histo1->SetYTitle(YTitle); histo2->SetYTitle(YTitle); histo3->SetYTitle(YTitle); histo4->SetYTitle(YTitle); histo0->SetXTitle(XTitle); histo1->SetXTitle(XTitle); histo2->SetXTitle(XTitle); histo3->SetXTitle(XTitle); histo4->SetXTitle(XTitle); histo1->SetTitleSize(0.05, "X"); histo1->GetXaxis()->SetTitleFont(62); histo1->GetXaxis()->SetLabelFont(61); histo1->GetYaxis()->SetLabelFont(61); histo1->GetYaxis()->SetTitleOffset(1.3); histo1->SetLabelSize(0.04, "Y"); histo1->SetLabelSize(0.04, "X"); int min = histoBg->FindBin(-1.5); int max = histoBg->FindBin(1.5); histoBg->GetXaxis()->SetRange(min,max); histoBg->SetMarkerStyle(20); histoBg->SetMarkerSize(1.0); histoBg->GetYaxis()->SetTitleOffset(1.40); histo0->SetMarkerStyle(21); histo0->SetMarkerSize(1.0); histoBg->Rebin(ReBin); histo0->Rebin(ReBin); histoBg->SetLineColor(4); histo0->SetLineColor(1); scaleHist(histoBg); scaleHist(histo0); cout << "bg events: " << histoBg->GetSumOfWeights() << endl; cout << "si events: " << histo0->GetSumOfWeights() << endl; histoBg->SetYTitle("Events"); histo1->SetMinimum(0.01); if(ysel == 0) { histo1->Draw("hist"); } else { histo0->Draw("E"); histo1->Draw("hist,same"); } histo2->Draw("hist,same"); histo3->Draw("hist,same"); histo4->Draw("hist,same"); histo0->Draw("E, same"); //histoBg->DrawCopy("hist"); //histo0->DrawCopy("hist,same"); TLegend* leg = new TLegend(0.63, 0.75, 0.92, 0.92); leg->SetFillColor(0); char theSLine[100]; if(mass != 999) sprintf(theSLine,"Signal, m_{H}=%d GeV",mass); else sprintf(theSLine,"WW"); cout << theSLine << endl; leg ->AddEntry(histo0,theSLine); leg ->AddEntry(histo4,"W+Jets, W#gamma","F"); leg ->AddEntry(histo3,"di-boson","F"); leg ->AddEntry(histo2,"t#bar{t}, tW","F"); leg ->AddEntry(histo1,"Drell-Yan","F"); leg->Draw("same"); TString fileOutput1(filename.Data()); TString theLine = "_"; theLine = theLine + "plot.eps"; fileOutput1.ReplaceAll(".root",theLine.Data()); fileOutput1.ReplaceAll("../",""); fileOutput1.ReplaceAll("rootfiles_fastsim/",""); fileOutput1.ReplaceAll("rootfiles_fullsim/",""); c1->SaveAs(fileOutput1.Data()); //return; //-------------------------------- TCanvas* c3 = new TCanvas("c3","c3",550,-200,500,500); c3->SetLogx(); c3->SetLogy(); gPad->SetGrid(1,1); TGraphErrors* gBDTD = makeGraphFromHists(histo0, histoBg); gBDTD->Draw("APXl"); TH1* zBDTD = gBDTD->GetHistogram(); zBDTD->SetXTitle("Signal Events"); zBDTD->SetYTitle("Signal/Background"); //zBDTD->SetYTitle("Background Events"); //zBDTD->DrawCopy(); TLegend* leg3 = new TLegend(0.7, 0.7, 0.9, 0.9); leg3->SetFillColor(0); leg3->AddEntry(gBDTD,theSLine,"lp"); leg3->Draw("same"); TString fileOutput2(filename.Data()); theLine = "_"; theLine = theLine + "counts.eps"; fileOutput2.ReplaceAll(".root",theLine.Data()); fileOutput2.ReplaceAll("../",""); fileOutput2.ReplaceAll("rootfiles_fastsim/",""); fileOutput2.ReplaceAll("rootfiles_fullsim/",""); c3->SaveAs(fileOutput2.Data()); }
void plot(int mass) { double myQCDRelUncert = 0.038; double myEWKRelUncert = 0.131; double myFakesRelUncert = 0.238; double delta = 1.4; double br = 0.05; bool debug = false; bool log = false; double ymin = 0.001; double ymax = 48; static bool bMessage = false; if (!bMessage) { cout << "Values used as relative uncertainty (please check):" << endl; cout << " QCD: " << myQCDRelUncert << endl; cout << " EWK genuine tau: " << myEWKRelUncert << endl; cout << " EWK fake tau: " << myFakesRelUncert << endl << endl; bMessage = true; } cout << "Processing mass point: " << mass << " GeV/c2" << endl; gStyle->SetOptFit(1); gStyle->SetOptStat(0); gStyle->SetOptTitle(0); gStyle->SetTitleFont(43, "xyz"); gStyle->SetTitleSize(33, "xyz"); gStyle->SetLabelFont(43, "xyz"); gStyle->SetLabelSize(27, "xyz"); //std::string infile = "EPS_data_nodeltaphi/hplus_100.root"; //std::string infile = "EPS_data_deltaphi160/hplus_100.root"; std::stringstream s; s << "lands_histograms_hplushadronic_m" << mass << ".root"; std::string infile = s.str(); // Canvas TCanvas *myCanvas = new TCanvas("myCanvas", "",0,0,600,600); myCanvas->SetHighLightColor(2); myCanvas->Range(0,0,1,1); myCanvas->SetFillColor(0); myCanvas->SetBorderMode(0); myCanvas->SetBorderSize(2); if (log) myCanvas->SetLogy(); myCanvas->SetTickx(1); myCanvas->SetTicky(1); myCanvas->SetLeftMargin(0.16); myCanvas->SetRightMargin(0.05); myCanvas->SetTopMargin(0.05); myCanvas->SetBottomMargin(0.08); myCanvas->SetFrameFillStyle(0); myCanvas->SetFrameBorderMode(0); myCanvas->SetFrameFillStyle(0); myCanvas->SetFrameBorderMode(0); myCanvas->cd(); Int_t ci; TFile* f = TFile::Open(infile.c_str()); s.str(""); s << "HW" << mass << "_1"; TH1* hw = (TH1*)f->Get(s.str().c_str()); s.str(""); s << "HH" << mass << "_1"; TH1* hh = (TH1*)f->Get(s.str().c_str()); TH1* data = (TH1*)f->Get("data_obs"); data->SetLineWidth(2); data->SetMarkerStyle(20); data->SetMarkerSize(1.2); TH1* ewktau = (TH1*)f->Get("EWK_Tau"); ci = TColor::GetColor("#993399"); ewktau->SetFillColor(ci); ewktau->SetLineWidth(0); TH1* ewkDY = (TH1*)f->Get("EWK_DYx"); TH1* ewkVV = (TH1*)f->Get("EWK_VVx"); ewktau->Add(ewkDY); ewktau->Add(ewkVV); //TH1* qcd = (TH1*)f->Get("QCDInv"); TH1* qcd = (TH1*)f->Get("QCD"); ci = TColor::GetColor("#ffcc33"); qcd->SetFillColor(ci); qcd->SetLineWidth(0); TH1* fakett = (TH1*)f->Get("fake_tt"); ci = TColor::GetColor("#669900"); fakett->SetFillColor(ci); fakett->SetLineWidth(0); TH1* fakeW = (TH1*)f->Get("fake_W"); ci = TColor::GetColor("#cc3300"); fakeW->SetFillColor(ci); fakeW->SetLineWidth(0); TH1* faket = (TH1*)f->Get("fake_t"); TH1F *hFrame = new TH1F("hFrame","",20,0,400); hFrame->SetMinimum(ymin); if (log) hFrame->SetMaximum(ymax*1.5); else hFrame->SetMaximum(ymax); hFrame->SetDirectory(0); hFrame->SetStats(0); hFrame->SetLineStyle(0); hFrame->SetMarkerStyle(20); hFrame->SetXTitle("Transverse mass (#tau jet, E_{T}^{miss}), (GeV/c^{2})"); if (paperStatus) hFrame->SetXTitle("Transverse mass (#tau_{h}, E_{T}^{miss}), (GeV/c^{2})"); hFrame->SetYTitle("Events / 20 GeV/c^{2}"); hFrame->GetXaxis()->SetTitleSize(0); hFrame->GetXaxis()->SetLabelSize(0); hFrame->GetYaxis()->SetTitleFont(43); hFrame->GetYaxis()->SetTitleSize(27); hFrame->GetYaxis()->SetTitleOffset(1.3); // signal hh->Scale(br*br); hw->Scale(2*br*(1.0-br)); TH1* signal = (TH1*)hh->Clone(); signal->Add(hw); ci = TColor::GetColor("#ff3399"); signal->SetLineColor(ci); signal->SetLineStyle(2); signal->SetLineWidth(2); // Fakes TH1* fakes = (TH1*)(fakett->Clone()); fakes->Add(fakeW); fakes->Add(faket); // stacked backgrounds THStack *exp = new THStack(); exp->SetName("exp"); exp->SetTitle("exp"); exp->Add(fakes); exp->Add(ewktau); exp->Add(qcd); exp->Add(signal); TH1* hExpBkg = (TH1*)fakes->Clone(); hExpBkg->Add(ewktau); hExpBkg->Add(qcd); // uncertainty TH1* uncert = (TH1*)fakeW->Clone(); uncert->Add(fakett); uncert->Add(ewktau); uncert->Add(qcd); uncert->SetFillColor(1); uncert->SetFillStyle(3344); uncert->SetLineColor(0); uncert->SetLineStyle(0); uncert->SetLineWidth(0); TH1* hExpBkgTotalUncert = (TH1*)uncert->Clone(); hExpBkgTotalUncert->SetFillStyle(3354); TH1* hAgreement = (TH1*)data->Clone(); hAgreement->Divide(hExpBkg); TGraphErrors* hAgreementRelUncert = new TGraphErrors(hAgreement->GetNbinsX()); hAgreementRelUncert->SetLineWidth(2); hAgreementRelUncert->SetLineColor(kBlack); for (int i = 1; i <= hFrame->GetNbinsX(); ++i) { double myQCDTotalUncert = TMath::Power(qcd->GetBinError(i), 2) + TMath::Power(qcd->GetBinContent(i)*myQCDRelUncert, 2); double myEWKTotalUncert = TMath::Power(ewktau->GetBinError(i), 2) + TMath::Power(ewktau->GetBinContent(i)*myEWKRelUncert, 2); double myFakesTotalUncert = TMath::Power(fakes->GetBinError(i), 2) + TMath::Power(fakes->GetBinContent(i)*myFakesRelUncert, 2); hExpBkgTotalUncert->SetBinError(i, TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert)); if (hExpBkg->GetBinContent(i) > 0) { hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), data->GetBinContent(i) / hExpBkg->GetBinContent(i)); double myUncertData = 0; if (data->GetBinContent(i) > 0) myUncertData = TMath::Power(data->GetBinError(i) / data->GetBinContent(i), 2); double myUncertBkg = (myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / TMath::Power(hExpBkg->GetBinContent(i), 2); hAgreementRelUncert->SetPointError(i-1, 0, data->GetBinContent(i) / hExpBkg->GetBinContent(i) * TMath::Sqrt(myUncertData + myUncertBkg)); } else { hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), 0); hAgreementRelUncert->SetPointError(i-1, 0, 0); } if (debug) { cout << "Point: " << hAgreementRelUncert->GetX()[i-1]-10 << "-" << hAgreementRelUncert->GetX()[i-1]+10 << " GeV/c2, agreement: " << hAgreementRelUncert->GetY()[i-1] << ", uncert: " << hAgreement->GetBinError(i) << ", " << hAgreementRelUncert->GetErrorY(i-1) << endl; cout << " bkg. stat. uncert. " << hExpBkg->GetBinError(i) << " (i.e. " << hExpBkg->GetBinError(i) / hExpBkg->GetBinContent(i) * 100.0 << " %)" << ", stat+syst uncert. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) << " (i.e. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / hExpBkg->GetBinContent(i) * 100.0 << " %)" << endl; } } // Agreement pad TPad* pad = new TPad("ratiopad","ratiopad",0.,0.,1.,.3); pad->Draw(); pad->cd(); pad->Range(0,0,1,1); pad->SetFillColor(0); pad->SetFillStyle(4000); pad->SetBorderMode(0); pad->SetBorderSize(2); pad->SetTickx(1); pad->SetTicky(1); pad->SetLeftMargin(0.16); pad->SetRightMargin(0.05); pad->SetTopMargin(0); pad->SetBottomMargin(0.34); pad->SetFrameFillStyle(0); pad->SetFrameBorderMode(0); // Plot here ratio if (1.0-delta > 0) hAgreement->SetMinimum(1.0-delta); else hAgreement->SetMinimum(0.); hAgreement->SetMaximum(1.0+delta); hAgreement->GetXaxis()->SetLabelOffset(0.007); hAgreement->GetXaxis()->SetLabelFont(43); hAgreement->GetXaxis()->SetLabelSize(27); hAgreement->GetYaxis()->SetLabelFont(43); hAgreement->GetYaxis()->SetLabelSize(27); hAgreement->GetYaxis()->SetLabelOffset(0.007); hAgreement->GetYaxis()->SetNdivisions(505); hAgreement->GetXaxis()->SetTitleFont(43); hAgreement->GetYaxis()->SetTitleFont(43); hAgreement->GetXaxis()->SetTitleSize(33); hAgreement->GetYaxis()->SetTitleSize(33); hAgreement->SetTitleSize(27, "xyz"); hAgreement->GetXaxis()->SetTitleOffset(3.2); hAgreement->GetYaxis()->SetTitleOffset(1.3); hAgreement->SetXTitle(hFrame->GetXaxis()->GetTitle()); hAgreement->SetYTitle("Data/#Sigmabkg"); hAgreement->Draw("e2"); // Plot line at zero TH1* hAgreementLine = dynamic_cast<TH1*>(hAgreement->Clone()); for (int i = 1; i <= hAgreementLine->GetNbinsX(); ++i) { hAgreementLine->SetBinContent(i,1.0); hAgreementLine->SetBinError(i,0.0); } hAgreementLine->SetLineColor(kRed); hAgreementLine->SetLineWidth(2); hAgreementLine->SetLineStyle(3); hAgreementLine->Draw("hist same"); hAgreement->Draw("same"); hAgreementRelUncert->Draw("[]"); pad->RedrawAxis(); myCanvas->cd(); TPad* plotpad = new TPad("plotpad", "plotpad",0,0.3,1.,1.); plotpad->Draw(); plotpad->cd(); plotpad->Range(0,0,1,1); plotpad->SetFillColor(0); plotpad->SetFillStyle(4000); plotpad->SetBorderMode(0); plotpad->SetBorderSize(2); //if (logy) // plotpad->SetLogy(); plotpad->SetTickx(1); plotpad->SetTicky(1); plotpad->SetLeftMargin(0.16); plotpad->SetRightMargin(0.05); plotpad->SetTopMargin(0.065); plotpad->SetBottomMargin(0.0); plotpad->SetFrameFillStyle(0); plotpad->SetFrameBorderMode(0); hFrame->GetXaxis()->SetTitleSize(0); hFrame->GetXaxis()->SetLabelSize(0); hFrame->GetYaxis()->SetTitleFont(43); hFrame->GetYaxis()->SetTitleSize(33); hFrame->GetYaxis()->SetTitleOffset(1.3); // Draw objects hFrame->Draw(); exp->Draw("hist same"); uncert->Draw("E2 same"); hExpBkgTotalUncert->Draw("E2 same"); // Data data->Draw("same"); //signal->Draw("same"); TLegend *leg = new TLegend(0.53,0.6,0.87,0.91,NULL,"brNDC"); leg->SetBorderSize(0); leg->SetTextFont(63); leg->SetTextSize(18); leg->SetLineColor(1); leg->SetLineStyle(1); leg->SetLineWidth(1); leg->SetFillColor(kWhite); //leg->SetFillStyle(4000); // enabling this will cause the plot to be erased from the pad TLegendEntry* entry = leg->AddEntry(data, "Data", "P"); s.str(""); s << "with H^{#pm}#rightarrow#tau^{#pm}#nu"; entry = leg->AddEntry(signal, s.str().c_str(), "L"); entry = leg->AddEntry(qcd, "QCD (meas.)", "F"); entry = leg->AddEntry(ewktau, "EWK genuine #tau (meas.)", "F"); entry = leg->AddEntry(fakes, "EWK fake #tau (MC)", "F"); entry = leg->AddEntry(uncert, "stat. uncert.", "F"); entry = leg->AddEntry(hExpBkgTotalUncert, "stat. #oplus syst. uncert.", "F"); leg->Draw(); string myTitle = "CMS Preliminary"; if (paperStatus) myTitle = "CMS"; TLatex *tex = new TLatex(0.62,0.945,myTitle.c_str()); tex->SetNDC(); tex->SetTextFont(43); tex->SetTextSize(27); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.2,0.945,"#sqrt{s} = 7 TeV"); tex->SetNDC(); tex->SetTextFont(43); tex->SetTextSize(27); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.43,0.945,"2.2 fb^{-1}"); tex->SetNDC(); tex->SetTextFont(43); tex->SetTextSize(27); tex->SetLineWidth(2); tex->Draw(); s.str(""); s << "m_{H^{#pm}} = " << mass << " GeV/c^{2}"; tex = new TLatex(0.28,0.865,s.str().c_str()); tex->SetNDC(); tex->SetTextFont(63); tex->SetTextSize(20); tex->SetLineWidth(2); tex->Draw(); s.str(""); s << "BR(t#rightarrowbH^{#pm})=" << setprecision(2) << br; tex = new TLatex(0.28,0.805,s.str().c_str()); tex->SetNDC(); tex->SetTextFont(63); tex->SetTextSize(20); tex->SetLineWidth(2); tex->Draw(); plotpad->RedrawAxis(); plotpad->Modified(); s.str(""); s << "mT_datadriven_m" << mass << ".png"; myCanvas->Print(s.str().c_str()); s.str(""); s << "mT_datadriven_m" << mass << ".C"; myCanvas->Print(s.str().c_str()); s.str(""); s << "mT_datadriven_m" << mass << ".eps"; myCanvas->Print(s.str().c_str()); }
void Template::makeResidualsControlPlot(const string& tag, unsigned int rebin) /*****************************************************************/ { if(numberOfDimensions()>0 && m_template->GetNbinsX()%rebin!=0) return; if(numberOfDimensions()>1 && m_template->GetNbinsY()%rebin!=0) return; if(numberOfDimensions()>2 && m_template->GetNbinsZ()%rebin!=0) return; stringstream cpName, cpRawName, resMapName, resDistName, relErrDistName; cpName << m_name << "_cp"; cpRawName << m_name << "_rawcp"; resMapName << m_name << "_resmap_" << tag << "_rebin" << rebin; resDistName << m_name << "_resdist_" << tag << "_rebin" << rebin; relErrDistName << m_name << "_relerrdist_" << tag << "_rebin" << rebin; TH1* cpTmp = NULL; TH1* cpRawTmp = NULL; if(rebin==1) { cpTmp = dynamic_cast<TH1*>(m_template->Clone(cpName.str().c_str())); cpRawTmp = dynamic_cast<TH1*>(m_rawTemplate->Clone(cpRawName.str().c_str())); } else { if(numberOfDimensions()==2) { cpTmp = dynamic_cast<TH2F*>(m_template)->Rebin2D(rebin, rebin, cpName.str().c_str()); cpRawTmp = dynamic_cast<TH2F*>(m_rawTemplate)->Rebin2D(rebin, rebin, cpName.str().c_str()); } else if(numberOfDimensions()==3) { cpTmp = dynamic_cast<TH3F*>(m_template)->Rebin3D(rebin, rebin, rebin, cpName.str().c_str()); cpRawTmp = dynamic_cast<TH3F*>(m_rawTemplate)->Rebin3D(rebin, rebin, rebin, cpName.str().c_str()); } } TH1* resMap = dynamic_cast<TH1*>(cpTmp->Clone(resMapName.str().c_str())); TH1D* resDist = new TH1D(resDistName.str().c_str(), resDistName.str().c_str(), 30, -3, 3); resDist->StatOverflows(); TH1D* relErrDist = new TH1D(relErrDistName.str().c_str(), relErrDistName.str().c_str(), 200, -1, 1); relErrDist->StatOverflows(); unsigned int nbins1 = cpTmp->GetNbinsX(); unsigned int nbins2 = cpTmp->GetNbinsY(); unsigned int nbins3 = cpTmp->GetNbinsZ(); for(unsigned int b1=1;b1<=nbins1;b1++) { for(unsigned int b2=1;b2<=nbins2;b2++) { for(unsigned int b3=1;b3<=nbins3;b3++) { double tmpValue = cpTmp->GetBinContent(b1,b2,b3); double tmpRawValue = cpRawTmp->GetBinContent(b1,b2,b3); double tmpRawError = cpRawTmp->GetBinError(b1,b2,b3); if(tmpValue>0. && tmpRawValue>0. && tmpRawError>0.) { double res = (tmpRawValue-tmpValue)/tmpRawError; double relErr = (tmpRawValue-tmpValue)/tmpRawValue; if(numberOfDimensions()==2) { resMap->SetBinContent(b1,b2,b3, res); resMap->SetBinError(b1,b2,b3, 0.); } resDist->Fill(res); relErrDist->Fill(relErr); } } } } stringstream plotMapName, plotDistName, plotErrDistName; plotMapName << "control_" << getName() << "_resMap" << "_" << tag << "_rebin" << rebin; plotDistName << "control_" << getName() << "_resDist" << "_" << tag << "_rebin" << rebin; plotErrDistName << "control_" << getName() << "_relErrDist" << "_" << tag << "_rebin" << rebin; if(numberOfDimensions()==2) { TCanvas* c = new TCanvas(plotMapName.str().c_str(),plotMapName.str().c_str(), 700,700); resMap->SetContour(99); resMap->SetAxisRange(-3., 3., "z"); resMap->Draw("color z"); resMap->SetXTitle(getVariable(0).c_str()); resMap->SetYTitle(getVariable(1).c_str()); addControlPlot(c); } TCanvas* c2 = new TCanvas(plotDistName.str().c_str(),plotDistName.str().c_str(), 700,700); resDist->SetLineColor(kBlack); resDist->SetLineWidth(2); resDist->SetMarkerColor(kBlack); resDist->SetMarkerStyle(20); resDist->SetXTitle("(raw-template)/error_{raw}"); resDist->Draw(); addControlPlot(c2); TCanvas* c3 = new TCanvas(plotErrDistName.str().c_str(),plotErrDistName.str().c_str(), 700,700); relErrDist->SetLineColor(kBlack); relErrDist->SetLineWidth(2); relErrDist->SetMarkerColor(kBlack); relErrDist->SetMarkerStyle(20); relErrDist->SetXTitle("(raw-template)/raw"); relErrDist->Draw(); addControlPlot(c3); if(cpTmp) delete cpTmp; if(cpRawTmp) delete cpRawTmp; }
void DrawTwoInPad(TVirtualPad* p, Int_t sub, TH1* h1, TH1* h2, Bool_t ratio, Bool_t logy=false, Bool_t legend=false) { TVirtualPad* pp = p->cd(sub); pp->SetRightMargin(0.02); pp->SetLeftMargin(0.10); TVirtualPad* ppp = pp; if (ratio) { pp->Divide(1,2,0,0); ppp = pp->cd(1); ppp->SetRightMargin(0.02); } if (logy) ppp->SetLogy(); TH1* hs[] = { h1, h2, 0 }; if (h1->GetMaximum() < h2->GetMaximum()) { hs[0] = h2; hs[1] = h1; } TH1** ph = hs; Double_t size = (ratio ? 0.1 : 0.05); Double_t off = (ratio ? 0.6 : 0.5); h1->SetFillStyle(3004); h2->SetFillStyle(3005); while (*ph) { TString opt("hist"); if (ph != hs) opt.Append(" same"); TH1* copy = (*ph)->DrawCopy(opt); copy->GetXaxis()->SetLabelSize(2*size); copy->GetYaxis()->SetLabelSize(size); copy->GetYaxis()->SetTitleSize(size); copy->GetYaxis()->SetTitleOffset(off); copy->SetYTitle(copy->GetTitle()); copy->SetTitle(""); copy->SetDirectory(0); ph++; } TString s1 = h1->GetYaxis()->GetTitle(); TString s2 = h2->GetYaxis()->GetTitle(); if (legend) { TLegend* l = new TLegend(0.6, 0.1, 0.9, 0.9); l->SetBorderSize(0); TLegendEntry* e = l->AddEntry("dummy", s1, "lf"); l->SetFillColor(kWhite); e->SetFillColor(kBlack); e->SetFillStyle(h1->GetFillStyle()); e = l->AddEntry("dummy", s2, "lf"); e->SetFillColor(kBlack); e->SetFillStyle(h2->GetFillStyle()); l->Draw(); } if (!ratio) return; ppp = pp->cd(2); ppp->SetRightMargin(0.02); TH1* r = static_cast<TH1*>(h1->Clone(Form("ratio%s", h1->GetName()))); r->SetDirectory(0); r->SetTitle(""); r->GetXaxis()->SetLabelSize(size); r->GetYaxis()->SetLabelSize(size); r->GetYaxis()->SetTitleSize(0.9*size); r->GetYaxis()->SetTitleOffset(0.9*off); r->SetMarkerStyle(20); r->SetMarkerColor(h1->GetFillColor()+1); r->SetFillStyle(3007); r->SetYTitle(Form("#frac{%s}{%s}", s1.Data(), s2.Data())); // r->Add(h2, -1); // r->Divide(h1); if (!r->IsA()->InheritsFrom(TProfile::Class())) { r->GetSumw2()->Set(0); // r->Sumw2(false); h2->GetSumw2()->Set(0); // h2->Sumw2(false); } r->Divide(h2); Printf("%s", r->GetName()); for (UShort_t bin = 1; bin <= r->GetNbinsX(); bin++) { Printf(" bin # %2d: Diff=%g+/-%g", bin, r->GetBinContent(bin), r->GetBinError(bin)); r->SetBinError(bin, 0); } r->GetSumw2()->Set(0); //r->Sumw2(false); r->SetMarkerSize(4); r->SetMaximum(r->GetMaximum()*1.2); r->SetMinimum(r->GetMinimum()*0.8); r->Draw("hist text30"); p->Modified(); p->Update(); p->cd(); }