288 lines
10 KiB
C++
Executable File
288 lines
10 KiB
C++
Executable File
//Renata Kopecna
|
|
|
|
#include <event.hh>
|
|
|
|
#include <vector>
|
|
#include <iostream>
|
|
#include <assert.h>
|
|
|
|
#include "TFile.h"
|
|
#include "TTree.h"
|
|
#include "TMath.h"
|
|
|
|
#include <helpers.hh>
|
|
#include <paths.hh>
|
|
#include <bu2kstarmumu_loader.hh>
|
|
#include <options.hh>
|
|
|
|
#include <spdlog.h>
|
|
|
|
void fcnc::print_event(const event& meas)
|
|
{
|
|
spdlog::info("Event has" );
|
|
spdlog::info( " m: {0:f}", meas.m);
|
|
spdlog::info( " sigma_m: {0:f}", meas.sigma_m);
|
|
spdlog::info( " weight: {0:f}", meas.weight);
|
|
spdlog::info( " delta_weight: {0:f}", meas.delta_weight);
|
|
spdlog::info( " max_mu_pt: {0:f}", meas.max_mu_pt);
|
|
spdlog::info( " kaon_pt: {0:f}", meas.kaon_pt);
|
|
spdlog::info( " event_type: {0:d}", meas.event_type);
|
|
spdlog::info( " Magnet polarity: {0:d}", meas.magnet );
|
|
spdlog::info( " cos(thetal): {0:f}", meas.costhetal );
|
|
spdlog::info( " cos(thetak): {0:f}", meas.costhetak );
|
|
spdlog::info( " phi: {0:f}", meas.phi );
|
|
|
|
spdlog::info( " q2: {0:f}", meas.q2 );
|
|
spdlog::info( " p2: {0:f}", meas.p2 );
|
|
spdlog::info( " cp conjugate: " +(meas.cp_conjugate) );
|
|
|
|
//spdlog::trace( " tagging_decision: {0:f}", meas.tagging_decision );
|
|
//spdlog::trace( " tagging_dilution: {0:f}", meas.tagging_dilution );
|
|
//spdlog::trace( " efficiency: {0:f}", meas.efficiency );
|
|
}
|
|
|
|
void fcnc::save_events(std::string filename, const std::vector<fcnc::event>& events){
|
|
TFile* output = new TFile(filename.c_str(), "RECREATE");
|
|
output->cd();
|
|
TTree* tree = new TTree("Events", "Events");
|
|
//init and link parameters
|
|
bool cp_conjugate;
|
|
int year, magnet, event_type;
|
|
double m, mkpi, sigma_m, costhetal, costhetak, phi, q2, p2, weight, delta_weight, kaon_pt, max_mu_pt, pseudo_q2;
|
|
tree->Branch("year",&year,"year/I");
|
|
tree->Branch("m",&m,"m/D");
|
|
tree->Branch("mkpi",&mkpi,"mkpi/D");
|
|
tree->Branch("sigma_m",&sigma_m,"sigma_m/D");
|
|
tree->Branch("costhetal",&costhetal,"costhetal/D");
|
|
tree->Branch("costhetak",&costhetak,"costhetak/D");
|
|
tree->Branch("phi",&phi,"phi/D");
|
|
tree->Branch("magnet", &magnet, "magnet/I");
|
|
tree->Branch("q2",&q2,"q2/D");
|
|
tree->Branch("p2",&p2,"p2/D");
|
|
tree->Branch("cp_conjugate",&cp_conjugate,"cp_conjugate/O");
|
|
tree->Branch("weight", &weight, "weight/D");
|
|
tree->Branch("delta_weight", &delta_weight, "delta_weight/D");
|
|
tree->Branch("kaon_pt", &kaon_pt, "kaon_pt/D");
|
|
tree->Branch("max_mu_pt", &max_mu_pt, "max_mu_pt/D");
|
|
tree->Branch("pseudo_q2", &pseudo_q2, "pseudo_q2/D");
|
|
tree->Branch("event_type", &event_type, "event_type/I"); //TODO
|
|
spdlog::info( "START to fill events into TTree and save to file!" );
|
|
|
|
for (unsigned int i=0; i< events.size(); i++){
|
|
//get event from vector
|
|
fcnc::event meas = events.at(i);
|
|
//copy all values to the linked objects to save in TBranches
|
|
year = meas.year;
|
|
m = meas.m;
|
|
mkpi = meas.mkpi;
|
|
sigma_m = meas.sigma_m;
|
|
costhetal = meas.costhetal;
|
|
costhetak = meas.costhetak;
|
|
phi = meas.phi;
|
|
magnet = meas.magnet;
|
|
q2 = meas.q2;
|
|
p2 = meas.p2;
|
|
cp_conjugate = meas.cp_conjugate;
|
|
weight = meas.weight;
|
|
delta_weight = meas.delta_weight;
|
|
kaon_pt = meas.kaon_pt;
|
|
max_mu_pt = meas.max_mu_pt;
|
|
pseudo_q2 = meas.pseudo_q2;
|
|
event_type = meas.event_type;
|
|
//write to TTree
|
|
tree->Fill();
|
|
}
|
|
Int_t N = tree->GetEntries();
|
|
tree->Write();
|
|
output->Write();
|
|
output->Close();
|
|
spdlog::info("DONE: Successfully saved {0:d} (out of {1:d}) events to file {2:s}", N, events.size(), filename);
|
|
return;
|
|
|
|
}
|
|
|
|
void fcnc::lhcbtotheory(const bool b_plus, const double ctl_lhcb, const double ctk_lhcb, const double phi_lhcb, double& ctl_th, double& ctk_th, double& phi_th)
|
|
{
|
|
ctl_th = b_plus ? ctl_lhcb : -ctl_lhcb;
|
|
ctk_th = -ctk_lhcb;
|
|
if (b_plus)
|
|
phi_th = phi_lhcb > 0 ? TMath::Pi() - phi_lhcb : -TMath::Pi() - phi_lhcb;
|
|
else
|
|
phi_th = phi_lhcb;
|
|
}
|
|
|
|
void fcnc::theorytolhcb(const bool b_plus, const double ctl_th, const double ctk_th, const double phi_th, double& ctl_lhcb, double& ctk_lhcb, double& phi_lhcb)
|
|
{
|
|
ctl_lhcb = b_plus ? ctl_th : -ctl_th;
|
|
ctk_lhcb = -ctk_th;
|
|
if (b_plus)
|
|
phi_lhcb = phi_th > 0 ? TMath::Pi() - phi_th : -TMath::Pi() - phi_th;
|
|
else
|
|
phi_lhcb = phi_th;
|
|
}
|
|
|
|
void fcnc::save_eos_events(std::string filename, const std::vector<fcnc::event>& events)
|
|
{
|
|
TFile* output = new TFile(filename.c_str(), "RECREATE");
|
|
output->cd();
|
|
TTree* tree = new TTree("Events", "Events");
|
|
fcnc::event meas;
|
|
tree->Branch("m",&meas.m,"m/D");
|
|
tree->Branch("mkpi",&meas.mkpi,"mkpi/D");
|
|
//double costhetal_lhcb, costhetak_lhcb, phi_lhcb;
|
|
double costhetal_th, costhetak_th, phi_th;
|
|
|
|
// tree->Branch("costhetal",&costhetal_lhcb,"costhetal/D");
|
|
// tree->Branch("costhetak",&costhetak_lhcb,"costhetak/D");
|
|
// tree->Branch("phi",&phi_lhcb,"phi/D");
|
|
|
|
// tree->Branch("costhetal_theory",&meas.costhetal,"costhetal_theory/D");
|
|
// tree->Branch("costhetak_theory",&meas.costhetak,"costhetak_theory/D");
|
|
// tree->Branch("phi_theory",&meas.phi,"phi_theory/D");
|
|
|
|
tree->Branch("costhetal",&meas.costhetal,"costhetal/D");
|
|
tree->Branch("costhetak",&meas.costhetak,"costhetak/D");
|
|
tree->Branch("phi",&meas.phi,"phi/D");
|
|
|
|
tree->Branch("costhetal_theory",&costhetal_th,"costhetal_theory/D");
|
|
tree->Branch("costhetak_theory",&costhetak_th,"costhetak_theory/D");
|
|
tree->Branch("phi_theory",&phi_th,"phi_theory/D");
|
|
|
|
tree->Branch("q2",&meas.q2,"q2/D");
|
|
tree->Branch("p2",&meas.p2,"p2/D");
|
|
tree->Branch("cp_conjugate",&meas.cp_conjugate,"cp_conjugate/O");
|
|
int bid;
|
|
tree->Branch("bid",&bid,"bid/I");
|
|
tree->Branch("bkgcat", &meas.event_type, "bkgcat/I");
|
|
|
|
for (unsigned int i=0; i< events.size(); i++)
|
|
{
|
|
meas = events.at(i);
|
|
bid = meas.cp_conjugate ? +511 : -511;
|
|
|
|
//convert from theory convention to lhcb convention
|
|
lhcbtotheory(bid > 0, meas.costhetal, meas.costhetak, meas.phi, costhetal_th, costhetak_th, phi_th);
|
|
tree->Fill();
|
|
}
|
|
tree->Write();
|
|
output->Write();
|
|
output->Close();
|
|
delete output;
|
|
}
|
|
|
|
//Removes the resonances from the data sample
|
|
bool isResonance(double q2){
|
|
for (auto bin: EXCLUDED_Q2){
|
|
if (bin[0]<q2 && q2<bin[1]) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::vector<fcnc::event> fcnc::filterResonances(std::vector<fcnc::event> events){
|
|
std::vector<fcnc::event> filtered;
|
|
for (auto evt: events){
|
|
if (isResonance(evt.q2)) continue;
|
|
filtered.push_back(evt);
|
|
}
|
|
return filtered;
|
|
}
|
|
|
|
std::vector<fcnc::event> fcnc::load_events(std::string filename, std::string treename, int neventsmax)
|
|
{
|
|
spdlog::info("Reading " + filename + " into fcnc event vector.");
|
|
TFile* input = new TFile(filename.c_str(), "READ");
|
|
TTree* tree = dynamic_cast<TTree*>(input->Get(treename.c_str()));
|
|
spdlog::debug("Treename: " + std::string(tree->GetName()));
|
|
fcnc::event meas;
|
|
|
|
tree->SetBranchAddress("year", &meas.year);
|
|
tree->SetBranchAddress("m",&meas.m);
|
|
tree->SetBranchAddress("mkpi",&meas.mkpi);
|
|
tree->SetBranchAddress("sigma_m",&meas.sigma_m);
|
|
|
|
tree->SetBranchAddress("costhetal",&meas.costhetal);
|
|
tree->SetBranchAddress("costhetak",&meas.costhetak);
|
|
tree->SetBranchAddress("phi",&meas.phi);
|
|
|
|
tree->SetBranchAddress("q2",&meas.q2);
|
|
tree->SetBranchAddress("p2",&meas.p2);
|
|
tree->SetBranchAddress("cp_conjugate",&meas.cp_conjugate);
|
|
//tree->SetBranchAddress("bkgcat",&meas.event_type); //ONLY USED IN TOYS
|
|
tree->SetBranchAddress("magnet", &meas.magnet);
|
|
tree->SetBranchAddress("weight", &meas.weight);
|
|
tree->SetBranchAddress("delta_weight", &meas.delta_weight);
|
|
tree->SetBranchAddress("kaon_pt", &meas.kaon_pt);
|
|
tree->SetBranchAddress("max_mu_pt", &meas.max_mu_pt);
|
|
|
|
std::vector<fcnc::event> result;
|
|
unsigned int nmax = tree->GetEntries();
|
|
if (neventsmax > 0){
|
|
unsigned int n = TMath::Abs(neventsmax);
|
|
if(n < nmax)nmax = n;
|
|
}
|
|
for (unsigned int i=0; i< nmax; i++){
|
|
tree->GetEntry(i);
|
|
if (!isEvtInAngleRange(&meas)) continue;
|
|
meas.costhetal_fa = meas.costhetal;
|
|
meas.costhetak_fa = meas.costhetak;
|
|
meas.phi_fa = meas.phi;
|
|
result.push_back(meas);
|
|
}
|
|
spdlog::debug("Read events: {0:d}",result.size());
|
|
input->Close();
|
|
//delete tree;
|
|
delete input;
|
|
return result;
|
|
};
|
|
|
|
std::vector<fcnc::event> merge_two_evtVecs(std::vector<fcnc::event> one, std::vector<fcnc::event> two){
|
|
std::vector<fcnc::event> merged_vec;
|
|
merged_vec.insert(merged_vec.end(), one.begin(), one.end());
|
|
merged_vec.insert(merged_vec.end(), two.begin(), two.end());
|
|
return merged_vec;
|
|
}
|
|
|
|
//run over the complete tree and create a tree with only the branches needed for FCNC in the correct nomenclature of the FCNCfitter
|
|
//the data and MC samples are divided into 6 sub-samples: 2 per Run, 3 per sub-decay (K+pi0, KS0pi+(DD) and KS0pi-(LL))
|
|
int convert_tuples(int job_id, std::string theFCNCpath, fcnc::options opts,std::vector<int> years){
|
|
|
|
spdlog::info( "Converting "+get_sample_from_jobID(job_id)+" tuples of Run {0:d} to FCNC format",opts.run);
|
|
|
|
reset_spdlog(); // back to default format
|
|
|
|
//load the options
|
|
fcnc::bu2kstarmumu_loader loader(&opts);
|
|
|
|
//initialize a vector of this special class of events
|
|
std::vector<fcnc::event> theEvents;
|
|
|
|
if(job_id==4 || job_id ==5) years={2017}; //Only one year available for GenLvl
|
|
//read the full tuple for each year
|
|
std::string treePath;
|
|
for(auto yr: years){
|
|
//Set the tree name
|
|
treePath = getSelectedTuplePath(job_id,opts.run,yr);
|
|
spdlog::debug("Processing " +treePath);
|
|
//Load the event vector
|
|
std::vector<fcnc::event> Events = loader.read_full_tuple(yr, treePath, get_inputTree_name(job_id),
|
|
job_id>0, job_id>0 && opts.useMC, job_id>=4, -1);
|
|
spdlog::debug("Inserting the vector into theEvents...");
|
|
//Add
|
|
theEvents.insert(theEvents.end(), Events.begin(), Events.end());
|
|
}
|
|
|
|
//Some log messages
|
|
spdlog::debug("Event vector lenght: {0:d}",theEvents.size());
|
|
if (theEvents.size()==0){
|
|
spdlog::error("Empty event vector! Abort.");
|
|
assert(0);
|
|
}
|
|
spdlog::info("Completed loading sample: Run {0:d} with years {1:s}", opts.run, convert_vector_to_string(years));
|
|
|
|
//save events to standardised output filepath
|
|
fcnc::save_events(theFCNCpath, theEvents);
|
|
spdlog::info( "Completed saving sample: Run {0:d}.", opts.run );
|
|
|
|
return 0;
|
|
}
|