kopecna/EWP-BplusToKstMuMu-AngAna
kopecna/EWP-BplusToKstMuMu-AngAna
2
1
Fork 0
Code Issues Pull Requests repo.project_board Releases Wiki Activity
94acfa56a1
EWP-BplusToKstMuMu-AngAna/Code/Scripts/Selection/sWeightSelection.cc

1343 lines
54 KiB
C++
Raw Normal View History

First commit, not including the most of the Codes/ folder
2022-02-10 15:49:54 +01:00
#include "../GlobalFunctions.hh"
#include "../Paths.hpp"
#include <algorithm> //Finding stuff in a vector
//////////////////////////////////////////////////////////////////////
/// sWeightSelection()
/// loops over all .root-files created by BDT selection. More kinematic, PID and
/// some more cuts are applied and saved in new file.
///
int sWeightSelection(bool useOld = false, std::string year = "2011", std::string magnet = "down", bool MC = false, bool ReferenceChannel = false, bool PHSP = false) {
TFile* input = 0;
TFile* output_new = 0;
TFile* output_old = 0;
TTree *tree;
if (PHSP) MC = true; //phase-space is always MC
string input_path = GetInputFile(year,magnet,true,MC,ReferenceChannel,PHSP,false);
coutDebug("input_path: " + input_path);
string output_new_path = GetInputFile(year,magnet,true,MC,ReferenceChannel,PHSP,false);
replace(output_new_path,".root","_tmp.root");
string output_old_path = GetInputFile(year,magnet,true,MC,ReferenceChannel,PHSP,false);
replace(output_old_path,".root","_old.root");
input = new TFile(input_path.c_str(),"UPDATE");
output_new = new TFile(output_new_path.c_str(),"RECREATE");
output_old = new TFile(output_old_path.c_str(),useOld ? "UPDATE" : "RECREATE");
if (useOld) tree = (TTree*)output_old->Get("DecayTree");
else tree = (TTree*)input->Get("DecayTree");
tree->SetBranchStatus("*",1);
//copy old tree into a backup
output_old->cd();
TTree *cpTree = tree->CloneTree();
if (!cpTree) coutERROR("Tree not cloned!");
else coutDebug("Tree copied!");
cpTree->Write("",TObject::kOverwrite); //copy old trees into a backup; prevent duplicate writting
if (!useOld) output_old->Close();
vector<std::string> Cuts;
// Kst2Kpluspi0Resolved Cuts
if(Kst2Kpluspi0Resolved){
//don't copy old cone variables
tree->SetBranchStatus("*_1.00",0);
tree->SetBranchStatus("*_0.90",0);
tree->SetBranchStatus("*_0.80",0);
tree->SetBranchStatus("*_0.70",0);
tree->SetBranchStatus("*_0.60",0);
tree->SetBranchStatus("*_0.50",0);
Cuts.push_back("K_plus_ProbNNk > 0.25");
//Cuts.push_back("gamma1_PT_DTF < 4000");
//Cuts.push_back("gamma2_PT_DTF < 4000");
//Cuts.push_back("log(1.0-B_plus_DIRA_OWNPV) > -20");
}
// Kst2Kpluspi0Merged cuts
if(Kst2Kpluspi0Merged){
//don't copy old cone variables
tree->SetBranchStatus("*_1.00",0);
tree->SetBranchStatus("*_0.90",0);
tree->SetBranchStatus("*_0.80",0);
tree->SetBranchStatus("*_0.70",0);
tree->SetBranchStatus("*_0.60",0);
tree->SetBranchStatus("*_0.50",0);
//#TODO
}
// Kst2Kspiplus cuts
if(Kst2Kspiplus){
//#TODO
}
std::string AllCuts = "";
if (Cuts.size()==0){
cout << "[ERROR]\t No cuts selected, nothing to do." << endl;
return 0;
}
AllCuts = AllCuts + *Cuts.begin();
cout << "[INFO]\t\t Appling cuts for year " << year << ":" << endl;
cout << "\t\t\t" << AllCuts << endl;
for (vector<std::string>::iterator t = Cuts.begin()+1;
t != Cuts.end();
++t){
AllCuts = AllCuts + " && " + *t ;
cout << "\t\t\t" << *t << endl;
}
Cuts.clear();
TTree* NewTree = tree->CopyTree( AllCuts.c_str() );
output_new->cd();
NewTree->Write();
input->cd();
NewTree->Write("",TObject::kOverwrite);
if (useOld) output_old->Close();
input->Close();
output_new->Close();
cout << "[INFO]\t\t New tree created." << endl;
return 1;
}
Int_t sWeightSelectionAllData(Int_t Run = 1, bool useOld = false) {
for (auto& year : yearsData(Run)){
if ( sWeightSelection(useOld, year,"down", false, false, false) == 0) return 0;
if ( sWeightSelection(useOld, year, "up", false, false, false) == 0) return 0;
}
return 1;
}
Int_t sWeightSelectionAllMC(Int_t Run = 1, bool useOld = false) {
for (auto& year : yearsMC(false, false, Run)){
if ( sWeightSelection(useOld, year, "down", true, false, false) == 0) return 0;
if ( sWeightSelection(useOld, year, "up", true, false, false) == 0) return 0;
}
return 1;
}
Int_t sWeightSelectionAllPHSP(Int_t Run = 1, bool useOld = false) {
for (auto& year : yearsMC(false, true, Run)){
if ( sWeightSelection(useOld, year, "down", true, false, true) == 0) return 0;
if ( sWeightSelection(useOld, year, "up", true, false, true) == 0) return 0;
}
return 1;
}
Int_t sWeightSelectionAllRefChannel(Int_t Run = 1, bool useOld = false) {
for (auto& year : yearsMC(true,false, Run)){
if ( sWeightSelection(useOld, year, "down", true, true, false) == 0) return 0;
if ( sWeightSelection(useOld, year, "up", true, true, false) == 0) return 0;
}
return 1;
}
Int_t sWeightSelectionAll(Int_t Run = 1, bool useOld = false) {
if (sWeightSelectionAllData(Run,useOld)==0) return 0;
if (sWeightSelectionAllMC(Run,useOld)==0) return 0;
if (sWeightSelectionAllRefChannel(Run,useOld)==0) return 0;
if (sWeightSelectionAllPHSP(Run,useOld)==0) return 0;
return 1;
}
int copyForFit(std::string year = "2011", std::string magnet = "down", bool MC = false, bool ReferenceChannel = false, bool PHSP = false) {
if (PHSP) MC = true; //phase-space is always MC
TChain* tree;
if(Kst2Kpluspi0Resolved){
tree=new TChain("b2KstKpi0mumuResolvedTuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,MC,ReferenceChannel,PHSP,smallSample).c_str());
}
//Kst2Kpluspi0Merged case
if(Kst2Kpluspi0Merged){
tree=new TChain("b2KstKpi0mumuMergedTuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,MC,ReferenceChannel,PHSP,smallSample).c_str());
}
//Kst2Kspiplus case
if(Kst2Kspiplus){
tree=new TChain("b2KstKs0pimumu_Tuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,MC,ReferenceChannel,PHSP,smallSample).c_str());
}
string output_path = GetInputFile(year,magnet,true,MC,ReferenceChannel,PHSP,false);
replace(output_path,".root","_StripForFit.root");
// cout << output_path << endl;
if(tree->GetEntries() == 0){
//If it complains while running, it's just trying to read also from David's preselected files
std::cout << std::endl << "[ERROR]\t\tNo entries found in TTree from tfile " + GetInputFile(year,magnet,false,MC,ReferenceChannel,PHSP,smallSample)+". Exit program!" << std::endl;
std::cout << std::endl << "[ERROR]\t\tExit program!" << std::endl;
return 0;
}
TFile *output = new TFile(output_path.c_str(),"RECREATE");
//Get B mass
Double_t B_plus_M;
Double_t B_plus_M_DTF;
Double_t B_plus_MERR_DTF;
Float_t f_B_plus_M_DTF[100];
Float_t f_B_plus_MERR_DTF[100];
tree->SetBranchStatus("*",0);
tree->SetBranchStatus("B_plus_M",1);
tree->SetBranchStatus("B_plus_DTF_M",1);
tree->SetBranchStatus("B_plus_DTF_MERR",1);
tree -> SetBranchAddress( "B_plus_M" , &B_plus_M);
tree -> SetBranchAddress( "B_plus_DTF_M" , &f_B_plus_M_DTF);
tree -> SetBranchAddress( "B_plus_DTF_MERR" , &f_B_plus_MERR_DTF);
//Get Q2
tree->SetBranchStatus("mu_minus_PX",1);
tree->SetBranchStatus("mu_minus_PY",1);
tree->SetBranchStatus("mu_minus_PZ",1);
tree->SetBranchStatus("mu_minus_PE",1);
tree->SetBranchStatus("B_plus_DTF_J_psi_1S_muminus_0_PX",1);
tree->SetBranchStatus("B_plus_DTF_J_psi_1S_muminus_0_PY",1);
tree->SetBranchStatus("B_plus_DTF_J_psi_1S_muminus_0_PZ",1);
tree->SetBranchStatus("B_plus_DTF_J_psi_1S_muminus_0_PE",1);
tree->SetBranchStatus("mu_plus_PX",1);
tree->SetBranchStatus("mu_plus_PY",1);
tree->SetBranchStatus("mu_plus_PZ",1);
tree->SetBranchStatus("mu_plus_PE",1);
tree->SetBranchStatus("B_plus_DTF_J_psi_1S_muminus_PX",1);
tree->SetBranchStatus("B_plus_DTF_J_psi_1S_muminus_PY",1);
tree->SetBranchStatus("B_plus_DTF_J_psi_1S_muminus_PZ",1);
tree->SetBranchStatus("B_plus_DTF_J_psi_1S_muminus_PE",1);
if (Kst2Kspiplus)tree->SetBranchStatus("B_plus_DTF_Kst_892_plus_piplus_ID",1);
else tree->SetBranchStatus("B_plus_DTF_Kst_892_plus_Kplus_ID",1);
Double_t mu_minus_PX = 0.;
Double_t mu_minus_PY = 0.;
Double_t mu_minus_PZ = 0.;
Double_t mu_minus_PE = 0.;
Float_t f_mu_minus_PX_DTF[100];
Float_t f_mu_minus_PY_DTF[100];
Float_t f_mu_minus_PZ_DTF[100];
Float_t f_mu_minus_PE_DTF[100];
Double_t mu_minus_PX_DTF = 0.;
Double_t mu_minus_PY_DTF = 0.;
Double_t mu_minus_PZ_DTF = 0.;
Double_t mu_minus_PE_DTF = 0.;
///mu+
Double_t mu_plus_PX = 0.;
Double_t mu_plus_PY = 0.;
Double_t mu_plus_PZ = 0.;
Double_t mu_plus_PE = 0.;
Float_t f_mu_plus_PX_DTF[100];
Float_t f_mu_plus_PY_DTF[100];
Float_t f_mu_plus_PZ_DTF[100];
Float_t f_mu_plus_PE_DTF[100];
Double_t mu_plus_PX_DTF = 0.;
Double_t mu_plus_PY_DTF = 0.;
Double_t mu_plus_PZ_DTF = 0.;
Double_t mu_plus_PE_DTF = 0.;
tree -> SetBranchAddress( "mu_minus_PX" , &mu_minus_PX );
tree -> SetBranchAddress( "B_plus_DTF_J_psi_1S_muminus_0_PX" , &f_mu_minus_PX_DTF );
tree -> SetBranchAddress( "mu_minus_PY" , &mu_minus_PY );
tree -> SetBranchAddress( "B_plus_DTF_J_psi_1S_muminus_0_PY" , &f_mu_minus_PY_DTF );
tree -> SetBranchAddress( "mu_minus_PZ" , &mu_minus_PZ );
tree -> SetBranchAddress( "B_plus_DTF_J_psi_1S_muminus_0_PZ" , &f_mu_minus_PZ_DTF );
tree -> SetBranchAddress( "mu_minus_PE" , &mu_minus_PE );
tree -> SetBranchAddress( "B_plus_DTF_J_psi_1S_muminus_0_PE" , &f_mu_minus_PE_DTF );
tree -> SetBranchAddress( "mu_plus_PX" , &mu_plus_PX );
tree -> SetBranchAddress( "B_plus_DTF_J_psi_1S_muminus_PX" , &f_mu_plus_PX_DTF );
tree -> SetBranchAddress( "mu_plus_PY" , &mu_plus_PY );
tree -> SetBranchAddress( "B_plus_DTF_J_psi_1S_muminus_PY" , &f_mu_plus_PY_DTF );
tree -> SetBranchAddress( "mu_plus_PZ" , &mu_plus_PZ );
tree -> SetBranchAddress( "B_plus_DTF_J_psi_1S_muminus_PZ" , &f_mu_plus_PZ_DTF );
tree -> SetBranchAddress( "mu_plus_PE" , &mu_plus_PE );
tree -> SetBranchAddress( "B_plus_DTF_J_psi_1S_muminus_PE" , &f_mu_plus_PE_DTF );
// Get Bplus charge to assign muplus and muminus correctly
// Not really necessary, but why not
//Not available for nonDTF at the moment!!!
bool IsBplus = true;
Double_t f_K_plus_ID_DTF[100];
Double_t f_pi_plus_ID_DTF[100];
if (Kst2Kspiplus) tree -> SetBranchAddress( "B_plus_DTF_Kst_892_plus_piplus_ID" , &f_pi_plus_ID_DTF );
else tree -> SetBranchAddress( "B_plus_DTF_Kst_892_plus_Kplus_ID" , &f_K_plus_ID_DTF );
//Define new branches
TTree * NewTree = tree->CloneTree(0);
NewTree->Branch("B_plus_M_DTF", &B_plus_M_DTF, "B_plus_M_DTF/D");
NewTree->Branch("B_plus_MERR_DTF", &B_plus_MERR_DTF, "B_plus_MERR_DTF/D");
unsigned int nDiMuonMassBin = 0;
NewTree->Branch("nDiMuonMassBin", &nDiMuonMassBin, "nDiMuonMassBin/I");
Double_t dQ2;
NewTree->Branch("Q2", &dQ2, "dQ2/D");
unsigned int Is_Phi_JPsi_Psi2S = 0;
NewTree->Branch("Is_Phi_JPsi_Psi2S", &Is_Phi_JPsi_Psi2S, "Is_Phi_JPsi_Psi2S/I");
//Define binning in DiMuon mass^2:
//bin# 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
float f_BinBoundaries[19] = {0.1, 0.98, 1.1, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 11.0, 11.75, 12.5, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0}; //in (GeV/c2)^2
for(int i = 0; i < 19; i++)f_BinBoundaries[i] *= 1e6; //in (MeV/c2)^2
//phi -resonance: bin #2
//jpsi -resonance: bin #9
//psi2s-resonance: bin #12
TLorentzVector LorVec_mu_minus;
TLorentzVector LorVec_mu_plus;
TLorentzVector LorVec_DiMuon;
// Kst2Kpluspi0Resolved Cuts
if(Kst2Kpluspi0Resolved){
//don't copy old cone variables
for (int evt = 0; evt < tree->GetEntries(); evt++){
tree->GetEntry(evt);
bool IsBplus = true;
B_plus_M_DTF = (Double_t) f_B_plus_M_DTF[0];
B_plus_MERR_DTF = (Double_t) f_B_plus_MERR_DTF[0];
if (UseDTF && B_plus_M_DTF<cut_B_plus_M_low) continue;
if (UseDTF && B_plus_M_DTF>cut_B_plus_M_high) continue;
if (!UseDTF && B_plus_M<cut_B_plus_M_low) continue;
if (!UseDTF && B_plus_M>cut_B_plus_M_high) continue;
// --------- Get Q2 bin --------- //
nDiMuonMassBin = 0;
Is_Phi_JPsi_Psi2S = 0;
if(Kst2Kspiplus) IsBplus = f_pi_plus_ID_DTF[0] > 0;
else IsBplus = f_K_plus_ID_DTF[0] > 0;
if(IsBplus){
mu_minus_PX_DTF = (Double_t) f_mu_plus_PX_DTF[0];
mu_minus_PY_DTF = (Double_t) f_mu_plus_PY_DTF[0];
mu_minus_PZ_DTF = (Double_t) f_mu_plus_PZ_DTF[0];
mu_minus_PE_DTF = (Double_t) f_mu_plus_PE_DTF[0];
mu_plus_PX_DTF = (Double_t) f_mu_minus_PX_DTF[0];
mu_plus_PY_DTF = (Double_t) f_mu_minus_PY_DTF[0];
mu_plus_PZ_DTF = (Double_t) f_mu_minus_PZ_DTF[0];
mu_plus_PE_DTF = (Double_t) f_mu_minus_PE_DTF[0];
}
else{
mu_plus_PX_DTF = (Double_t) f_mu_plus_PX_DTF[0];
mu_plus_PY_DTF = (Double_t) f_mu_plus_PY_DTF[0];
mu_plus_PZ_DTF = (Double_t) f_mu_plus_PZ_DTF[0];
mu_plus_PE_DTF = (Double_t) f_mu_plus_PE_DTF[0];
mu_minus_PX_DTF = (Double_t) f_mu_minus_PX_DTF[0];
mu_minus_PY_DTF = (Double_t) f_mu_minus_PY_DTF[0];
mu_minus_PZ_DTF = (Double_t) f_mu_minus_PZ_DTF[0];
mu_minus_PE_DTF = (Double_t) f_mu_minus_PE_DTF[0];
}
if (UseDTF){
if (UsePDGmIn4Dvectors){
LorVec_mu_minus.SetXYZM (mu_minus_PX_DTF, mu_minus_PY_DTF, mu_minus_PZ_DTF, PDGMASS.MU);
LorVec_mu_plus.SetXYZM (mu_plus_PX_DTF, mu_plus_PY_DTF, mu_plus_PZ_DTF, PDGMASS.MU);
}
else{
LorVec_mu_minus.SetPxPyPzE (mu_minus_PX_DTF, mu_minus_PY_DTF, mu_minus_PZ_DTF, mu_minus_PE_DTF);
LorVec_mu_plus.SetPxPyPzE (mu_plus_PX_DTF, mu_plus_PY_DTF, mu_plus_PZ_DTF, mu_minus_PE_DTF);
}
}
else{
if (UsePDGmIn4Dvectors){
LorVec_mu_minus.SetXYZM (mu_minus_PX, mu_minus_PY, mu_minus_PZ, PDGMASS.MU);
LorVec_mu_plus.SetXYZM (mu_plus_PX, mu_plus_PY, mu_plus_PZ, PDGMASS.MU);
}
else{
LorVec_mu_minus.SetPxPyPzE (mu_minus_PX, mu_minus_PY, mu_minus_PZ, mu_minus_PE);
LorVec_mu_plus.SetPxPyPzE (mu_plus_PX, mu_plus_PY, mu_plus_PZ, mu_plus_PE);
}
}
LorVec_DiMuon = LorVec_mu_minus + LorVec_mu_plus;
dQ2 = LorVec_DiMuon.M2();
Is_Phi_JPsi_Psi2S = 0;
//if(dQ2< f_BinBoundaries[0] || dQ2 > f_BinBoundaries[18])continue;
while(dQ2 >= f_BinBoundaries[nDiMuonMassBin]){
nDiMuonMassBin++;
}
if(nDiMuonMassBin == 2 || nDiMuonMassBin == 9 || nDiMuonMassBin == 12){
Is_Phi_JPsi_Psi2S = 1;
}
///////////////////////////////////////
NewTree->Fill();
}
}
// Kst2Kspiplus cuts
if(Kst2Kspiplus){
//#TODO
}
output->cd();
NewTree->Write("",TObject::kWriteDelete);
output->Close();
cout << "[INFO]\t\t New tree created." << endl;
return 1;
}
int copyForFitAllData(){
for (auto& year : yearsData(12)){
if (copyForFit(year,"down",false,false,false)==0) return 0;
if (copyForFit(year,"up", false,false,false)==0) return 0;
}
return 1;
}
int copyForFitAllSig(){
for (auto& year : yearsMC(false,false,12)){
if (copyForFit(year,"down",true,false,false)==0) return 0;
if (copyForFit(year,"up", true,false,false)==0) return 0;
}
return 1;
}
int copyForFitAllRef(){
for (auto& year : yearsMC(true,false,12)){
if (copyForFit(year,"down",true,true,false)==0) return 0;
if (copyForFit(year,"up", true,true,false)==0) return 0;
}
return 1;
}
int copyForFitAllPHSP(){
for (auto& year : yearsMC(false,true,12)){
if (copyForFit(year,"down",true,false,false)==0) return 0;
if (copyForFit(year,"up", true,false,false)==0) return 0;
}
return 1;
}
int eventType(bool ReferenceChannel = false, bool PHSP = false){
if (ReferenceChannel && PHSP) return 0;
if(Kst2Kspiplus){
if(ReferenceChannel) return 12145102;
else if (PHSP) return 12115179;
else return 12115102;
}
if(Kst2Kpluspi0Resolved){
if(ReferenceChannel) return 12143401;
else if (PHSP) return 12113446;
else return 12113100;
}
return 0;
}
string eventTypeStr(bool ReferenceChannel = false, bool PHSP = false){
if (ReferenceChannel && PHSP) return 0;
if(Kst2Kspiplus){
if(ReferenceChannel) return "12145102";
else if (PHSP) return "12115179";
else return "12115102";
}
if(Kst2Kpluspi0Resolved){
if(ReferenceChannel) return "12143401";
else if (PHSP) return "12113446";
else return "12113100";
}
return 0;
}
int copyForPID(std::string year = "2011", std::string magnet = "down", bool ReferenceChannel = false, bool PHSP = false) {
cout << "[INFO]\t\tCopy tuple for PID checks: " << year << magnet << endl;
TChain* tree = new TChain();
if(Kst2Kpluspi0Resolved){
tree=new TChain("b2KstKpi0mumuResolvedTuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,true,ReferenceChannel,PHSP,smallSample).c_str());
}
//Kst2Kpluspi0Merged case
if(Kst2Kpluspi0Merged){
tree=new TChain("b2KstKpi0mumuMergedTuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,true,ReferenceChannel,PHSP,smallSample).c_str());
}
//Kst2Kspiplus case
if(Kst2Kspiplus){
tree=new TChain("b2KstKs0pimumu_Tuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,true,ReferenceChannel,PHSP,smallSample).c_str());
}
if(tree->GetEntries() > 0){
std::cout << "[LOAD]\t\tSuccessfully loaded original TTree with " << tree->GetEntries() << " entries." << std::endl;
}
else
return 0;
string output_path = "";
if(Kst2Kpluspi0Resolved)output_path = "/home/lhcb/kopecna/public/PID/Bu_Kstmumu_Kpi0_gammagamma_"+year+magnet+"_"+eventTypeStr(ReferenceChannel,PHSP)+".root";
if(Kst2Kspiplus) output_path = "/home/he/dgerick/Public/PID/Bu_Kstmumu_KSpi_pipi_" +year+magnet+"_"+eventTypeStr(ReferenceChannel,PHSP)+".root";
if(ReferenceChannel) replace(output_path,"mumu","Jpsi_mumu");
TFile *output = new TFile(output_path.c_str(),"RECREATE");
///////////////////////////////////////
// Get particle variables //
///////////////////////////////////////
// ----- K+pi0 ----- //
Double_t K_plus_P; //Kst_0_K_0
Double_t K_plus_PT;
Int_t K_plus_TRUEID;
Double_t K_plus_PIDe;
Double_t K_plus_PIDmu;
Double_t K_plus_PIDK;
Double_t K_plus_PIDp;
Double_t K_plus_ProbNNe;
Double_t K_plus_ProbNNmu;
Double_t K_plus_ProbNNk;
Double_t K_plus_ProbNNp;
Double_t K_plus_ProbNNpi;
Double_t pi_zero_P; //Kst_0_Pi0_0
Double_t pi_zero_PT;
Int_t pi_zero_TRUEID;
Double_t pi_zero_M;
Double_t pi_zero_isPhoton;
Double_t pi_zero_isNotH;
Double_t pi_zero_isNotE;
Double_t Gamma_0_P; //Pi0_0_Gamma_0
Double_t Gamma_0_PT;
Int_t Gamma_0_TRUEID;
Double_t Gamma_0_isPhoton;
Double_t Gamma_0_isNotH;
Double_t Gamma_0_isNotE;
Double_t Gamma_1_P; //Pi0_0_Gamma_1
Double_t Gamma_1_PT;
Int_t Gamma_1_TRUEID;
Double_t Gamma_1_isPhoton;
Double_t Gamma_1_isNotH;
Double_t Gamma_1_isNotE;
// ----- Kspi+ ----- //
Double_t K_short_P; //Kst_0_K_0
Double_t K_short_PT;
Int_t K_short_TRUEID;
Double_t pi_plus_P; //Kst_0_Pi_0
Double_t pi_plus_PT;
Int_t pi_plus_TRUEID;
Double_t pi_plus_PIDe;
Double_t pi_plus_PIDmu;
Double_t pi_plus_PIDK;
Double_t pi_plus_PIDp;
Double_t pi_plus_ProbNNe;
Double_t pi_plus_ProbNNmu;
Double_t pi_plus_ProbNNk;
Double_t pi_plus_ProbNNp;
Double_t pi_plus_ProbNNpi;
Double_t Ks_pi_plus_P; //Ks_0_Pi_0
Double_t Ks_pi_plus_PT;
Int_t Ks_pi_plus_TRUEID;
Double_t Ks_pi_plus_PIDe;
Double_t Ks_pi_plus_PIDmu;
Double_t Ks_pi_plus_PIDK;
Double_t Ks_pi_plus_PIDp;
Double_t Ks_pi_plus_ProbNNe;
Double_t Ks_pi_plus_ProbNNmu;
Double_t Ks_pi_plus_ProbNNk;
Double_t Ks_pi_plus_ProbNNp;
Double_t Ks_pi_plus_ProbNNpi;
Double_t Ks_pi_minus_P; //Ks_0_Pi_1
Double_t Ks_pi_minus_PT;
Int_t Ks_pi_minus_TRUEID;
Double_t Ks_pi_minus_PIDe;
Double_t Ks_pi_minus_PIDmu;
Double_t Ks_pi_minus_PIDK;
Double_t Ks_pi_minus_PIDp;
Double_t Ks_pi_minus_ProbNNe;
Double_t Ks_pi_minus_ProbNNmu;
Double_t Ks_pi_minus_ProbNNk;
Double_t Ks_pi_minus_ProbNNp;
Double_t Ks_pi_minus_ProbNNpi;
// ---- mumu ----- //
Double_t mu_plus_P; //B_0_Mu_0
Double_t mu_plus_PT;
Int_t mu_plus_TRUEID;
Double_t mu_plus_PIDe;
Double_t mu_plus_PIDmu;
Double_t mu_plus_PIDK;
Double_t mu_plus_PIDp;
Double_t mu_plus_ProbNNe;
Double_t mu_plus_ProbNNmu;
Double_t mu_plus_ProbNNk;
Double_t mu_plus_ProbNNp;
Double_t mu_plus_ProbNNpi;
Double_t mu_minus_P; //B_0_Mu_1
Double_t mu_minus_PT;
Int_t mu_minus_TRUEID;
Double_t mu_minus_PIDe;
Double_t mu_minus_PIDmu;
Double_t mu_minus_PIDK;
Double_t mu_minus_PIDp;
Double_t mu_minus_ProbNNe;
Double_t mu_minus_ProbNNmu;
Double_t mu_minus_ProbNNk;
Double_t mu_minus_ProbNNp;
Double_t mu_minus_ProbNNpi;
///////////////////////////////////////
// Load branches //
///////////////////////////////////////
tree->SetBranchStatus("*",0);
// ----- K+pi0 ----- //
if(Kst2Kpluspi0Resolved){
tree->SetBranchStatus("K_plus_P",1); //Kst_0_K_0
tree->SetBranchStatus("K_plus_PT",1);
tree->SetBranchStatus("K_plus_TRUEID",1);
tree->SetBranchStatus("K_plus_PIDe",1);
tree->SetBranchStatus("K_plus_PIDmu",1);
tree->SetBranchStatus("K_plus_PIDK",1);
tree->SetBranchStatus("K_plus_PIDp",1);
tree->SetBranchStatus("K_plus_ProbNNe",1);
tree->SetBranchStatus("K_plus_ProbNNmu",1);
tree->SetBranchStatus("K_plus_ProbNNk",1);
tree->SetBranchStatus("K_plus_ProbNNp",1);
tree->SetBranchStatus("K_plus_ProbNNpi",1);
tree->SetBranchAddress("K_plus_P",&K_plus_P); //Kst_0_K_0
tree->SetBranchAddress("K_plus_PT",&K_plus_PT);
tree->SetBranchAddress("K_plus_TRUEID",&K_plus_TRUEID);
tree->SetBranchAddress("K_plus_PIDe",&K_plus_PIDe);
tree->SetBranchAddress("K_plus_PIDmu",&K_plus_PIDmu);
tree->SetBranchAddress("K_plus_PIDK",&K_plus_PIDK);
tree->SetBranchAddress("K_plus_PIDp",&K_plus_PIDp);
tree->SetBranchAddress("K_plus_ProbNNe",&K_plus_ProbNNe);
tree->SetBranchAddress("K_plus_ProbNNmu",&K_plus_ProbNNmu);
tree->SetBranchAddress("K_plus_ProbNNk",&K_plus_ProbNNk);
tree->SetBranchAddress("K_plus_ProbNNp",&K_plus_ProbNNp);
tree->SetBranchAddress("K_plus_ProbNNpi",&K_plus_ProbNNpi);
tree->SetBranchStatus("pi_zero_resolved_P",1); //Kst_0_Pi0_0
tree->SetBranchStatus("pi_zero_resolved_PT",1);
tree->SetBranchStatus("pi_zero_resolved_TRUEID",1);
tree->SetBranchStatus("pi_zero_resolved_M",1);
//tree->SetBranchStatus("pi_zero_resolved_isPhoton",1);
//tree->SetBranchStatus("pi_zero_resolved_isNotH",1);
//tree->SetBranchStatus("pi_zero_resolved_isNotE",1);
tree->SetBranchAddress("pi_zero_resolved_P",&pi_zero_P); //Kst_0_Pi0_0
tree->SetBranchAddress("pi_zero_resolved_PT",&pi_zero_PT);
tree->SetBranchAddress("pi_zero_resolved_TRUEID",&pi_zero_TRUEID);
tree->SetBranchAddress("pi_zero_resolved_M",&pi_zero_M);
//tree->SetBranchAddress("pi_zero_resolved_isPhoton",&pi_zero_isPhoton);
//tree->SetBranchAddress("pi_zero_resolved_isNotH",&pi_zero_isNotH);
//tree->SetBranchAddress("pi_zero_resolved_isNotE",&pi_zero_isNotE);
tree->SetBranchStatus("gamma1_P",1); //Pi0_0_Gamma_0
tree->SetBranchStatus("gamma1_PT",1);
tree->SetBranchStatus("gamma1_TRUEID",1);
//tree->SetBranchStatus("gamma1_isPhoton",1);
//tree->SetBranchStatus("gamma1_isNotH",1);
//tree->SetBranchStatus("gamma1_isNotE",1);
tree->SetBranchStatus("gamma2_P",1); //Pi0_0_Gamma_1
tree->SetBranchStatus("gamma2_PT",1);
tree->SetBranchStatus("gamma2_TRUEID",1);
//tree->SetBranchStatus("gamma2_isPhoton",1);
//tree->SetBranchStatus("gamma2_isNotH",1);
//tree->SetBranchStatus("gamma2_isNotE",1);
tree->SetBranchAddress("gamma1_P",&Gamma_0_P); //Pi0_0_Gamma_0
tree->SetBranchAddress("gamma1_PT",&Gamma_0_PT);
tree->SetBranchAddress("gamma1_TRUEID",&Gamma_0_TRUEID);
//tree->SetBranchAddress("gamma1_isPhoton",&Gamma_0_isPhoton);
//tree->SetBranchAddress("gamma1_isNotH",&Gamma_0_isNotH);
//tree->SetBranchAddress("gamma1_isNotE",&Gamma_0_isNotE);
tree->SetBranchAddress("gamma2_P",&Gamma_1_P); //Pi0_0_Gamma_1
tree->SetBranchAddress("gamma2_PT",&Gamma_1_PT);
tree->SetBranchAddress("gamma2_TRUEID",&Gamma_1_TRUEID);
//tree->SetBranchAddress("gamma2_isPhoton",&Gamma_1_isPhoton);
//tree->SetBranchAddress("gamma2_isNotH",&Gamma_1_isNotH);
//tree->SetBranchAddress("gamma2_isNotE",&Gamma_1_isNotE);
}
// ----- Kspi+ ----- //
if(Kst2Kspiplus){
tree->SetBranchStatus("K_short_P",1); //Kst_0_K_0
tree->SetBranchStatus("K_short_PT",1);
tree->SetBranchStatus("K_short_TRUEID",1);
tree->SetBranchStatus("pi_plus_P",1); //Kst_0_Pi_0
tree->SetBranchStatus("pi_plus_PT",1);
tree->SetBranchStatus("pi_plus_TRUEID",1);
tree->SetBranchStatus("pi_plus_PIDe",1);
tree->SetBranchStatus("pi_plus_PIDmu",1);
tree->SetBranchStatus("pi_plus_PIDK",1);
tree->SetBranchStatus("pi_plus_PIDp",1);
tree->SetBranchStatus("pi_plus_ProbNNe",1);
tree->SetBranchStatus("pi_plus_ProbNNmu",1);
tree->SetBranchStatus("pi_plus_ProbNNk",1);
tree->SetBranchStatus("pi_plus_ProbNNp",1);
tree->SetBranchStatus("pi_plus_ProbNNpi",1);
tree->SetBranchStatus("Ks_pi_plus_P",1); //Ks_0_Pi_0
tree->SetBranchStatus("Ks_pi_plus_PT",1);
tree->SetBranchStatus("Ks_pi_plus_TRUEID",1);
tree->SetBranchStatus("Ks_pi_plus_PIDe",1);
tree->SetBranchStatus("Ks_pi_plus_PIDmu",1);
tree->SetBranchStatus("Ks_pi_plus_PIDK",1);
tree->SetBranchStatus("Ks_pi_plus_PIDp",1);
tree->SetBranchStatus("Ks_pi_plus_ProbNNe",1);
tree->SetBranchStatus("Ks_pi_plus_ProbNNmu",1);
tree->SetBranchStatus("Ks_pi_plus_ProbNNk",1);
tree->SetBranchStatus("Ks_pi_plus_ProbNNp",1);
tree->SetBranchStatus("Ks_pi_plus_ProbNNpi",1);
tree->SetBranchStatus("Ks_pi_minus_P",1); //Ks_0_Pi_1
tree->SetBranchStatus("Ks_pi_minus_PT",1);
tree->SetBranchStatus("Ks_pi_minus_TRUEID",1);
tree->SetBranchStatus("Ks_pi_minus_PIDe",1);
tree->SetBranchStatus("Ks_pi_minus_PIDmu",1);
tree->SetBranchStatus("Ks_pi_minus_PIDK",1);
tree->SetBranchStatus("Ks_pi_minus_PIDp",1);
tree->SetBranchStatus("Ks_pi_minus_ProbNNe",1);
tree->SetBranchStatus("Ks_pi_minus_ProbNNmu",1);
tree->SetBranchStatus("Ks_pi_minus_ProbNNk",1);
tree->SetBranchStatus("Ks_pi_minus_ProbNNp",1);
tree->SetBranchStatus("Ks_pi_minus_ProbNNpi",1);
tree->SetBranchAddress("K_short_P",&K_short_P); //Kst_0_K_0
tree->SetBranchAddress("K_short_PT",&K_short_PT);
tree->SetBranchAddress("K_short_TRUEID",&K_short_TRUEID);;
tree->SetBranchAddress("pi_plus_P",&pi_plus_P); //Kst_0_Pi_0
tree->SetBranchAddress("pi_plus_PT",&pi_plus_PT);
tree->SetBranchAddress("pi_plus_TRUEID",&pi_plus_TRUEID);
tree->SetBranchAddress("pi_plus_PIDe",&pi_plus_PIDe);
tree->SetBranchAddress("pi_plus_PIDmu",&pi_plus_PIDmu);
tree->SetBranchAddress("pi_plus_PIDK",&pi_plus_PIDK);
tree->SetBranchAddress("pi_plus_PIDp",&pi_plus_PIDp);
tree->SetBranchAddress("pi_plus_ProbNNe",&pi_plus_ProbNNe);
tree->SetBranchAddress("pi_plus_ProbNNmu",&pi_plus_ProbNNmu);
tree->SetBranchAddress("pi_plus_ProbNNk",&pi_plus_ProbNNk);
tree->SetBranchAddress("pi_plus_ProbNNp",&pi_plus_ProbNNp);
tree->SetBranchAddress("pi_plus_ProbNNpi",&pi_plus_ProbNNpi);
tree->SetBranchAddress("Ks_pi_plus_P",&Ks_pi_plus_P); //Ks_0_Pi_0
tree->SetBranchAddress("Ks_pi_plus_PT",&Ks_pi_plus_PT);
tree->SetBranchAddress("Ks_pi_plus_TRUEID",&Ks_pi_plus_TRUEID);
tree->SetBranchAddress("Ks_pi_plus_PIDe",&Ks_pi_plus_PIDe);
tree->SetBranchAddress("Ks_pi_plus_PIDmu",&Ks_pi_plus_PIDmu);
tree->SetBranchAddress("Ks_pi_plus_PIDK",&Ks_pi_plus_PIDK);
tree->SetBranchAddress("Ks_pi_plus_PIDp",&Ks_pi_plus_PIDp);
tree->SetBranchAddress("Ks_pi_plus_ProbNNe",&Ks_pi_plus_ProbNNe);
tree->SetBranchAddress("Ks_pi_plus_ProbNNmu",&Ks_pi_plus_ProbNNmu);
tree->SetBranchAddress("Ks_pi_plus_ProbNNk",&Ks_pi_plus_ProbNNk);
tree->SetBranchAddress("Ks_pi_plus_ProbNNp",&Ks_pi_plus_ProbNNp);
tree->SetBranchAddress("Ks_pi_plus_ProbNNpi",&Ks_pi_plus_ProbNNpi);
tree->SetBranchAddress("Ks_pi_minus_P",&Ks_pi_minus_P); //Ks_0_Pi_1
tree->SetBranchAddress("Ks_pi_minus_PT",&Ks_pi_minus_PT);
tree->SetBranchAddress("Ks_pi_minus_TRUEID",&Ks_pi_minus_TRUEID);
tree->SetBranchAddress("Ks_pi_minus_PIDe",&Ks_pi_minus_PIDe);
tree->SetBranchAddress("Ks_pi_minus_PIDmu",&Ks_pi_minus_PIDmu);
tree->SetBranchAddress("Ks_pi_minus_PIDK",&Ks_pi_minus_PIDK);
tree->SetBranchAddress("Ks_pi_minus_PIDp",&Ks_pi_minus_PIDp);
tree->SetBranchAddress("Ks_pi_minus_ProbNNe",&Ks_pi_minus_ProbNNe);
tree->SetBranchAddress("Ks_pi_minus_ProbNNmu",&Ks_pi_minus_ProbNNmu);
tree->SetBranchAddress("Ks_pi_minus_ProbNNk",&Ks_pi_minus_ProbNNk);
tree->SetBranchAddress("Ks_pi_minus_ProbNNp",&Ks_pi_minus_ProbNNp);
tree->SetBranchAddress("Ks_pi_minus_ProbNNpi",&Ks_pi_minus_ProbNNpi);
}
// ---- mumu ----- //
tree->SetBranchStatus("mu_plus_P",1); //B_0_Mu_0
tree->SetBranchStatus("mu_plus_PT",1);
tree->SetBranchStatus("mu_plus_TRUEID",1);
tree->SetBranchStatus("mu_plus_PIDe",1);
tree->SetBranchStatus("mu_plus_PIDmu",1);
tree->SetBranchStatus("mu_plus_PIDK",1);
tree->SetBranchStatus("mu_plus_PIDp",1);
tree->SetBranchStatus("mu_plus_ProbNNe",1);
tree->SetBranchStatus("mu_plus_ProbNNmu",1);
tree->SetBranchStatus("mu_plus_ProbNNk",1);
tree->SetBranchStatus("mu_plus_ProbNNp",1);
tree->SetBranchStatus("mu_plus_ProbNNpi",1);
tree->SetBranchStatus("mu_minus_P",1); //B_0_Mu_1
tree->SetBranchStatus("mu_minus_PT",1);
tree->SetBranchStatus("mu_minus_TRUEID",1);
tree->SetBranchStatus("mu_minus_PIDe",1);
tree->SetBranchStatus("mu_minus_PIDmu",1);
tree->SetBranchStatus("mu_minus_PIDK",1);
tree->SetBranchStatus("mu_minus_PIDp",1);
tree->SetBranchStatus("mu_minus_ProbNNe",1);
tree->SetBranchStatus("mu_minus_ProbNNmu",1);
tree->SetBranchStatus("mu_minus_ProbNNk",1);
tree->SetBranchStatus("mu_minus_ProbNNp",1);
tree->SetBranchStatus("mu_minus_ProbNNpi",1);
tree->SetBranchAddress("mu_plus_P",&mu_plus_P); //B_0_Mu_0
tree->SetBranchAddress("mu_plus_PT",&mu_plus_PT);
tree->SetBranchAddress("mu_plus_TRUEID",&mu_plus_TRUEID);
tree->SetBranchAddress("mu_plus_PIDe",&mu_plus_PIDe);
tree->SetBranchAddress("mu_plus_PIDmu",&mu_plus_PIDmu);
tree->SetBranchAddress("mu_plus_PIDK",&mu_plus_PIDK);
tree->SetBranchAddress("mu_plus_PIDp",&mu_plus_PIDp);
tree->SetBranchAddress("mu_plus_ProbNNe",&mu_plus_ProbNNe);
tree->SetBranchAddress("mu_plus_ProbNNmu",&mu_plus_ProbNNmu);
tree->SetBranchAddress("mu_plus_ProbNNk",&mu_plus_ProbNNk);
tree->SetBranchAddress("mu_plus_ProbNNp",&mu_plus_ProbNNp);
tree->SetBranchAddress("mu_plus_ProbNNpi",&mu_plus_ProbNNpi);
tree->SetBranchAddress("mu_minus_P",&mu_minus_P); //B_0_Mu_1
tree->SetBranchAddress("mu_minus_PT",&mu_minus_PT);
tree->SetBranchAddress("mu_minus_TRUEID",&mu_minus_TRUEID);
tree->SetBranchAddress("mu_minus_PIDe",&mu_minus_PIDe);
tree->SetBranchAddress("mu_minus_PIDmu",&mu_minus_PIDmu);
tree->SetBranchAddress("mu_minus_PIDK",&mu_minus_PIDK);
tree->SetBranchAddress("mu_minus_PIDp",&mu_minus_PIDp);
tree->SetBranchAddress("mu_minus_ProbNNe",&mu_minus_ProbNNe);
tree->SetBranchAddress("mu_minus_ProbNNmu",&mu_minus_ProbNNmu);
tree->SetBranchAddress("mu_minus_ProbNNk",&mu_minus_ProbNNk);
tree->SetBranchAddress("mu_minus_ProbNNp",&mu_minus_ProbNNp);
tree->SetBranchAddress("mu_minus_ProbNNpi",&mu_minus_ProbNNpi);
///////////////////////////////////////
// Define new branches //
///////////////////////////////////////
TTree * NewTree = new TTree("DecayTree", "DecayTree");
// ----- K+pi0 ----- //
if(Kst2Kpluspi0Resolved){
NewTree->Branch("Kst_0_K_0_P",&K_plus_P,"Kst_0_K_0_P/D"); //Kst_0_K_0
NewTree->Branch("Kst_0_K_0_PT",&K_plus_PT,"Kst_0_K_0_PT/D");
NewTree->Branch("Kst_0_K_0_TRUEID",&K_plus_TRUEID,"Kst_0_K_0_TRUEID/I");
NewTree->Branch("Kst_0_K_0_PIDe",&K_plus_PIDe,"Kst_0_K_0_PIDe/D");
NewTree->Branch("Kst_0_K_0_PIDmu",&K_plus_PIDmu,"Kst_0_K_0_PIDmu/D");
NewTree->Branch("Kst_0_K_0_PIDK",&K_plus_PIDK,"Kst_0_K_0_PIDK/D");
NewTree->Branch("Kst_0_K_0_PIDp",&K_plus_PIDp,"Kst_0_K_0_PIDp/D");
NewTree->Branch("Kst_0_K_0_ProbNNe",&K_plus_ProbNNe,"Kst_0_K_0_ProbNNe/D");
NewTree->Branch("Kst_0_K_0_ProbNNmu",&K_plus_ProbNNmu,"Kst_0_K_0_ProbNNmu/D");
NewTree->Branch("Kst_0_K_0_ProbNNk",&K_plus_ProbNNk,"Kst_0_K_0_ProbNNk/D");
NewTree->Branch("Kst_0_K_0_ProbNNp",&K_plus_ProbNNp,"Kst_0_K_0_ProbNNp/D");
NewTree->Branch("Kst_0_K_0_ProbNNpi",&K_plus_ProbNNpi,"Kst_0_K_0_ProbNNpi/D");
NewTree->Branch("Kst_0_Pi0_0_P",&pi_zero_P,"Kst_0_Pi0_0_P/D"); //Kst_0_Pi0_0
NewTree->Branch("Kst_0_Pi0_0_PT",&pi_zero_PT,"Kst_0_Pi0_0_PT/D");
NewTree->Branch("Kst_0_Pi0_0_TRUEID",&pi_zero_TRUEID,"Kst_0_Pi0_0_TRUEID/I");
NewTree->Branch("Kst_0_Pi0_0_M",&pi_zero_M,"Kst_0_Pi0_0_M/D");
//NewTree->Branch("Kst_0_Pi0_0_isPhoton",&pi_zero_isPhoton,"Kst_0_Pi0_0_isPhoton/D");
//NewTree->Branch("Kst_0_Pi0_0_isNotH",&pi_zero_isNotH,"Kst_0_Pi0_0_isNotH/D");
//NewTree->Branch("Kst_0_Pi0_0_isNotE",&pi_zero_isNotE,"Kst_0_Pi0_0_isNotE/D");
NewTree->Branch("Pi0_0_Gamma_0_P",&Gamma_0_P,"Pi0_0_Gamma_0_P/D"); //Pi0_0_Gamma_0
NewTree->Branch("Pi0_0_Gamma_0_PT",&Gamma_0_PT,"Pi0_0_Gamma_0_PT/D");
NewTree->Branch("Pi0_0_Gamma_0_TRUEID",&Gamma_0_TRUEID,"Pi0_0_Gamma_0_TRUEID/I");
//NewTree->Branch("Pi0_0_Gamma_0_isPhoton",&Gamma_0_isPhoton,"Pi0_0_Gamma_0_isPhoton/D");
//NewTree->Branch("Pi0_0_Gamma_0_isNotH",&Gamma_0_isNotH,"Pi0_0_Gamma_0_isNotH/D");
//NewTree->Branch("Pi0_0_Gamma_0_isNotE",&Gamma_0_isNotE,"Pi0_0_Gamma_0_isNotE/D");
NewTree->Branch("Pi0_0_Gamma_1_P",&Gamma_1_P,"Pi0_0_Gamma_1_P/D"); //Pi0_0_Gamma_1
NewTree->Branch("Pi0_0_Gamma_1_PT",&Gamma_1_PT,"Pi0_0_Gamma_1_PT/D");
NewTree->Branch("Pi0_0_Gamma_1_TRUEID",&Gamma_1_TRUEID,"Pi0_0_Gamma_1_TRUEID/I");
//NewTree->Branch("Pi0_0_Gamma_1_isPhoton",&Gamma_1_isPhoton,"Pi0_0_Gamma_1_isPhoton/D");
//NewTree->Branch("Pi0_0_Gamma_1_isNotH",&Gamma_1_isNotH,"Pi0_0_Gamma_1_isNotH/D");
//NewTree->Branch("Pi0_0_Gamma_1_isNotE",&Gamma_1_isNotE,"Pi0_0_Gamma_1_isNotE/D");
}
// ----- Kspi+ ----- //
if(Kst2Kspiplus){
NewTree->Branch("Kst_0_K_0_P",&K_short_P,"Kst_0_K_0_P/D"); //Kst_0_K_0
NewTree->Branch("Kst_0_K_0_PT",&K_short_PT,"Kst_0_K_0_PT/D");
NewTree->Branch("Kst_0_K_0_TRUEID",&K_short_TRUEID,"Kst_0_K_0_TRUEID/I");
NewTree->Branch("Kst_0_Pi_0_P",&pi_plus_P,"Kst_0_Pi_0_P/D"); //Kst_0_Pi_0
NewTree->Branch("Kst_0_Pi_0_PT",&pi_plus_PT,"Kst_0_Pi_0_PT/D");
NewTree->Branch("Kst_0_Pi_0_TRUEID",&pi_plus_TRUEID,"Kst_0_Pi_0_TRUEID/I");
NewTree->Branch("Kst_0_Pi_0_PIDe",&pi_plus_PIDe,"Kst_0_Pi_0_PIDe/D");
NewTree->Branch("Kst_0_Pi_0_PIDmu",&pi_plus_PIDmu,"Kst_0_Pi_0_PIDmu/D");
NewTree->Branch("Kst_0_Pi_0_PIDK",&pi_plus_PIDK,"Kst_0_Pi_0_PIDK/D");
NewTree->Branch("Kst_0_Pi_0_PIDp",&pi_plus_PIDp,"Kst_0_Pi_0_PIDp/D");
NewTree->Branch("Kst_0_Pi_0_ProbNNe",&pi_plus_ProbNNe,"Kst_0_Pi_0_ProbNNe/D");
NewTree->Branch("Kst_0_Pi_0_ProbNNmu",&pi_plus_ProbNNmu,"Kst_0_Pi_0_ProbNNmu/D");
NewTree->Branch("Kst_0_Pi_0_ProbNNk",&pi_plus_ProbNNk,"Kst_0_Pi_0_ProbNNk/D");
NewTree->Branch("Kst_0_Pi_0_ProbNNp",&pi_plus_ProbNNp,"Kst_0_Pi_0_ProbNNp/D");
NewTree->Branch("Kst_0_Pi_0_ProbNNpi",&pi_plus_ProbNNpi,"Kst_0_Pi_0_ProbNNpi/D");
NewTree->Branch("K_0_Pi_0_P",&Ks_pi_plus_P,"K_0_Pi_0_P/D"); //Ks_0_Pi_0
NewTree->Branch("K_0_Pi_0_PT",&Ks_pi_plus_PT,"K_0_Pi_0_PT/D");
NewTree->Branch("K_0_Pi_0_TRUEID",&Ks_pi_plus_TRUEID,"K_0_Pi_0_TRUEID/I");
NewTree->Branch("K_0_Pi_0_PIDe",&Ks_pi_plus_PIDe,"K_0_Pi_0_PIDe/D");
NewTree->Branch("K_0_Pi_0_PIDmu",&Ks_pi_plus_PIDmu,"K_0_Pi_0_PIDmu/D");
NewTree->Branch("K_0_Pi_0_PIDK",&Ks_pi_plus_PIDK,"K_0_Pi_0_PIDK/D");
NewTree->Branch("K_0_Pi_0_PIDp",&Ks_pi_plus_PIDp,"K_0_Pi_0_PIDp/D");
NewTree->Branch("K_0_Pi_0_ProbNNe",&Ks_pi_plus_ProbNNe,"K_0_Pi_0_ProbNNe/D");
NewTree->Branch("K_0_Pi_0_ProbNNmu",&Ks_pi_plus_ProbNNmu,"K_0_Pi_0_ProbNNmu/D");
NewTree->Branch("K_0_Pi_0_ProbNNk",&Ks_pi_plus_ProbNNk,"K_0_Pi_0_ProbNNk/D");
NewTree->Branch("K_0_Pi_0_ProbNNp",&Ks_pi_plus_ProbNNp,"K_0_Pi_0_ProbNNp/D");
NewTree->Branch("K_0_Pi_0_ProbNNpi",&Ks_pi_plus_ProbNNpi,"K_0_Pi_0_ProbNNpi/D");
NewTree->Branch("K_0_Pi_1_P",&Ks_pi_minus_P,"K_0_Pi_1_P/D"); //Ks_0_Pi_1
NewTree->Branch("K_0_Pi_1_PT",&Ks_pi_minus_PT,"K_0_Pi_1_PT/D");
NewTree->Branch("K_0_Pi_1_TRUEID",&Ks_pi_minus_TRUEID,"K_0_Pi_1_TRUEID/I");
NewTree->Branch("K_0_Pi_1_PIDe",&Ks_pi_minus_PIDe,"K_0_Pi_1_PIDe/D");
NewTree->Branch("K_0_Pi_1_PIDmu",&Ks_pi_minus_PIDmu,"K_0_Pi_1_PIDmu/D");
NewTree->Branch("K_0_Pi_1_PIDK",&Ks_pi_minus_PIDK,"K_0_Pi_1_PIDK/D");
NewTree->Branch("K_0_Pi_1_PIDp",&Ks_pi_minus_PIDp,"K_0_Pi_1_PIDp/D");
NewTree->Branch("K_0_Pi_1_ProbNNe",&Ks_pi_minus_ProbNNe,"K_0_Pi_1_ProbNNe/D");
NewTree->Branch("K_0_Pi_1_ProbNNmu",&Ks_pi_minus_ProbNNmu,"K_0_Pi_1_ProbNNmu/D");
NewTree->Branch("K_0_Pi_1_ProbNNk",&Ks_pi_minus_ProbNNk,"K_0_Pi_1_ProbNNk/D");
NewTree->Branch("K_0_Pi_1_ProbNNp",&Ks_pi_minus_ProbNNp,"K_0_Pi_1_ProbNNp/D");
NewTree->Branch("K_0_Pi_1_ProbNNpi",&Ks_pi_minus_ProbNNpi,"K_0_Pi_1_ProbNNpi/D");
}
// ---- mumu ----- //
if (ReferenceChannel){
NewTree->Branch("Jpsi_0_Mu_0_P",&mu_plus_P,"Jpsi_0_Mu_0_P/D"); //Jpsi_0_Mu_0
NewTree->Branch("Jpsi_0_Mu_0_PT",&mu_plus_PT,"Jpsi_0_Mu_0_PT/D");
NewTree->Branch("Jpsi_0_Mu_0_TRUEID",&mu_plus_TRUEID,"Jpsi_0_Mu_0_TRUEID/I");
NewTree->Branch("Jpsi_0_Mu_0_PIDe",&mu_plus_PIDe,"Jpsi_0_Mu_0_PIDe/D");
NewTree->Branch("Jpsi_0_Mu_0_PIDmu",&mu_plus_PIDmu,"Jpsi_0_Mu_0_PIDmu/D");
NewTree->Branch("Jpsi_0_Mu_0_PIDK",&mu_plus_PIDK,"Jpsi_0_Mu_0_PIDK/D");
NewTree->Branch("Jpsi_0_Mu_0_PIDp",&mu_plus_PIDp,"Jpsi_0_Mu_0_PIDp/D");
NewTree->Branch("Jpsi_0_Mu_0_ProbNNe",&mu_plus_ProbNNe,"Jpsi_0_Mu_0_ProbNNe/D");
NewTree->Branch("Jpsi_0_Mu_0_ProbNNmu",&mu_plus_ProbNNmu,"Jpsi_0_Mu_0_ProbNNmu/D");
NewTree->Branch("Jpsi_0_Mu_0_ProbNNk",&mu_plus_ProbNNk,"Jpsi_0_Mu_0_ProbNNk/D");
NewTree->Branch("Jpsi_0_Mu_0_ProbNNp",&mu_plus_ProbNNp,"Jpsi_0_Mu_0_ProbNNp/D");
NewTree->Branch("Jpsi_0_Mu_0_ProbNNpi",&mu_plus_ProbNNpi,"Jpsi_0_Mu_0_ProbNNpi/D");
NewTree->Branch("Jpsi_0_Mu_1_P",&mu_minus_P,"Jpsi_0_Mu_1_P/D"); //Jpsi_0_Mu_1
NewTree->Branch("Jpsi_0_Mu_1_PT",&mu_minus_PT,"Jpsi_0_Mu_1_PT/D");
NewTree->Branch("Jpsi_0_Mu_1_TRUEID",&mu_minus_TRUEID,"Jpsi_0_Mu_1_TRUEID/I");
NewTree->Branch("Jpsi_0_Mu_1_PIDe",&mu_minus_PIDe,"Jpsi_0_Mu_1_PIDe/D");
NewTree->Branch("Jpsi_0_Mu_1_PIDmu",&mu_minus_PIDmu,"Jpsi_0_Mu_1_PIDmu/D");
NewTree->Branch("Jpsi_0_Mu_1_PIDK",&mu_minus_PIDK,"Jpsi_0_Mu_1_PIDK/D");
NewTree->Branch("Jpsi_0_Mu_1_PIDp",&mu_minus_PIDp,"Jpsi_0_Mu_1_PIDp/D");
NewTree->Branch("Jpsi_0_Mu_1_ProbNNe",&mu_minus_ProbNNe,"Jpsi_0_Mu_1_ProbNNe/D");
NewTree->Branch("Jpsi_0_Mu_1_ProbNNmu",&mu_minus_ProbNNmu,"Jpsi_0_Mu_1_ProbNNmu/D");
NewTree->Branch("Jpsi_0_Mu_1_ProbNNk",&mu_minus_ProbNNk,"Jpsi_0_Mu_1_ProbNNk/D");
NewTree->Branch("Jpsi_0_Mu_1_ProbNNp",&mu_minus_ProbNNp,"Jpsi_0_Mu_1_ProbNNp/D");
NewTree->Branch("Jpsi_0_Mu_1_ProbNNpi",&mu_minus_ProbNNpi,"Jpsi_0_Mu_1_ProbNNpi/D");
}
else{
NewTree->Branch("B_0_Mu_0_P",&mu_plus_P,"B_0_Mu_0_P/D"); //B_0_Mu_0
NewTree->Branch("B_0_Mu_0_PT",&mu_plus_PT,"B_0_Mu_0_PT/D");
NewTree->Branch("B_0_Mu_0_TRUEID",&mu_plus_TRUEID,"B_0_Mu_0_TRUEID/I");
NewTree->Branch("B_0_Mu_0_PIDe",&mu_plus_PIDe,"B_0_Mu_0_PIDe/D");
NewTree->Branch("B_0_Mu_0_PIDmu",&mu_plus_PIDmu,"B_0_Mu_0_PIDmu/D");
NewTree->Branch("B_0_Mu_0_PIDK",&mu_plus_PIDK,"B_0_Mu_0_PIDK/D");
NewTree->Branch("B_0_Mu_0_PIDp",&mu_plus_PIDp,"B_0_Mu_0_PIDp/D");
NewTree->Branch("B_0_Mu_0_ProbNNe",&mu_plus_ProbNNe,"B_0_Mu_0_ProbNNe/D");
NewTree->Branch("B_0_Mu_0_ProbNNmu",&mu_plus_ProbNNmu,"B_0_Mu_0_ProbNNmu/D");
NewTree->Branch("B_0_Mu_0_ProbNNk",&mu_plus_ProbNNk,"B_0_Mu_0_ProbNNk/D");
NewTree->Branch("B_0_Mu_0_ProbNNp",&mu_plus_ProbNNp,"B_0_Mu_0_ProbNNp/D");
NewTree->Branch("B_0_Mu_0_ProbNNpi",&mu_plus_ProbNNpi,"B_0_Mu_0_ProbNNpi/D");
NewTree->Branch("B_0_Mu_1_P",&mu_minus_P,"B_0_Mu_1_P/D"); //B_0_Mu_1
NewTree->Branch("B_0_Mu_1_PT",&mu_minus_PT,"B_0_Mu_1_PT/D");
NewTree->Branch("B_0_Mu_1_TRUEID",&mu_minus_TRUEID,"B_0_Mu_1_TRUEID/I");
NewTree->Branch("B_0_Mu_1_PIDe",&mu_minus_PIDe,"B_0_Mu_1_PIDe/D");
NewTree->Branch("B_0_Mu_1_PIDmu",&mu_minus_PIDmu,"B_0_Mu_1_PIDmu/D");
NewTree->Branch("B_0_Mu_1_PIDK",&mu_minus_PIDK,"B_0_Mu_1_PIDK/D");
NewTree->Branch("B_0_Mu_1_PIDp",&mu_minus_PIDp,"B_0_Mu_1_PIDp/D");
NewTree->Branch("B_0_Mu_1_ProbNNe",&mu_minus_ProbNNe,"B_0_Mu_1_ProbNNe/D");
NewTree->Branch("B_0_Mu_1_ProbNNmu",&mu_minus_ProbNNmu,"B_0_Mu_1_ProbNNmu/D");
NewTree->Branch("B_0_Mu_1_ProbNNk",&mu_minus_ProbNNk,"B_0_Mu_1_ProbNNk/D");
NewTree->Branch("B_0_Mu_1_ProbNNp",&mu_minus_ProbNNp,"B_0_Mu_1_ProbNNp/D");
NewTree->Branch("B_0_Mu_1_ProbNNpi",&mu_minus_ProbNNpi,"B_0_Mu_1_ProbNNpi/D");
}
for (int evt = 0; evt < tree->GetEntries(); evt++){
tree->GetEntry(evt);
NewTree->Fill();
}
output->cd();
NewTree->Write("",TObject::kWriteDelete);
string dict_path = Kst2Kspiplus ? "/home/he/dgerick/Public/PID/ForDict.txt" : "/home/lhcb/kopecna/public/PID/ForDict.txt";
ofstream myfile;
myfile.open (dict_path,ios::app);
myfile << eventTypeStr(ReferenceChannel,PHSP) << ":[\"" << year << "\",\"" << magnet << "\", " << NewTree->GetEntries() <<"]," << endl;
output->Close();
cout << "[INFO]\t\t New tree created and saved to file." << endl;
return 1;
}
int copyForPIDAllSig(){
for (auto& year : yearsMC(false, false,12)){
if (copyForPID(year,"down",false,false)==0) return 0;
if (copyForPID(year,"up", false,false)==0) return 0;
}
return 1;
}
int copyForPIDAllRef(){
for (auto& year : yearsMC(true, false,12)){
if (copyForPID(year,"down",true,false)==0) return 0;
if (copyForPID(year,"up", true,false)==0) return 0;
}
return 1;
}
int copySameRunNumber(int year1 = 2018, int year2 = 2020, std::string mag = "down") {
//put both magnet polarities into one TChain
string tupleName = Kst2Kpluspi0Resolved ? "b2KstKpi0mumuResolvedTuple/DecayTree" : "b2KstKs0pimumu_Tuple/DecayTree";
TChain * treeData1 = new TChain(tupleName.c_str());
TChain * treeData2 = new TChain(tupleName.c_str());
if (year1 < 2019)
treeData1->Add(Form("%s/data/%i%s/%i*_B2Kstmumu*.root", path_to_output_KshortPiplus.c_str(), year1, mag.c_str(), year1));
else
treeData1->Add(Form("%s/data/%i%s/%i*_B2Kstmumu*_validation.root", Kst2Kpluspi0Resolved ? path_to_output_KplusPizero.c_str() : path_to_output_KshortPiplus.c_str(), year1, mag.c_str(), year1));
if (year2 < 2019)
treeData2->Add(Form("%s/data/%i%s/%i*_B2Kstmumu*.root", path_to_output_KshortPiplus.c_str(), year2, mag.c_str(), year2));
else
treeData2->Add(Form("%s/data/%i%s/%i*_B2Kstmumu*_validation.root", Kst2Kpluspi0Resolved ? path_to_output_KplusPizero.c_str() : path_to_output_KshortPiplus.c_str(), year2, mag.c_str(), year2));
if(treeData1->GetEntries() == 0){
std::cout << "[ERROR]\tNo entries found in ntuple for year " << year1 << std::endl;
return 0;
}
if(treeData2->GetEntries() == 0){
std::cout << "[ERROR]\tNo entries found in ntuple for year " << year2 << std::endl;
return 0;
}
UInt_t runNumber1 = 0;
UInt_t runNumber2 = 0;
treeData1->SetBranchStatus("*",1);
treeData1->SetBranchStatus("runNumber",1);
treeData1->SetBranchAddress("runNumber",&runNumber1);
treeData2->SetBranchStatus("*",1);
treeData2->SetBranchStatus("runNumber",1);
treeData2->SetBranchAddress("runNumber",&runNumber2);
std::vector<int>vRunNumber;
std::vector<int>vRunNumber1;
std::vector<int>vRunNumber2;
/*
for (int evt1 = 0; evt1 < treeData1->GetEntries(); evt1++){
treeData1->GetEntry(evt1);
vRunNumber1.push_back(runNumber1);
}
*/
for (int evt2 = 0; evt2< treeData2->GetEntries(); evt2++){
treeData2->GetEntry(evt2);
vRunNumber.push_back(runNumber2);
}
/*
std::sort(vRunNumber1.begin(), vRunNumber1.end());
auto last1 = std::unique(vRunNumber1.begin(), vRunNumber1.end());
vRunNumber1.erase(last1, vRunNumber1.end());
for (std::vector<int>::const_iterator i = vRunNumber1.begin(); i != vRunNumber1.end(); ++i){
cout << *i << endl;
}
cout << "First vector" << endl;
std::sort(vRunNumber2.begin(), vRunNumber2.end());
auto last2 = std::unique(vRunNumber2.begin(), vRunNumber2.end());
vRunNumber2.erase(last2, vRunNumber2.end());
for (std::vector<int>::const_iterator ii = vRunNumber2.begin(); ii != vRunNumber2.end(); ++ii){
cout << *ii << endl;
}
cout << "Second vector" << endl;
for (int i = 0; i < vRunNumber1.size(); i++){
for (int ii = 0; ii < vRunNumber2.size(); ii++){
if ( vRunNumber1[i] == vRunNumber2[ii]){
vRunNumber.push_back(vRunNumber1[i]);
cout << vRunNumber1[i] << endl;
continue;
}
}
}
*/
std::sort(vRunNumber.begin(), vRunNumber.end());
auto last = std::unique(vRunNumber.begin(), vRunNumber.end());
vRunNumber.erase(last, vRunNumber.end());
cout << "Loop to get the run numbers done" << endl;
/*
TTree * NewTree1 = new TTree(tupleName.c_str(),tupleName.c_str());
for (int evt = 0; evt < treeData1->GetEntries(); evt++){
treeData1->GetEntry(evt);
for(unsigned rn = 0; rn < vRunNumber.size(); rn++){
if (runNumber1 == vRunNumber.at(rn)){
NewTree1->Fill();
continue;
}
}
}
cout << "Loop to get the first tree done" << endl;
TTree * NewTree2 = new TTree(tupleName.c_str(),tupleName.c_str());
for (int evt = 0; evt < treeData2->GetEntries(); evt++){
treeData2->GetEntry(evt);
for(unsigned rn = 0; rn < vRunNumber.size(); rn++){
if (runNumber2 == vRunNumber.at(rn)){
NewTree2->Fill();
continue;
}
}
cout << evt << endl;
}
*/
if (vRunNumber.size() ==0) return 0;
std::string AllCuts = "runNumber== " + to_string(vRunNumber.at(0));
cout << "[INFO]\t\t Appling cuts:" << AllCuts << endl;
for (vector<int>::iterator t = vRunNumber.begin()+1;
t != vRunNumber.end();
++t){
AllCuts = AllCuts + " || runNumber== " + to_string(*t) ;
cout << "\t\t\t" << " || runNumber== " << *t << endl;
}
cout << "Start copying the trees" << endl;
TTree* NewTree1 = treeData1->CopyTree( AllCuts.c_str() );
TTree* NewTree2 = treeData2->CopyTree( AllCuts.c_str() );
cout << "Copying the trees done" << endl;
TFile *output1, *output2;
if (year1 < 2019)
output1 = new TFile(Form("%s/data/%i%s/%i%i*_B2Kstmumu*_runNumberSame.root", path_to_output_KshortPiplus.c_str(), year1, mag.c_str(), year1, year2),"RECREATE");
else
output1 = new TFile(Form("%s/data/%i%s/%i%i*_B2Kstmumu*_validation_runNumberSame.root", Kst2Kpluspi0Resolved ? path_to_output_KplusPizero.c_str() : path_to_output_KshortPiplus.c_str(), year1, mag.c_str(), year1, year2),"RECREATE");
if (year2 < 2019)
output2 = new TFile(Form("%s/data/%i%s/%i%i*_B2Kstmumu*_runNumberSame.root", path_to_output_KshortPiplus.c_str(), year2, mag.c_str(), year1, year2),"RECREATE");
else
output2 = new TFile(Form("%s/data/%i%s/%i%i*_B2Kstmumu*_validation_runNumberSame.root", Kst2Kpluspi0Resolved ? path_to_output_KplusPizero.c_str() : path_to_output_KshortPiplus.c_str(), year2, mag.c_str(), year1, year2),"RECREATE");
output1->cd();
NewTree1->Write("",TObject::kWriteDelete);
output2->cd();
NewTree2->Write("",TObject::kWriteDelete);
output1->Close();
output2->Close();
cout << "[INFO]\t\t New tree created and saved to file." << endl;
return 1;
}
int copyForL0Efficiency(int year = 2011, string magnet = "down", bool MC = false, bool ReferenceChannel = false, bool PHSP = false){
//Load all files
TChain* tree = 0;
//Reference channel and PHSP are both MC data
if(ReferenceChannel)MC = true;
if(PHSP)MC = true;
if(ReferenceChannel && PHSP){
std::cout << "[WARNING]\tCannot set boolean of reference channel and phase-space MC at the same time! Process Reference Channel!" << std::endl;
PHSP = false;
}
if(Kst2Kpluspi0Resolved){
tree=new TChain("b2KstKpi0mumuResolvedTuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,MC,ReferenceChannel,PHSP,false).c_str());
}
//Kst2Kpluspi0Merged case
if(Kst2Kpluspi0Merged){
tree=new TChain("b2KstKpi0mumuMergedTuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,MC,ReferenceChannel,PHSP,false).c_str());
}
//Kst2Kspiplus case
if(Kst2Kspiplus){
tree=new TChain("b2KstKs0pimumu_Tuple/DecayTree");
tree->Add(GetInputFile(year,magnet,false,MC,ReferenceChannel,PHSP,false).c_str());
}
int N = tree->GetEntries();
coutDebug("Old files contain " + to_string(N) + " events.");
if(N == 0){
coutERROR("Tree has no entries. Exit!");
return 0;
}
//Disable all branches
tree->SetBranchStatus("*",0);
//activate needed branches
tree->SetBranchStatus("mu_plus_PT",1) ;
tree->SetBranchStatus("mu_minus_PT",1) ;
tree->SetBranchStatus("mu_plus_ProbNNmu",1) ;
tree->SetBranchStatus("mu_minus_ProbNNmu",1) ;
tree->SetBranchStatus("mu_plus_PIDmu",1) ;
tree->SetBranchStatus("mu_minus_PIDmu",1) ;
tree->SetBranchStatus("nSPDHits",1) ;
if (MC){
tree->SetBranchStatus("mu_plus_TRUEPT",1) ;
tree->SetBranchStatus("mu_minus_TRUEPT",1) ;
}
tree->SetBranchStatus("B_plus_L0MuonDecision_TOS",1) ;
tree->SetBranchStatus("B_plus_L0Global_TIS",1);
if (year > 2012) tree->SetBranchStatus("B_plus_L0DiMuonDecision_TOS",1) ;
//open output file
string output_path = GetInputFile(year, magnet,true,MC,ReferenceChannel,PHSP,false);
replace(output_path,".root","_L0Muon.root");
TFile *output = new TFile(output_path.c_str(),"RECREATE");
output->cd();
TTree* newTree = tree->CopyTree("B_plus_L0Global_TIS==1");
if (newTree->GetEntries()==0) coutERROR("Failed while coping!");
newTree->Write("",TObject::kOverwrite);
delete newTree;
output->Close();
return 1;
//TODO: delete pointers
}
int copyForL0Efficiency(string year = "2011", string magnet = "down", bool MC = false, bool ReferenceChannel = false, bool PHSP = false){
return copyForL0Efficiency(stoi(year),magnet,MC,ReferenceChannel,PHSP);
}
int copyForL0EfficiencyData(int Run){
for (auto& year : yearsData(Run)){
if (copyForL0Efficiency(year,"up",false, false, false)==0) return 0;
if (copyForL0Efficiency(year,"down",false, false, false)==0) return 0;
}
return 1;
}
int copyForL0EfficiencyMC(int Run){
for (auto& year : yearsMC(false,false,Run)){
if (copyForL0Efficiency(year,"up",true, false, false)==0) return 0;
if (copyForL0Efficiency(year,"down",true, false, false)==0) return 0;
}
return 1;
}
int copyForL0EfficiencyRefMC(int Run){
for (auto& year : yearsMC(true,false,Run)){
if (copyForL0Efficiency(year,"up",false, true, false)==0) return 0;
if (copyForL0Efficiency(year,"down",false, true, false)==0) return 0;
}
return 1;
}
int copyForL0EfficiencyPHSP(int Run){
for (auto& year : yearsMC(false,true,Run)){
if (copyForL0Efficiency(year,"up",false, false, true)==0) return 0;
if (copyForL0Efficiency(year,"down",false, false, true)==0) return 0;
}
return 1;
}
int copyForL0EfficiencyAll(int Run){
if (copyForL0EfficiencyData(Run)==0) return 0;
if (copyForL0EfficiencyMC(Run)==0) return 0;
if (copyForL0EfficiencyRefMC(Run)==0) return 0;
if (copyForL0EfficiencyPHSP(Run)==0) return 0;
return 1;
}
Reference in New Issue Copy Permalink