kopecna
/
EWP-BplusToKstMuMu-AngAna
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Angular analysis of B+->K*+(K+pi0)mumu
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.
15 Commits
2 Branches
0 Tags
92 MiB
 
 
 
 
Tree: df6722555b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'df6722555b'
${ noResults }
EWP-BplusToKstMuMu-AngAna/Code/Scripts/Selection/QuickChecker.cpp

653 lines
29 KiB
Raw Blame History

#include "../GlobalFunctions.hh"
//////////////////////////////////////////////////////////////////////
/// QuickChecker()
///
/// Epicly flexible tool to quickly create basic plots for checking various features.
///
/// All definitions happen in the AllBranches constructor, where used branches are defined.
/// Cuts are also defined in the constructor, the strings are transferred to CopyTree.
/// EpicOptimizer() doesn't need to be touched at all.
///
///
/// Options to create either standalone years plots (Run==0),
/// plots per Run (Run==1 || Run ==2) or both runs combined (Run==12)
///
/// Possibility to run on stripped/preselected data/MC/PHSP/Ref.
/// In the case of MC also possibility to run only on TruthMatched data.
///
/// TODO: should add an option tfor sweighted and BDT-cutted data
///
/// Standard output in data/MC/PHSP/Ref folder, year/run and preselection option in the name.
///
/// Disclaimer: Probably leaky and not super-safe to you, so proceed with caution.
///
///
/*******************************/
class Int_branch{
public:
int BranchVar; //where to save the branch
const char* BranchName; //Name of the branch
Int_branch(); //default constructor
Int_branch(int var, const char* name); //default constructor
~Int_branch(); //destuctor
};
Int_branch::Int_branch(int var, const char* name){ //here add what branches you wanna load
BranchVar = var;
BranchName = name;
}
/*******************************/
class Float_branch{
public:
float BranchVar; //where to save the branch
const char* BranchName; //Name of the branch
Float_branch(); //default constructor
~Float_branch(); //destuctor
Float_branch(float var, const char* name); //constructor
};
Float_branch::Float_branch(float var, const char* name){ //here add what branches you wanna load
BranchVar = var;
BranchName = name;
}
/*******************************/
class Float_arr_branch{
public:
float *BranchVar; //where to save the branch
const char* BranchName; //Name of the branch
Float_arr_branch(); //default constructor
Float_arr_branch(float *var, const char* name); //constructor
~Float_arr_branch(); //destuctor
};
Float_arr_branch::Float_arr_branch(float *var, const char* name){ //here add what branches you wanna load
BranchVar = var;
BranchName = name;
}
/*******************************/
class Double_branch{
public:
double BranchVar; //where to save the branch
const char* BranchName; //Name of the branch
Double_branch(); //default constructor
Double_branch(double var, const char* name); //constructor
~Double_branch(); //destuctor
};
Double_branch::Double_branch(double var, const char* name){ //here add what branches you wanna load
BranchVar = var;
BranchName = name;
}
/*******************************/
class Double_arr_branch{
public:
double *BranchVar; //where to save the branch
const char* BranchName; //Name of the branch
Double_arr_branch(); //default constructor
Double_arr_branch(double *var, const char* name); //constructor
~Double_arr_branch(); //destuctor
};
Double_arr_branch::Double_arr_branch(double *var, const char* name){ //here add what branches you wanna load
BranchVar = var;
BranchName = name;
}
/*******************************/
class AllBranches{
public:
vector <Int_branch*> IntBranches;
vector <Float_branch*> FloatBranches;
vector <Float_arr_branch*> FloatArrBranches;
vector <Double_branch*> DoubleBranches;
vector <Double_arr_branch*> DoubleArrBranches;
vector<std::string> Cuts;
AllBranches(); //default constructor
~AllBranches(); //destuctor
};
AllBranches::AllBranches(){ //here add what branches you wanna load
// int I_nTracks = 0;
// IntBranches.push_back(new Int_branch(I_nTracks, "nTracks"));
/*
double D_K_star_plus_PT = 0.0;
DoubleBranches.push_back(new Double_branch(D_K_star_plus_PT, "K_star_plus_PT"));
Cuts.push_back("K_star_plus_PT > 1300");
//Cuts.push_back("K_star_plus_PT < 300");
*/
double D_B_plus_ThetaL = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_ThetaL, "B_plus_ThetaL"));
double D_B_plus_ThetaK = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_ThetaK, "B_plus_ThetaK"));
double D_B_plus_Phi = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_Phi, "B_plus_Phi"));
double D_B_plus_TRUEThetaL = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_TRUEThetaL, "B_plus_TRUEThetaL"));
double D_B_plus_TRUEThetaK = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_TRUEThetaK, "B_plus_TRUEThetaK"));
double D_B_plus_TRUEPhi = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_TRUEPhi, "B_plus_TRUEPhi"));
double D_B_plus_M = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_M, "B_plus_M"));
Cuts.push_back("B_plus_M < 600000000");
/*
double D_B_plus_M = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_M, "B_plus_M"));
Cuts.push_back("B_plus_M > 5000");
Cuts.push_back("B_plus_M < 6000");
float K_star_plus_M = 0;
DoubleBranches.push_back(new Double_branch(K_star_plus_M,"K_star_plus_M"));
Cuts.push_back("K_star_plus_M > 792");
Cuts.push_back("K_star_plus_M <1050");
double D_K_plus_PT = 0.0;
DoubleBranches.push_back(new Double_branch(D_K_plus_PT, "K_plus_PT"));
Cuts.push_back("K_plus_PT > 300");
double D_B_plus_PT = 0.0;
DoubleBranches.push_back(new Double_branch(D_B_plus_PT, "B_plus_PT"));
Cuts.push_back("B_plus_PT > 2000");
double K_star_plus_FDCHI2_OWNPV = 0.0;
DoubleBranches.push_back(new Double_branch(K_star_plus_FDCHI2_OWNPV, "K_star_plus_FDCHI2_OWNPV"));
Cuts.push_back("K_star_plus_FDCHI2_OWNPV > -100000");
double B_plus_FDCHI2_OWNPV = 0.0;
DoubleBranches.push_back(new Double_branch(B_plus_FDCHI2_OWNPV, "B_plus_FDCHI2_OWNPV"));
Cuts.push_back("B_plus_FDCHI2_OWNPV > 121");
double K_star_plus_FDCHI2_OWNPV = 0.0;
DoubleBranches.push_back(new Double_branch(K_star_plus_FDCHI2_OWNPV, "K_star_plus_FDCHI2_OWNPV"));
Cuts.push_back("K_star_plus_FDCHI2_OWNPV > -100000");
int B_plus_Hlt2Topo3BodyBBDTDecision_TOS = 0.0;
int B_plus_Hlt2TopoMu2BodyBBDTDecision_TOS = 0.0;
int B_plus_Hlt2TopoMu3BodyBBDTDecision_TOS = 0.0;
int B_plus_Hlt2TopoMuMu2BodyBBDTDecision_TOS = 0.0;
int B_plus_Hlt2TopoMuMu3BodyBBDTDecision_TOS = 0.0;
double D_pi_zero_resolved_TRUEP_X = 0.0;
DoubleBranches.push_back(new Double_branch(D_pi_zero_resolved_TRUEP_X, "pi_zero_resolved_TRUEP_X"));
Cuts.push_back("pi_zero_resolved_TRUEP_X > -100000");
double D_pi_zero_resolved_TRUEP_Y = 0.0;
DoubleBranches.push_back(new Double_branch(D_pi_zero_resolved_TRUEP_Y, "pi_zero_resolved_TRUEP_Y"));
Cuts.push_back("pi_zero_resolved_TRUEP_Y > -100000");
double D_pi_zero_resolved_TRUEP_Z = 0.0;
DoubleBranches.push_back(new Double_branch(D_pi_zero_resolved_TRUEP_Z, "pi_zero_resolved_TRUEP_Z"));
Cuts.push_back("pi_zero_resolved_TRUEP_Z > -100000");
double D_pi_zero_resolved_ETA = 0.0;
DoubleBranches.push_back(new Double_branch(D_pi_zero_resolved_ETA, "pi_zero_resolved_ETA"));
Cuts.push_back("pi_zero_resolved_ETA > -100000");
double D_pi_zero_resolved_PX = 0.0;
DoubleBranches.push_back(new Double_branch(D_pi_zero_resolved_PX, "pi_zero_resolved_PX"));
Cuts.push_back("pi_zero_resolved_PX > -100000");
double D_pi_zero_resolved_PY = 0.0;
DoubleBranches.push_back(new Double_branch(D_pi_zero_resolved_PY, "pi_zero_resolved_PY"));
Cuts.push_back("pi_zero_resolved_PY > -100000");
double D_pi_zero_resolved_PZ = 0.0;
DoubleBranches.push_back(new Double_branch(D_pi_zero_resolved_PZ, "pi_zero_resolved_PZ"));
Cuts.push_back("pi_zero_resolved_PZ> -100000");
double D_K_star_plus_M_DTF = 0.0;
DoubleBranches.push_back(new Double_branch(D_K_star_plus_M_DTF, "K_star_plus_M_DTF"));
Cuts.push_back("K_star_plus_M_DTF > 792");
Cuts.push_back("K_star_plus_M_DTF <1050");
*/
/*
float K_star_plus_M = 0;
DoubleBranches.push_back(new Double_branch(K_star_plus_M,"K_star_plus_M"));
Cuts.push_back("K_star_plus_M > 792");
Cuts.push_back("K_star_plus_M <1050");
*/
/*
float F_B_plus_DTF_Kst_892_plus_M[20];
FloatArrBranches.push_back(new Float_arr_branch(F_B_plus_DTF_Kst_892_plus_M,"B_plus_DTF_Kst_892_plus_M"));
Cuts.push_back("B_plus_DTF_Kst_892_plus_M[0] > 792");
Cuts.push_back("B_plus_DTF_Kst_892_plus_M[0] <1050");
*/
//truthmatching
//assign variables to TRUEID
/* int B_plus_TRUEID= 0;;
IntBranches.push_back(new Int_branch(B_plus_TRUEID, "B_plus_TRUEID"));
Cuts.push_back("abs(B_plus_TRUEID) == " + to_string(TRUEID.B_PLUS));
int K_star_plus_TRUEID= 0;
IntBranches.push_back(new Int_branch(K_star_plus_TRUEID, "K_star_plus_TRUEID"));
Cuts.push_back("abs(K_star_plus_TRUEID) == " + to_string(TRUEID.K_STAR_PLUS));
int K_plus_TRUEID= 0;
IntBranches.push_back(new Int_branch(K_plus_TRUEID, "K_plus_TRUEID"));
Cuts.push_back("abs(K_plus_TRUEID) == " + to_string(TRUEID.K_PLUS));
int pi_zero_TRUEID= 0;
IntBranches.push_back(new Int_branch(pi_zero_TRUEID, "pi_zero_resolved_TRUEID"));
Cuts.push_back("abs(pi_zero_resolved_TRUEID) == " + to_string(TRUEID.PI_ZERO));
int gamma1_TRUEID= 0;
IntBranches.push_back(new Int_branch(gamma1_TRUEID, "gamma1_TRUEID"));
Cuts.push_back("abs(gamma1_TRUEID) == " + to_string(TRUEID.GAMMA));
int gamma2_TRUEID= 0;
IntBranches.push_back(new Int_branch(gamma2_TRUEID, "gamma2_TRUEID"));
Cuts.push_back("abs(gamma2_TRUEID) == " + to_string(TRUEID.GAMMA));
//assign variables to TRUE_MOTHER_ID
int K_star_plus_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(K_star_plus_MOTHER_ID, "K_star_plus_MC_MOTHER_ID"));
Cuts.push_back("abs(K_star_plus_MC_MOTHER_ID) == " + to_string(TRUEID.B_PLUS));
int K_plus_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(K_plus_MOTHER_ID, "K_plus_MC_MOTHER_ID"));
Cuts.push_back("abs(K_plus_MC_MOTHER_ID) == " + to_string(TRUEID.K_STAR_PLUS));
int pi_zero_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(pi_zero_MOTHER_ID, "pi_zero_resolved_MC_MOTHER_ID"));
Cuts.push_back("abs(pi_zero_resolved_MC_MOTHER_ID) == " + to_string(TRUEID.K_STAR_PLUS));
int gamma1_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(gamma1_MOTHER_ID, "gamma1_MC_MOTHER_ID"));
Cuts.push_back("abs(gamma1_MC_MOTHER_ID) == " + to_string(TRUEID.PI_ZERO));
int gamma2_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(gamma2_MOTHER_ID, "gamma2_MC_MOTHER_ID"));
Cuts.push_back("abs(gamma2_MC_MOTHER_ID) == " + to_string(TRUEID.PI_ZERO));
//assign variables to TRUE_GD_MOTHER_ID
int K_plus_GD_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(K_plus_GD_MOTHER_ID, "K_plus_MC_GD_MOTHER_ID"));
Cuts.push_back("abs(K_plus_MC_GD_MOTHER_ID) == " + to_string(TRUEID.B_PLUS));
int pi_zero_GD_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(pi_zero_GD_MOTHER_ID, "pi_zero_resolved_MC_GD_MOTHER_ID"));
Cuts.push_back("abs(pi_zero_resolved_MC_GD_MOTHER_ID) == " + to_string(TRUEID.B_PLUS));
int gamma1_GD_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(gamma1_GD_MOTHER_ID, "gamma1_MC_GD_MOTHER_ID"));
Cuts.push_back("abs(gamma1_MC_GD_MOTHER_ID) == " + to_string(TRUEID.K_STAR_PLUS));
int gamma2_GD_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(gamma2_GD_MOTHER_ID, "gamma2_MC_GD_MOTHER_ID"));
Cuts.push_back("abs(gamma2_MC_GD_MOTHER_ID) == " + to_string(TRUEID.K_STAR_PLUS));
//assign variables to TRUE_GD_MOTHER_ID
int gamma1_GD_GD_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(gamma1_GD_GD_MOTHER_ID, "gamma1_MC_GD_GD_MOTHER_ID"));
Cuts.push_back("abs(gamma1_MC_GD_GD_MOTHER_ID) == " + to_string(TRUEID.B_PLUS));
int gamma2_GD_GD_MOTHER_ID= 0;
IntBranches.push_back(new Int_branch(gamma2_GD_GD_MOTHER_ID, "gamma2_MC_GD_GD_MOTHER_ID"));
Cuts.push_back("abs(gamma2_MC_GD_GD_MOTHER_ID) == " + to_string(TRUEID.B_PLUS));
*/
}
int EpicOptimizer(std::string year = "2012", std::string magnet = "down", int Run = 0, bool MC = false,
bool ReferenceChannel = false, bool PHSP = false, bool preselected = true, bool truthMatched = false) {
int MaxEntries = 1000000;
//specify year(s)
std::vector<std::string> years;
if (!(Run == 0 || Run == 1 || Run == 2 || Run == 12)){
cout << "[INFO]\t\tWrong run number, allowed options are 0 ,1, 2 or 12!" << endl;
cout << "[INFO]\t\tUsing Run = 0, meaning year " << year << endl;
Run = 0;
}
switch (Run){
case (0): {
years.push_back(year);
break;
}
case (1): {
years.push_back("2011");
years.push_back("2012");
break;
}
case (2): {
years.push_back("2015");
years.push_back("2016");
break;
}
case (12): {
years.push_back("2011");
years.push_back("2012");
years.push_back("2015");
years.push_back("2016");
break;
}
}
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;
}
TFile* output = 0;
TChain* tree = 0;
if (!preselected){
if(Kst2Kpluspi0Resolved) tree=new TChain("b2KstKpi0mumuResolvedTuple/DecayTree");
if(Kst2Kpluspi0Merged) tree=new TChain("b2KstKpi0mumuMergeddTuple/DecayTree");
if(Kst2Kspiplus) tree=new TChain("b2KstKs0pimumu_Tuple/DecayTree");
}
else{
if ((MC||ReferenceChannel||PHSP) && truthMatched) tree=new TChain("DecayTreeTruthMatched");
else tree=new TChain("DecayTree");
}
for (std::vector<string>::iterator y = years.begin(); y != years.end(); ++y){ //load data for given years
if (!preselected){ //load stripped data
//Kst2Kpluspi0Resolved case
if(Kst2Kpluspi0Resolved){
if(!MC){
if(smallSample) tree->Add(Form("%s/data/%s%s/*B2Kstmumu*13.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else{
tree->Add(Form("%s/data/%s%s/*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
std::cout << "Adding " << Form("%s/data/%s%s/*B2Kstmumu*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()) << endl;
}
}
else{
if(ReferenceChannel){
if(smallSample) tree->Add(Form("%s/data/MC/RefKplusPi0/%s%s/*B2KstJpsi*1.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/MC/RefKplusPi0/%s%s/*B2KstJpsi*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
else if(PHSP){
if(smallSample) tree->Add(Form("%s/data/PHSP/KplusPi0/%s%s/*B2Kstmumu*1.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/PHSP/KplusPi0/%s%s/*B2Kstmumu*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
else{
if(smallSample) tree->Add(Form("%s/data/MC/KplusPi0/%s%s/*B2Kstmumu*1.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/MC/KplusPi0/%s%s/*B2Kstmumu*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
}
}
//Kst2Kpluspi0Merged case
if(Kst2Kpluspi0Merged){
if(!MC){
if(smallSample) tree->Add(Form("%s/data/%s%s/*B2Kstmumu*13.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/%s%s/*B2Kstmumu*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
else{
if(smallSample) tree->Add(Form("%s/data/MC/KplusPi0/%s%s/*B2Kstmumu*1.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/MC/KplusPi0/%s%s/*B2Kstmumu*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
}
//Kst2Kspiplus case
if(Kst2Kspiplus){
tree=new TChain("b2KstKs0pimumu_Tuple/DecayTree");
if(!MC){
if(smallSample) tree->Add(Form("%s/data/%s%s/*B2Kstmumu*23.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/%s%s/*B2Kstmumu*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
else{
if(ReferenceChannel){
if(smallSample) tree->Add(Form("%s/data/MC/RefKshortPiplus/%s%s/*B2KstJpsi*13.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/MC/RefKshortPiplus/%s%s/*B2KstJpsi*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
else if(PHSP){
if(smallSample) tree->Add(Form("%s/data/PHSP/KshortPiplus/%s%s/*B2Kstmumu*1.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/PHSP/KshortPiplus/%s%s/*B2Kstmumu*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
else{
if(smallSample) tree->Add(Form("%s/data/MC/KshortPiplus/%s%s/*B2Kstmumu*1.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
else tree->Add(Form("%s/data/MC/KshortPiplus/%s%s/*B2Kstmumu*.root",path_to_data.c_str(), y->c_str(),magnet.c_str()));
}
}
}
}
else{ //load preselected data
// Kst2Kpluspi0Resolved case
if(Kst2Kpluspi0Resolved){
if(!MC){
tree->Add(Form("%s/data/%s%s/%s%s_pi0Resolved.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
cout << Form("%s/data/%s%s/%s%s_pi0Resolved.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()) << endl;
}
else{
if(ReferenceChannel){
tree->Add(Form("%s/data/MC/RefKplusPi0/%s%s/%s%s_pi0Resolved.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
else if (PHSP){
tree->Add(Form("%s/data/PHSP/KplusPi0/%s%s/%s%s_pi0Resolved.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
else{
tree->Add(Form("%s/data/MC/KplusPi0/%s%s/%s%s_pi0Resolved.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
cout << Form("%s/data/MC/KplusPi0/%s%s/%s%s_pi0Resolved.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()) << endl;
}
}
}
// Kst2Kpluspi0Merged case
if(Kst2Kpluspi0Merged){
if(!MC){
tree->Add(Form("%s/data/%s%s/%s%s_pi0Merged.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
else{
if(ReferenceChannel){
tree->Add(Form("%s/data/MC/RefKplusPi0/%s%s/%s%s_pi0Merged.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
else if (PHSP){
tree->Add(Form("%s/data/PHSP/KplusPi0/%s%s/%s%s_pi0Merged.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
else{
tree->Add(Form("%s/data/MC/KplusPi0/%s%s/%s%s_pi0Merged.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
}
}
// Kst2Kspiplus case
if(Kst2Kspiplus){
if (!MC){
tree->Add(Form("%s/data/%s%s/%s%s_piplus.root",path_to_output_KshortPiplus.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
else{
if(ReferenceChannel){
tree->Add(Form("%s/data/MC/RefKshortPiplus/%s%s/%s%s_piplus.root",path_to_output_KshortPiplus.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
else if (PHSP){
tree->Add(Form("%s/data/PHSP/KshortPiplus/%s%s/%s%s_piplus.root",path_to_output_KplusPizero.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
else{
tree->Add(Form("%s/data/MC/KshortPiplus/%s%s/%s%s_piplus.root",path_to_output_KshortPiplus.c_str(), y->c_str(),magnet.c_str(), y->c_str(),magnet.c_str()));
}
}
}
} //end of preselected data if
} //end of the year loop
// set branches here
tree->SetBranchStatus("*",0);
cout << "[INFO]\tOld tree entries: " << tree->GetEntries() << endl;
AllBranches * AllB = NULL;
AllB = new AllBranches();
for (std::vector<Int_branch*>::iterator IB = AllB->IntBranches.begin(); IB != AllB->IntBranches.end(); ++IB){
tree->SetBranchStatus((*IB)->BranchName,1);
tree->SetBranchAddress((*IB)->BranchName,&(*IB)->BranchVar);
}
for (std::vector<Float_branch*>::iterator FB = AllB->FloatBranches.begin(); FB != AllB->FloatBranches.end(); ++FB){
tree->SetBranchStatus((*FB)->BranchName,1);
tree->SetBranchAddress((*FB)->BranchName,&(*FB)->BranchVar);
}
for (std::vector<Float_arr_branch*>::iterator FaB = AllB->FloatArrBranches.begin(); FaB != AllB->FloatArrBranches.end(); ++FaB){
tree->SetBranchStatus((*FaB)->BranchName,1);
tree->SetBranchAddress((*FaB)->BranchName,&(*FaB)->BranchVar);
}
for (std::vector<Double_branch*>::iterator DB = AllB->DoubleBranches.begin(); DB != AllB->DoubleBranches.end(); ++DB){
tree->SetBranchStatus((*DB)->BranchName,1);
tree->SetBranchAddress((*DB)->BranchName,&(*DB)->BranchVar);
}
for (std::vector<Double_arr_branch*>::iterator DaB = AllB->DoubleArrBranches.begin(); DaB != AllB->DoubleArrBranches.end(); ++DaB){
tree->SetBranchStatus((*DaB)->BranchName,1);
tree->SetBranchAddress((*DaB)->BranchName,&(*DaB)->BranchVar);
}
//parse cuts
std::string AllCuts = "";
if (AllB->Cuts.size()==0){
cout << "[ERROR]\t No cuts selected, just copying the tree." << endl;
return 0;
}
AllCuts = AllCuts + *AllB->Cuts.begin();
cout << "[INFO]\t\t MaxEntries: " << MaxEntries << endl;
cout << "[INFO]\t\t Appling cuts:" << endl;
cout << "\t\t\t" << AllCuts << endl;
for (vector<std::string>::iterator t = AllB->Cuts.begin()+1; t != AllB->Cuts.end(); ++t){
AllCuts = AllCuts + " && " + *t ;
cout << "\t\t\t" << *t << endl;
}
AllB->Cuts.clear();
TTree* NewTree = tree->CopyTree( AllCuts.c_str(),"",MaxEntries,0 );
cout << "[INFO]\tNew tree entries: " << NewTree->GetEntries() << endl;
//Set the appropriate outputfile
string path = "";
if (Run==0) Run = std::stoi( year );
// Kst2Kpluspi0Resolved case
if(Kst2Kpluspi0Resolved){
path = path_to_output_KplusPizero + "/data/";
if(!MC){
path =path+ to_string(Run) + magnet + "_" +(preselected ? "preselected" : "") + "_quickcheck_pi0Resolved.root";
output = new TFile(path.c_str(),"RECREATE");
}
else{
if(ReferenceChannel)path =path +"MC/RefKplusPi0";
else if (PHSP) path =path +"PHSP/KplusPi0/";
else path =path +"MC/KplusPi0/";
path =path + to_string(Run) + magnet +(preselected ? "_preselected" : "") + (truthMatched ? "_TruthMatched" : "") + "_quickcheck_pi0Resolved.root";
output = new TFile(path.c_str(),"RECREATE");
}
}
// Kst2Kpluspi0Merged case
if(Kst2Kpluspi0Merged){
path = path_to_output_KplusPizero + "/data/";
if(!MC){
path =path+ to_string(Run) + magnet + "_" +(preselected ? "preselected" : "") + "_quickcheck_pi0Merged.root";
output = new TFile(path.c_str(),"RECREATE");
}
else{
if(ReferenceChannel)path =path +"MC/RefKplusPi0";
else if (PHSP) path =path +"PHSP/KplusPi0/";
else path =path +"MC/KplusPi0/";
path =path + to_string(Run) + magnet +(preselected ? "_preselected" : "") + (truthMatched ? "_TruthMatched" : "") + "_quickcheck_pi0Merged.root";
output = new TFile(path.c_str(),"RECREATE");
}
}
// Kst2Kspiplus case //TODO: needs a check
if(Kst2Kspiplus){
path = path_to_output_KshortPiplus + "/data/";
if(!MC){
path =path+ to_string(Run) + magnet + "_" +(preselected ? "preselected" : "") + "_quickcheck_piplus.root";
output = new TFile(path.c_str(),"RECREATE");
}
else{
if(ReferenceChannel)path =path +"MC/RefKshortPiplus/";
else if (PHSP) path =path +"PHSP/KshortPiplus/";
else path =path +"MC/KshortPiplus/";
path =path + to_string(Run) + magnet +(preselected ? "_preselected" : "") + (truthMatched ? "_TruthMatched" : "") + "_quickcheck_piplus.root";
output = new TFile(path.c_str(),"RECREATE");
}
}
output->cd();
// Stupid arrays :)
/*
TCanvas *c1 = new TCanvas("c1", "", 10,10,800,800);
c1->cd();
NewTree->Draw("B_plus_DTF_Kst_892_plus_M[0]");
output->cd();
c1->Write();
*/
NewTree->Write();
output->Close();
cout << "[INFO]\t\t New tree created." << endl;
return 1;
}
int EpicOptimizerDataSeparate(string magnet = "down", bool preselected=false) {
if ( EpicOptimizer( "2011" ,magnet,0, false, false,false,preselected,false) == 0) return 0;
if ( EpicOptimizer( "2012" ,magnet,0, false, false,false,preselected,false) == 0) return 0;
if ( EpicOptimizer( "2015" ,magnet,0, false, false,false,preselected,false) == 0) return 0;
if ( EpicOptimizer( "2016" ,magnet,0, false, false,false,preselected,false) == 0) return 0;
return 1;
}
int EpicOptimizerAllDataSeparate(bool preselected) {
if ( EpicOptimizerDataSeparate("down",preselected) == 0) return 0;
if ( EpicOptimizerDataSeparate("up",preselected) == 0) return 0;
return 1;
}
int EpicOptimizerMCSeparate(string magnet = "down", bool preselected=false, bool truthMatched=false) {
if ( EpicOptimizer( "2011" ,magnet,0, true, false,false,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2012" ,magnet,0, true, false,false,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2015" ,magnet,0, true, false,false,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2016" ,magnet,0, true, false,false,preselected,truthMatched) == 0) return 0;
return 1;
}
int EpicOptimizerAllMCSeparate(bool preselected=false, bool truthMatched=false) {
if ( EpicOptimizerMCSeparate("down",preselected, truthMatched) == 0) return 0;
if ( EpicOptimizerMCSeparate("up", preselected, truthMatched) == 0) return 0;
return 1;
}
int EpicOptimizerRefSeparate(string magnet = "down", bool preselected=false, bool truthMatched=false) {
if ( EpicOptimizer( "2011" ,magnet,0, true, true,false,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2012" ,magnet,0, true, true,false,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2015" ,magnet,0, true, true,false,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2016" ,magnet,0, true, true,false,preselected,truthMatched) == 0) return 0;
return 1;
}
int EpicOptimizerAllRefSeparate(bool preselected=false, bool truthMatched=false) {
if ( EpicOptimizerRefSeparate("down",preselected, truthMatched) == 0) return 0;
if ( EpicOptimizerRefSeparate("up", preselected, truthMatched) == 0) return 0;
return 1;
}
int EpicOptimizerPHSPSeparate(string magnet = "down", bool preselected=false, bool truthMatched=false) {
if ( EpicOptimizer( "2011" ,magnet,0, true, false,true,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2012" ,magnet,0, true, false,true,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2015" ,magnet,0, true, false,true,preselected,truthMatched) == 0) return 0;
if ( EpicOptimizer( "2016" ,magnet,0, true, false,true,preselected,truthMatched) == 0) return 0;
return 1;
}
int EpicOptimizerAllPHSPSeparate(bool preselected=false, bool truthMatched=false) {
if ( EpicOptimizerPHSPSeparate("down",preselected, truthMatched) == 0) return 0;
if ( EpicOptimizerPHSPSeparate("up", preselected, truthMatched) == 0) return 0;
return 1;
}