File indexing completed on 2025-08-07 08:12:44
0001 #include "FinalResult.h"
0002
0003 FinalResult::FinalResult(
0004 int runnumber_in,
0005 int Mbin_in,
0006 std::string StandardData_directory_in,
0007 std::string StandardData_file_name_in,
0008 std::string StandardMC_directory_in,
0009 std::string StandardMC_file_name_in,
0010 std::string sPH_label_in,
0011 std::string Output_directory_in
0012 ):
0013 runnumber(runnumber_in),
0014 Mbin(Mbin_in),
0015 StandardData_directory(StandardData_directory_in),
0016 StandardData_file_name(StandardData_file_name_in),
0017 StandardMC_directory(StandardMC_directory_in),
0018 StandardMC_file_name(StandardMC_file_name_in),
0019 sPH_label(sPH_label_in),
0020 Output_directory(Output_directory_in)
0021 {
0022 Output_directory = (Output_directory == "Not_given") ? StandardData_directory : Output_directory;
0023
0024 PrepareOutputFolderName();
0025 system(Form("if [ ! -d %s/%s/completed ]; then mkdir -p %s/%s/completed; fi;", Output_directory.c_str(), output_folder_name.c_str(), Output_directory.c_str(), output_folder_name.c_str()));
0026 final_output_directory = Form("%s/%s", Output_directory.c_str(), output_folder_name.c_str());
0027
0028 file_in_data_standard = TFile::Open(Form("%s/%s", StandardData_directory.c_str(), StandardData_file_name.c_str()));
0029 h1D_data_standard = (TH1D*) file_in_data_standard -> Get(StandardData_h1D_name.c_str());
0030
0031 file_in_MC_standard = TFile::Open(Form("%s/%s", StandardMC_directory.c_str(), StandardMC_file_name.c_str()));
0032 h1D_truth_standard = (TH1D*) file_in_MC_standard -> Get(StandardTruth_h1D_name.c_str());
0033
0034 h1D_MC_closure_standard = (TH1D*) file_in_MC_standard -> Get(StandardData_h1D_name.c_str());
0035
0036 if (
0037 h1D_data_standard == nullptr ||
0038 h1D_truth_standard == nullptr ||
0039
0040 h1D_data_standard -> GetNbinsX() != h1D_truth_standard -> GetNbinsX() ||
0041 h1D_data_standard -> GetXaxis() -> GetXmin() != h1D_truth_standard -> GetXaxis() -> GetXmin() ||
0042 h1D_data_standard -> GetXaxis() -> GetXmax() != h1D_truth_standard -> GetXaxis() -> GetXmax()
0043 ){
0044 std::cout << "Error : the standard data or MC is not found" << std::endl;
0045 exit(1);
0046 }
0047
0048 h1D_RunSegmentError_vec.clear();
0049 h1D_ClusAdcError_vec.clear();
0050 h1D_GeoOffsetError_vec.clear();
0051 h1D_DeltaPhiError_vec.clear();
0052 h1D_StrangenessError_vec.clear();
0053 h1D_GeneratorError_vec.clear();
0054
0055 SetsPhenixStyle();
0056 c1 = new TCanvas("c1", "c1", 950, 800);
0057
0058
0059
0060
0061
0062 ltx = new TLatex();
0063 ltx->SetNDC();
0064 ltx->SetTextSize(0.045);
0065 ltx->SetTextAlign(31);
0066
0067 draw_text = new TLatex();
0068 draw_text -> SetNDC();
0069 draw_text -> SetTextSize(0.03);
0070
0071 leg_errors = new TLegend(0.31,0.58,0.41,0.87);
0072 leg_errors -> SetBorderSize(0);
0073 leg_errors -> SetTextSize(0.03);
0074
0075 leg_variation = new TLegend(0.21,0.85,0.41,1);
0076 leg_variation -> SetBorderSize(0);
0077 leg_variation -> SetTextSize(0.03);
0078
0079 leg_variation_recoTracklet = new TLegend(0.21,0.85,0.41,1);
0080 leg_variation_recoTracklet -> SetBorderSize(0);
0081 leg_variation_recoTracklet -> SetTextSize(0.03);
0082
0083 leg_final = new TLegend(0.45,0.75,0.8,0.87);
0084 leg_final -> SetBorderSize(0);
0085 leg_final -> SetTextSize(0.03);
0086
0087 leg_TruthReco = new TLegend(0.52,0.81,0.72,0.9);
0088 leg_TruthReco -> SetBorderSize(0);
0089 leg_TruthReco -> SetTextSize(0.025);
0090 leg_TruthReco -> SetMargin(0.2);
0091
0092 line = new TLine();
0093 line -> SetLineStyle(2);
0094 line -> SetLineWidth(2);
0095 line -> SetLineColor(28);
0096
0097 file_out = new TFile(Form("%s/%s.root", final_output_directory.c_str(), output_folder_name.c_str()), "RECREATE");
0098 tree_out = new TTree("tree","max min unc.");
0099
0100 tree_out -> Branch("UncRange_StatUnc", &UncRange_StatUnc);
0101 tree_out -> Branch("UncRange_RunSegment", &UncRange_RunSegment);
0102 tree_out -> Branch("UncRange_ClusAdc", &UncRange_ClusAdc);
0103 tree_out -> Branch("UncRange_GeoOffset", &UncRange_GeoOffset);
0104 tree_out -> Branch("UncRange_DeltaPhi", &UncRange_DeltaPhi);
0105 tree_out -> Branch("UncRange_Strangeness", &UncRange_Strangeness);
0106 tree_out -> Branch("UncRange_Generator", &UncRange_Generator);
0107 tree_out -> Branch("UncRange_ClusPhiSize", &UncRange_ClusPhiSize);
0108 tree_out -> Branch("UncRange_Final", &UncRange_Final);
0109
0110 gStyle->SetPaintTextFormat("1.3f");
0111
0112 }
0113
0114 void FinalResult::PrepareBaseLineTGraph()
0115 {
0116 gr_dNdEta_baseline = h1D_to_TGraph(h1D_data_standard);
0117 gr_dNdEta_baseline -> SetMarkerStyle(20);
0118 gr_dNdEta_baseline -> SetMarkerSize(1);
0119 gr_dNdEta_baseline -> SetMarkerColor(1);
0120 gr_dNdEta_baseline -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0121 gr_dNdEta_baseline -> GetYaxis() -> SetTitle("dN_{ch}/d#eta");
0122
0123 gr_dNdEta_baseline -> GetXaxis() -> SetLabelOffset(999);
0124 gr_dNdEta_baseline -> GetXaxis() -> SetLabelSize(0);
0125 gr_dNdEta_baseline -> GetXaxis() -> SetTitleOffset(999);
0126
0127
0128 gr_dNdEta_baseline -> GetYaxis() -> SetRangeUser(
0129 gr_dNdEta_baseline -> GetYaxis() -> GetXmin() * 0.8,
0130 gr_dNdEta_baseline -> GetYaxis() -> GetXmax() * 1.2
0131 );
0132
0133 gr_recoTracklet_baseline = h1D_to_TGraph(
0134 (TH1D*) file_in_data_standard -> Get(h1D_RecoTracklet_name.c_str())
0135 );
0136 gr_recoTracklet_baseline -> SetMarkerStyle(20);
0137 gr_recoTracklet_baseline -> SetMarkerSize(1);
0138 gr_recoTracklet_baseline -> SetMarkerColor(1);
0139 gr_recoTracklet_baseline -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0140 gr_recoTracklet_baseline -> GetYaxis() -> SetTitle("Avg. reco. tracklets per event");
0141
0142 gr_recoTracklet_baseline -> GetXaxis() -> SetLabelOffset(999);
0143 gr_recoTracklet_baseline -> GetXaxis() -> SetLabelSize(0);
0144 gr_recoTracklet_baseline -> GetXaxis() -> SetTitleOffset(999);
0145
0146 gr_recoTracklet_baseline -> GetYaxis() -> SetRangeUser(
0147 gr_recoTracklet_baseline -> GetYaxis() -> GetXmin() * 0.8,
0148 gr_recoTracklet_baseline -> GetYaxis() -> GetXmax() * 1.2
0149 );
0150 }
0151
0152 void FinalResult::PrepareMCClosureTGraph()
0153 {
0154 gr_MC_closure_standard = h1D_to_TGraph(h1D_MC_closure_standard);
0155 gr_MC_closure_standard -> SetMarkerStyle(20);
0156 gr_MC_closure_standard -> SetMarkerSize(1);
0157 gr_MC_closure_standard -> SetMarkerColor(2);
0158 }
0159
0160 void FinalResult::PrepareOutputFolderName()
0161 {
0162 std::string runnumber_str = std::to_string( runnumber );
0163 if (runnumber != -1){
0164 int runnumber_str_len = 8;
0165 runnumber_str.insert(0, runnumber_str_len - runnumber_str.size(), '0');
0166 }
0167
0168 output_folder_name = "Final";
0169 output_folder_name += "_Mbin" + std::to_string(Mbin);
0170
0171 output_folder_name += Form("_%s",runnumber_str.c_str());
0172 }
0173
0174
0175 void FinalResult::PrepareStatisticalError()
0176 {
0177 h1D_error_statistic = (TH1D*) h1D_data_standard -> Clone("h1D_error_statistic");
0178 h1D_error_statistic -> Reset("ICESM");
0179
0180 for (int i = 1; i <= h1D_data_standard -> GetNbinsX(); i++){
0181
0182 double error = h1D_data_standard -> GetBinError(i) / h1D_data_standard -> GetBinContent(i);
0183 error = (error == error && error != 1) ? error : 0;
0184 h1D_error_statistic -> SetBinContent(i, error);
0185 }
0186
0187 h1D_error_statistic -> SetMarkerStyle(20);
0188 h1D_error_statistic -> SetMarkerSize(1);
0189 h1D_error_statistic -> SetLineWidth(0);
0190 h1D_error_statistic -> SetLineColorAlpha(1,0);
0191 h1D_error_statistic -> SetMarkerColor(TColor::GetColor(color_code[0].c_str()));
0192
0193 UncRange_StatUnc = GetH1DMinMax(h1D_error_statistic);
0194 }
0195
0196
0197 void FinalResult::PrepareRunSegmentError(std::vector<std::string> file_directory_vec_in, std::vector<std::string> file_title_in, std::string leg_header_in)
0198 {
0199 TFile * temp_file_in;
0200
0201 c1 -> Clear();
0202 c1 -> cd();
0203 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0204 pad1 -> Draw();
0205 pad1 -> cd();
0206
0207 gr_dNdEta_baseline -> Draw("ap");
0208 leg_variation -> AddEntry(gr_dNdEta_baseline, file_title_in.back().c_str(), "p");
0209 leg_variation -> SetHeader(leg_header_in.c_str());
0210
0211 std::vector<TGraph*> gr_variation_vec; gr_variation_vec.clear();
0212
0213 for (int i = 0; i < file_directory_vec_in.size(); i++)
0214 {
0215 temp_file_in = TFile::Open(file_directory_vec_in[i].c_str());
0216
0217 h1D_RunSegmentError_vec.push_back( (TH1D*) temp_file_in -> Get(StandardData_h1D_name.c_str()) );
0218
0219 gr_variation_vec.push_back( h1D_to_TGraph(h1D_RunSegmentError_vec.back()) );
0220 gr_variation_vec.back() -> SetMarkerStyle(marker_code[i]);
0221 gr_variation_vec.back() -> SetMarkerSize(1);
0222 gr_variation_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0223 std::cout<<"test, run seg variation: "<<gr_variation_vec.back() -> GetN()<<", "<<gr_variation_vec.back() -> GetPointY(0)<<std::endl;
0224 gr_variation_vec.back() -> Draw("p same");
0225
0226 leg_variation -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0227
0228 h1D_RunSegmentError_vec.back() -> Divide(h1D_data_standard);
0229 h1D_to_AbsRatio(h1D_RunSegmentError_vec.back());
0230 }
0231
0232 h1D_error_Run_segmentation = h1D_FindLargestOnes("h1D_error_Run_segmentation", h1D_RunSegmentError_vec);
0233
0234 h1D_error_Run_segmentation -> SetMarkerStyle(25);
0235 h1D_error_Run_segmentation -> SetMarkerSize(1);
0236 h1D_error_Run_segmentation -> SetLineWidth(0);
0237 h1D_error_Run_segmentation -> SetLineColorAlpha(1,0);
0238 h1D_error_Run_segmentation -> SetMarkerColor(TColor::GetColor(color_code[1].c_str()));
0239
0240 UncRange_RunSegment = GetH1DMinMax(h1D_error_Run_segmentation);
0241
0242
0243 c1 -> cd();
0244 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0245 pad2 -> Draw();
0246 pad2 -> cd();
0247
0248 for (int i = 0; i < gr_variation_vec.size(); i++){
0249 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0250
0251 TGraph * temp_gr = GetRatioGr(
0252 gr_variation_vec[i],
0253 gr_dNdEta_baseline
0254 );
0255 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0256 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0257 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0258 temp_gr -> Draw(plot_draw_text.c_str());
0259 }
0260 line -> DrawLine(gr_variation_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_vec.back()->GetXaxis()->GetXmax(), 1);
0261
0262
0263 c1 -> cd();
0264 leg_variation -> Draw("same");
0265 c1 -> Print(Form("%s/RunSegmentationVariation_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0266 c1 -> Clear();
0267 leg_variation -> Clear();
0268 }
0269
0270 void FinalResult::PrepareClusAdcError(std::vector<std::string> file_directory_vec_in, std::vector<std::string> file_title_in, std::string leg_header_in)
0271 {
0272 TFile * temp_file_in;
0273
0274 c1 -> Clear();
0275 c1 -> cd();
0276 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0277 pad1 -> Draw();
0278 pad1 -> cd();
0279
0280 gr_dNdEta_baseline -> Draw("ap");
0281 leg_variation -> AddEntry(gr_dNdEta_baseline, file_title_in.back().c_str(), "p");
0282 leg_variation -> SetHeader(leg_header_in.c_str());
0283
0284 leg_variation_recoTracklet -> AddEntry(gr_recoTracklet_baseline, file_title_in.back().c_str(), "p");
0285 leg_variation_recoTracklet -> SetHeader(leg_header_in.c_str());
0286
0287 std::vector<TGraph*> gr_variation_vec; gr_variation_vec.clear();
0288 std::vector<TGraph*> gr_variation_recoTracklet_vec; gr_variation_recoTracklet_vec.clear();
0289
0290 for (int i = 0; i < file_directory_vec_in.size(); i++)
0291 {
0292 temp_file_in = TFile::Open(file_directory_vec_in[i].c_str());
0293
0294 h1D_ClusAdcError_vec.push_back( (TH1D*) temp_file_in -> Get(StandardData_h1D_name.c_str()) );
0295
0296 gr_variation_vec.push_back( h1D_to_TGraph(h1D_ClusAdcError_vec.back()) );
0297 gr_variation_vec.back() -> SetMarkerStyle(marker_code[i]);
0298 gr_variation_vec.back() -> SetMarkerSize(1);
0299 gr_variation_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0300 gr_variation_vec.back() -> Draw("p same");
0301
0302 leg_variation -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0303
0304 h1D_ClusAdcError_vec.back() -> Divide(h1D_data_standard);
0305 h1D_to_AbsRatio(h1D_ClusAdcError_vec.back());
0306
0307
0308 gr_variation_recoTracklet_vec.push_back(
0309 h1D_to_TGraph(
0310 (TH1D*) temp_file_in -> Get(h1D_RecoTracklet_name.c_str())
0311 )
0312 );
0313 gr_variation_recoTracklet_vec.back() -> SetMarkerStyle(marker_code[i]);
0314 gr_variation_recoTracklet_vec.back() -> SetMarkerSize(1);
0315 gr_variation_recoTracklet_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0316
0317 leg_variation_recoTracklet -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0318 }
0319
0320 h1D_error_ClusAdc = h1D_FindLargestOnes("h1D_error_ClusAdc", h1D_ClusAdcError_vec);
0321
0322 h1D_error_ClusAdc -> SetMarkerStyle(26);
0323 h1D_error_ClusAdc -> SetMarkerSize(1);
0324 h1D_error_ClusAdc -> SetLineWidth(0);
0325 h1D_error_ClusAdc -> SetLineColorAlpha(1,0);
0326 h1D_error_ClusAdc -> SetMarkerColor(TColor::GetColor(color_code[2].c_str()));
0327
0328 c1 -> cd();
0329 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0330 pad2 -> Draw();
0331 pad2 -> cd();
0332
0333 for (int i = 0; i < gr_variation_vec.size(); i++){
0334 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0335
0336 TGraph * temp_gr = GetRatioGr(
0337 gr_variation_vec[i],
0338 gr_dNdEta_baseline
0339 );
0340 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0341 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0342 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0343 temp_gr -> Draw(plot_draw_text.c_str());
0344 }
0345 line -> DrawLine(gr_variation_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_vec.back()->GetXaxis()->GetXmax(), 1);
0346
0347 UncRange_ClusAdc = GetH1DMinMax(h1D_error_ClusAdc);
0348
0349 c1 -> cd();
0350 leg_variation -> Draw("same");
0351 c1 -> Print(Form("%s/RunClusAdcVariation_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0352 c1 -> Clear();
0353
0354
0355 c1 -> cd();
0356 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0357 pad1 -> Draw();
0358 pad1 -> cd();
0359
0360 gr_recoTracklet_baseline -> Draw("ap");
0361 for (int i = 0; i < gr_variation_recoTracklet_vec.size(); i++){
0362 gr_variation_recoTracklet_vec[i] -> Draw("p same");
0363 }
0364
0365 c1 -> cd();
0366 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0367 pad2 -> Draw();
0368 pad2 -> cd();
0369
0370 for (int i = 0; i < gr_variation_recoTracklet_vec.size(); i++){
0371 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0372
0373 TGraph * temp_gr = GetRatioGr(
0374 gr_variation_recoTracklet_vec[i],
0375 gr_recoTracklet_baseline
0376 );
0377 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0378 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0379 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0380 temp_gr -> Draw(plot_draw_text.c_str());
0381 }
0382 line -> DrawLine(gr_variation_recoTracklet_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_recoTracklet_vec.back()->GetXaxis()->GetXmax(), 1);
0383
0384 c1 -> cd();
0385 leg_variation_recoTracklet -> Draw("same");
0386 c1 -> Print(Form("%s/RunClusAdcVariation_RecoTracklet_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0387 c1 -> Clear();
0388
0389
0390 leg_variation -> Clear();
0391 leg_variation_recoTracklet -> Clear();
0392
0393 }
0394
0395 void FinalResult::PrepareGeoOffsetError(std::string file_directory_in, std::string alpha_corr_directory_in)
0396 {
0397 TFile * temp_file_in_GeoUnc = TFile::Open(file_directory_in.c_str());
0398 TFile * temp_file_in_AlphaCorr = TFile::Open(alpha_corr_directory_in.c_str());
0399
0400 h1D_error_GeoOffset = (TH1D*) h1D_data_standard -> Clone("h1D_error_GeoOffset");
0401
0402 auto temp_h1D_GeoUnc = (TH1D*) temp_file_in_GeoUnc -> Get("h1D_RotatedBkg_RecoTrackletEtaPerEvt_VariationSigma");
0403 auto temp_h1D_AlphaCorr = (TH1D*) temp_file_in_AlphaCorr -> Get("h1D_RotatedBkg_alpha_correction");
0404
0405 h1D_error_GeoOffset -> Divide(
0406 temp_h1D_GeoUnc,
0407 temp_h1D_AlphaCorr
0408 );
0409
0410 for (int i = 1; i <= h1D_error_GeoOffset -> GetNbinsX(); i++){
0411 std::cout<<"GeoOffset: bin: "<< i <<", eta: ["<<h1D_error_GeoOffset->GetXaxis()->GetBinLowEdge(i)<<", "<<h1D_error_GeoOffset->GetXaxis()->GetBinUpEdge(i)<<"]"
0412 << ", GeoUnc: " << temp_h1D_GeoUnc -> GetBinContent(i)
0413 << ", AlphaCorr: " << temp_h1D_AlphaCorr -> GetBinContent(i)
0414 <<", final_error: " << h1D_error_GeoOffset -> GetBinContent(i)
0415 << std::endl;
0416 }
0417
0418
0419 h1D_error_GeoOffset -> SetMarkerStyle(27);
0420 h1D_error_GeoOffset -> SetMarkerSize(1);
0421 h1D_error_GeoOffset -> SetLineWidth(0);
0422 h1D_error_GeoOffset -> SetLineColorAlpha(1,0);
0423 h1D_error_GeoOffset -> SetMarkerColor(TColor::GetColor(color_code[3].c_str()));
0424
0425 UncRange_GeoOffset = GetH1DMinMax(h1D_error_GeoOffset);
0426 }
0427
0428
0429 void FinalResult::PrepareDeltaPhiError(std::vector<std::string> file_directory_vec_in, std::vector<std::string> file_title_in, std::string leg_header_in)
0430 {
0431 TFile * temp_file_in;
0432
0433 c1 -> Clear();
0434 c1 -> cd();
0435 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0436 pad1 -> Draw();
0437 pad1 -> cd();
0438
0439 gr_dNdEta_baseline -> Draw("ap");
0440 leg_variation -> AddEntry(gr_dNdEta_baseline, file_title_in.back().c_str(), "p");
0441 leg_variation -> SetHeader(leg_header_in.c_str());
0442
0443 leg_variation_recoTracklet -> AddEntry(gr_recoTracklet_baseline, file_title_in.back().c_str(), "p");
0444 leg_variation_recoTracklet -> SetHeader(leg_header_in.c_str());
0445
0446 std::vector<TGraph*> gr_variation_vec; gr_variation_vec.clear();
0447 std::vector<TGraph*> gr_variation_recoTracklet_vec; gr_variation_recoTracklet_vec.clear();
0448
0449 for (int i = 0; i < file_directory_vec_in.size(); i++)
0450 {
0451 temp_file_in = TFile::Open(file_directory_vec_in[i].c_str());
0452
0453 h1D_DeltaPhiError_vec.push_back( (TH1D*) temp_file_in -> Get(StandardData_h1D_name.c_str()) );
0454
0455
0456 gr_variation_vec.push_back( h1D_to_TGraph(h1D_DeltaPhiError_vec.back()) );
0457 gr_variation_vec.back() -> SetMarkerStyle(marker_code[i]);
0458 gr_variation_vec.back() -> SetMarkerSize(1);
0459 gr_variation_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0460 gr_variation_vec.back() -> Draw("p same");
0461
0462 leg_variation -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0463
0464
0465 h1D_DeltaPhiError_vec.back() -> Divide(h1D_data_standard);
0466 h1D_to_AbsRatio(h1D_DeltaPhiError_vec.back());
0467
0468
0469 gr_variation_recoTracklet_vec.push_back(
0470 h1D_to_TGraph(
0471 (TH1D*) temp_file_in -> Get(h1D_RecoTracklet_name.c_str())
0472 )
0473 );
0474 gr_variation_recoTracklet_vec.back() -> SetMarkerStyle(marker_code[i]);
0475 gr_variation_recoTracklet_vec.back() -> SetMarkerSize(1);
0476 gr_variation_recoTracklet_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0477
0478 leg_variation_recoTracklet -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0479 }
0480
0481 h1D_error_DeltaPhi = h1D_FindLargestOnes("h1D_error_DeltaPhi", h1D_DeltaPhiError_vec);
0482
0483 h1D_error_DeltaPhi -> SetMarkerStyle(28);
0484 h1D_error_DeltaPhi -> SetMarkerSize(1);
0485 h1D_error_DeltaPhi -> SetLineWidth(0);
0486 h1D_error_DeltaPhi -> SetLineColorAlpha(1,0);
0487 h1D_error_DeltaPhi -> SetMarkerColor(TColor::GetColor(color_code[4].c_str()));
0488
0489 UncRange_DeltaPhi = GetH1DMinMax(h1D_error_DeltaPhi);
0490
0491 c1 -> cd();
0492 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0493 pad2 -> Draw();
0494 pad2 -> cd();
0495
0496 for (int i = 0; i < gr_variation_vec.size(); i++){
0497 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0498
0499 TGraph * temp_gr = GetRatioGr(
0500 gr_variation_vec[i],
0501 gr_dNdEta_baseline
0502 );
0503 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0504 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0505 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0506 temp_gr -> Draw(plot_draw_text.c_str());
0507 }
0508 line -> DrawLine(gr_variation_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_vec.back()->GetXaxis()->GetXmax(), 1);
0509
0510 c1 -> cd();
0511 leg_variation -> Draw("same");
0512 c1 -> Print(Form("%s/RunDeltaPhiVariation_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0513 c1 -> Clear();
0514
0515
0516 c1 -> cd();
0517 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0518 pad1 -> Draw();
0519 pad1 -> cd();
0520
0521 gr_recoTracklet_baseline -> Draw("ap");
0522 for (int i = 0; i < gr_variation_recoTracklet_vec.size(); i++){
0523 gr_variation_recoTracklet_vec[i] -> Draw("p same");
0524 }
0525
0526 c1 -> cd();
0527 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0528 pad2 -> Draw();
0529 pad2 -> cd();
0530
0531 for (int i = 0; i < gr_variation_recoTracklet_vec.size(); i++){
0532 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0533
0534 TGraph * temp_gr = GetRatioGr(
0535 gr_variation_recoTracklet_vec[i],
0536 gr_recoTracklet_baseline
0537 );
0538 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0539 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0540 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0541 temp_gr -> Draw(plot_draw_text.c_str());
0542 }
0543 line -> DrawLine(gr_variation_recoTracklet_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_recoTracklet_vec.back()->GetXaxis()->GetXmax(), 1);
0544
0545 c1 -> cd();
0546 leg_variation_recoTracklet -> Draw("same");
0547 c1 -> Print(Form("%s/RunDeltaPhiVariation_RecoTracklet_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0548 c1 -> Clear();
0549
0550 leg_variation -> Clear();
0551 leg_variation_recoTracklet -> Clear();
0552 }
0553
0554 void FinalResult::PrepareStrangenessError(std::vector<std::string> file_directory_vec_in, std::vector<std::string> file_title_in, std::string leg_header_in)
0555 {
0556 TFile * temp_file_in;
0557
0558 c1 -> Clear();
0559 c1 -> cd();
0560 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0561 pad1 -> Draw();
0562 pad1 -> cd();
0563
0564 gr_dNdEta_baseline -> Draw("ap");
0565 leg_variation -> AddEntry(gr_dNdEta_baseline, file_title_in.back().c_str(), "p");
0566 leg_variation -> SetHeader(leg_header_in.c_str());
0567
0568 leg_variation_recoTracklet -> AddEntry(gr_recoTracklet_baseline, file_title_in.back().c_str(), "p");
0569 leg_variation_recoTracklet -> SetHeader(leg_header_in.c_str());
0570
0571 std::vector<TGraph*> gr_variation_vec; gr_variation_vec.clear();
0572 std::vector<TGraph*> gr_variation_recoTracklet_vec; gr_variation_recoTracklet_vec.clear();
0573
0574 for (int i = 0; i < file_directory_vec_in.size(); i++)
0575 {
0576 temp_file_in = TFile::Open(file_directory_vec_in[i].c_str());
0577
0578 h1D_StrangenessError_vec.push_back( (TH1D*) temp_file_in -> Get(StandardData_h1D_name.c_str()) );
0579
0580
0581 gr_variation_vec.push_back( h1D_to_TGraph(h1D_StrangenessError_vec.back()) );
0582 gr_variation_vec.back() -> SetMarkerStyle(marker_code[i]);
0583 gr_variation_vec.back() -> SetMarkerSize(1);
0584 gr_variation_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0585 gr_variation_vec.back() -> Draw("p same");
0586
0587 leg_variation -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0588
0589
0590 h1D_StrangenessError_vec.back() -> Divide(h1D_data_standard);
0591 h1D_to_AbsRatio(h1D_StrangenessError_vec.back());
0592
0593
0594 gr_variation_recoTracklet_vec.push_back(
0595 h1D_to_TGraph(
0596 (TH1D*) temp_file_in -> Get(h1D_RecoTracklet_name.c_str())
0597 )
0598 );
0599 gr_variation_recoTracklet_vec.back() -> SetMarkerStyle(marker_code[i]);
0600 gr_variation_recoTracklet_vec.back() -> SetMarkerSize(1);
0601 gr_variation_recoTracklet_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0602
0603 leg_variation_recoTracklet -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0604 }
0605
0606 h1D_error_Strangeness = h1D_FindLargestOnes("h1D_error_Strangeness", h1D_StrangenessError_vec);
0607
0608 h1D_error_Strangeness -> SetMarkerStyle(42);
0609 h1D_error_Strangeness -> SetMarkerSize(1);
0610 h1D_error_Strangeness -> SetLineWidth(0);
0611 h1D_error_Strangeness -> SetLineColorAlpha(1,0);
0612 h1D_error_Strangeness -> SetMarkerColor(TColor::GetColor(color_code[6].c_str()));
0613
0614 UncRange_Strangeness = GetH1DMinMax(h1D_error_Strangeness);
0615
0616 c1 -> cd();
0617 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0618 pad2 -> Draw();
0619 pad2 -> cd();
0620
0621 for (int i = 0; i < gr_variation_vec.size(); i++){
0622 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0623
0624 TGraph * temp_gr = GetRatioGr(
0625 gr_variation_vec[i],
0626 gr_dNdEta_baseline
0627 );
0628 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0629 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0630 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0631 temp_gr -> Draw(plot_draw_text.c_str());
0632 }
0633 line -> DrawLine(gr_variation_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_vec.back()->GetXaxis()->GetXmax(), 1);
0634
0635 c1 -> cd();
0636 leg_variation -> Draw("same");
0637 c1 -> Print(Form("%s/RunStrangenessVariation_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0638 c1 -> Clear();
0639
0640
0641 c1 -> cd();
0642 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0643 pad1 -> Draw();
0644 pad1 -> cd();
0645
0646 gr_recoTracklet_baseline -> Draw("ap");
0647 for (int i = 0; i < gr_variation_recoTracklet_vec.size(); i++){
0648 gr_variation_recoTracklet_vec[i] -> Draw("p same");
0649 }
0650
0651 c1 -> cd();
0652 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0653 pad2 -> Draw();
0654 pad2 -> cd();
0655
0656 for (int i = 0; i < gr_variation_recoTracklet_vec.size(); i++){
0657 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0658
0659 TGraph * temp_gr = GetRatioGr(
0660 gr_variation_recoTracklet_vec[i],
0661 gr_recoTracklet_baseline
0662 );
0663 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0664 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0665 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0666 temp_gr -> Draw(plot_draw_text.c_str());
0667 }
0668 line -> DrawLine(gr_variation_recoTracklet_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_recoTracklet_vec.back()->GetXaxis()->GetXmax(), 1);
0669
0670 c1 -> cd();
0671 leg_variation_recoTracklet -> Draw("same");
0672 c1 -> Print(Form("%s/RunStrangenessVariation_RecoTracklet_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0673 c1 -> Clear();
0674
0675 leg_variation -> Clear();
0676 leg_variation_recoTracklet -> Clear();
0677 }
0678
0679 void FinalResult::PrepareGeneratorError(std::vector<std::string> file_directory_vec_in, std::vector<std::string> file_title_in, std::string leg_header_in)
0680 {
0681 TFile * temp_file_in;
0682
0683 c1 -> Clear();
0684 c1 -> cd();
0685 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0686 pad1 -> Draw();
0687 pad1 -> cd();
0688
0689 gr_dNdEta_baseline -> Draw("ap");
0690 leg_variation -> AddEntry(gr_dNdEta_baseline, file_title_in.back().c_str(), "p");
0691 leg_variation -> SetHeader(leg_header_in.c_str());
0692
0693 leg_variation_recoTracklet -> AddEntry(gr_recoTracklet_baseline, file_title_in.back().c_str(), "p");
0694 leg_variation_recoTracklet -> SetHeader(leg_header_in.c_str());
0695
0696 std::vector<TGraph*> gr_variation_vec; gr_variation_vec.clear();
0697 std::vector<TGraph*> gr_variation_recoTracklet_vec; gr_variation_recoTracklet_vec.clear();
0698
0699 for (int i = 0; i < file_directory_vec_in.size(); i++)
0700 {
0701 temp_file_in = TFile::Open(file_directory_vec_in[i].c_str());
0702
0703 h1D_GeneratorError_vec.push_back( (TH1D*) temp_file_in -> Get(StandardData_h1D_name.c_str()) );
0704
0705
0706 gr_variation_vec.push_back( h1D_to_TGraph(h1D_GeneratorError_vec.back()) );
0707 gr_variation_vec.back() -> SetMarkerStyle(marker_code[i]);
0708 gr_variation_vec.back() -> SetMarkerSize(1);
0709 gr_variation_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0710 gr_variation_vec.back() -> Draw("p same");
0711
0712 leg_variation -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0713
0714
0715 h1D_GeneratorError_vec.back() -> Divide(h1D_data_standard);
0716 h1D_to_AbsRatio(h1D_GeneratorError_vec.back());
0717
0718
0719 gr_variation_recoTracklet_vec.push_back(
0720 h1D_to_TGraph(
0721 (TH1D*) temp_file_in -> Get(h1D_RecoTracklet_name.c_str())
0722 )
0723 );
0724 gr_variation_recoTracklet_vec.back() -> SetMarkerStyle(marker_code[i]);
0725 gr_variation_recoTracklet_vec.back() -> SetMarkerSize(1);
0726 gr_variation_recoTracklet_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0727
0728 leg_variation_recoTracklet -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0729 }
0730
0731 h1D_error_Generator = h1D_FindLargestOnes("h1D_error_Generator", h1D_GeneratorError_vec);
0732
0733 h1D_error_Generator -> SetMarkerStyle(32);
0734 h1D_error_Generator -> SetMarkerSize(1);
0735 h1D_error_Generator -> SetLineWidth(0);
0736 h1D_error_Generator -> SetLineColorAlpha(1,0);
0737 h1D_error_Generator -> SetMarkerColor(TColor::GetColor(color_code[7].c_str()));
0738
0739 UncRange_Generator = GetH1DMinMax(h1D_error_Generator);
0740
0741 c1 -> cd();
0742 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0743 pad2 -> Draw();
0744 pad2 -> cd();
0745
0746 for (int i = 0; i < gr_variation_vec.size(); i++){
0747 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0748
0749 TGraph * temp_gr = GetRatioGr(
0750 gr_variation_vec[i],
0751 gr_dNdEta_baseline
0752 );
0753 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0754 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0755 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0756 temp_gr -> Draw(plot_draw_text.c_str());
0757 }
0758 line -> DrawLine(gr_variation_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_vec.back()->GetXaxis()->GetXmax(), 1);
0759
0760 c1 -> cd();
0761 leg_variation -> Draw("same");
0762 c1 -> Print(Form("%s/RunGeneratorVariation_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0763 c1 -> Clear();
0764
0765
0766 c1 -> cd();
0767 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0768 pad1 -> Draw();
0769 pad1 -> cd();
0770
0771 gr_recoTracklet_baseline -> Draw("ap");
0772 for (int i = 0; i < gr_variation_recoTracklet_vec.size(); i++){
0773 gr_variation_recoTracklet_vec[i] -> Draw("p same");
0774 }
0775
0776 c1 -> cd();
0777 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0778 pad2 -> Draw();
0779 pad2 -> cd();
0780
0781 for (int i = 0; i < gr_variation_recoTracklet_vec.size(); i++){
0782 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0783
0784 TGraph * temp_gr = GetRatioGr(
0785 gr_variation_recoTracklet_vec[i],
0786 gr_recoTracklet_baseline
0787 );
0788 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0789 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0790 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0791 temp_gr -> Draw(plot_draw_text.c_str());
0792 }
0793 line -> DrawLine(gr_variation_recoTracklet_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_recoTracklet_vec.back()->GetXaxis()->GetXmax(), 1);
0794
0795 c1 -> cd();
0796 leg_variation_recoTracklet -> Draw("same");
0797 c1 -> Print(Form("%s/RunGeneratorVariation_RecoTracklet_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0798 c1 -> Clear();
0799
0800 leg_variation -> Clear();
0801 leg_variation_recoTracklet -> Clear();
0802 }
0803
0804 void FinalResult::PrepareClusPhiSizeError(std::vector<std::string> file_directory_vec_in, std::vector<std::string> file_title_in, std::string leg_header_in)
0805 {
0806 TFile * temp_file_in;
0807
0808 c1 -> Clear();
0809 c1 -> cd();
0810 pad1 = new TPad("pad1", "pad1", 0, 0.31, 1, 0.85);
0811 pad1 -> Draw();
0812 pad1 -> cd();
0813
0814 gr_dNdEta_baseline -> Draw("ap");
0815 leg_variation -> AddEntry(gr_dNdEta_baseline, file_title_in.back().c_str(), "p");
0816 leg_variation -> SetHeader(leg_header_in.c_str());
0817
0818 std::vector<TGraph*> gr_variation_vec; gr_variation_vec.clear();
0819
0820 for (int i = 0; i < file_directory_vec_in.size(); i++)
0821 {
0822 temp_file_in = TFile::Open(file_directory_vec_in[i].c_str());
0823
0824 h1D_ClusPhiSizeError_vec.push_back( (TH1D*) temp_file_in -> Get(StandardData_h1D_name.c_str()) );
0825
0826
0827 gr_variation_vec.push_back( h1D_to_TGraph(h1D_ClusPhiSizeError_vec.back()) );
0828 gr_variation_vec.back() -> SetMarkerStyle(marker_code[i]);
0829 gr_variation_vec.back() -> SetMarkerSize(1);
0830 gr_variation_vec.back() -> SetMarkerColor(TColor::GetColor(color_code[i].c_str()));
0831 gr_variation_vec.back() -> Draw("p same");
0832
0833 leg_variation -> AddEntry(gr_variation_vec.back(), file_title_in[i].c_str(), "p");
0834
0835
0836 h1D_ClusPhiSizeError_vec.back() -> Divide(h1D_data_standard);
0837 h1D_to_AbsRatio(h1D_ClusPhiSizeError_vec.back());
0838 }
0839
0840 h1D_error_ClusPhiSize = h1D_FindLargestOnes("h1D_error_ClusPhiSize", h1D_ClusPhiSizeError_vec);
0841
0842 h1D_error_ClusPhiSize -> SetMarkerStyle(30);
0843 h1D_error_ClusPhiSize -> SetMarkerSize(1);
0844 h1D_error_ClusPhiSize -> SetLineWidth(0);
0845 h1D_error_ClusPhiSize -> SetLineColorAlpha(1,0);
0846 h1D_error_ClusPhiSize -> SetMarkerColor(TColor::GetColor(color_code[5].c_str()));
0847
0848 UncRange_ClusPhiSize = GetH1DMinMax(h1D_error_ClusPhiSize);
0849
0850 c1 -> cd();
0851 pad2 = new TPad("pad2", "pad2", 0, 0., 1, 0.38);
0852 pad2 -> Draw();
0853 pad2 -> cd();
0854
0855 for (int i = 0; i < gr_variation_vec.size(); i++){
0856 std::string plot_draw_text = (i == 0) ? "ap" : "p same";
0857
0858 TGraph * temp_gr = GetRatioGr(
0859 gr_variation_vec[i],
0860 gr_dNdEta_baseline
0861 );
0862 temp_gr -> GetYaxis() -> SetRangeUser(0.9,1.1);
0863 temp_gr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
0864 temp_gr -> GetYaxis() -> SetTitle("Ratio to baseline");
0865 temp_gr -> Draw(plot_draw_text.c_str());
0866 }
0867 line -> DrawLine(gr_variation_vec.back()->GetXaxis()->GetXmin(), 1, gr_variation_vec.back()->GetXaxis()->GetXmax(), 1);
0868
0869 c1 -> cd();
0870 leg_variation -> Draw("same");
0871 c1 -> Print(Form("%s/RunClusPhiSizeVariation_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
0872 c1 -> Clear();
0873 leg_variation -> Clear();
0874
0875 }
0876
0877 void FinalResult::PrepareMCMergedError(std::vector<std::string> file_directory_vec_in)
0878 {
0879 TFile * temp_file_in;
0880
0881 for (std::string file_dir : file_directory_vec_in)
0882 {
0883 temp_file_in = TFile::Open(file_dir.c_str());
0884
0885 h1D_MCMergedError_vec.push_back( (TH1D*) temp_file_in -> Get(StandardData_h1D_name.c_str()) );
0886 h1D_MCMergedError_vec.back() -> Divide(h1D_data_standard);
0887 h1D_to_AbsRatio(h1D_MCMergedError_vec.back());
0888 }
0889
0890 h1D_error_MCMerged = h1D_FindLargestOnes("h1D_error_MCMerged", h1D_MCMergedError_vec);
0891
0892 h1D_error_MCMerged -> SetMarkerStyle(20);
0893 h1D_error_MCMerged -> SetMarkerSize(1);
0894 h1D_error_MCMerged -> SetLineWidth(0);
0895 h1D_error_MCMerged -> SetLineColorAlpha(1,0);
0896 h1D_error_MCMerged -> SetMarkerColor(TColor::GetColor(color_code[6].c_str()));
0897
0898 }
0899
0900
0901 void FinalResult::PrepareFinalError()
0902 {
0903 if (h1D_error_statistic == nullptr){
0904 std::cout << "Error : the statistical error is not found" << std::endl;
0905 exit(1);
0906 }
0907
0908 h1D_error_Final = (TH1D*) h1D_error_statistic -> Clone("h1D_error_Final");
0909 h1D_error_Final -> Reset("ICESM");
0910
0911 for (int i = 1; i <= h1D_error_Final -> GetNbinsX(); i++){
0912
0913 double _error_statistic = (h1D_error_statistic != nullptr) ? h1D_error_statistic -> GetBinContent(i) : 0;
0914 _error_statistic = (_error_statistic == _error_statistic && _error_statistic != 1) ? _error_statistic : 0;
0915
0916 double _error_Run_segmentation = (h1D_error_Run_segmentation != nullptr) ? h1D_error_Run_segmentation -> GetBinContent(i) : 0;
0917 _error_Run_segmentation = (_error_Run_segmentation == _error_Run_segmentation && _error_Run_segmentation != 1) ? _error_Run_segmentation : 0;
0918
0919 double _error_ClusAdc = (h1D_error_ClusAdc != nullptr) ? h1D_error_ClusAdc -> GetBinContent(i) : 0;
0920 _error_ClusAdc = (_error_ClusAdc == _error_ClusAdc && _error_ClusAdc != 1) ? _error_ClusAdc : 0;
0921
0922 double _error_GeoOffset = (h1D_error_GeoOffset != nullptr) ? h1D_error_GeoOffset -> GetBinContent(i) : 0;
0923 _error_GeoOffset = (_error_GeoOffset == _error_GeoOffset && _error_GeoOffset != 1) ? _error_GeoOffset : 0;
0924
0925 double _error_DeltaPhi = (h1D_error_DeltaPhi != nullptr) ? h1D_error_DeltaPhi -> GetBinContent(i) : 0;
0926 _error_DeltaPhi = (_error_DeltaPhi == _error_DeltaPhi && _error_DeltaPhi != 1) ? _error_DeltaPhi : 0;
0927
0928 double _error_Strangeness = (h1D_error_Strangeness != nullptr) ? h1D_error_Strangeness -> GetBinContent(i) : 0;
0929 _error_Strangeness = (_error_Strangeness == _error_Strangeness && _error_Strangeness != 1) ? _error_Strangeness : 0;
0930
0931 double _error_Generator = (h1D_error_Generator != nullptr) ? h1D_error_Generator -> GetBinContent(i) : 0;
0932 _error_Generator = (_error_Generator == _error_Generator && _error_Generator != 1) ? _error_Generator : 0;
0933
0934 double _error_ClusPhiSize = (h1D_error_ClusPhiSize != nullptr) ? h1D_error_ClusPhiSize -> GetBinContent(i) : 0;
0935 _error_ClusPhiSize = (_error_ClusPhiSize == _error_ClusPhiSize && _error_ClusPhiSize != 1) ? _error_ClusPhiSize : 0;
0936
0937 double _error_MCMerged = (h1D_error_MCMerged != nullptr) ? h1D_error_MCMerged -> GetBinContent(i) : 0;
0938 _error_MCMerged = (_error_MCMerged == _error_MCMerged && _error_MCMerged != 1) ? _error_MCMerged : 0;
0939
0940
0941 double _final_error = std::sqrt(
0942 pow(_error_statistic, 2) +
0943 pow(_error_Run_segmentation, 2) +
0944 pow(_error_ClusAdc, 2) +
0945 pow(_error_GeoOffset, 2) +
0946 pow(_error_DeltaPhi, 2) +
0947 pow(_error_Strangeness, 2) +
0948 pow(_error_Generator, 2) +
0949 pow(_error_ClusPhiSize, 2) +
0950 pow(_error_MCMerged, 2)
0951 );
0952
0953 std::cout<<"bin: "<< i <<", eta: ["<<h1D_error_Final->GetXaxis()->GetBinLowEdge(i)<<", "<<h1D_error_Final->GetXaxis()->GetBinUpEdge(i)<<"]"
0954 << ", statistic: " << Form("%.5f",_error_statistic)
0955 << ", Run_segmentation: " << Form("%.5f",_error_Run_segmentation)
0956 << ", ClusAdc: " << Form("%.5f",_error_ClusAdc)
0957 << ", GeoOffset: " << Form("%.5f",_error_GeoOffset)
0958 << ", DeltaPhi: " << Form("%.5f",_error_DeltaPhi)
0959 << ", ClusPhiSize: " << Form("%.5f",_error_ClusPhiSize)
0960 << ", Strangeness: " << Form("%.5f",_error_Strangeness)
0961 << ", Generator: " << Form("%.5f",_error_Generator)
0962
0963 << " final_error: " << Form("%.5f",_final_error)
0964 << std::endl;
0965
0966 h1D_error_Final -> SetBinContent(i, _final_error);
0967 }
0968
0969
0970 for (int i = 1; i <= h1D_error_Final -> GetNbinsX(); i++)
0971 {
0972 double lowEdge = h1D_error_Final -> GetXaxis() -> GetBinLowEdge(i);
0973 double upEdge = h1D_error_Final -> GetXaxis() -> GetBinUpEdge(i);
0974 double binCenter = h1D_error_Final -> GetXaxis() -> GetBinCenter(i);
0975
0976 if (binCenter < eta_range.first || binCenter > eta_range.second){
0977
0978 std::cout<<"Rejection, bin: "<< i <<", eta: ["<<lowEdge<<", "<<upEdge<<"]"
0979 << ", Total error: " << h1D_error_Final -> GetBinContent(i)
0980 << std::endl;
0981
0982 h1D_error_Final -> SetBinContent(i, -30);
0983 h1D_error_Final -> SetBinError(i, 0);
0984
0985 if (h1D_error_statistic != nullptr) {
0986 h1D_error_statistic -> SetBinContent(i, -30);
0987 h1D_error_statistic -> SetBinError(i, 0);
0988 }
0989
0990 if (h1D_error_Run_segmentation != nullptr) {
0991 h1D_error_Run_segmentation -> SetBinContent(i, -30);
0992 h1D_error_Run_segmentation -> SetBinError(i, 0);
0993 }
0994
0995 if (h1D_error_ClusAdc != nullptr) {
0996 h1D_error_ClusAdc -> SetBinContent(i, -30);
0997 h1D_error_ClusAdc -> SetBinError(i, 0);
0998 }
0999
1000 if (h1D_error_GeoOffset != nullptr) {
1001 h1D_error_GeoOffset -> SetBinContent(i, -30);
1002 h1D_error_GeoOffset -> SetBinError(i, 0);
1003 }
1004
1005 if (h1D_error_DeltaPhi != nullptr) {
1006 h1D_error_DeltaPhi -> SetBinContent(i, -30);
1007 h1D_error_DeltaPhi -> SetBinError(i, 0);
1008 }
1009
1010 if (h1D_error_Strangeness != nullptr) {
1011 h1D_error_Strangeness -> SetBinContent(i, -30);
1012 h1D_error_Strangeness -> SetBinError(i, 0);
1013 }
1014
1015 if (h1D_error_Generator != nullptr) {
1016 h1D_error_Generator -> SetBinContent(i, -30);
1017 h1D_error_Generator -> SetBinError(i, 0);
1018 }
1019
1020 if (h1D_error_ClusPhiSize != nullptr) {
1021 h1D_error_ClusPhiSize -> SetBinContent(i, -30);
1022 h1D_error_ClusPhiSize -> SetBinError(i, 0);
1023 }
1024
1025 if (h1D_error_MCMerged != nullptr) {
1026 h1D_error_MCMerged -> SetBinContent(i, -30);
1027 h1D_error_MCMerged -> SetBinError(i, 0);
1028 }
1029
1030 }
1031 }
1032
1033
1034
1035
1036 h1D_error_Final -> SetMinimum(0);
1037 h1D_error_Final -> SetMaximum(SystUncPlot_Ymax);
1038 h1D_error_Final -> SetLineWidth(2);
1039 h1D_error_Final -> SetLineColor(1);
1040 h1D_error_Final -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
1041 h1D_error_Final -> GetYaxis() -> SetTitle("Relative uncertainty");
1042
1043 leg_errors -> AddEntry(h1D_error_Final, "Total Uncertainty", "l");
1044 if (h1D_error_statistic != nullptr) {leg_errors -> AddEntry(h1D_error_statistic, "Stat. Unc.", "p");}
1045 if (h1D_error_Run_segmentation != nullptr) {leg_errors -> AddEntry(h1D_error_Run_segmentation, "Run segmentation variation", "p");}
1046 if (h1D_error_ClusAdc != nullptr) {leg_errors -> AddEntry(h1D_error_ClusAdc, "Cluster ADC variation", "p");}
1047 if (h1D_error_GeoOffset != nullptr) {leg_errors -> AddEntry(h1D_error_GeoOffset, "Geo. misalignment variation", "p");}
1048 if (h1D_error_DeltaPhi != nullptr) {leg_errors -> AddEntry(h1D_error_DeltaPhi, "#Delta#phi cut variation", "p");}
1049 if (h1D_error_ClusPhiSize != nullptr) {leg_errors -> AddEntry(h1D_error_ClusPhiSize, "Cluster#kern[0.4]{#phi} size variation", "p");}
1050 if (h1D_error_Strangeness != nullptr) {leg_errors -> AddEntry(h1D_error_Strangeness, "Strangeness variation", "p");}
1051 if (h1D_error_Generator != nullptr) {leg_errors -> AddEntry(h1D_error_Generator, "Generator variation", "p");}
1052 if (h1D_error_MCMerged != nullptr) {leg_errors -> AddEntry(h1D_error_MCMerged, "MC merge variation", "p");}
1053
1054 file_out -> cd();
1055
1056 c1 -> cd();
1057 h1D_error_Final -> Draw("hist");
1058
1059 UncRange_Final = GetH1DMinMax(h1D_error_Final);
1060
1061 if (h1D_error_statistic != nullptr) {h1D_error_statistic -> Draw("p same");}
1062 if (h1D_error_Run_segmentation != nullptr) {h1D_error_Run_segmentation -> Draw("p same");}
1063 if (h1D_error_ClusAdc != nullptr) {h1D_error_ClusAdc -> Draw("p same");}
1064 if (h1D_error_GeoOffset != nullptr) {h1D_error_GeoOffset -> Draw("p same");}
1065 if (h1D_error_DeltaPhi != nullptr) {h1D_error_DeltaPhi -> Draw("p same");}
1066 if (h1D_error_ClusPhiSize != nullptr) {h1D_error_ClusPhiSize -> Draw("p same");}
1067 if (h1D_error_Strangeness != nullptr) {h1D_error_Strangeness -> Draw("p same");}
1068 if (h1D_error_Generator != nullptr) {h1D_error_Generator -> Draw("p same");}
1069 if (h1D_error_MCMerged != nullptr) {h1D_error_MCMerged -> Draw("p same");}
1070
1071 if (AnaDescription.second.size() > 0){
1072 draw_text -> DrawLatex(AnaDescription.first.first, AnaDescription.first.second, AnaDescription.second.c_str());
1073 }
1074
1075 ltx->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{#bf{sPHENIX}} %s", sPH_label.c_str()));
1076
1077 leg_errors -> Draw("same");
1078
1079 c1 -> Print(Form("%s/SystUnc_Summary_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
1080 c1 -> Write("SystUnc_Summary");
1081
1082 c1 -> Clear();
1083
1084
1085
1086
1087
1088 }
1089
1090 void FinalResult::PrepareFinalResult(double Hist_Y_max)
1091 {
1092 h1D_data_standard -> SetMarkerStyle(20);
1093 h1D_data_standard -> SetMarkerSize(1);
1094 h1D_data_standard -> SetMarkerColor(1);
1095 h1D_data_standard -> SetFillColorAlpha(1,0.5);
1096 h1D_data_standard -> SetLineColorAlpha(1,0);
1097 h1D_data_standard -> SetLineWidth(0);
1098
1099 gE_data_final = new TGraphErrors();
1100 gE_data_final -> SetMarkerStyle(20);
1101 gE_data_final -> SetMarkerSize(1);
1102 gE_data_final -> SetMarkerColor(1);
1103 gE_data_final -> SetFillColorAlpha(1,0.5);
1104 gE_data_final -> SetLineColorAlpha(1,0);
1105 gE_data_final -> SetLineWidth(0);
1106
1107 for (int i = 1; i <= h1D_data_standard -> GetNbinsX(); i++){
1108 double _content = h1D_data_standard -> GetBinContent(i);
1109 double _error = h1D_error_Final -> GetBinContent(i);
1110 double _BinCenter = h1D_data_standard -> GetXaxis() -> GetBinCenter(i);
1111 double _BinWidth = h1D_data_standard -> GetXaxis() -> GetBinWidth(i);
1112
1113 double final_error = (_content != 0) ? _content * _error : 0.;
1114
1115
1116 h1D_data_standard -> SetBinError(i, _error * _content);
1117
1118
1119 if (_BinCenter < eta_range.first || _BinCenter > eta_range.second){
1120 h1D_data_standard -> SetBinContent(i, -10);
1121 h1D_data_standard -> SetBinError(i, 0);
1122 }
1123
1124 if (_BinCenter >= eta_range.first && _BinCenter <= eta_range.second){
1125 gE_data_final -> SetPoint(gE_data_final -> GetN(), _BinCenter, _content);
1126 gE_data_final -> SetPointError(gE_data_final -> GetN() - 1, _BinWidth/2., final_error);
1127
1128 std::cout<<"bin: "<< i <<", eta: ["<<h1D_data_standard->GetXaxis()->GetBinLowEdge(i)<<", "<<h1D_data_standard->GetXaxis()->GetBinUpEdge(i)<<"]"
1129 << ", content: " << Form("%.3f",_content)
1130 << ", error: " << Form("%.3f",_error)
1131 << ", final_error: " << Form("%.3f",final_error)
1132 << std::endl;
1133
1134 }
1135 }
1136
1137 gE_data_final -> GetYaxis() -> SetRangeUser(0, Hist_Y_max);
1138 gE_data_final -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
1139 gE_data_final -> GetYaxis() -> SetTitle("dN_{ch}/d#eta");
1140
1141 h1D_data_standard -> SetMinimum(0);
1142 h1D_data_standard -> SetMaximum(Hist_Y_max);
1143 h1D_data_standard -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
1144 h1D_data_standard -> GetYaxis() -> SetTitle("dN_{ch}/d#eta");
1145
1146 h1D_truth_standard -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
1147 h1D_truth_standard -> GetYaxis() -> SetTitle("dN_{ch}/d#eta");
1148 h1D_truth_standard -> SetMinimum(0);
1149 h1D_truth_standard -> SetMaximum(Hist_Y_max);
1150 h1D_truth_standard -> SetLineColor(TColor::GetColor("#3288bd"));
1151 h1D_truth_standard -> SetLineWidth(2);
1152 h1D_truth_standard -> SetFillColorAlpha(1,0);
1153
1154 leg_final -> AddEntry(h1D_data_standard, Final_Data_MC_text.first.c_str(), "fp");
1155 leg_final -> AddEntry(h1D_truth_standard, Final_Data_MC_text.second.c_str(), "l");
1156 leg_final -> AddEntry(gr_MC_closure_standard, "MC closure test", "p");
1157
1158
1159 file_out -> cd();
1160 c1 -> cd();
1161 c1 -> Clear();
1162
1163
1164 h1D_truth_standard -> Draw("hist");
1165 gr_MC_closure_standard -> Draw("p same");
1166
1167
1168 if (Have_PHOBOS && Mbin < 11)
1169 {
1170 TGraphAsymmErrors * PHOBOS_grae = GetPHOBOSData();
1171 leg_final -> AddEntry(PHOBOS_grae, "PHOBOS", "fp");
1172 PHOBOS_grae -> Draw("E3 same");
1173 PHOBOS_grae -> Draw("p same");
1174 }
1175
1176 gE_data_final -> Draw("P2 same");
1177
1178
1179
1180 if (AnaDescription.second.size() > 0){
1181 draw_text -> DrawLatex(AnaDescription.first.first, AnaDescription.first.second, AnaDescription.second.c_str());
1182 }
1183
1184 if (Collision_str.second.size() > 0){
1185 draw_text -> DrawLatex(Collision_str.first.first, Collision_str.first.second, Collision_str.second.c_str());
1186 }
1187
1188 ltx->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{#bf{sPHENIX}} %s", sPH_label.c_str()));
1189 leg_final -> Draw("same");
1190
1191 c1 -> Print(Form("%s/FinalResult_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
1192 c1 -> Write("FinalResult");
1193
1194 }
1195
1196 void FinalResult::EndRun()
1197 {
1198 tree_out -> Fill();
1199 tree_out -> Write();
1200
1201 std::cout<<"========================================================================================="<<std::endl;
1202 std::cout<<Form("StatUnc, min: %.4f%, max: %.4f%", 100 * UncRange_StatUnc.first, 100 * UncRange_StatUnc.second)<<std::endl;
1203 std::cout<<Form("RunSegment, min: %.4f%, max: %.4f%", 100 * UncRange_RunSegment.first, 100 * UncRange_RunSegment.second)<<std::endl;
1204 std::cout<<Form("ClusAdc, min: %.4f%, max: %.4f%", 100 * UncRange_ClusAdc.first, 100 * UncRange_ClusAdc.second)<<std::endl;
1205 std::cout<<Form("GeoOffset, min: %.4f%, max: %.4f%", 100 * UncRange_GeoOffset.first, 100 * UncRange_GeoOffset.second)<<std::endl;
1206 std::cout<<Form("DeltaPhi, min: %.4f%, max: %.4f%", 100 * UncRange_DeltaPhi.first, 100 * UncRange_DeltaPhi.second)<<std::endl;
1207 std::cout<<Form("ClusPhiSize, min: %.4f%, max: %.4f%", 100 * UncRange_ClusPhiSize.first, 100 * UncRange_ClusPhiSize.second)<<std::endl;
1208 std::cout<<Form("Strangeness, min: %.4f%, max: %.4f%", 100 * UncRange_Strangeness.first, 100 * UncRange_Strangeness.second)<<std::endl;
1209 std::cout<<Form("Generator, min: %.4f%, max: %.4f%", 100 * UncRange_Generator.first, 100 * UncRange_Generator.second)<<std::endl;
1210 std::cout<<Form("Final, min: %.4f%, max: %.4f%", 100 * UncRange_Final.first, 100 * UncRange_Final.second)<<std::endl;
1211 std::cout<<"========================================================================================="<<std::endl;
1212
1213 gE_data_final -> Write("gE_dNdEta_reco");
1214 h1D_data_standard -> Write("h1D_dNdEta_reco");
1215 h1D_truth_standard -> Write("h1D_dNdEta_truth");
1216 h1D_MC_closure_standard -> Write("h1D_MC_closure");
1217 gr_MC_closure_standard -> Write("gr_MC_closure");
1218
1219 if(h1D_error_statistic != nullptr) {h1D_error_statistic->SetMarkerColor(1); h1D_error_statistic -> Write();}
1220 if(h1D_error_Run_segmentation != nullptr) {h1D_error_Run_segmentation -> Write();}
1221 if(h1D_error_ClusAdc != nullptr) {h1D_error_ClusAdc -> Write();}
1222 if(h1D_error_GeoOffset != nullptr) {h1D_error_GeoOffset -> Write();}
1223 if(h1D_error_DeltaPhi != nullptr) {h1D_error_DeltaPhi -> Write();}
1224 if(h1D_error_ClusPhiSize != nullptr) {h1D_error_ClusPhiSize -> Write();}
1225 if(h1D_error_Strangeness != nullptr) {h1D_error_Strangeness -> Write();}
1226 if(h1D_error_Generator != nullptr) {h1D_error_Generator -> Write();}
1227 if(h1D_error_MCMerged != nullptr) {h1D_error_MCMerged -> Write();}
1228 if(h1D_error_Final != nullptr) {h1D_error_Final -> Write();}
1229
1230 file_out -> Close();
1231 }
1232
1233 void FinalResult::h1D_to_AbsRatio(TH1D * h1D_in)
1234 {
1235 for (int i = 1; i <= h1D_in -> GetNbinsX(); i++){
1236 h1D_in -> SetBinContent(i, std::abs( h1D_in -> GetBinContent(i) - 1 ));
1237 }
1238 }
1239
1240 TH1D * FinalResult::h1D_FindLargestOnes(std::string hist_name, std::vector<TH1D*> h1D_vec_in)
1241 {
1242 TH1D * h1D_out = (TH1D*) h1D_vec_in.front()->Clone(hist_name.c_str());
1243
1244 for (int i = 1; i < h1D_vec_in.size(); i++)
1245 {
1246 for (int j = 1; j <= h1D_out -> GetNbinsX(); j++)
1247 {
1248 if (h1D_vec_in[i] -> GetBinContent(j) > h1D_out -> GetBinContent(j)){
1249 h1D_out -> SetBinContent(j, h1D_vec_in[i] -> GetBinContent(j));
1250 }
1251 }
1252 }
1253
1254 return h1D_out;
1255 }
1256
1257 TGraph * FinalResult::h1D_to_TGraph(TH1D * hist_in)
1258 {
1259 TGraph * g_out = new TGraph();
1260
1261
1262 for (int i = 1; i <= hist_in -> GetNbinsX(); i++){
1263
1264 double H1DBinCenterX = hist_in -> GetXaxis() -> GetBinCenter(i);
1265
1266 if (H1DBinCenterX < eta_range.first || H1DBinCenterX > eta_range.second){
1267 continue;
1268 }
1269
1270 g_out -> SetPoint(g_out -> GetN(), H1DBinCenterX, hist_in -> GetBinContent(i));
1271 }
1272
1273 return g_out;
1274 }
1275
1276 void FinalResult::DrawAlphaCorrectionPlots(
1277 std::string AlphaCorr_file_directory,
1278 std::vector<std::tuple<double,double,std::string>> additional_text,
1279 std::vector<std::tuple<int, std::string, std::string>> legend_text
1280 )
1281 {
1282 c1 -> cd();
1283 TFile * temp_file_in = TFile::Open(AlphaCorr_file_directory.c_str());
1284
1285 TH1D * h1D_AlphaCorr = (TH1D*) temp_file_in -> Get(h1D_AlphaCorr_name.c_str());
1286 h1D_AlphaCorr -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
1287 h1D_AlphaCorr -> GetYaxis() -> SetTitle("Acc. & Effi. correction (Reco. / Gen.)");
1288 h1D_AlphaCorr -> SetMinimum(0);
1289 h1D_AlphaCorr -> SetMaximum(1.4);
1290 h1D_AlphaCorr -> SetLineWidth(2);
1291
1292 h1D_AlphaCorr -> SetMarkerSize(1);
1293 h1D_AlphaCorr -> Draw("hist TEXT90");
1294
1295 ltx->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{#bf{sPHENIX}} Simulation"));
1296
1297 for (auto text : additional_text){
1298 double x = std::get<0>(text);
1299 double y = std::get<1>(text);
1300 std::string text_str = std::get<2>(text);
1301
1302 draw_text -> DrawLatex(x, y, text_str.c_str());
1303 }
1304
1305 c1 -> Print(Form("%s/h1D_AlphaCorrection_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
1306 c1 -> Clear();
1307
1308
1309
1310 TH1D * h1D_truth_hadron_001 = (TH1D*) temp_file_in -> Get(StandardTruth_h1D_name.c_str());
1311 TH1D * h1D_recoTracklet_001 = (TH1D*) temp_file_in -> Get(h1D_RecoTracklet_name.c_str());
1312
1313 h1D_truth_hadron_001 -> SetMarkerColor(std::get<0>(legend_text[0]));
1314 h1D_truth_hadron_001 -> SetLineColor(std::get<0>(legend_text[0]));
1315 leg_TruthReco -> AddEntry(h1D_truth_hadron_001, std::get<1>(legend_text[0]).c_str(), std::get<2>(legend_text[0]).c_str());
1316 h1D_truth_hadron_001 -> SetMinimum(0);
1317 h1D_truth_hadron_001 -> SetMaximum(
1318 h1D_truth_hadron_001 -> GetBinContent(h1D_truth_hadron_001 -> GetMaximumBin()) * 1.45
1319 );
1320 h1D_truth_hadron_001 -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
1321 h1D_truth_hadron_001 -> GetYaxis() -> SetTitle("Avg. multiplicity per event");
1322 h1D_truth_hadron_001 -> SetLineWidth(2);
1323
1324 h1D_recoTracklet_001 -> SetMarkerColor(std::get<0>(legend_text[1]));
1325 h1D_recoTracklet_001 -> SetLineColor(std::get<0>(legend_text[1]));
1326 leg_TruthReco -> AddEntry(h1D_recoTracklet_001, std::get<1>(legend_text[1]).c_str(), std::get<2>(legend_text[1]).c_str());
1327 h1D_recoTracklet_001 -> SetLineWidth(2);
1328
1329 c1 -> cd();
1330 h1D_truth_hadron_001 -> Draw("hist");
1331 h1D_recoTracklet_001 -> Draw("hist same");
1332 ltx->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{#bf{sPHENIX}} Simulation"));
1333
1334 for (auto text : additional_text){
1335 double x = std::get<0>(text);
1336 double y = std::get<1>(text);
1337 std::string text_str = std::get<2>(text);
1338
1339 draw_text -> DrawLatex(x, y, text_str.c_str());
1340 }
1341
1342 leg_TruthReco -> Draw("same");
1343
1344 c1 -> Print(Form("%s/h1D_TruthReco_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
1345 c1 -> Clear();
1346 leg_TruthReco -> Clear();
1347
1348 temp_file_in -> Close();
1349 }
1350
1351 void FinalResult::DrawGoodPair2DFineBinPlot(std::vector<std::tuple<double,double,std::string>> additional_text)
1352 {
1353
1354 c1 -> cd();
1355
1356 TH2D * h2D_GoodPair = (TH2D*) file_in_data_standard -> Get(h2D_GoodProtoTracklet_EtaVtxZ_FineBin_name.c_str());
1357 h2D_GoodPair -> GetXaxis() -> SetTitle("Pair #eta");
1358 h2D_GoodPair -> GetYaxis() -> SetTitle("INTT vtxZ [cm]");
1359 h2D_GoodPair -> Draw("colz0");
1360 ltx->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{#bf{sPHENIX}} %s", sPH_label.c_str()));
1361
1362 c1 -> Print(Form("%s/GoodPair2DFineBin_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
1363 c1 -> Clear();
1364 }
1365
1366 void FinalResult::DrawRecoTrackletDataMCPlot(
1367 std::vector<std::tuple<double,double,std::string>> additional_text,
1368 std::vector<std::tuple<int, std::string, std::string>> legend_text
1369 )
1370 {
1371 TH1D * h1D_recoTracklet_data = (TH1D*) file_in_data_standard -> Get(h1D_RecoTracklet_name.c_str());
1372 TH1D * h1D_recoTracklet_MC = (TH1D*) file_in_MC_standard -> Get(h1D_RecoTracklet_name.c_str());
1373
1374 h1D_recoTracklet_data -> SetMarkerColor(std::get<0>(legend_text[0]));
1375 h1D_recoTracklet_data -> SetLineColor(std::get<0>(legend_text[0]));
1376 leg_TruthReco -> AddEntry(h1D_recoTracklet_data, std::get<1>(legend_text[0]).c_str(), std::get<2>(legend_text[0]).c_str());
1377 h1D_recoTracklet_data -> SetMinimum(0);
1378 h1D_recoTracklet_data -> SetMaximum(
1379 h1D_recoTracklet_data -> GetBinContent(h1D_recoTracklet_data -> GetMaximumBin()) * 1.45
1380 );
1381 h1D_recoTracklet_data -> GetXaxis() -> SetTitle("Pseudorapidity #eta");
1382 h1D_recoTracklet_data -> GetYaxis() -> SetTitle("Avg. Reco. Tracklets per event");
1383
1384 h1D_recoTracklet_MC -> SetMarkerColor(std::get<0>(legend_text[1]));
1385 h1D_recoTracklet_MC -> SetLineColor(std::get<0>(legend_text[1]));
1386 h1D_recoTracklet_MC -> SetLineWidth(2);
1387 leg_TruthReco -> AddEntry(h1D_recoTracklet_MC, std::get<1>(legend_text[1]).c_str(), std::get<2>(legend_text[1]).c_str());
1388
1389 c1 -> cd();
1390 h1D_recoTracklet_data -> Draw("ep");
1391 h1D_recoTracklet_MC -> Draw("hist same");
1392 ltx->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{#bf{sPHENIX}} %s", sPH_label.c_str()));
1393
1394 for (auto text : additional_text){
1395 double x = std::get<0>(text);
1396 double y = std::get<1>(text);
1397 std::string text_str = std::get<2>(text);
1398
1399 draw_text -> DrawLatex(x, y, text_str.c_str());
1400 }
1401
1402 leg_TruthReco -> Draw("same");
1403
1404 c1 -> Print(Form("%s/h1D_RecoTrackletDataMC_Mbin%d.pdf", final_output_directory.c_str(), Mbin));
1405 c1 -> Clear();
1406 leg_TruthReco -> Clear();
1407
1408 }
1409
1410 std::pair<double, double> FinalResult::GetH1DMinMax(TH1D * h1D_in)
1411 {
1412 double min = 99999;
1413 double max = -99999;
1414
1415 for (int i = 1; i <= h1D_in -> GetNbinsX(); i++){
1416
1417 if (h1D_in->GetXaxis()->GetBinCenter(i) < eta_range.first || h1D_in->GetXaxis()->GetBinCenter(i) > eta_range.second){
1418 continue;
1419 }
1420
1421 double content = h1D_in -> GetBinContent(i);
1422 if (content < min) {min = content;}
1423 if (content > max) {max = content;}
1424 }
1425
1426 return std::make_pair(min, max);
1427 }
1428
1429 TGraph * FinalResult::GetRatioGr(TGraph * gr_numerator, TGraph * gr_denominator)
1430 {
1431 TGraph * gr_out = new TGraph();
1432
1433 if (gr_numerator -> GetN() != gr_denominator -> GetN()){
1434 std::cout<<"Error : the number of points in the numerator and denominator are not the same"<<std::endl;
1435 exit(1);
1436 }
1437
1438 for (int i = 0; i < gr_numerator -> GetN(); i++){
1439 double x = 0;
1440 double y = 0;
1441 gr_numerator -> GetPoint(i, x, y);
1442
1443 double x2 = 0;
1444 double y2 = 0;
1445 gr_denominator -> GetPoint(i, x2, y2);
1446
1447 if (y2 == 0) {continue;}
1448
1449 gr_out -> SetPoint(gr_out -> GetN(), x, y / y2);
1450 }
1451
1452 gr_out -> SetMarkerStyle(gr_numerator -> GetMarkerStyle());
1453 gr_out -> SetMarkerSize(gr_numerator -> GetMarkerSize());
1454 gr_out -> SetMarkerColor(gr_numerator -> GetMarkerColor());
1455
1456 return gr_out;
1457 }
1458
1459 TGraphAsymmErrors * FinalResult::GetPHOBOSData()
1460 {
1461 std::ifstream PHOBOS_file(Form("%s/%s",PHOBOS_data_directory.c_str(),PHOBOS_data_file_name.c_str()));
1462 if(!PHOBOS_file.is_open())
1463 {
1464 std::cout<<"Error: PHOBOS file not found!"<<std::endl;
1465 return nullptr;
1466 }
1467
1468 TGraphAsymmErrors * PHOBOS_data = new TGraphAsymmErrors();
1469 PHOBOS_data -> SetTitle("PHOBOS_data;#eta;dN_{ch}/d#eta");
1470
1471 std::string line;
1472 while (std::getline(PHOBOS_file, line)) {
1473
1474 if (line.empty() || line[0] == '#' || line[0] == '&') continue;
1475
1476 std::istringstream iss(line);
1477 double eta;
1478 double dNdEta;
1479 double err_plus;
1480 double err_neg;
1481
1482 if (iss >> eta >> dNdEta >> err_plus >> err_neg) {
1483 PHOBOS_data -> SetPoint(PHOBOS_data -> GetN(), eta, dNdEta);
1484 PHOBOS_data -> SetPointError(PHOBOS_data -> GetN()-1, 0, 0, fabs(err_neg), err_plus);
1485
1486
1487
1488
1489
1490
1491
1492 }
1493 }
1494
1495 PHOBOS_file.close();
1496
1497 PHOBOS_data -> SetMarkerStyle(21);
1498 PHOBOS_data -> SetMarkerSize(1);
1499 PHOBOS_data -> SetMarkerColor(9);
1500 PHOBOS_data -> SetFillColorAlpha(9,0.5);
1501 PHOBOS_data -> SetLineColorAlpha(1,0);
1502 PHOBOS_data -> SetLineWidth(0);
1503
1504
1505
1506 return PHOBOS_data;
1507
1508 }
