NewCode2024/GetFinalResult/GetFinalResult.cpp

0001 #include "GetFinalResult.h"
0002
0003 GetFinalResult::GetFinalResult(
0004     int runnumber_in,
0005     int SelectedMbin_in, // note : 0, 1, ---- 10, 70, 100
0006     std::pair<double,double> vtxZ_range_in, // note : cm
0007     bool isTypeA_in,
0008     bool ApplyGeoAccCorr_in,
0009     std::pair<bool, std::pair<double,double>> cut_EtaRange_in,
0010
0011     std::string output_file_name_suffix_in,
0012
0013     std::string output_directory_in
0014 ):
0015     runnumber(runnumber_in),
0016     SelectedMbin(SelectedMbin_in),
0017     vtxZ_range(vtxZ_range_in),
0018     isTypeA(isTypeA_in),
0019     ApplyGeoAccCorr(ApplyGeoAccCorr_in),
0020     cut_EtaRange(cut_EtaRange_in),
0021     output_file_name_suffix(output_file_name_suffix_in),
0022     output_directory(output_directory_in)
0023 {
0024     SetResultRangeFolderName = Form("vtxZ_%.0f_%.0fcm_MBin%d", vtxZ_range.first, vtxZ_range.second, SelectedMbin);
0025     SetResultRangeFolderName += (isTypeA) ? "_TypeA" : "";
0026     SetResultRangeFolderName += (ApplyGeoAccCorr) ? "_GeoAccCorr" : "";
0027
0028     SemiMotherFolderName = output_directory + "/" + SetResultRangeFolderName;
0029
0030     system(Form("if [ ! -d %s ]; then mkdir -p %s; fi;", SemiMotherFolderName.c_str(), SemiMotherFolderName.c_str()));
0031
0032     BaseLine_AlphaCorr_directory = no_map;
0033     BaseLine_dNdEta_directory = no_map;
0034 }
0035
0036 void GetFinalResult::PrepareBaseLine(
0037     std::string data_input_directory,
0038     std::string data_input_filename,
0039
0040     std::string MC_input_directory,
0041     std::string MC1_input_filename,
0042     std::string MC2_input_filename
0043 )
0044 {
0045     std::vector<std::string> temp_file_dir = PreparedNdEtaPlain(
0046         0,
0047         true,
0048         true,
0049         Folder_BaseLine,
0050         data_input_directory,
0051         data_input_filename,
0052
0053         MC_input_directory,
0054         MC1_input_filename,
0055         MC2_input_filename,
0056
0057         {true, BaseLineDeltaPhiCut}
0058     );
0059
0060     // todo: if there are more directories in temp_file_dir, check here
0061     BaseLine_AlphaCorr_directory = temp_file_dir[0];
0062     BaseLine_dNdEta_directory = temp_file_dir[1];
0063 }
0064
0065 void GetFinalResult::PrepareRunSegment(
0066     std::string data_input_directory,
0067     std::vector<std::string> data_input_filename,
0068
0069     std::string MC_input_directory,
0070     std::string MC1_input_filename,
0071     std::string MC2_input_filename
0072 ) // note : two times
0073 {
0074     for (int i = 0; i < data_input_filename.size(); i++){
0075         PreparedNdEtaPlain(
0076             i,
0077             true,
0078             true,
0079             Folder_RunSegment,
0080             data_input_directory,
0081             data_input_filename[i],
0082
0083             MC_input_directory,
0084             MC1_input_filename,
0085             MC2_input_filename,
0086
0087             {true, BaseLineDeltaPhiCut}
0088         );
0089     }
0090 }
0091
0092 void GetFinalResult::PrepareClusAdcCut(
0093     int run_index,
0094     std::string data_input_directory,
0095     std::string data_input_filename,
0096
0097     std::string MC_input_directory,
0098     std::string MC1_input_filename,
0099     std::string MC2_input_filename
0100 ) // todo : can be twice
0101 {
0102     PreparedNdEtaPlain(
0103         run_index,
0104         true,
0105         true,
0106         Folder_ClusAdcCut,
0107         data_input_directory,
0108         data_input_filename,
0109
0110         MC_input_directory,
0111         MC1_input_filename,
0112         MC2_input_filename,
0113
0114         {true, BaseLineDeltaPhiCut}
0115     );
0116 }
0117
0118 void GetFinalResult::PrepareClusPhiCut(
0119     std::string data_input_directory,
0120     std::vector<std::string> data_input_filename,
0121
0122     std::string MC_input_directory,
0123     std::string MC1_input_filename,
0124     std::string MC2_input_filename
0125 )
0126 {
0127     for (int i = 0; i < data_input_filename.size(); i++){
0128         PreparedNdEtaPlain(
0129             i,
0130             true,
0131             true,
0132             Folder_ClusPhiCut,
0133             data_input_directory,
0134             data_input_filename[i],
0135
0136             MC_input_directory,
0137             MC1_input_filename,
0138             MC2_input_filename,
0139
0140             {true, BaseLineDeltaPhiCut}
0141         );
0142     }
0143 }
0144
0145 void GetFinalResult::PrepareAMPT(
0146     std::string data_input_directory,
0147     std::vector<std::string> data_input_filename,
0148
0149     std::string MC_input_directory,
0150     std::string MC1_input_filename,
0151     std::string MC2_input_filename
0152 )
0153 {
0154     for (int i = 0; i < data_input_filename.size(); i++){
0155         PreparedNdEtaPlain(
0156             i,
0157             true,
0158             true,
0159             Folder_AMPT,
0160             data_input_directory,
0161             data_input_filename[i],
0162
0163             MC_input_directory,
0164             MC1_input_filename,
0165             MC2_input_filename,
0166
0167             {true, BaseLineDeltaPhiCut}
0168         );
0169     }
0170 }
0171
0172 void GetFinalResult::PrepareEPOS(
0173     std::string data_input_directory,
0174     std::vector<std::string> data_input_filename,
0175
0176     std::string MC_input_directory,
0177     std::string MC1_input_filename,
0178     std::string MC2_input_filename
0179 )
0180 {
0181     for (int i = 0; i < data_input_filename.size(); i++){
0182         PreparedNdEtaPlain(
0183             i,
0184             true,
0185             true,
0186             Folder_EPOS,
0187             data_input_directory,
0188             data_input_filename[i],
0189
0190             MC_input_directory,
0191             MC1_input_filename,
0192             MC2_input_filename,
0193
0194             {true, BaseLineDeltaPhiCut}
0195         );
0196     }
0197 }
0198
0199 void GetFinalResult::PrepareHIJING_strange(
0200     std::string data_input_directory,
0201     std::vector<std::string> data_input_filename,
0202
0203     std::string MC_input_directory,
0204     std::string MC1_input_filename,
0205     std::string MC2_input_filename
0206 )
0207 {
0208     for (int i = 0; i < data_input_filename.size(); i++){
0209         PreparedNdEtaPlain(
0210             i,
0211             true,
0212             true,
0213             Folder_HIJING_strange,
0214             data_input_directory,
0215             data_input_filename[i],
0216
0217             MC_input_directory,
0218             MC1_input_filename,
0219             MC2_input_filename,
0220
0221             {true, BaseLineDeltaPhiCut}
0222         );
0223     }
0224 }
0225
0226
0227 void GetFinalResult::PrepareDeltaPhiCut(
0228     std::vector<double> cut_SigDeltaPhi,
0229     std::string data_input_directory,
0230     std::string data_input_filename,
0231
0232     std::string MC_input_directory,
0233     std::string MC1_input_filename,
0234     std::string MC2_input_filename
0235 ) // note : two times
0236 {
0237     for (int i = 0; i < cut_SigDeltaPhi.size(); i++)
0238     {
0239         PreparedNdEtaPlain(
0240             i,
0241             true,
0242             true,
0243             Folder_DeltaPhiCut,
0244             data_input_directory,
0245             data_input_filename,
0246
0247             MC_input_directory,
0248             MC1_input_filename,
0249             MC2_input_filename,
0250
0251             {true, {-1. * cut_SigDeltaPhi[i], cut_SigDeltaPhi[i]}}
0252         );
0253     }
0254 }
0255
0256
0257 // Division : -the macros---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
0258
0259 std::vector<std::string> GetFinalResult::PreparedNdEtaPlain(
0260     int index,
0261     bool PrepareAlphaCorr,
0262     bool RunComparison,
0263     std::string sub_folder_name,
0264     std::string data_input_directory,
0265     std::string data_input_filename,
0266
0267     std::string MC_input_directory,
0268     std::string MC1_input_filename,
0269     std::string MC2_input_filename,
0270
0271     std::pair<bool, std::pair<double,double>> cut_DeltaPhi_Signal_range // note : default : {false, {-0.026, 0.026}}
0272 )
0273 {
0274     std::string Plain_output_directory = SemiMotherFolderName + "/" + sub_folder_name + "/Run_" + std::to_string(index);
0275     system(Form("if [ ! -d %s ]; then mkdir -p %s; fi;", Plain_output_directory.c_str(), Plain_output_directory.c_str()));
0276
0277     // todo:
0278     std::string GeoAccCorr_directory = no_map;
0279
0280     // Division : ------------------------------------------------------------------------------
0281     int    MC1_process_id = 1;
0282     int    MC1_run_num = -1;
0283     bool   MC1_ApplyAlphaCorr = false;
0284     std::pair<bool, std::pair<double,double>> MC1_setEtaRange = {false, eta_range_dNdEta_Preparation};
0285
0286     // note : MC2 applying the alpha corrections
0287     int    MC2_process_id = 2;
0288     int    MC2_run_num = -1;
0289     bool   MC2_ApplyAlphaCorr = true;
0290     std::pair<bool, std::pair<double,double>> MC2_setEtaRange = {true, eta_range_dNdEta_Preparation};
0291
0292     int    data_process_id = 0;
0293     bool   data_ApplyAlphaCorr = true;
0294     std::pair<bool, std::pair<double,double>> data_setEtaRange = {true, eta_range_dNdEta_Preparation};
0295
0296     // Division : ------------------------------------------------------------------------------
0297
0298     std::string alpha_correction_input_directory = no_map;
0299     std::string MC1_dNdeta_file = no_map;
0300     std::string MC2_dNdeta_file = no_map;
0301
0302     if (PrepareAlphaCorr){
0303         MC1_dNdeta_file = Run_PreparedNdEtaEach(
0304             MC1_process_id,
0305             MC1_run_num,
0306             MC_input_directory,
0307             MC1_input_filename,
0308             Plain_output_directory,
0309
0310             output_file_name_suffix,
0311
0312             MC1_ApplyAlphaCorr,
0313             ApplyGeoAccCorr,
0314
0315             isTypeA,
0316             vtxZ_range,
0317             SelectedMbin,
0318
0319             cut_DeltaPhi_Signal_range,
0320             {false, {-2.7, 2.7}}, // note : the eta range
0321             GeoAccCorr_directory,
0322             no_map
0323         );
0324
0325         alpha_correction_input_directory = MC1_dNdeta_file;
0326     }
0327     else {
0328         alpha_correction_input_directory = BaseLine_AlphaCorr_directory;
0329         if (alpha_correction_input_directory == no_map){
0330             std::cout<<"Error : alpha_correction_input_directory == \"no_map\""<<std::endl;
0331             exit(1);
0332         }
0333     }
0334
0335     if (PrepareAlphaCorr){
0336         MC2_dNdeta_file = Run_PreparedNdEtaEach(
0337             MC2_process_id,
0338             MC2_run_num,
0339             MC_input_directory,
0340             MC2_input_filename,
0341             Plain_output_directory,
0342
0343             output_file_name_suffix,
0344
0345             MC2_ApplyAlphaCorr,
0346             ApplyGeoAccCorr,
0347
0348             isTypeA,
0349             vtxZ_range,
0350             SelectedMbin,
0351
0352             cut_DeltaPhi_Signal_range,
0353             MC2_setEtaRange,
0354             GeoAccCorr_directory,
0355             alpha_correction_input_directory
0356         );
0357     }
0358
0359
0360     std::string data_dNdeta_file = Run_PreparedNdEtaEach(
0361         data_process_id,
0362         runnumber,
0363         data_input_directory,
0364         data_input_filename,
0365         Plain_output_directory,
0366
0367         output_file_name_suffix,
0368
0369         data_ApplyAlphaCorr,
0370         ApplyGeoAccCorr,
0371
0372         isTypeA,
0373         vtxZ_range,
0374         SelectedMbin,
0375
0376         cut_DeltaPhi_Signal_range,
0377         data_setEtaRange,
0378         GeoAccCorr_directory,
0379         alpha_correction_input_directory
0380     );
0381
0382     if (RunComparison && PrepareAlphaCorr)
0383     {
0384         DataMcComp(data_dNdeta_file, MC1_dNdeta_file, Plain_output_directory, "DataMc1Comp.root");
0385         McMcComp(MC1_dNdeta_file, MC2_dNdeta_file, Plain_output_directory, "McMcComp.root");
0386         DataMcComp(data_dNdeta_file, MC2_dNdeta_file, Plain_output_directory, "DataMc2Comp.root");
0387     }
0388
0389     return {
0390         alpha_correction_input_directory,
0391         data_dNdeta_file
0392     };
0393
0394 }
0395
0396
0397 std::string GetFinalResult::Run_PreparedNdEtaEach(
0398   int process_id,
0399   int run_num,
0400   std::string input_directory,
0401   std::string input_filename,
0402   std::string output_directory,
0403
0404   // todo : modify here
0405   std::string output_file_name_suffix,
0406
0407   bool ApplyAlphaCorr,
0408   bool func_ApplyGeoAccCorr,
0409
0410   bool isTypeA,
0411   std::pair<double,double> cut_INTTvtxZ,
0412   int SelectedMbin,
0413
0414   std::pair<bool, std::pair<double,double>> setBkgRotated_DeltaPhi_Signal_range,
0415   std::pair<bool, std::pair<double,double>> setEtaRange,
0416   std::string GeoAccCorr_input_directory,
0417   std::string alpha_correction_input_directory
0418 )
0419 {
0420
0421     system(Form("if [ ! -d %s/completed ]; then mkdir -p %s/completed; fi;", output_directory.c_str(), output_directory.c_str()));
0422
0423   PreparedNdEtaEach * PNEE = new PreparedNdEtaEach(
0424     process_id,
0425     run_num,
0426     input_directory,
0427     input_filename,
0428     output_directory,
0429
0430     output_file_name_suffix,
0431
0432     ApplyAlphaCorr,
0433     func_ApplyGeoAccCorr,
0434
0435     isTypeA,
0436     cut_INTTvtxZ,
0437     SelectedMbin
0438   );
0439
0440   if (func_ApplyGeoAccCorr && GeoAccCorr_input_directory != no_map)
0441   {
0442     PNEE -> SetGeoAccCorrH2DMap(
0443       GetGeoAccCorrH2DMap(
0444         GeoAccCorr_input_directory,
0445         PNEE->GetGeoAccCorrNameMap()
0446       )
0447     );
0448   }
0449
0450   if (ApplyAlphaCorr && alpha_correction_input_directory != no_map)
0451   {
0452     PNEE -> SetAlphaCorrectionH1DMap(
0453       GetAlphaCorrectionH1DMap(
0454         alpha_correction_input_directory,
0455         PNEE->GetAlphaCorrectionNameMap()
0456       )
0457     );
0458   }
0459
0460   if (setEtaRange.first) {PNEE -> SetSelectedEtaRange(setEtaRange.second);}
0461
0462   if (setBkgRotated_DeltaPhi_Signal_range.first)
0463   {
0464     PNEE -> SetBkgRotated_DeltaPhi_Signal_range(setBkgRotated_DeltaPhi_Signal_range.second);
0465   }
0466
0467   std::vector<std::string> final_output_file_name = PNEE->GetOutputFileName();
0468   for (auto filename : final_output_file_name){
0469     cout<<"final_output_file_name: "<<filename<<endl;
0470     system(Form("if [ -f %s/completed/%s ]; then rm %s/completed/%s; fi;", output_directory.c_str(), filename.c_str(), output_directory.c_str(), filename.c_str()));
0471   }
0472
0473   std::cout<<000<<endl;
0474   PNEE -> PrepareStacks();
0475   std::cout<<111<<endl;
0476   PNEE -> DoFittings();
0477   std::cout<<222<<endl;
0478   PNEE -> PrepareMultiplicity();
0479   std::cout<<333<<endl;
0480   PNEE -> PreparedNdEtaHist();
0481   std::cout<<444<<endl;
0482   PNEE -> DeriveAlphaCorrection();
0483   std::cout<<555<<endl;
0484   PNEE -> EndRun();
0485
0486     std::string dNdEta_file_out;
0487
0488   for (auto filename : final_output_file_name){
0489     system(Form("mv %s/%s %s/completed", output_directory.c_str(), filename.c_str(), output_directory.c_str()));
0490
0491     if (filename.find("_dNdEta.root") != std::string::npos){
0492       dNdEta_file_out = output_directory + "/completed/" + filename;
0493     }
0494   }
0495
0496   std::cout<<"dNdEta_file_out: "<<dNdEta_file_out<<std::endl;
0497
0498     // note : testing
0499     delete PNEE;
0500
0501   return dNdEta_file_out;
0502 }
0503
0504 int GetFinalResult::DataMcComp(string data_directory_in, string MC_directory_in, string output_directory_in, string output_filename_in)
0505 {
0506     TFile * file_in_data = TFile::Open(data_directory_in.c_str());
0507     TFile * file_in_mc = TFile::Open(MC_directory_in.c_str());
0508
0509     TH1D * data_h1D_BestPair_RecoTrackletEtaPerEvt = (TH1D*)file_in_data->Get("h1D_BestPair_RecoTrackletEtaPerEvt");
0510     TH1D * data_h1D_RotatedBkg_RecoTrackletEtaPerEvt = (TH1D*)file_in_data->Get("h1D_RotatedBkg_RecoTrackletEtaPerEvt");
0511     TH1D * data_h1D_BestPair_RecoTrackletEtaPerEvtPostAC = (TH1D*)file_in_data->Get("h1D_BestPair_RecoTrackletEtaPerEvtPostAC");
0512     TH1D * data_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC = (TH1D*)file_in_data->Get("h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC");
0513
0514     data_h1D_BestPair_RecoTrackletEtaPerEvt -> SetMarkerColor(1);
0515     data_h1D_BestPair_RecoTrackletEtaPerEvt -> SetLineColor(1);
0516
0517     data_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> SetMarkerColor(1);
0518     data_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> SetLineColor(1);
0519
0520     data_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> SetMarkerColor(1);
0521     data_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> SetLineColor(1);
0522
0523     data_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> SetMarkerColor(1);
0524     data_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> SetLineColor(1);
0525
0526
0527
0528     TH1D * MC_h1D_BestPair_RecoTrackletEtaPerEvt = (TH1D*)file_in_mc->Get("h1D_BestPair_RecoTrackletEtaPerEvt");
0529     TH1D * MC_h1D_RotatedBkg_RecoTrackletEtaPerEvt = (TH1D*)file_in_mc->Get("h1D_RotatedBkg_RecoTrackletEtaPerEvt");
0530     TH1D * MC_h1D_BestPair_RecoTrackletEtaPerEvtPostAC = (TH1D*)file_in_mc->Get("h1D_BestPair_RecoTrackletEtaPerEvtPostAC");
0531     TH1D * MC_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC = (TH1D*)file_in_mc->Get("h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC");
0532
0533     MC_h1D_BestPair_RecoTrackletEtaPerEvt -> SetMarkerColor(2); // note : red
0534     MC_h1D_BestPair_RecoTrackletEtaPerEvt -> SetLineColor(2);
0535
0536     MC_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> SetMarkerColor(2);
0537     MC_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> SetLineColor(2);
0538
0539     MC_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> SetMarkerColor(2);
0540     MC_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> SetLineColor(2);
0541
0542     MC_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> SetMarkerColor(2);
0543     MC_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> SetLineColor(2);
0544
0545
0546
0547     TH1D * h1D_TruedNdEta = (TH1D*)file_in_mc->Get("h1D_TruedNdEta");
0548     h1D_TruedNdEta -> SetLineColor(3); // note : green
0549
0550
0551     TFile * file_out = new TFile(Form("%s/%s",output_directory_in.c_str(), output_filename_in.c_str()), "RECREATE");
0552     TCanvas * c1 = new TCanvas("c1", "c1", 800, 600);
0553
0554     c1 -> cd();
0555     data_h1D_BestPair_RecoTrackletEtaPerEvt -> Draw("ep");
0556     MC_h1D_BestPair_RecoTrackletEtaPerEvt -> Draw("hist same");
0557     c1 -> Write("h1D_BestPair_RecoTrackletEtaPerEvt");
0558     c1 -> Clear();
0559
0560     c1 -> cd();
0561     data_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> Draw("ep");
0562     MC_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> Draw("hist same");
0563     c1 -> Write("h1D_RotatedBkg_RecoTrackletEtaPerEvt");
0564     c1 -> Clear();
0565
0566     c1 -> cd();
0567     data_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> Draw("ep");
0568     MC_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> Draw("hist same");
0569     h1D_TruedNdEta -> SetFillColorAlpha(2,0);
0570     h1D_TruedNdEta -> Draw("hist same");
0571     c1 -> Write("h1D_BestPair_RecoTrackletEtaPerEvtPostAC");
0572     c1 -> Clear();
0573
0574     c1 -> cd();
0575     data_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> Draw("ep");
0576     MC_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> Draw("hist same");
0577     h1D_TruedNdEta -> Draw("hist same");
0578
0579     c1 -> Write("h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC");
0580     c1 -> Clear();
0581
0582     file_out -> Close();
0583
0584
0585
0586     return 0;
0587 }
0588
0589 int GetFinalResult::McMcComp(string MC1_directory_in, string MC2_directory_in, string output_directory_in, string output_filename_in)
0590 {
0591     TFile * file_in_mc1 = TFile::Open(MC1_directory_in.c_str());
0592     TFile * file_in_mc2 = TFile::Open(MC2_directory_in.c_str());
0593
0594     TH1D * MC1_h1D_BestPair_RecoTrackletEtaPerEvt = (TH1D*)file_in_mc1->Get("h1D_BestPair_RecoTrackletEtaPerEvt");
0595     TH1D * MC1_h1D_RotatedBkg_RecoTrackletEtaPerEvt = (TH1D*)file_in_mc1->Get("h1D_RotatedBkg_RecoTrackletEtaPerEvt");
0596     TH1D * MC1_h1D_BestPair_RecoTrackletEtaPerEvtPostAC = (TH1D*)file_in_mc1->Get("h1D_BestPair_RecoTrackletEtaPerEvtPostAC");
0597     TH1D * MC1_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC = (TH1D*)file_in_mc1->Get("h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC");
0598
0599     MC1_h1D_BestPair_RecoTrackletEtaPerEvt -> SetMarkerColor(1);
0600     MC1_h1D_BestPair_RecoTrackletEtaPerEvt -> SetLineColor(1);
0601
0602     MC1_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> SetMarkerColor(1);
0603     MC1_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> SetLineColor(1);
0604
0605     MC1_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> SetMarkerColor(1);
0606     MC1_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> SetLineColor(1);
0607
0608     MC1_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> SetMarkerColor(1);
0609     MC1_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> SetLineColor(1);
0610
0611     TH1D * MC1_h1D_TruedNdEta = (TH1D*)file_in_mc1->Get("h1D_TruedNdEta");
0612     MC1_h1D_TruedNdEta -> SetFillColorAlpha(1,0);
0613     MC1_h1D_TruedNdEta -> SetLineColor(4); // note : blue
0614
0615
0616
0617     TH1D * MC2_h1D_BestPair_RecoTrackletEtaPerEvt = (TH1D*)file_in_mc2->Get("h1D_BestPair_RecoTrackletEtaPerEvt");
0618     TH1D * MC2_h1D_RotatedBkg_RecoTrackletEtaPerEvt = (TH1D*)file_in_mc2->Get("h1D_RotatedBkg_RecoTrackletEtaPerEvt");
0619     TH1D * MC2_h1D_BestPair_RecoTrackletEtaPerEvtPostAC = (TH1D*)file_in_mc2->Get("h1D_BestPair_RecoTrackletEtaPerEvtPostAC");
0620     TH1D * MC2_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC = (TH1D*)file_in_mc2->Get("h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC");
0621
0622     MC2_h1D_BestPair_RecoTrackletEtaPerEvt -> SetMarkerColor(2);
0623     MC2_h1D_BestPair_RecoTrackletEtaPerEvt -> SetLineColor(2);
0624
0625     MC2_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> SetMarkerColor(2);
0626     MC2_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> SetLineColor(2);
0627
0628     MC2_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> SetMarkerColor(2);
0629     MC2_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> SetLineColor(2);
0630
0631     MC2_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> SetMarkerColor(2);
0632     MC2_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> SetLineColor(2);
0633
0634
0635
0636     TH1D * MC2_h1D_TruedNdEta = (TH1D*)file_in_mc2->Get("h1D_TruedNdEta");
0637     MC2_h1D_TruedNdEta -> SetFillColorAlpha(2,0);
0638     MC2_h1D_TruedNdEta -> SetLineColor(3); // note : green
0639
0640
0641     TFile * file_out = new TFile((output_directory_in+"/"+output_filename_in).c_str(), "RECREATE");
0642     TCanvas * c1 = new TCanvas("c1", "c1", 800, 600);
0643
0644     c1 -> cd();
0645     MC1_h1D_BestPair_RecoTrackletEtaPerEvt -> Draw("ep");
0646     MC2_h1D_BestPair_RecoTrackletEtaPerEvt -> Draw("hist same");
0647     c1 -> Write("h1D_BestPair_RecoTrackletEtaPerEvt");
0648     c1 -> Clear();
0649
0650     c1 -> cd();
0651     MC1_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> Draw("ep");
0652     MC2_h1D_RotatedBkg_RecoTrackletEtaPerEvt -> Draw("hist same");
0653     c1 -> Write("h1D_RotatedBkg_RecoTrackletEtaPerEvt");
0654     c1 -> Clear();
0655
0656     c1 -> cd();
0657     MC1_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> Draw("ep");
0658     MC2_h1D_BestPair_RecoTrackletEtaPerEvtPostAC -> Draw("hist same");
0659     MC2_h1D_TruedNdEta -> Draw("hist same");
0660     MC1_h1D_TruedNdEta -> Draw("hist same");
0661     c1 -> Write("h1D_BestPair_RecoTrackletEtaPerEvtPostAC");
0662     c1 -> Clear();
0663
0664     c1 -> cd();
0665     MC1_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> Draw("ep");
0666     MC2_h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC -> Draw("hist same");
0667     MC2_h1D_TruedNdEta -> Draw("hist same");
0668     MC1_h1D_TruedNdEta -> Draw("hist same");
0669     c1 -> Write("h1D_RotatedBkg_RecoTrackletEtaPerEvtPostAC");
0670     c1 -> Clear();
0671
0672     c1 -> cd();
0673     MC2_h1D_TruedNdEta -> Draw("hist");
0674     MC1_h1D_TruedNdEta -> Draw("ep same");
0675     c1 -> Write("h1D_TruedNdEta");
0676     c1 -> Clear();
0677
0678     file_out -> Close();
0679
0680
0681
0682     return 0;
0683 }
0684
0685
0686 std::map<std::string, TH1D*> GetFinalResult::GetAlphaCorrectionH1DMap(std::string alpha_correction_input_directory_in, std::vector<std::string> map_name_in){
0687
0688   TFile * file_in = TFile::Open(alpha_correction_input_directory_in.c_str());
0689   std::map<std::string, TH1D*> h1D_alpha_correction_map; h1D_alpha_correction_map.clear();
0690
0691
0692   for (TObject* keyAsObj : *file_in->GetListOfKeys()){
0693     auto key = dynamic_cast<TKey*>(keyAsObj);
0694     std::string hist_name  = key->GetName();
0695     std::string class_name = key->GetClassName();
0696
0697     if (class_name != "TH1D") {continue;}
0698     if (std::find(map_name_in.begin(), map_name_in.end(), hist_name) == map_name_in.end()) {continue;}
0699
0700     h1D_alpha_correction_map.insert(
0701       std::make_pair(
0702         hist_name,
0703         (TH1D*)file_in->Get(hist_name.c_str())
0704       )
0705     );
0706   }
0707
0708   for (auto &pair : h1D_alpha_correction_map){
0709     // pair.second->SetDirectory(0);
0710     std::cout << "alpha correction name : " << pair.first << std::endl;
0711   }
0712
0713   return h1D_alpha_correction_map;
0714 }
0715
0716
0717 std::map<std::string, TH2D*> GetFinalResult::GetGeoAccCorrH2DMap(std::string GeoAccCorr_input_directory_in, std::vector<std::string> map_name_in){
0718
0719   TFile * file_in = TFile::Open(GeoAccCorr_input_directory_in.c_str());
0720   std::map<std::string, TH2D*> h2D_GeoAccCorr_map; h2D_GeoAccCorr_map.clear();
0721
0722
0723   for (TObject* keyAsObj : *file_in->GetListOfKeys()){
0724     auto key = dynamic_cast<TKey*>(keyAsObj);
0725     std::string hist_name  = key->GetName();
0726     std::string class_name = key->GetClassName();
0727
0728     if (class_name != "TH2D") {continue;}
0729     if (std::find(map_name_in.begin(), map_name_in.end(), hist_name) == map_name_in.end()) {continue;}
0730
0731     h2D_GeoAccCorr_map.insert(
0732       std::make_pair(
0733         hist_name,
0734         (TH2D*)file_in->Get(hist_name.c_str())
0735       )
0736     );
0737   }
0738
0739   for (auto &pair : h2D_GeoAccCorr_map){
0740     // pair.second->SetDirectory(0);
0741     std::cout << "Geo Acc Corr map name : " << pair.first << std::endl;
0742   }
0743
0744   if (h2D_GeoAccCorr_map.size() == 0){
0745     std::cout << "Error : h2D_GeoAccCorr_map.size() == 0" << std::endl;
0746     exit(1);
0747   }
0748
0749   return h2D_GeoAccCorr_map;
0750 }