You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1342 lines
54 KiB
1342 lines
54 KiB
|
|
#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;
|
|
}
|