LightFlavorRatios/truth_ratio/plot_truth_comparison.C

0001 #include "../util/binning.h"
0002
0003 void formatDefault(TH1F* h, EColor color)
0004 {
0005   h->SetLineColor(color);
0006   h->SetMarkerStyle(kFullCircle);
0007   h->SetMarkerColor(color);
0008   h->SetMarkerSize(0.7);
0009 }
0010
0011 void plot_lambda(TFile* f_inc, TFile* f_pos, TFile* f_neg, std::string hname, std::string title, std::string filename, float x_legend, float y_legend, bool scale)
0012 {
0013   std::string clonename = scale? hname+"_scaled" : hname+"_unscaled";
0014
0015   TH1F* h_inc = (TH1F*)f_inc->Get(hname.c_str())->Clone(clonename.c_str());
0016   TH1F* h_pos = (TH1F*)f_pos->Get(hname.c_str())->Clone(clonename.c_str());
0017   TH1F* h_neg = (TH1F*)f_neg->Get(hname.c_str())->Clone(clonename.c_str());
0018   if(scale)
0019   {
0020     h_inc->Scale(1.,"width");
0021     h_pos->Scale(1.,"width");
0022     h_neg->Scale(1.,"width");
0023   }
0024
0025   TCanvas* c = new TCanvas("c","c",800,800);
0026   //c->SetLogy();
0027
0028   c->SetTitle(title.c_str());
0029
0030   float plot_min = std::min(h_pos->GetMinimum(),h_neg->GetMinimum());
0031   if(plot_min<0.) plot_min = 1.;
0032
0033   float plot_max = std::max(h_inc->GetMaximum(),h_pos->GetMaximum());
0034   if(h_neg->GetMaximum()>plot_max) plot_max = h_neg->GetMaximum();
0035
0036   h_inc->SetMinimum(0.);
0037   h_inc->SetMaximum(1.3*plot_max);
0038
0039   formatDefault(h_inc,kBlack);
0040   formatDefault(h_pos,kRed);
0041   formatDefault(h_neg,kBlue);
0042
0043   h_inc->Draw();
0044   h_pos->Draw("SAME");
0045   h_neg->Draw("SAME");
0046
0047   float x_legend_high = std::min(x_legend+0.25,0.9);
0048   float y_legend_high = std::min(y_legend+0.13,0.9);
0049
0050   TLegend* llyt = new TLegend(x_legend,y_legend,x_legend_high,y_legend_high);
0051   llyt->AddEntry(h_inc,"(#Lambda^{0}+#bar{#Lambda}^{0})");
0052   llyt->AddEntry(h_pos,"#Lambda^{0}");
0053   llyt->AddEntry(h_neg,"#bar{#Lambda}^{0}");
0054   llyt->Draw();
0055
0056   c->SaveAs(filename.c_str());
0057   c->Close();
0058 }
0059
0060 void plot_ks(TFile* f, std::string hname, std::string title, std::string filename, bool scale)
0061 {
0062   std::string clonename = scale? hname+"_scaled" : hname+"_unscaled";
0063
0064   TH1F* h = (TH1F*)f->Get(hname.c_str())->Clone(clonename.c_str());
0065
0066   if(scale)
0067   {
0068     h->Scale(1.,"width");
0069   }
0070
0071   h->SetMinimum(0.);
0072   h->SetMaximum(h->GetMaximum()*1.3);
0073
0074   TCanvas* c = new TCanvas("c","c",800,800);
0075   //c->SetLogy();
0076
0077   h->SetTitle(title.c_str());
0078   formatDefault(h,kBlack);
0079   h->Draw();
0080
0081   c->SaveAs(filename.c_str());
0082   c->Close();
0083 }
0084
0085 void plot_ratio(TH1F* ratio_inc, TH1F* ratio_pos, TH1F* ratio_neg, std::string title, std::string filename, float x_legend, float y_legend)
0086 {
0087   TCanvas* c = new TCanvas("c","c",800,800);
0088
0089   formatDefault(ratio_inc,kBlack);
0090   formatDefault(ratio_pos,kRed);
0091   formatDefault(ratio_neg,kBlue);
0092
0093   ratio_inc->SetTitle(title.c_str());
0094   ratio_inc->SetMinimum(0.);
0095   ratio_inc->SetMaximum(1.3*std::max(ratio_pos->GetMaximum(),ratio_neg->GetMaximum()));
0096
0097   ratio_inc->Draw();
0098   ratio_pos->Draw("SAME");
0099   ratio_neg->Draw("SAME");
0100
0101   float x_legend_high = std::min(x_legend+0.25,0.9);
0102   float y_legend_high = std::min(y_legend+0.13,0.9);
0103
0104   TLegend* lrt = new TLegend(x_legend,y_legend,x_legend_high,y_legend_high);
0105   lrt->AddEntry(ratio_inc,"(#Lambda^{0}+#bar{#Lambda}^{0})/2K_{S}^{0}");
0106   lrt->AddEntry(ratio_pos,"#Lambda^{0}/K_{S}^{0}");
0107   lrt->AddEntry(ratio_neg,"#bar{#Lambda}^{0}/K_{S}^{0}");
0108   lrt->Draw();
0109
0110   c->SaveAs(filename.c_str());
0111   c->Close();
0112 }
0113
0114 void plot_truth_vsreco(TH1F* truth, TH1F* reco, std::string title, std::string filename, float x_legend, float y_legend)
0115 {
0116   TCanvas* c = new TCanvas("c","c",800,800);
0117
0118   formatDefault(truth,kBlack);
0119   formatDefault(reco,kRed);
0120
0121   truth->SetTitle(title.c_str());
0122   truth->SetMinimum(0.);
0123   truth->SetMaximum(1.1*std::max(truth->GetMaximum(),reco->GetMaximum()));
0124
0125   truth->Draw();
0126   reco->Draw("SAME");
0127
0128   float x_legend_high = std::min(x_legend+0.25,0.9);
0129   float y_legend_high = std::min(y_legend+0.25,0.9);
0130
0131   TLegend* ltr = new TLegend(x_legend,y_legend,x_legend_high,y_legend_high);
0132   ltr->AddEntry(truth,"truth");
0133   ltr->AddEntry(reco,"reco");
0134
0135   c->SaveAs(filename.c_str());
0136   c->Close();
0137 }
0138
0139 void plot_correction_sequence(TH1F* truth, TH1F* reco, TH1F* geo_acc, TH1F* cut_eff, std::string title, std::string filename, float x_legend, float y_legend)
0140 {
0141   TCanvas* c = new TCanvas("c","c",800,800);
0142
0143 //  truth->Sumw2();
0144 //  reco->Sumw2();
0145 //  geo_acc->Sumw2();
0146 //  cut_eff->Sumw2();
0147
0148   TH1F* reco_geo = (TH1F*)reco->Clone((std::string(reco->GetName())+"_geo").c_str());
0149   TH1F* reco_geo_cut = (TH1F*)reco->Clone((std::string(reco->GetName())+"_geo_cut").c_str());
0150
0151   formatDefault(truth,kBlack);
0152   formatDefault(reco,kRed);
0153   formatDefault(reco_geo,kBlue);
0154   formatDefault(reco_geo_cut,kGreen);
0155
0156   reco_geo->Divide(geo_acc);
0157   reco_geo_cut->Divide(geo_acc);
0158   reco_geo_cut->Divide(cut_eff);
0159
0160   std::cout << reco->GetName() << std::endl;
0161   for(int i=1;i<=truth->GetNbinsX();i++)
0162   {
0163     std::cout << "bin " << i << ": " << std::endl
0164       << "reco: " << reco->GetBinContent(i) << " +- " << reco->GetBinError(i) << std::endl
0165       << "geo acceptance: " << geo_acc->GetBinContent(i) << " +- " << geo_acc->GetBinError(i) << std::endl
0166       << "cut eff: " << cut_eff->GetBinContent(i) << " +- " << cut_eff->GetBinError(i) << std::endl
0167       << "reco/geoacc: " << reco_geo->GetBinContent(i) << " +- " << reco_geo->GetBinError(i) << std::endl
0168       << "reco/(geoacc*cuteff): " << reco_geo_cut->GetBinContent(i) << " +- " << reco_geo_cut->GetBinError(i) << std::endl;
0169   }
0170
0171   truth->SetTitle(title.c_str());
0172   truth->SetMinimum(0.);
0173   truth->SetMaximum(1.1*std::max(truth->GetMaximum(),reco_geo_cut->GetMaximum()));
0174
0175   truth->Draw();
0176   reco->Draw("SAME");
0177   reco_geo->Draw("SAME");
0178   reco_geo_cut->Draw("SAME");
0179
0180   float x_legend_high = std::min(x_legend+0.25,0.9);
0181   float y_legend_high = std::min(y_legend+0.25,0.9);
0182
0183   TLegend* lc = new TLegend(x_legend,y_legend,x_legend_high,y_legend_high);
0184   lc->AddEntry(truth,"truth");
0185   lc->AddEntry(reco,"reco uncorrected");
0186   lc->AddEntry(reco_geo,"reco, geometric acceptance corrected");
0187   lc->AddEntry(reco_geo_cut,"reco, geometric acceptance and cut efficiency corrected");
0188   lc->Draw();
0189
0190   c->SaveAs(filename.c_str());
0191   c->Close();
0192 }
0193
0194 void plot_correction(TH1F* corr, std::string title, std::string filename)
0195 {
0196   TCanvas* c = new TCanvas("c","c",800,800);
0197
0198   formatDefault(corr,kBlack);
0199
0200   corr->SetTitle(title.c_str());
0201   corr->SetMinimum(0.);
0202   corr->SetMaximum(1.2*corr->GetMaximum());
0203
0204   corr->Draw();
0205
0206   c->SaveAs(filename.c_str());
0207   c->Close();
0208 }
0209
0210 void plot_inverse_correction_sequence(TH1F* truth, TH1F* reco, TH1F* geo_acc, TH1F* cut_eff, std::string title, std::string filename, float x_legend, float y_legend)
0211 {
0212   TCanvas* c = new TCanvas("c","c",800,800);
0213
0214 //  truth->Sumw2();
0215 //  reco->Sumw2();
0216 //  geo_acc->Sumw2();
0217 //  cut_eff->Sumw2();
0218
0219   TH1F* truth_cut = (TH1F*)truth->Clone((std::string(truth->GetName())+"_geo").c_str());
0220   TH1F* truth_cut_geo = (TH1F*)truth->Clone((std::string(truth->GetName())+"_geo_cut").c_str());
0221
0222   TH1F* reco_geo = (TH1F*)reco->Clone((std::string(reco->GetName())+"_geo").c_str());
0223   TH1F* reco_geo_cut = (TH1F*)reco->Clone((std::string(reco->GetName())+"_geo_cut").c_str());
0224
0225   formatDefault(truth,kBlack);
0226   formatDefault(reco,kRed);
0227   formatDefault(truth_cut,kViolet);
0228   formatDefault(truth_cut_geo,kOrange);
0229   formatDefault(reco_geo,kBlue);
0230   formatDefault(reco_geo_cut,kGreen);
0231
0232   truth_cut->Multiply(cut_eff);
0233   truth_cut_geo->Multiply(cut_eff);
0234   truth_cut_geo->Multiply(geo_acc);
0235
0236   reco_geo->Divide(geo_acc);
0237   reco_geo_cut->Divide(geo_acc);
0238   reco_geo_cut->Divide(cut_eff);
0239
0240   std::cout << reco->GetName() << std::endl;
0241   for(int i=1;i<=truth->GetNbinsX();i++)
0242   {
0243     std::cout << "bin " << i << ": " << std::endl
0244       << "truth: " << truth->GetBinContent(i) << " +- " << truth->GetBinError(i) << std::endl
0245       << "geo acceptance: " << geo_acc->GetBinContent(i) << " +- " << geo_acc->GetBinError(i) << std::endl
0246       << "cut eff: " << cut_eff->GetBinContent(i) << " +- " << cut_eff->GetBinError(i) << std::endl
0247       << "truth*cuteff: " << truth_cut->GetBinContent(i) << " +- " << truth_cut->GetBinError(i) << std::endl
0248       << "truth*(geoacc*cuteff): " << truth_cut_geo->GetBinContent(i) << " +- " << truth_cut_geo->GetBinError(i) << std::endl
0249       << "reco: " << reco->GetBinContent(i) << " +- " << reco->GetBinError(i) << std::endl;
0250   }
0251
0252   truth->SetTitle(title.c_str());
0253   truth->SetMinimum(0.);
0254   truth->SetMaximum(1.1*truth->GetMaximum());
0255
0256   truth->Draw();
0257   reco->Draw("SAME");
0258   truth_cut->Draw("SAME");
0259   truth_cut_geo->Draw("SAME");
0260   reco_geo->Draw("SAME");
0261   reco_geo_cut->Draw("SAME");
0262
0263   float x_legend_high = std::min(x_legend+0.4,0.9);
0264   float y_legend_high = std::min(y_legend+0.2,0.9);
0265
0266   TLegend* lc = new TLegend(x_legend,y_legend,x_legend_high,y_legend_high);
0267   lc->AddEntry(truth,"truth");
0268   lc->AddEntry(reco,"reco uncorrected");
0269   lc->AddEntry(truth_cut,"truth after cut efficiency");
0270   lc->AddEntry(truth_cut_geo,"truth after cut efficiency and geometric acceptance");
0271   lc->AddEntry(reco_geo,"reco after geometric acceptance correction");
0272   lc->AddEntry(reco_geo_cut,"reco after geometric acceptance and cut efficiency correction");
0273   lc->Draw();
0274
0275   c->SaveAs(filename.c_str());
0276   c->Close();
0277 }
0278
0279 void plot_truth_comparison()
0280 {
0281   gROOT->SetBatch();
0282
0283   TFile* ftruth = TFile::Open("merged_truth_ratio.root");
0284   TFile* ftruth_pos = TFile::Open("merged_ratio_pos.root");
0285   TFile* ftruth_neg = TFile::Open("merged_ratio_neg.root");
0286
0287   TFile* freco = TFile::Open("../yield_and_ratios/fits_MC.root");
0288   TFile* freco_pos = TFile::Open("../yield_and_ratios/fits_MC_pos.root");
0289   TFile* freco_neg = TFile::Open("../yield_and_ratios/fits_MC_neg.root");
0290
0291   TFile* fdata = TFile::Open("../yield_and_ratios/fits.root");
0292   TFile* fdata_pos = TFile::Open("../yield_and_ratios/fits_pos.root");
0293   TFile* fdata_neg = TFile::Open("../yield_and_ratios/fits_neg.root");
0294
0295   TFile* fgeo_corr = TFile::Open("/sphenix/tg/tg01/hf/mjpeters/LightFlavorProduction/geometricAcceptanceCorrection/corrections/geo_acceptance_inclusive.root");
0296   TFile* fgeo_corr_pos = TFile::Open("/sphenix/tg/tg01/hf/mjpeters/LightFlavorProduction/geometricAcceptanceCorrection/corrections/geo_acceptance_lambdaonly.root");
0297   TFile* fgeo_corr_neg = TFile::Open("/sphenix/tg/tg01/hf/mjpeters/LightFlavorProduction/geometricAcceptanceCorrection/corrections/geo_acceptance_lambdabaronly.root");
0298
0299   TFile* fcut_corr = TFile::Open("/sphenix/tg/tg01/hf/mjpeters/LightFlavorProduction/cutEfficiencyCorrection/cut_efficiency_correction.root");
0300   TFile* fcut_corr_pos = TFile::Open("/sphenix/tg/tg01/hf/mjpeters/LightFlavorProduction/cutEfficiencyCorrection/cut_efficiency_correction_pos.root");
0301   TFile* fcut_corr_neg = TFile::Open("/sphenix/tg/tg01/hf/mjpeters/LightFlavorProduction/cutEfficiencyCorrection/cut_efficiency_correction_neg.root");
0302
0303   std::vector<HistogramInfo> variables = {
0304     BinInfo::final_pt_bins,
0305     BinInfo::final_eta_bins,
0306     BinInfo::final_phi_bins,
0307     BinInfo::final_rapidity_bins
0308   };
0309
0310   gStyle->SetOptStat(0);
0311
0312   for(int i=0; i<variables.size(); i++)
0313   {
0314     std::string vname = variables[i].name;
0315     std::string vtitle = variables[i].title;
0316
0317     // lambda yields
0318
0319     plot_lambda(ftruth,ftruth_pos,ftruth_neg,"hn_vs"+vname,"#Lambda yield vs. "+vtitle+" from truth",
0320                 "plots/yields/lambda_yields_truth_vs"+vname+".png",0.65,0.77,false);
0321     plot_lambda(ftruth,ftruth_pos,ftruth_neg,"hn_vs"+vname,"#Lambda yield vs. "+vtitle+" from truth (scaled by bin width)",
0322                 "plots/yields/lambda_yields_truth_scaled_vs"+vname+".png",0.65,0.77,true);
0323     plot_lambda(ftruth,ftruth_pos,ftruth_neg,"hn_wd_vs"+vname,"#Lambda yield vs. "+vtitle+" from truth, with all reco daughters reconstructed",
0324                 "plots/yields/lambda_yields_wd_truth_vs"+vname+".png",0.65,0.77,false);
0325     plot_lambda(ftruth,ftruth_pos,ftruth_neg,"hn_wd_vs"+vname,"#Lambda yield vs. "+vtitle+" from truth, with all reco daughters reconstructed (scaled by bin width)","plots/yields/lambda_yields_wd_truth_scaled_vs"+vname+".png",0.65,0.77,true);
0326     plot_lambda(freco,freco_pos,freco_neg,"Lambda0_yield_vs"+vname,"#Lambda yield (uncorrected) vs. "+vtitle+" from reco",
0327                 "plots/yields/lambda_yields_reco_vs"+vname+".png",0.65,0.77,false);
0328     plot_lambda(freco,freco_pos,freco_neg,"Lambda0_yield_vs"+vname,"#Lambda yield (uncorrected) vs. "+vtitle+" from reco (scaled by bin width)",
0329                 "plots/yields/lambda_yields_reco_scaled_vs"+vname+".png",0.65,0.77,true);
0330 //    plot_lambda(fdata,fdata_pos,fdata_neg,"Lambda0_yield_vs"+vname,"#Lambda yield (uncorrected) vs. "+vtitle+" from data",
0331 //                "plots/yields/lambda_yields_data_vs"+vname+".png",0.65,0.77,false);
0332 //    plot_lambda(fdata,fdata_pos,fdata_neg,"Lambda0_yield_vs"+vname,"#Lambda yield (uncorrected) vs. "+vtitle+" from data (scaled by bin width)",
0333 //                "plots/yields/lambda_yields_data_scaled_vs"+vname+".png",0.65,0.77,true);
0334
0335     // Ks yields
0336
0337     plot_ks(ftruth,"hd_vs"+vname,"K_{S} yield vs. "+vtitle+" from truth","plots/yields/ks_yield_truth_vs"+vname+".png",false);
0338     plot_ks(ftruth,"hd_vs"+vname,"K_{S} yield vs. "+vtitle+" from truth (scaled by bin width)","plots/yields/ks_yield_truth_scaled_vs"+vname+".png",true);
0339     plot_ks(ftruth,"hd_wd_vs"+vname,"K_{S} yield vs. "+vtitle+" from truth, with all reco daughters reconstructed","plots/yields/ks_yield_wd_truth_vs"+vname+".png",false);
0340     plot_ks(ftruth,"hd_wd_vs"+vname,"K_{S} yield vs. "+vtitle+" from truth, with all reco daughters reconstructed (scaled by bin width)","plots/yields/ks_yield_wd_truth_scaled_vs"+vname+".png",true);
0341     plot_ks(freco,"K_S0_yield_vs"+vname,"K_{S} yield vs. "+vtitle+" from reco","plots/yields/ks_yield_reco_vs"+vname+".png",false);
0342     plot_ks(freco,"K_S0_yield_vs"+vname,"K_{S} yield vs. "+vtitle+" from reco (scaled by bin width)","plots/yields/ks_yield_reco_scaled_vs"+vname+".png",true);
0343 //    plot_ks(fdata,"K_S0_yield_vs"+vname,"K_{S} yield vs. "+vtitle+" from data","plots/yields/ks_yield_data_vs"+vname+".png",false);
0344 //    plot_ks(fdata,"K_S0_yield_vs"+vname,"K_{S} yield vs. "+vtitle+" from data (scaled by bin width)","plots/yields/ks_yield_data_scaled_vs"+vname+".png",true);
0345
0346     // Ratios
0347
0348     TH1F* ratio_truth = makeHistogram("ratio_truth","(#Lambda^{0}+#bar{#Lambda^{0}})/2K^{0}_{S} ratio from truth",variables[i]);
0349     TH1F* ratio_truth_pos = makeHistogram("ratio_truth_pos","#Lambda^{0}/K^{0}_{S} ratio from truth",variables[i]);
0350     TH1F* ratio_truth_neg = makeHistogram("ratio_truth_neg","#bar{#Lambda^{0}}/K^{0}_{S} ratio from truth",variables[i]);
0351
0352     TH1F* lambda_truth = (TH1F*)ftruth->Get(("hn_vs"+vname).c_str());
0353     TH1F* lambda_truth_pos = (TH1F*)ftruth_pos->Get(("hn_vs"+vname).c_str());
0354     TH1F* lambda_truth_neg = (TH1F*)ftruth_neg->Get(("hn_vs"+vname).c_str());
0355     TH1F* ks_truth = (TH1F*)ftruth->Get(("hd_vs"+vname).c_str());
0356
0357     for(TH1F* h : {lambda_truth, lambda_truth_pos, lambda_truth_neg, ks_truth})
0358     {
0359       h->Sumw2();
0360     }
0361
0362     ratio_truth->Divide(lambda_truth,ks_truth,1.,2.);
0363     ratio_truth_pos->Divide(lambda_truth_pos,ks_truth);
0364     ratio_truth_neg->Divide(lambda_truth_neg,ks_truth);
0365
0366     std::string reco_uncorrected_name = "lambdaKsratio_vs"+vname;
0367     std::string reco_corrected_name = "lambdaKsratio_vs"+vname+"_lambdafeeddowncorrected_effcorrected_geoacceptancecorrected_cutefficiencycorrected";
0368
0369     TH1F* ratio_reco_inc = (TH1F*)freco->Get(reco_uncorrected_name.c_str());
0370     TH1F* ratio_reco_pos = (TH1F*)freco_pos->Get(reco_uncorrected_name.c_str());
0371     TH1F* ratio_reco_neg = (TH1F*)freco_neg->Get(reco_uncorrected_name.c_str());
0372     TH1F* ratio_reco_corr_inc = (TH1F*)freco->Get(reco_corrected_name.c_str());
0373     TH1F* ratio_reco_corr_pos = (TH1F*)freco_pos->Get(reco_corrected_name.c_str());
0374     TH1F* ratio_reco_corr_neg = (TH1F*)freco_neg->Get(reco_corrected_name.c_str());
0375 /*
0376     TH1F* ratio_data_inc = (TH1F*)fdata->Get(reco_uncorrected_name.c_str());
0377     TH1F* ratio_data_pos = (TH1F*)fdata_pos->Get(reco_uncorrected_name.c_str());
0378     TH1F* ratio_data_neg = (TH1F*)fdata_neg->Get(reco_uncorrected_name.c_str());
0379     TH1F* ratio_data_corr_inc = (TH1F*)fdata->Get(reco_corrected_name.c_str());
0380     TH1F* ratio_data_corr_pos = (TH1F*)fdata_pos->Get(reco_corrected_name.c_str());
0381     TH1F* ratio_data_corr_neg = (TH1F*)fdata_neg->Get(reco_corrected_name.c_str());
0382 */
0383
0384     double lambda_BR = 0.638719992;
0385     double Ks_BR = 0.691086452;
0386
0387     for(TH1F* h : {ratio_reco_inc, ratio_reco_pos, ratio_reco_neg, ratio_reco_corr_inc, ratio_reco_corr_pos, ratio_reco_corr_neg})
0388 //                   ratio_data_inc, ratio_data_pos, ratio_data_neg, ratio_data_corr_inc, ratio_data_corr_pos, ratio_data_corr_neg})
0389     {
0390       h->Scale(Ks_BR/lambda_BR);
0391     }
0392
0393     plot_ratio(ratio_truth,ratio_truth_pos,ratio_truth_neg,"Ratio comparison vs. "+vtitle+" from truth","plots/ratios/ratio_truth_vs"+vname+".png",0.55,0.15);
0394     plot_ratio(ratio_reco_inc,ratio_reco_pos,ratio_reco_neg,"Ratio comparison vs. "+vtitle+" (uncorrected) from reco","plots/ratios/ratio_reco_vs"+vname+".png",0.15,0.75);
0395     plot_ratio(ratio_reco_corr_inc,ratio_reco_corr_pos,ratio_reco_corr_neg,"Ratio comparison vs. "+vtitle+" (fully corrected) from reco","plots/ratios/ratio_reco_corr_vs"+vname+".png",0.65,0.77);
0396 //    plot_ratio(ratio_data_inc,ratio_data_pos,ratio_data_neg,"Ratio comparison vs. "+vtitle+" (uncorrected) from data","plots/ratios/ratio_data_vs"+vname+".png",0.65,0.77);
0397 //    plot_ratio(ratio_data_corr_inc,ratio_data_corr_pos,ratio_data_corr_neg,"Ratio comparison vs. "+vtitle+" (fully corrected) from data","plots/ratios/ratio_data_corr_vs"+vname+".png",0.65,0.77);
0398
0399     // Truth-reco closure comparisons
0400     plot_truth_vsreco(ratio_truth,ratio_reco_corr_inc,"(#Lambda+#bar{#Lambda})/2K_{S}^{0} ratio","plots/closure/closure_ratio_vs"+vname+".png",0.55,0.15);
0401     plot_truth_vsreco(ratio_truth_pos,ratio_reco_corr_pos,"#Lambda/K_{S}^{0} ratio","plots/closure/closure_ratio_pos_vs"+vname+".png",0.55,0.15);
0402     plot_truth_vsreco(ratio_truth_neg,ratio_reco_corr_neg,"#bar{#Lambda}/K_{S}^{0} ratio","plots/closure/closure_ratio_neg_vs"+vname+".png",0.55,0.15);
0403
0404     // Direct yield comparisons
0405     TH1F* lambda_geo_acceptance = (TH1F*)fgeo_corr->Get(("Lambda0_acceptance_vs"+vname).c_str());
0406     TH1F* lambda_geo_acceptance_pos = (TH1F*)fgeo_corr_pos->Get(("Lambda0_acceptance_vs"+vname).c_str());
0407     TH1F* lambda_geo_acceptance_neg = (TH1F*)fgeo_corr_neg->Get(("Lambda0_acceptance_vs"+vname).c_str());
0408
0409     plot_correction(lambda_geo_acceptance,"(#Lambda+#bar{#Lambda}) geometric acceptance","plots/corrections/lambda_geo_acceptance_vs"+vname+".png");
0410     plot_correction(lambda_geo_acceptance_pos,"#Lambda geometric acceptance","plots/corrections/lambda_pos_geo_acceptance_vs"+vname+".png");
0411     plot_correction(lambda_geo_acceptance_neg,"#bar{#Lambda} geometric acceptance","plots/corrections/lambda_neg_geo_acceptance_vs"+vname+".png");
0412
0413     TH1F* lambda_cut_efficiency = (TH1F*)fcut_corr->Get(("Lambda0_cuteff_vs"+vname).c_str());
0414     TH1F* lambda_cut_efficiency_pos = (TH1F*)fcut_corr_pos->Get(("Lambda0_cuteff_vs"+vname).c_str());
0415     TH1F* lambda_cut_efficiency_neg = (TH1F*)fcut_corr_neg->Get(("Lambda0_cuteff_vs"+vname).c_str());
0416
0417     plot_correction(lambda_cut_efficiency,"(#Lambda+#bar{#Lambda}) cut efficiency","plots/corrections/lambda_cut_efficiency_vs"+vname+".png");
0418     plot_correction(lambda_cut_efficiency_pos,"#Lambda cut efficiency","plots/corrections/lambda_pos_cut_efficiency_vs"+vname+".png");
0419     plot_correction(lambda_cut_efficiency_neg,"#bar{#Lambda} cut efficiency","plots/corrections/lambda_neg_cut_efficiency_vs"+vname+".png");
0420
0421     TH1F* lambda_reco_inc = (TH1F*)freco->Get(("Lambda0_yield_vs"+vname).c_str());
0422     TH1F* lambda_reco_pos = (TH1F*)freco_pos->Get(("Lambda0_yield_vs"+vname).c_str());
0423     TH1F* lambda_reco_neg = (TH1F*)freco_neg->Get(("Lambda0_yield_vs"+vname).c_str());
0424
0425     lambda_truth->Scale(1.,"width");
0426     lambda_truth_pos->Scale(1.,"width");
0427     lambda_truth_neg->Scale(1.,"width");
0428     lambda_reco_inc->Scale(1.,"width");
0429     lambda_reco_pos->Scale(1.,"width");
0430     lambda_reco_neg->Scale(1.,"width");
0431
0432     TH1F* Kshort_geo_acceptance = (TH1F*)fgeo_corr->Get(("K_S0_acceptance_vs"+vname).c_str());
0433
0434     TH1F* Kshort_cut_efficiency = (TH1F*)fcut_corr->Get(("K_S0_cuteff_vs"+vname).c_str());
0435
0436     plot_correction(Kshort_geo_acceptance,"K_{S}^{0} geometric acceptance","plots/corrections/ks_geo_acceptance_vs"+vname+".png");
0437     plot_correction(Kshort_cut_efficiency,"K_{S}^{0} cut efficiency","plots/corrections/ks_cut_efficiency_vs"+vname+".png");
0438
0439     TH1F* geoacc_corr = (TH1F*)fgeo_corr->Get(("Lambda0_over_K_S0_geo_acceptance_correction_vs"+vname).c_str());
0440     TH1F* geoacc_corr_pos = (TH1F*)fgeo_corr_pos->Get(("Lambda0_over_K_S0_geo_acceptance_correction_vs"+vname).c_str());
0441     TH1F* geoacc_corr_neg = (TH1F*)fgeo_corr_neg->Get(("Lambda0_over_K_S0_geo_acceptance_correction_vs"+vname).c_str());
0442     TH1F* cuteff_corr = (TH1F*)fcut_corr->Get(("Lambda0_over_K_S0_cuteff_correction_vs"+vname).c_str());
0443     TH1F* cuteff_corr_pos = (TH1F*)fcut_corr->Get(("Lambda0_over_K_S0_cuteff_correction_vs"+vname).c_str());
0444     TH1F* cuteff_corr_neg = (TH1F*)fcut_corr->Get(("Lambda0_over_K_S0_cuteff_correction_vs"+vname).c_str());
0445
0446     plot_correction(geoacc_corr,"(#Lambda+#bar{#Lambda})/2K_{S}^{0} geometric acceptance correction","plots/corrections/ratio_geo_acceptance_vs"+vname+".png");
0447     plot_correction(geoacc_corr_pos,"#Lambda/K_{S}^{0} geometric acceptance correction","plots/corrections/ratio_geo_acceptance_pos_vs"+vname+".png");
0448     plot_correction(geoacc_corr_neg,"#bar{#Lambda}/K_{S}^{0} geometric acceptance correction","plots/corrections/ratio_geoacceptance_neg_vs"+vname+".png");
0449     plot_correction(cuteff_corr,"(#Lambda+#bar{#Lambda})/2K_{S}^{0} cut efficiency correction","plots/corrections/ratio_cuteff_vs"+vname+".png");
0450     plot_correction(cuteff_corr_pos,"#Lambda/K_{S}^{0} cut efficiency correction","plots/corrections/ratio_cuteff_pos_vs"+vname+".png");
0451     plot_correction(cuteff_corr_neg,"#bar{#Lambda}/K_{S}^{0} cut efficiency correction","plots/corrections/ratio_cuteff_neg_vs"+vname+".png");
0452
0453     TH1F* Kshort_reco_inc = (TH1F*)freco->Get(("K_S0_yield_vs"+vname).c_str());
0454
0455     Kshort_reco_inc->Scale(1.,"width");
0456     ks_truth->Scale(1.,"width");
0457
0458     Kshort_reco_inc->Scale(1./Ks_BR);
0459     lambda_reco_inc->Scale(1./lambda_BR);
0460     lambda_reco_pos->Scale(1./lambda_BR);
0461     lambda_reco_neg->Scale(1./lambda_BR);
0462
0463     plot_correction_sequence(lambda_truth,lambda_reco_inc,lambda_geo_acceptance,lambda_cut_efficiency,"(#Lambda+#bar{#Lambda}) yield","plots/closure/closure_lambda_corrections_vs"+vname+".png",0.55,0.15);
0464     plot_correction_sequence(lambda_truth_pos,lambda_reco_pos,lambda_geo_acceptance_pos,lambda_cut_efficiency_pos,"#Lambda yield","plots/closure/closure_lambda_pos_corrections_vs"+vname+".png",0.55,0.15);
0465     plot_correction_sequence(lambda_truth_neg,lambda_reco_neg,lambda_geo_acceptance_neg,lambda_cut_efficiency_neg,"#bar{#Lambda} yield","plots/closure/closure_lambda_neg_corrections_vs"+vname+".png",0.55,0.15);
0466     plot_correction_sequence(ks_truth,Kshort_reco_inc,Kshort_geo_acceptance,Kshort_cut_efficiency,"K_{S}^{0} yield","plots/closure/closure_kshort_corrections_vs"+vname+".png",0.55,0.15);
0467
0468     plot_inverse_correction_sequence(lambda_truth,lambda_reco_inc,lambda_geo_acceptance,lambda_cut_efficiency,"(#Lambda+#bar{#Lambda}) yield","plots/closure/inverse_closure_lambda_corrections_vs"+vname+".png",0.45,0.2);
0469     plot_inverse_correction_sequence(lambda_truth_pos,lambda_reco_pos,lambda_geo_acceptance_pos,lambda_cut_efficiency_pos,"#Lambda yield","plots/closure/inverse_closure_lambda_pos_corrections_vs"+vname+".png",0.45,0.2);
0470     plot_inverse_correction_sequence(lambda_truth_neg,lambda_reco_neg,lambda_geo_acceptance_neg,lambda_cut_efficiency_neg,"#bar{#Lambda} yield","plots/closure/inverse_closure_lambda_neg_corrections_vs"+vname+".png",0.45,0.2);
0471     plot_inverse_correction_sequence(ks_truth,Kshort_reco_inc,Kshort_geo_acceptance,Kshort_cut_efficiency,"K_{S}^{0} yield","plots/closure/inverse_closure_kshort_corrections_vs"+vname+".png",0.45,0.2);
0472   }
0473 /*
0474   TH1F* lambda_eff = makeHistogram("lambda_eff","(#Lambda^{0}+#bar{#Lambda}^{0}) fraction with all daughter tracks reconstructed",BinInfo::final_pt_bins);
0475   TH1F* lambda_eff_pos = makeHistogram("lambda_eff_pos","#Lambda^{0} fraction with all daughter tracks reconstructed",BinInfo::final_pt_bins);
0476   TH1F* lambda_eff_neg = makeHistogram("lambda_eff_neg","#bar{#Lambda}^{0} fraction with all daughter tracks reconstructed",BinInfo::final_pt_bins);
0477   TH1F* ks_eff = makeHistogram("ks_eff","K^{0}_{S} fraction with all daughter tracks reconstructed",BinInfo::final_pt_bins);
0478
0479   lambda_eff->Divide(lambda_truth_withdaughters,lambda_truth);
0480   lambda_eff_pos->Divide(lambda_truth_withdaughters_pos,lambda_truth_pos);
0481   lambda_eff_neg->Divide(lambda_truth_withdaughters_neg,lambda_truth_neg);
0482   ks_eff->Divide(ks_truth_withdaughters,ks_truth);
0483
0484   TCanvas* eff_n = new TCanvas("en","en",800,800);
0485
0486   formatDefault(lambda_eff,kBlack);
0487   formatDefault(lambda_eff_pos,kRed);
0488   formatDefault(lambda_eff_neg,kBlue);
0489
0490   lambda_eff->SetTitle("#Lambda fraction with both daughters reconstructed;pT [GeV/c];");
0491   lambda_eff->SetMinimum(0.);
0492   lambda_eff->SetMaximum(1.1*std::max(lambda_eff_pos->GetMaximum(),lambda_eff_neg->GetMaximum()));
0493
0494   lambda_eff->Draw();
0495   lambda_eff_pos->Draw("SAME");
0496   lambda_eff_neg->Draw("SAME");
0497
0498   TLegend* le = new TLegend(0.55,0.15,0.88,0.35);
0499   le->AddEntry(ratio_truth,"#Lambda^{0}+#bar{#Lambda}^{0}");
0500   le->AddEntry(ratio_truth_pos,"#Lambda^{0}");
0501   le->AddEntry(ratio_truth_neg,"#bar{#Lambda}^{0}");
0502   le->Draw();
0503
0504   eff_n->SaveAs("plots/eff_n.png");
0505   eff_n->Close();
0506
0507   TCanvas* eff_d = new TCanvas("ed","ed",800,800);
0508
0509   formatDefault(ks_eff,kBlack);
0510
0511   ks_eff->SetTitle("K^{0}_{S} fraction with both daughters reconstructed;pT [GeV/c];");
0512   ks_eff->SetMinimum(0.);
0513
0514   ks_eff->Draw();
0515
0516   eff_d->SaveAs("plots/eff_d.png");
0517   eff_d->Close();
0518 */
0519 }