//Truth matching of MC data for the decay B+->Kst+mumu //david gerick //Renata Kopecna #include "GlobalFunctions.hh" #include "Design.hpp" #include "MassFit.hpp" #include "Paths.hpp" #include "TMsource.cpp" bool FixParameters = false; using namespace std; using namespace RooFit ; ////////////////////////////////////////////////////// /// MCtruth() /// compares the particleID of all reconstructed particles in the chain with the trueID /// ID-check of the (grand)mother particles will be performed! /// /// TruthMatchAll() /// run the MCtruth() for all four configurations of 2011/2012 and down/up /// /// PlotTruthMatchingEfficienciesToPDF() /// Take the four TGraphErrors from the TFile, plot them nicely into canvases and print it to pdf files in a dedicated folder! /// /// PlotAllTruthMatchingEfficienciesToPDF() /// The function name explains it all ;) /// Double_t YieldBeforeTruthMatching = 0., YieldAfterTruthMatching = 0.; Double_t YieldBeforeTruthMatchingErr = 0., YieldAfterTruthMatchingErr = 0.; //1: passed gammas (both), 2: one passed, one converted, 3: both converted, 4: one passed, one random, 5: one converted, one random, 6: both failed int passGammas(gamma_IDs gamma1, gamma_IDs gamma2, counters *counter, bool B_plus_TM, bool K_star_plus_TM, bool pi_zero_TM, bool gamma_TM, bool gamma_TM_full){ bool pass1 = gamma1.isGammaTrue(counter,gamma_TM,gamma_TM_full,pi_zero_TM,K_star_plus_TM,B_plus_TM); bool pass2 = gamma2.isGammaTrue(counter,gamma_TM,gamma_TM_full,pi_zero_TM,K_star_plus_TM,B_plus_TM); bool conv1 = gamma1.isGammaConversion(counter,gamma_TM,pi_zero_TM,K_star_plus_TM); bool conv2 = gamma2.isGammaConversion(counter,gamma_TM,pi_zero_TM,K_star_plus_TM); if (pass1 && pass2){ coutDebug("Both gammas passed."); return 1; } else{ if (pass1 || pass2){ if (conv1 || conv2){ coutDebug("One gamma passed, one is converted."); return 2; } else{ coutDebug("One gamma passed, one is random."); return 4; } } else{ if (conv1 && conv2){ coutDebug("Both gammas are converted."); return 3; } else{ if (conv1 || conv2){ coutDebug("One gamma is converted, one is random."); return 5; } else{ coutDebug("Both gammas failed."); return 6; } } } } } bool passAllTM(B_plus_IDs B_plus,K_star_IDs K_star,J_psi_IDs J_psi,mu_IDs mu_plus, mu_IDs mu_minus, K_plus_IDs K_plus,pi_zero_IDs pi_zero, K_short_IDs K_short,pi_plus_IDs pi_plus,Ks_pi_IDs Ks_pi_plus, Ks_pi_IDs Ks_pi_minus, counters *counter,double pi_zero_resolved_M, double B_plus_M, TH1D *h_pi0_mismatched_mass,TH1D *h_Bplus_M_pi0mismatched, TH1D *h_Bplus_M_noPi0Constr,TH1D *h_pi0_resolved_mass,TH1D *h_Bplus_M_pi0random, bool B_plus_TM, bool K_star_plus_TM, bool K_plus_TM, bool pi_zero_TM, bool mu_TM, bool J_psi_TM, bool pi_zero_TM_full ){ if(!B_plus.isBplus(counter,B_plus_TM)) return false; coutDebug("B+:\t passed"); if (!K_star.isKstar(counter,K_star_plus_TM, B_plus_TM))return false; coutDebug("K*:\t passed"); if (!J_psi.isJpsi(counter,J_psi_TM, B_plus_TM))return false; coutDebug("J/psi:\t passed"); if (!mu_plus.isMu(counter, mu_TM, J_psi_TM, B_plus_TM))return false; coutDebug("Mu+:\t passed"); if (!mu_minus.isMu(counter, mu_TM, J_psi_TM, B_plus_TM))return false; coutDebug("Mu-:\t passed"); if (Kst2Kspiplus){ if (!K_short.isKshort(counter)) return false; if (!pi_plus.isPiPlus(counter)) return false; if (!Ks_pi_plus.isKsPi(counter)) return false; if (!Ks_pi_minus.isKsPi(counter)) return false; } else if (Kst2Kpluspi0Resolved){ if (!K_plus.isKplus(counter, K_plus_TM, K_star_plus_TM, B_plus_TM))return false; coutDebug("K+:\t passed"); h_Bplus_M_noPi0Constr->Fill(B_plus_M); if (pi_zero_TM_full){ if (!pi_zero.isPi0(counter, pi_zero_TM, K_star_plus_TM, B_plus_TM, pi_zero_resolved_M, B_plus_M, h_pi0_mismatched_mass, h_Bplus_M_pi0mismatched, h_pi0_resolved_mass)){ h_Bplus_M_pi0random->Fill(B_plus_M); return false; } else coutDebug("pi0:\t passed"); } } return true; } Int_t MCtruth(string year = "2011", string magnet = "down", bool ReferenceChannel = false, bool PHSP = false, bool B0 = false, bool K1 = false, bool Inc = false) { gSystem->Load("./Design_cpp.so"); if(ReferenceChannel && PHSP){ coutWarning("Cannot set boolean of reference channel and phase-space MC at the same time! Process Reference Channel!"); PHSP = false; } //Load MC data from preselected TFile TChain * treeMC = new TChain("DecayTree"); string string_input = ""; if (B0 || K1 || Inc) string_input = GetInputFileBkg(year, magnet, true, ReferenceChannel, B0, K1, Inc); else string_input = GetInputFile(year,magnet,true,true,ReferenceChannel,PHSP,false); treeMC->Add(string_input.c_str()); //Save TMed data string string_output = ""; if (B0 || K1 || Inc) string_output = GetInputFileBkg(year, magnet, true, ReferenceChannel, B0, K1, Inc); else string_output = GetInputFile(year,magnet,true,true,ReferenceChannel,PHSP,false); replace(string_output,".root","_TM.root"); TFile * outputFile = outputFile = new TFile(string_output.c_str(), "RECREATE"); Int_t nEvents = treeMC->GetEntries(); if (nEvents==0){ coutERROR("No events in the tree! Exit."); return 0; } //BKGCAT branch Int_t BKGCAT = -10; B_plus_IDs B_plus_ID; K_star_IDs K_star_ID; J_psi_IDs J_psi_ID(ReferenceChannel); mu_IDs mu_plus_ID(ReferenceChannel); mu_IDs mu_minus_ID(ReferenceChannel); K_plus_IDs K_plus_ID; pi_zero_IDs pi_zero_ID; gamma_IDs gamma1_ID; gamma_IDs gamma2_ID; K_short_IDs K_short_ID; pi_plus_IDs pi_plus_ID; Ks_pi_IDs Ks_pi_plus_ID; Ks_pi_IDs Ks_pi_minus_ID; //link variables to branches if(UseBKGCAT){ treeMC -> SetBranchAddress( "B_plus_BKGCAT" , &BKGCAT ); } if (Kst2Kpluspi0Resolved){//I need control plots to check pi0 TM and so on treeMC -> SetBranchAddress( "B_plus_TRUEID" , &B_plus_ID.B_plus_TRUEID ); treeMC -> SetBranchAddress( "K_star_plus_TRUEID" , &K_star_ID.K_star_plus_TRUEID ); treeMC -> SetBranchAddress( "mu_plus_TRUEID" , &mu_plus_ID.mu_TRUEID ); treeMC -> SetBranchAddress( "mu_minus_TRUEID" , &mu_minus_ID.mu_TRUEID ); treeMC -> SetBranchAddress( "K_star_plus_MC_MOTHER_ID" , &K_star_ID.K_star_plus_MOTHER_ID ); treeMC -> SetBranchAddress( "mu_plus_MC_MOTHER_ID" , &mu_plus_ID.mu_MOTHER_ID ); treeMC -> SetBranchAddress( "mu_minus_MC_MOTHER_ID" , &mu_minus_ID.mu_MOTHER_ID ); treeMC -> SetBranchAddress( "mu_plus_MC_GD_MOTHER_ID" , &mu_plus_ID.mu_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "mu_minus_MC_GD_MOTHER_ID" , &mu_minus_ID.mu_GD_MOTHER_ID ); if(Kst2Kpluspi0Resolved){ treeMC -> SetBranchAddress( "B_plus_BKGCAT" , &BKGCAT ); treeMC -> SetBranchAddress( "K_plus_TRUEID" , &K_plus_ID.K_plus_TRUEID ); treeMC -> SetBranchAddress( "pi_zero_resolved_TRUEID" , &pi_zero_ID.pi_zero_TRUEID ); treeMC -> SetBranchAddress( "gamma1_TRUEID" , &gamma1_ID.gamma_TRUEID ); treeMC -> SetBranchAddress( "gamma2_TRUEID" , &gamma2_ID.gamma_TRUEID ); treeMC -> SetBranchAddress( "K_plus_MC_MOTHER_ID" , &K_plus_ID.K_plus_MOTHER_ID ); treeMC -> SetBranchAddress( "pi_zero_resolved_MC_MOTHER_ID", &pi_zero_ID.pi_zero_MOTHER_ID ); treeMC -> SetBranchAddress( "gamma1_MC_MOTHER_ID" , &gamma1_ID.gamma_MOTHER_ID ); treeMC -> SetBranchAddress( "gamma2_MC_MOTHER_ID" , &gamma2_ID.gamma_MOTHER_ID ); treeMC -> SetBranchAddress( "K_plus_MC_GD_MOTHER_ID" , &K_plus_ID.K_plus_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "pi_zero_resolved_MC_GD_MOTHER_ID", &pi_zero_ID.pi_zero_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "gamma1_MC_GD_MOTHER_ID" , &gamma1_ID.gamma_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "gamma2_MC_GD_MOTHER_ID" , &gamma2_ID.gamma_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "gamma1_MC_GD_GD_MOTHER_ID" , &gamma1_ID.gamma_GD_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "gamma2_MC_GD_GD_MOTHER_ID" , &gamma2_ID.gamma_GD_GD_MOTHER_ID ); } if(Kst2Kspiplus){ treeMC -> SetBranchAddress( "K_short_TRUEID" , &K_short_ID.K_short_TRUEID ); treeMC -> SetBranchAddress( "pi_plus_TRUEID" , &pi_plus_ID.pi_plus_TRUEID ); treeMC -> SetBranchAddress( "Ks_pi_plus_TRUEID" , &Ks_pi_plus_ID.Ks_pi_TRUEID ); treeMC -> SetBranchAddress( "Ks_pi_minus_TRUEID" , &Ks_pi_minus_ID.Ks_pi_TRUEID ); treeMC -> SetBranchAddress( "K_short_MC_MOTHER_ID" , &K_short_ID.K_short_MOTHER_ID ); treeMC -> SetBranchAddress( "pi_plus_MC_MOTHER_ID" , &pi_plus_ID.pi_plus_MOTHER_ID ); treeMC -> SetBranchAddress( "Ks_pi_plus_MC_MOTHER_ID" , &Ks_pi_plus_ID.Ks_pi_MOTHER_ID ); treeMC -> SetBranchAddress( "Ks_pi_minus_MC_MOTHER_ID" ,&Ks_pi_minus_ID.Ks_pi_MOTHER_ID ); treeMC -> SetBranchAddress( "K_short_MC_GD_MOTHER_ID" , &K_short_ID.K_short_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "pi_plus_MC_GD_MOTHER_ID" , &pi_plus_ID.pi_plus_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "Ks_pi_plus_MC_GD_MOTHER_ID" , &Ks_pi_plus_ID.Ks_pi_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "Ks_pi_minus_MC_GD_MOTHER_ID" , &Ks_pi_minus_ID.Ks_pi_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "Ks_pi_plus_MC_GD_GD_MOTHER_ID" , &Ks_pi_plus_ID.Ks_pi_GD_GD_MOTHER_ID ); treeMC -> SetBranchAddress( "Ks_pi_minus_MC_GD_GD_MOTHER_ID" , &Ks_pi_minus_ID.Ks_pi_GD_GD_MOTHER_ID ); } treeMC -> SetBranchAddress( "J_psi_TRUEID" , &J_psi_ID.J_psi_TRUEID ); treeMC -> SetBranchAddress( "J_psi_MC_MOTHER_ID" , &J_psi_ID.J_psi_MOTHER_ID ); } Int_t TRUE_events = 0; //counter for BKGCAT: Int_t BKGCAT_VETO[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; Int_t BKGCAT_TRUE[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //control plots for pi0 Double_t pi_zero_resolved_M = 0.0; if (Kst2Kpluspi0Resolved) treeMC -> SetBranchAddress( "pi_zero_resolved_M" , &pi_zero_resolved_M ); //Use either B mass from tuple or from DTF Double_t B_plus_M; UseDTF ? treeMC->SetBranchStatus( "B_plus_M_DTF", 1) : treeMC->SetBranchStatus( "B_plus_M", 1); UseDTF ? treeMC->SetBranchAddress("B_plus_M_DTF", &B_plus_M): treeMC->SetBranchAddress("B_plus_M", &B_plus_M); //Control pi0 histograms TH1D * h_pi0_resolved_mass = generalHistogram("h_pi0_resolved_mass" , "m_{#pi^{0}} resolved", 70, 100, 170, "m_{pi^{0}} resolved [MeV]", "Counts / 1MeV", kBlue); TH1D * h_pi0_mismatched_mass= generalHistogram("h_pi0_mismatched_mass" , "m_{#pi^{0}} IDed as gamma", 70, 100, 170, "m_{pi^{0}}[MeV] MisIDed", "Counts / 1MeV", kRed); //Control B+ mass for pi0 correctly/wrong/no matched TH1D * h_Bplus_M_pi0mismatched= BmassHistogram("", "m_{B^{+}}, #pi^{0} not #pi^{0}", "m_{B^{+}}[MeV] mismatched #pi^{0}",kRed); TH1D * h_Bplus_M_pi0random = BmassHistogram("h_Bplus_M_pi0random", "m_{B^{+}}, #pi^{0} random", "m_{B^{+}}[MeV] random #pi^{0}",kBlue); TH1D * h_Bplus_M_noPi0Constr = BmassHistogram("h_Bplus_M_noPi0Constr", "m_{B^{+}}, no #pi^{0} TM", "m_{B^{+}}[MeV], no #pi^{0} TM",kBlack); TH1D * h_Bplus_M_TM_BKGCAT = BmassHistogram("h_Bplus_M_TM_BKGCAT", "m_{B^{+}} TMed", "m_{B^{+}}[MeV] TMed(BKG CAT)",kGreen+2); TH1D * h_Bplus_M_TMed = BmassHistogram("h_Bplus_M_TMed", "m_{B^{+}} TMed", "m_{B^{+}}[MeV] TMed",kGreen+2); TH1D * h_Bplus_M_TMed_noPi0 = BmassHistogram("h_Bplus_M_TMed_noPi0", "m_{B^{+}} TMed, no #pi^{0}", "m_{B^{+}}[MeV] TMed, no #pi^{0}",kGreen+2); TH1D * h_Bplus_M_TMed_noPi0_noBplus = BmassHistogram("h_Bplus_M_TMed_noPi0_noBplus", "m_{B^{+}} TMed, no #pi^{0}, B^{+}", "m_{B^{+}}[MeV] TMed, no #pi^{0}, B^{+}",kGreen+2); TH1D * h_Bplus_M_TMed_noPi0_noKst_noBplus= BmassHistogram("h_Bplus_M_TMed_noPi0_noKst_noBplus", "m_{B^{+}} TMed, no #pi^{0}, K^{*}, B^{+}", "m_{B^{+}}[MeV] TMed, no #pi^{0}, K^{*}, B^{+}",kGreen+2); TH1D * h_Bplus_M_notTM_BKGCAT = BmassHistogram("h_Bplus_M_notTM_BKGCAT", "m_{B^{+}} not TMed", "m_{B^{+}}[MeV] not TMed(BKG CAT)",kRed); TH1D * h_Bplus_M_notTMed = BmassHistogram("h_Bplus_M_notTMed", "m_{B^{+}} not TMed", "m_{B^{+}}[MeV] not TMed",kRed); TH1D * h_Bplus_M_notTMed_noPi0 = BmassHistogram("h_Bplus_M_notTMed_noPi0", "m_{B^{+}} not TMed, no #pi^{0}", "m_{B^{+}}[MeV] not TMed, no #pi^{0}",kRed); TH1D * h_Bplus_M_notTMed_noPi0_noBplus = BmassHistogram("h_Bplus_M_notTMed_noPi0_noBplus", "m_{B^{+}} not TMed, no #pi^{0}, B^{+},", "m_{B^{+}}[MeV] not TMed, no #pi^{0}, B^{+}",kRed); TH1D * h_Bplus_M_notTMed_noPi0_noKst_noBplus= BmassHistogram("h_Bplus_M_notTMed_noPi0_noKst_noBplus", "m_{B^{+}} not TMed, no #pi^{0}, K^{*}, B^{+}", "m_{B^{+}}[MeV] not TMed, no #pi^{0}, K^{*}, B^{+}",kRed); TH1D * h_Bplus_M_all = BmassHistogram("h_Bplus_M_all", "m_{B^{+}} ", "m_{B^{+}}[MeV] preSel", kBlack); //TMP empty histogram (filled when running over not pi0 TM) TH1D * h_Bplus_M_tmp = BmassHistogram("h_Bplus_M_tmp", "m_{B^{+}}", "m_{B^{+}}[MeV]",kBlack); //control PID plots TH1D * h_B_plus_TRUEID = new TH1D("h_B_plus_TRUEID", "B^{+} TRUEID", 100000, -1, 99999); TH1D * h_K_star_plus_TRUEID = new TH1D("h_K_star_plus_TRUEID", "K^{*+} TRUEID", 100000, -1, 99999); TH1D * h_K_plus_TRUEID = new TH1D("h_K_plus_TRUEID", "K^{+} TRUEID", 100000, -1, 99999); TH1D * h_pi_zero_TRUEID = new TH1D("h_pi_zero_TRUEID", "#pi^{0} TRUEID", 100000, -1, 99999); TH1D * h_gamma_TRUEID = new TH1D("h_gamma_TRUEID", "#gamma TRUEID", 100000, -1, 99999); TTree * treeTruthMatched = treeMC->CloneTree(0); treeTruthMatched->SetName("DecayTreeTruthMatched"); //If needed to save the eents into a new file (when adding branches such as TMed), uncomment //TMed branch //0: didn't pass TM,1: passed TM Int_t iTMed = -1; treeTruthMatched->Branch("TMed", &iTMed, "iTMed/I"); Int_t iTMedBKGCAT = -1; treeTruthMatched->Branch("TMedBKGCAT", &iTMedBKGCAT, "iTMedBKGCAT/I"); Int_t iTMed_noPi0 = -1; if (!KshortChannel) treeTruthMatched->Branch("TMed_noPi0", &iTMed_noPi0, "iTMed_noPi0/I"); Int_t iTMed_noPi0_noBplus = -1; if (!KshortChannel) treeTruthMatched->Branch("TMed_noPi0_noBplus", &iTMed_noPi0_noBplus, "iTMed_noPi0_noBplus/I"); Int_t iTMed_noPi0_noKst_noBplus = -1; if (!KshortChannel) treeTruthMatched->Branch("TMed_noPi0_noKst_noBplus", &iTMed_noPi0_noKst_noBplus, "iTMed_noPi0_noKst_noBplus/I"); //1: passed gammas (both), 2: one passed, one converted, 3: both converted, 4: one passed, one random, 5: one converted, one random, 6: both failed Int_t TM_gammas = -1; if (!KshortChannel) treeTruthMatched->Branch("TM_gammas", &TM_gammas, "TM_gammas/I"); Int_t TM_gammas_noPi0 = -1; if (!KshortChannel) treeTruthMatched->Branch("TM_gammas_noPi0", &TM_gammas_noPi0, "TM_gammas_noPi0/I"); Int_t TM_gammas_noPi0_noBplus = -1; if (!KshortChannel) treeTruthMatched->Branch("TM_gammas_noPi0_noBplus", &TM_gammas_noPi0_noBplus, "TM_gammas_noPi0_noBplus/I"); Int_t TM_gammas_noPi0_noKst_noBplus= -1; if (!KshortChannel) treeTruthMatched->Branch("TM_gammas_noPi0_noKst_noBplus", &TM_gammas_noPi0_noKst_noBplus, "TM_gammas_noPi0_noKst_noBplus/I"); //initialize VETO counters counters veto_counters; counters veto_counters_noPi0; counters veto_counters_noPi0_noBplus; counters veto_counters_noPi0_noKst_noBplus; //MC loop coutInfo("Truth matching of " + to_string(nEvents) + " MC events for " + year + magnet + "."); for(int i = 0; i < nEvents; i++){ if(i%2000==0 && i != 0)coutDebug("Loading MC event "+to_string(i) +" / " +to_string(nEvents)); treeMC->GetEntry(i); h_Bplus_M_all->Fill(B_plus_M); //Check the BKGCAT category and fill control histograms if (isBKGCAT(BKGCAT,ReferenceChannel)){ BKGCAT_TRUE[BKGCAT/10]++; iTMedBKGCAT = 1; TRUE_events++; h_Bplus_M_TM_BKGCAT->Fill(B_plus_M); } else{ BKGCAT_VETO[BKGCAT/10]++; iTMedBKGCAT = 0; h_Bplus_M_notTM_BKGCAT->Fill(B_plus_M); } //====================================== //check all particles for correct TRUEID //====================================== if (B0 || K1){ //TODO } else{ if (Inc){ h_B_plus_TRUEID ->Fill(TMath::Abs(B_plus_ID.B_plus_TRUEID)); h_K_star_plus_TRUEID->Fill(TMath::Abs(K_star_ID.K_star_plus_TRUEID)); h_K_plus_TRUEID ->Fill(TMath::Abs(K_plus_ID.K_plus_TRUEID)); h_pi_zero_TRUEID ->Fill(TMath::Abs(pi_zero_ID.pi_zero_TRUEID)); } iTMed = passAllTM(B_plus_ID,K_star_ID,J_psi_ID,mu_plus_ID,mu_minus_ID, K_plus_ID,pi_zero_ID, K_short_ID,pi_plus_ID,Ks_pi_plus_ID,Ks_pi_minus_ID, &veto_counters, pi_zero_resolved_M, B_plus_M, h_pi0_mismatched_mass,h_Bplus_M_pi0mismatched, h_Bplus_M_noPi0Constr, h_pi0_resolved_mass, h_Bplus_M_pi0random, true, true, true, true, true, true, true); iTMed_noPi0 = passAllTM(B_plus_ID,K_star_ID,J_psi_ID,mu_plus_ID,mu_minus_ID, K_plus_ID,pi_zero_ID, K_short_ID,pi_plus_ID,Ks_pi_plus_ID,Ks_pi_minus_ID, &veto_counters_noPi0, pi_zero_resolved_M, B_plus_M, h_pi0_mismatched_mass,h_Bplus_M_pi0mismatched, h_Bplus_M_tmp, h_pi0_resolved_mass, h_Bplus_M_tmp, true, true, true, false, true, true, false); iTMed_noPi0_noBplus = passAllTM(B_plus_ID,K_star_ID,J_psi_ID,mu_plus_ID,mu_minus_ID, K_plus_ID,pi_zero_ID, K_short_ID,pi_plus_ID,Ks_pi_plus_ID,Ks_pi_minus_ID, &veto_counters_noPi0_noBplus, pi_zero_resolved_M, B_plus_M, h_pi0_mismatched_mass,h_Bplus_M_pi0mismatched, h_Bplus_M_tmp, h_pi0_resolved_mass, h_Bplus_M_tmp, false, true, true, false, true, true, true); iTMed_noPi0_noKst_noBplus= passAllTM(B_plus_ID,K_star_ID,J_psi_ID,mu_plus_ID,mu_minus_ID, K_plus_ID,pi_zero_ID, K_short_ID,pi_plus_ID,Ks_pi_plus_ID,Ks_pi_minus_ID, &veto_counters_noPi0_noKst_noBplus, pi_zero_resolved_M, B_plus_M, h_pi0_mismatched_mass,h_Bplus_M_pi0mismatched, h_Bplus_M_tmp, h_pi0_resolved_mass, h_Bplus_M_tmp, false, false, true, false, true, true, true); } if (Kst2Kpluspi0Resolved){ TM_gammas = passGammas(gamma1_ID,gamma2_ID,&veto_counters, true,true,true,true,true); TM_gammas_noPi0 = passGammas(gamma1_ID,gamma2_ID,&veto_counters, true,true,false,true,true); TM_gammas_noPi0_noBplus = passGammas(gamma1_ID,gamma2_ID,&veto_counters, false,true,false,true,true); TM_gammas_noPi0_noKst_noBplus =passGammas(gamma1_ID,gamma2_ID,&veto_counters, false,false,false,true,true); } if (iTMed) h_Bplus_M_TMed->Fill(B_plus_M); else h_Bplus_M_notTMed->Fill(B_plus_M); if (iTMed_noPi0) h_Bplus_M_TMed_noPi0->Fill(B_plus_M); else h_Bplus_M_notTMed_noPi0->Fill(B_plus_M); if (iTMed_noPi0_noBplus) h_Bplus_M_TMed_noPi0_noBplus->Fill(B_plus_M); else h_Bplus_M_notTMed_noPi0_noBplus->Fill(B_plus_M); if (iTMed_noPi0_noKst_noBplus) h_Bplus_M_TMed_noPi0_noKst_noBplus->Fill(B_plus_M); else h_Bplus_M_notTMed_noPi0_noKst_noBplus->Fill(B_plus_M); treeTruthMatched->Fill(); }//loop over events end //output truthmatching results coutInfo("Resulting TruthMatching data: " + to_string(TRUE_events) + "/" + to_string(nEvents) + " are found to be correctly reconstructed!" ); coutInfo("For the sample: " + year + " " + magnet + ":\t" + (ReferenceChannel ? "JpsiChannel" : (PHSP ? "PHSP" : "Signal")) + " MC events" ); coutInfo("The following BKGCAT have been found in the sample:" ); coutInfo("BKGCAT\tAccepted\tRejected\tTotal"); for(int i = 0; i < 20; i++){ if(BKGCAT_VETO[i] != 0 || BKGCAT_TRUE[i] != 0){ coutInfo(to_string(i*10) + "\t" + to_string(BKGCAT_TRUE[i]) + "\t\t" + to_string(BKGCAT_VETO[i]) + "\t\t" + to_string(BKGCAT_TRUE[i]+BKGCAT_VETO[i]) ); } } veto_counters.printCounters(B0,K1); veto_counters_noPi0.printCounters(false,false); veto_counters_noPi0_noBplus.printCounters(false,false); veto_counters_noPi0_noKst_noBplus.printCounters(false,false); if(!outputFile->IsOpen()){ coutERROR("ile was not opened succesfully!"); return 0; } outputFile->cd(); treeTruthMatched->Write("",TObject::kWriteDelete); if (Kst2Kpluspi0Resolved){ //Save hists into a file string path = GetInputFile(year,magnet,true,true,ReferenceChannel,PHSP, false); replace(path,".root", "_TMcontrolPlots.root"); TFile *controlHists = new TFile(path.c_str(),"RECREATE"); gROOT->SetBatch(kTRUE); controlHists->cd(); h_Bplus_M_pi0mismatched->Write("",TObject::kWriteDelete); h_Bplus_M_pi0random->Write("",TObject::kWriteDelete); h_Bplus_M_noPi0Constr->Write("",TObject::kWriteDelete); h_Bplus_M_TM_BKGCAT->Write("",TObject::kWriteDelete); h_Bplus_M_notTM_BKGCAT->Write("",TObject::kWriteDelete); h_Bplus_M_TMed->Write("",TObject::kWriteDelete); h_Bplus_M_notTMed->Write("",TObject::kWriteDelete); h_Bplus_M_TMed_noPi0->Write("",TObject::kWriteDelete); h_Bplus_M_notTMed_noPi0->Write("",TObject::kWriteDelete); h_Bplus_M_TMed_noPi0_noBplus->Write("",TObject::kWriteDelete); h_Bplus_M_notTMed_noPi0_noBplus->Write("",TObject::kWriteDelete); h_Bplus_M_TMed_noPi0_noKst_noBplus->Write("",TObject::kWriteDelete); h_Bplus_M_notTMed_noPi0_noKst_noBplus->Write("",TObject::kWriteDelete); h_Bplus_M_all->Write("",TObject::kWriteDelete); if (Inc){ h_B_plus_TRUEID->Write("",TObject::kWriteDelete); h_K_star_plus_TRUEID->Write("",TObject::kWriteDelete); h_K_plus_TRUEID->Write("",TObject::kWriteDelete); h_pi_zero_TRUEID->Write("",TObject::kWriteDelete); h_gamma_TRUEID->Write("",TObject::kWriteDelete); } h_pi0_mismatched_mass->Write("",TObject::kWriteDelete); h_pi0_resolved_mass->Write("",TObject::kWriteDelete); //Draw and save TM_canvas("Check_pi0", h_pi0_resolved_mass,h_pi0_mismatched_mass, h_pi0_mismatched_mass, year,ReferenceChannel,PHSP, B0, K1, Inc); TM_canvas("BKGCAT", h_Bplus_M_all,h_Bplus_M_TM_BKGCAT, h_Bplus_M_notTM_BKGCAT, year,ReferenceChannel,PHSP, B0, K1, Inc); TM_canvas("TMed", h_Bplus_M_all,h_Bplus_M_TMed, h_Bplus_M_notTMed, year,ReferenceChannel,PHSP, B0, K1, Inc); TM_canvas("TMed_noPi0", h_Bplus_M_all,h_Bplus_M_TMed_noPi0, h_Bplus_M_notTMed_noPi0, year,ReferenceChannel,PHSP, B0, K1, Inc); TM_canvas("TMed_noPi0_noBplus", h_Bplus_M_all,h_Bplus_M_TMed_noPi0_noBplus, h_Bplus_M_notTMed_noPi0_noBplus, year,ReferenceChannel,PHSP, B0, K1, Inc); TM_canvas("TMed_noPi0_noKst_noBplus", h_Bplus_M_all,h_Bplus_M_TMed_noPi0_noKst_noBplus,h_Bplus_M_notTMed_noPi0_noKst_noBplus, year,ReferenceChannel,PHSP, B0, K1, Inc); controlHists->Close(); } delete h_Bplus_M_pi0mismatched; delete h_Bplus_M_pi0random; delete h_Bplus_M_noPi0Constr; delete h_Bplus_M_all; delete h_Bplus_M_TM_BKGCAT; delete h_Bplus_M_notTM_BKGCAT; delete h_Bplus_M_TMed; delete h_Bplus_M_notTMed; delete h_Bplus_M_TMed_noPi0; delete h_Bplus_M_notTMed_noPi0; delete h_Bplus_M_TMed_noPi0_noBplus; delete h_Bplus_M_notTMed_noPi0_noBplus; delete h_Bplus_M_TMed_noPi0_noKst_noBplus; delete h_Bplus_M_notTMed_noPi0_noKst_noBplus; delete h_B_plus_TRUEID; delete h_K_star_plus_TRUEID; delete h_K_plus_TRUEID; delete h_pi_zero_TRUEID; delete h_gamma_TRUEID; delete h_pi0_mismatched_mass; delete h_pi0_resolved_mass; delete treeMC; delete treeTruthMatched; outputFile->Close(); string command = "mv " + string_input + " "; replace(string_input,".root","_TMbackup.root"); command += string_input; system(command.c_str()); replace(string_input,"_TMbackup.root",".root"); command = "mv " + string_output + " " + string_input; system(command.c_str()); coutInfo("Finished Truth-Matching for sample: " + year + " " + magnet + " : " + TheDecay + (ReferenceChannel ? " RefMC" : (PHSP ? " PHSP MC" : " ") ) ); return 1; } bool restore_from_backup(string year = "2011", string magnet = "down", bool ReferenceChannel = false, bool PHSP = false, bool B0 = false, bool K1 = false, bool Inc = false){ //In case one needs to rerun the TruthMatching string string_input = ""; if (B0 || K1 || Inc) string_input = GetInputFileBkg(year, magnet, true, ReferenceChannel, B0, K1, Inc); else string_input = GetInputFile(year,magnet,true,true,ReferenceChannel,PHSP,false); replace(string_input,".root","_TMbackup.root"); string command = "mv " + string_input + " "; replace(string_input,"_TMbackup.root",".root"); command += string_input; coutDebug(command); system(command.c_str()); coutInfo("Succesfully restored all MC for " + TheDecay + (ReferenceChannel ? " (Reference channel)" : "") + " in year " + year); return 1; } bool restore_allyears_from_backup(int Run = 1, bool Reference = false, bool PHSP = false, bool B0 = false, bool K1 = false, bool Inc = false){ std::vector years = (B0 || K1 || Inc) ? yearsBkgMC(Reference, B0, K1, Inc, Run) : yearsMC(Reference,PHSP,Run); if (years.empty()){ coutERROR("Invalid Run number given: " + to_string(Run) + ". Exit program!"); return 0; } for(unsigned int y = 0; y < years.size(); y++){ if(restore_from_backup(years.at(y),"down", Reference, PHSP, B0, K1, Inc) == 0){ coutERROR("Failed to restore " + years.at(y) + " magnet DOWN for " + TheDecay + getDataTypeTag(true, Reference, PHSP, B0, K1, Inc) + " from backup"); return 0; } if(restore_from_backup(years.at(y),"up", Reference, PHSP, B0, K1, Inc) == 0){ coutERROR("Failed to restore " + years.at(y) + " magnet UP for " + TheDecay + getDataTypeTag(true, Reference, PHSP, B0, K1, Inc) +" from backup"); return 0; } coutInfo("Sucesfully restored " + years.at(y) + " magnet UP for " + TheDecay + getDataTypeTag(true, Reference, PHSP, B0, K1, Inc) +" from backup"); } return 1; } bool restore_all_from_backup(){ if (restore_allyears_from_backup(12, false, false, false, false, false) ==0){ coutERROR("Failed to restore signal MC from backup!"); return 0; } if (restore_allyears_from_backup(12, true, false, false, false, false) ==0){ coutERROR("Failed to restore reference MC from backup!"); return 0; } if (restore_allyears_from_backup(12, false, true, false, false, false) ==0){ coutERROR("Failed to restore PHSP MC from backup!"); return 0; } coutInfo("Succesfully restored all MC for alls samples!"); return 1; } Int_t TruthMatchAllBkg(bool Reference = false, Int_t Run = 1, bool B0 = false, bool K1 = false, bool Inc = false){ std::vector years = yearsBkgMC(Reference,B0,K1,Inc,Run); if (years.empty()){ coutERROR("Invalid Run number given: " + to_string(Run) + ". Exit program!"); return 0; } for(unsigned int y = 0; y < years.size(); y++){ if(MCtruth(years.at(y),"down", Reference, false, B0, K1, Inc) == 0){ coutERROR("Failed to process " + years.at(y) + " magnet DOWN for " + TheDecay+ getDataTypeTag(true, Reference, false, B0, K1, Inc) + " from backup"); return 0; } if(MCtruth(years.at(y),"up", Reference, false, B0, K1, Inc) == 0){ coutERROR("Failed to process " + years.at(y) + " magnet UP for " + TheDecay + getDataTypeTag(true, Reference, false, B0, K1, Inc) + " from backup"); return 0; } } coutInfo("Succesfully finished all truth-matching for " + TheDecay + getDataTypeTag(true, Reference, false, B0, K1, Inc) + " in Run" + to_string(Run)); return 1; } Int_t TruthMatchAll(bool Reference = false, bool PHSP = false, Int_t Run = 1){ std::vector years = yearsMC(Reference,PHSP,Run); if (years.empty()){ coutERROR("Invalid Run number given: " + to_string(Run) + ". Exit program!"); return 0; } for(unsigned int y = 0; y < years.size(); y++){ if(MCtruth(years.at(y),"down", Reference, PHSP, false, false, false) == 0){ coutERROR("Failed to process " + years.at(y) + " magnet DOWN for " + TheDecay + getDataTypeTag(true, Reference, PHSP, false, false, false) + " from backup"); return 0; } if(MCtruth(years.at(y),"up", Reference, PHSP, false, false, false) == 0){ coutERROR("Failed to process " + years.at(y) + " magnet UP for " + TheDecay + getDataTypeTag(true, Reference, PHSP, false, false, false) + " from backup"); return 0; } } coutInfo("Succesfully finished all truth-matching for " + TheDecay + getDataTypeTag(true, Reference, PHSP, false, false, false) + " in Run" + to_string(Run)); return 1; } Int_t TruthMatchAllAll(Int_t Run){ if (TruthMatchAll(false, false, Run) ==0) return 0; if (TruthMatchAll(true, false, Run) ==0) return 0; if (TruthMatchAll(false, true, Run) ==0) return 0; return 1; } //This is a reliq from the TM issue we had back in the day in DaVinci, not really used now Int_t CombinePolarityPi0MisID(string year ="2011", bool ReferenceChannel = false, bool PHSP = false){ gROOT->SetBatch(kTRUE); string filePath = ""; //Define combined TH1 and make it pretty TH1D * h_Bplus_M_pi0mismatched= new TH1D("h_Bplus_M_pi0mismatched" , "m_{B^{+}}, #pi^{0} not TMed", 100, cut_B_plus_M_low, cut_B_plus_M_high); TCanvas *canvas_B = new TCanvas("canvas", "#pi^0 TM check", 10,10, 1200,600); design_canvas_Bmass(canvas_B,"#pi^0 TM check"); int counts = (cut_B_plus_M_high-cut_B_plus_M_low)/100; design_lines(h_Bplus_M_pi0mismatched,"m_{B^{+}}, #pi^{0} not TMed","Counts / " + to_string(counts)+"MeV",kRed+1); h_Bplus_M_pi0mismatched->GetYaxis()->SetTitleOffset(0.7); string Magnets[] = {"down", "up"}; //Loop over polarities and load the histograms for(string & magnet : Magnets){ //loop over both magnet polaritys string path = GetInputFile(year,magnet,true,true,ReferenceChannel,PHSP, false); replace(path,".root", "_TMcontrolPlots.root"); TFile *file = TFile::Open(path.c_str()); TH1D *tmp = (TH1D*)file->Get("h_Bplus_M_pi0mismatched"); h_Bplus_M_pi0mismatched->Add(tmp); file->Close(); } //Save the combined TH1 in a canvas canvas_B->cd(); h_Bplus_M_pi0mismatched->Draw(); filePath = "./../../data/figures/pi0TM/" + year + (ReferenceChannel ? "_Ref":"") + (PHSP ? "_PHSP":"") + "_Bmass"; string adr = filePath + ".eps"; canvas_B->Print(adr.c_str(), "eps"); adr = filePath + ".root"; canvas_B->Print(adr.c_str(), "root"); return 1; } //Also obsolete (see one function up) Int_t CombineYearsPi0MisID(Int_t Run =1, bool ReferenceChannel = false, bool PHSP = false){ gROOT->SetBatch(kTRUE); string filePath = ""; //Define combined TH1 and make it pretty TH1D * h_Bplus_M_pi0mismatched= new TH1D("h_Bplus_M_pi0mismatched" , "m_{B^{+}}, #pi^{0} not TMed", 100, cut_B_plus_M_low, cut_B_plus_M_high); TCanvas *canvas_B = new TCanvas("canvas", "#pi^0 TM check", 10,10, 1200,600); design_canvas_Bmass(canvas_B,"#pi^0 TM check"); int counts = (cut_B_plus_M_high-cut_B_plus_M_low)/100; design_lines(h_Bplus_M_pi0mismatched,"m_{B^{+}}, #pi^{0} not TMed","Counts / " + to_string(counts)+"MeV",kRed+1); h_Bplus_M_pi0mismatched->GetYaxis()->SetTitleOffset(0.7); //Loop over years and polarities, load the histograms std::vector years; if(Run == 1){ years.push_back("2011"); years.push_back("2012"); } if(Run == 2){ years.push_back("2015"); years.push_back("2016"); if(Use2017 && !ReferenceChannel)years.push_back("2017"); if(Use2018 && !ReferenceChannel)years.push_back("2018"); } string Magnets[] = {"down", "up"}; for(unsigned int y = 0; y < years.size(); y++){ //loop over all years for(string & magnet : Magnets){ //loop over both magnet polaritys string path = GetInputFile(years.at(y),magnet,true,true,ReferenceChannel,PHSP, false); replace(path,".root", "_TMcontrolPlots.root"); TFile *file = TFile::Open(path.c_str()); TH1D *tmp = (TH1D*)file->Get("h_Bplus_M_pi0mismatched"); h_Bplus_M_pi0mismatched->Add(tmp); file->Close(); } } //Save the combined TH1 in a canvas canvas_B->cd(); h_Bplus_M_pi0mismatched->Draw(); filePath = "./../../data/figures/pi0TM/Run" + to_string(Run) + (ReferenceChannel ? "_Ref":"") + (PHSP ? "_PHSP":"") + "_Bmass"; string adr = filePath + ".eps"; canvas_B->Print(adr.c_str(), "eps"); adr = filePath + ".root"; canvas_B->Print(adr.c_str(), "root"); return 1; }