933 lines
43 KiB
C++
933 lines
43 KiB
C++
//create MC weights for B+->Kst+mumu
|
|
//signal B+ mass is fitted to generate sPlots
|
|
//david gerick
|
|
//Renata Kopecna
|
|
|
|
#include "GlobalFunctions.hh"
|
|
#include "MassFit.cpp"
|
|
#include "Paths.hpp"
|
|
#include "Utils.hpp"
|
|
#include "BmassShape/ParamValues.hpp"
|
|
|
|
using namespace std;
|
|
using namespace RooFit ;
|
|
using namespace RooStats;
|
|
|
|
//////////////////////////////////////////////////////
|
|
/// quickFit()
|
|
//////////////////////////////////////////////////////
|
|
/// Function is imported from MassFit.hpp
|
|
///
|
|
/// the function merges up and down events into a new file.
|
|
/// from the fit to the B+ mass distribution, a sPlot weight is saved to a new Branch in this merged file.
|
|
/// the fitted B+ mass spectrum may be saved in pdf and root files
|
|
///
|
|
/// FEATURES:
|
|
/// - choose your background and signal model:
|
|
/// signal: (double) Gaussian, left/right/double CrystalBall function
|
|
/// background: (double) Exponential, Exponential plus RooExpGaus or no background
|
|
/// - get signal shape from MC data if needed and restrict shape to these parameters
|
|
///
|
|
/// OPTIONAL:
|
|
/// To determine the signal yield of the reference/resonance channel, the boolean UseOnlyJpsiEvents can be set.
|
|
/// Then only B+ -> J/psi K*+ events are fitted for S and B. The Q^2 bin #9 is taken, with 8.0 GeV^2 < Q^2 < 11.0 GeV^2
|
|
/// Also the seperation into DD and LL tracks for the Kshort Channel is possible!
|
|
///
|
|
///
|
|
///
|
|
//////////////////////////////////////////////////////
|
|
/// quickFitAll()
|
|
//////////////////////////////////////////////////////
|
|
///
|
|
/// Function to fit all years, sWeights all data years
|
|
/// Possible for data or MC. Most options of quickFit() are identically choosable
|
|
///
|
|
///
|
|
///
|
|
//////////////////////////////////////////////////////
|
|
/// NtrackWeight()
|
|
//////////////////////////////////////////////////////
|
|
///
|
|
/// the sPlot results from the quickFit() function are used to weight the nTrack signal distribution.
|
|
/// the ratio of MC / data of this nTrack distribution is used to create 1D weights for the MC sample,
|
|
/// which is later used as input for the BDT selection///
|
|
///
|
|
/// MC can be reweighted also without sWeights!
|
|
///
|
|
/// NEWLY ADDED: the sPlot results from the quickFit() function are used to 2 * 1D-weight the MC sample.
|
|
/// It will be weighted in nTracks first and then in the transverse momentum of the B+ (B_plus_PT)
|
|
///
|
|
/// Weight branches can be re-defined in GlobalFunctions.hh (see firstMCweight and seconMCweight)
|
|
///
|
|
///
|
|
///
|
|
//////////////////////////////////////////////////////
|
|
/// WeightAll()
|
|
//////////////////////////////////////////////////////
|
|
///
|
|
/// run the quickFit for both years, then apply NtrackWeights to both years.
|
|
///
|
|
///
|
|
///
|
|
//////////////////////////////////////////////////////
|
|
/// ReweightMCOnly()
|
|
//////////////////////////////////////////////////////
|
|
///
|
|
/// Do not fit the data but use the sWeighted data to re-weight the MC.
|
|
/// Including options to re-weight Reference channel MC and PHSP MC.
|
|
///
|
|
///
|
|
//////////////////////////////////////////////////////
|
|
/// GetSignalAndBckgndEstimation()
|
|
///
|
|
/// Uses the quickFit() function with the optional boolean to only fit the Jpsi events to get the estimation of
|
|
/// signal candidates for the reference channel before pre-selection. Via the PDG Branching Ratios, the signal
|
|
/// yield of the signal channel is calculated. From the total number of candidates for the signal channel within
|
|
/// the B-plus mass window estimated as 2*sigma window
|
|
/// the background is determined via B = N - S, with S the calculated signal estimation from
|
|
/// first part
|
|
///
|
|
/// (not very suitable for pi0)
|
|
///
|
|
|
|
//Initilize MC tracks histograms
|
|
TH1D *get_hist_MC_w(TH1D *hist, string name, bool is2D){
|
|
TH1D* hist_nTracks_MC_w = (TH1D*) hist->Clone((is2D ? seconMCweight : firstMCweight+name).c_str());
|
|
if (is2D) hist_nTracks_MC_w->SetTitle((seconMCweight+" MC 2D weights [norm.]").c_str());
|
|
else hist_nTracks_MC_w->SetTitle((firstMCweight+" MC weights [norm.]").c_str());
|
|
return hist_nTracks_MC_w;
|
|
}
|
|
|
|
//Initialize
|
|
TH1D *get_hist(string name, bool is2D, bool isMC){
|
|
TH1D* hist = NULL;
|
|
if (!isMC){
|
|
if (is2D) hist = new TH1D(seconMCweight.c_str(), (seconMCweight+" Yield [norm.]").c_str(), secondnBins, seconMCrange[0], seconMCrange[1]);
|
|
else hist = new TH1D(firstMCweight.c_str() ,(firstMCweight+" Yield [norm.]").c_str(), firstnBins, firstMCrange[0], firstMCrange[1]);
|
|
}
|
|
else{
|
|
if (is2D) hist = new TH1D((seconMCweight+name).c_str(),(seconMCweight+" MC weighted by "+firstMCweight+" [norm.]").c_str(), secondnBins, seconMCrange[0], seconMCrange[1]);
|
|
else hist = new TH1D((firstMCweight+name).c_str(),(firstMCweight+" MC [norm.]").c_str(), firstnBins, firstMCrange[0], firstMCrange[1]);
|
|
}
|
|
coutDebug("Hist name: " + string(hist->GetName()));
|
|
return hist;
|
|
}
|
|
|
|
|
|
//Get MC weights
|
|
void getWeightHist(TChain *tree, string weightName, TH1D *hist, TH1D *hist_w, string TMmethod, bool KshortDecayInVelo, bool gammaTM){
|
|
|
|
tree->SetBranchStatus("*",0);
|
|
//activate needed branches
|
|
tree->SetBranchStatus(TMmethod.c_str(),1);
|
|
tree->SetBranchStatus(weightName.c_str(),1);
|
|
if(Kst2Kspiplus)tree->SetBranchStatus("KshortDecayInVeLo",1);
|
|
|
|
//assign variables
|
|
Double_t weight = 0;
|
|
Int_t weight_I = 0;
|
|
bool isInt = false;
|
|
if (weightName.find("Track") != std::string::npos) isInt = true; //check if the value is integer or not
|
|
Int_t KshortDecayInVeLo = 0;
|
|
Int_t TMed = 0;
|
|
Int_t TMed_gammas = 0;
|
|
|
|
tree->SetBranchAddress(TMmethod.c_str(), &TMed);
|
|
tree->SetBranchAddress("TM_gammas",&TMed_gammas);
|
|
if (isInt) tree->SetBranchAddress(weightName.c_str() , &weight_I);
|
|
else tree->SetBranchAddress(weightName.c_str() , &weight);
|
|
|
|
if(Kst2Kspiplus)tree->SetBranchAddress("KshortDecayInVeLo" , &KshortDecayInVeLo);
|
|
|
|
int nEvts = tree->GetEntries();
|
|
for(int i=0; i < nEvts ; i++){
|
|
if (0ul == (i % 10000ul) || nEvts == i + 1) coutDebug("Read MC event " + to_string(i) + "/" + to_string(nEvts));
|
|
tree->GetEntry(i);
|
|
if (!isTM(TMmethod,TMed,gammaTM,TMed_gammas)) continue;
|
|
|
|
//only write the correct DD or LL tracks into the histogram!
|
|
if(Kst2Kspiplus && SplitDDandLL){
|
|
if (KshortDecayInVelo ^ KshortDecayInVeLo) continue; //^ is a xor operator
|
|
}
|
|
isInt ? hist->Fill(weight_I) : hist->Fill(TMath::Log(weight));
|
|
}
|
|
|
|
//normalize the histogram by its integral
|
|
hist->Sumw2();
|
|
hist->Scale(1./hist->Integral());
|
|
|
|
//divide histograms (hist_w = clone of hist_data)
|
|
hist_w->Divide(hist);
|
|
|
|
//reset branch links because root is stupid
|
|
tree->ResetBranchAddresses();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
//Find the weight for each event
|
|
void fillWeightHist(double &w, double &delta_w, int bin, bool TM, TH1D *h_w){
|
|
if (TM){
|
|
w = h_w->GetBinContent(bin);
|
|
delta_w = h_w->GetBinError(bin);
|
|
}
|
|
else{
|
|
w = 1.0;
|
|
delta_w = -1.0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
double getDelta_w2D(double w, double delta_w, double w2D, double delta_w2D){
|
|
if(delta_w < 0.0 || delta_w2D < 0.0)//keep delta_w2D negative, if both deltas are negative
|
|
return (-TMath::Sqrt(TMath::Power(delta_w*w2D,2)+TMath::Power(delta_w2D*w,2)));
|
|
else
|
|
return (TMath::Sqrt(TMath::Power(delta_w*w2D,2)+TMath::Power(delta_w2D*w,2)));
|
|
}
|
|
|
|
int quickFitAll(string SignalShape = "OneCB", string BckShape = "SingleExponential", bool sWeight=true, bool GetShapeFromMC = true,
|
|
bool ConstrainParameters = true, int Run = 1){
|
|
//Creates sWeights in data
|
|
|
|
bool UseOnlyJpsiEvents = true; //Set based on if reweighted by Jpsi or not
|
|
bool UseOnlyMuMuEvents = false;
|
|
std::vector<string> years = yearsMC(false,UseOnlyJpsiEvents,Run);
|
|
|
|
for(unsigned int y = 0; y < years.size(); y++){
|
|
if(Kst2Kspiplus && SplitDDandLL){
|
|
if(quickFit(years.at(y), false, sWeight, UseOnlyJpsiEvents, UseOnlyMuMuEvents, true, GetShapeFromMC, SignalShape, BckShape, ConstrainParameters) == 0){
|
|
coutERROR("Failed quickFit() for " + years.at(y) + " (LL tracks). Exit!");
|
|
return 0;
|
|
}
|
|
if(quickFit(years.at(y), false, sWeight, UseOnlyJpsiEvents, UseOnlyMuMuEvents, false, GetShapeFromMC, SignalShape, BckShape, ConstrainParameters) == 0){
|
|
coutERROR("Failed quickFit() for " + years.at(y) + " (DD tracks). Exit!");
|
|
return 0;
|
|
}
|
|
}
|
|
else{
|
|
if(quickFit(years.at(y), false, sWeight, UseOnlyJpsiEvents, UseOnlyMuMuEvents, false, GetShapeFromMC, SignalShape, BckShape, ConstrainParameters) == 0){
|
|
coutERROR("Failed quickFit() for " + years.at(y) + ". Exit!");
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int NtrackWeight(string year = "2011", const bool ReferenceChannel = false, bool PHSP = false, bool ReweightInBplusPT = true, bool KshortDecayInVelo = true, bool sWeightUse = true) {
|
|
//the bollean is called sWeightUse in order not to be confused with sWeight branches
|
|
|
|
coutInfo("Start MonteCarlo re-weighting: " + year + string(Kst2Kspiplus && SplitDDandLL ? (KshortDecayInVelo ? " (LL tracks)" : " (DD tracks)") : ""));
|
|
|
|
if (!checkMC(ReferenceChannel,PHSP)) return false;
|
|
//Make ROOT shutup
|
|
gStyle -> SetOptStat(0);
|
|
LHCbStyle();
|
|
gROOT->SetBatch(kTRUE);
|
|
|
|
//get data and MC file(s)
|
|
TChain * tree = new TChain("DecayTree");
|
|
TChain * treeMCTM = new TChain("DecayTreeTruthMatched");
|
|
TFile * output;
|
|
|
|
bool GetWeightsFromJpsiChannel = ReweightByRefChannel;
|
|
string MCyear = year;
|
|
if(KshortChannel){
|
|
if(ReweightByRefChannel && !checkRefYear(year))
|
|
GetWeightsFromJpsiChannel = false;
|
|
}
|
|
else{ //K+ pi0 channel
|
|
if (GetWeightsFromJpsiChannel && !checkRefYear(year)) MCyear = "2016"; //Use 2016 MC for reweighting 2017 and 2018 signal MC
|
|
}
|
|
//Decide if reweighting by Reference channel or not
|
|
bool loadRefChannel = (AlwaysUseRefChannelData || GetWeightsFromJpsiChannel || ReferenceChannel);
|
|
|
|
///DATA
|
|
//load sWeighted OnlyJpsi data OR load the full data-set of Jpsi and non-resonant mumu data events (sWeighted)
|
|
tree->Add(GetBDTinputFile(year,false,loadRefChannel,false,KshortDecayInVelo).c_str());
|
|
coutDebug("Adding " + GetBDTinputFile(year,false,loadRefChannel,false,KshortDecayInVelo));
|
|
|
|
///MC
|
|
//load MonteCarlo sample of up and down type. truthmatched and non-truthmatched
|
|
treeMCTM->Add(GetInputFile(MCyear,"down",true, true, loadRefChannel, false, false).c_str());
|
|
treeMCTM->Add(GetInputFile(MCyear,"up", true, true, loadRefChannel, false, false).c_str());
|
|
|
|
coutDebug("Adding " + GetInputFile(MCyear,"down",true, true, loadRefChannel, false, false));
|
|
coutDebug("Adding " + GetInputFile(MCyear,"up", true, true, loadRefChannel, false, false));
|
|
checkEntries(tree);
|
|
checkEntries(treeMCTM);
|
|
|
|
//deactivate all other branches
|
|
tree->SetBranchStatus("*",0);
|
|
tree->SetBranchStatus(firstMCweight.c_str(),1);
|
|
tree->SetBranchStatus(seconMCweight.c_str(),1);
|
|
if (sWeightUse) tree->SetBranchStatus("N_Bplus_sw",1);
|
|
//assign variables
|
|
Int_t nTracks = 0;
|
|
Double_t sWeights = 1.0;
|
|
Double_t B_plus_PT = 0.0;
|
|
|
|
//link variables to branches
|
|
tree->SetBranchAddress(firstMCweight.c_str() , &nTracks);
|
|
tree->SetBranchAddress(seconMCweight.c_str() , &B_plus_PT);
|
|
|
|
if (sWeightUse) tree->SetBranchAddress("N_Bplus_sw",&sWeights);
|
|
|
|
//Make histograms
|
|
TH1::SetDefaultSumw2();
|
|
TH2::SetDefaultSumw2();
|
|
|
|
TH1D* hist_nTracks = get_hist("",false,false);
|
|
TH1D* hist_nTracks_MC = get_hist("_MC",false,true);
|
|
TH1D* hist_nTracks_MC_TM = get_hist("_MC_TM",false,true);
|
|
TH1D* hist_nTracks_MC_TM_rndGamma = get_hist("_MC_TM_rndGamma",false,true);
|
|
TH1D* hist_nTracks_MC_noPi0TM = get_hist("_MC_noPi0TM",false,true);
|
|
|
|
TH1D* hist_BplusPT = get_hist("",true,false);
|
|
TH1D* hist_BplusPT_MC = get_hist("_weighted",true,true);
|
|
TH1D* hist_BplusPT_MC_TM = get_hist("_weighted_TM",true,true);
|
|
TH1D* hist_BplusPT_MC_TM_rndGamma = get_hist("_weighted_TM_rndGamma",true,true);
|
|
TH1D* hist_BplusPT_MC_noPi0TM = get_hist("_weighted_noPi0TM",true,true);
|
|
|
|
//histogram to check correlations between nTracks and B_plus_PT
|
|
TH2D* hCorrelationCheck = new TH2D((firstMCweight+"_"+seconMCweight+"_correlation").c_str(),("correlation between "+firstMCweight+" and "+seconMCweight).c_str(),
|
|
firstnBins,firstMCrange[0], firstMCrange[1], secondnBins, seconMCrange[0], seconMCrange[1]);
|
|
|
|
///-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/
|
|
/// load data (nTracks and B_plus_PT) into histograms
|
|
///-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/
|
|
|
|
Int_t nEvents = tree->GetEntries();
|
|
Int_t nEventsMCTM = treeMCTM->GetEntries();
|
|
|
|
//loop over data events
|
|
coutInfo("Loop over data sample from " + year + TheDecay + " to fill histogram!");
|
|
if (sWeightUse){
|
|
for(int i=0; i < nEvents; i++){
|
|
if (0ul == (i % 10000ul) || nEvents == i + 1) coutDebug("Read data event " + to_string(i) + "/" + to_string(nEvents));
|
|
tree->GetEntry(i);
|
|
hist_nTracks->Fill(nTracks, sWeights);
|
|
hist_BplusPT->Fill(TMath::Log(B_plus_PT), sWeights);
|
|
hCorrelationCheck->Fill(nTracks, TMath::Log(B_plus_PT), sWeights);
|
|
}
|
|
}
|
|
else {
|
|
for(int i=0; i < nEvents; i++){
|
|
if (0ul == (i % 10000ul) || nEvents == i + 1) coutDebug("Read data event " + to_string(i) + "/" + to_string(nEvents));
|
|
tree->GetEntry(i);
|
|
hist_nTracks->Fill(nTracks);
|
|
hist_BplusPT->Fill(TMath::Log(B_plus_PT));
|
|
hCorrelationCheck->Fill(nTracks, TMath::Log(B_plus_PT));
|
|
}
|
|
}
|
|
|
|
Double_t CorrelationCoefficent = hCorrelationCheck->GetCorrelationFactor();
|
|
coutDebug("The correlation coefficient between " + firstMCweight + " and " + seconMCweight + " is: " + to_string(CorrelationCoefficent));
|
|
|
|
//normalize histograms by its integral
|
|
hist_nTracks->Scale(1./hist_nTracks->Integral());
|
|
hist_BplusPT->Scale(1./hist_BplusPT->Integral());
|
|
|
|
//clone normalized histogram for determining the ratio between data/MC of nTracks string
|
|
//Make three histograms, each for given TM method
|
|
TH1D* hist_nTracks_MC_w = get_hist_MC_w(hist_nTracks,"_MC_weights", false);
|
|
TH1D* hist_nTracks_MC_w_TM = get_hist_MC_w(hist_nTracks,"_MC_weights_TM", false);
|
|
TH1D* hist_nTracks_MC_w_TM_rndGamma = get_hist_MC_w(hist_nTracks,"_MC_weights_TM_rndGamma", false);
|
|
TH1D* hist_nTracks_MC_w_noPi0TM = get_hist_MC_w(hist_nTracks,"_MC_weights_noPi0TM", false);
|
|
//clone normalized histogram for determining the ratio between data/MC
|
|
TH1D* hist_BplusPT_MC_w2D = get_hist_MC_w(hist_BplusPT,"_MC_weights", true);
|
|
TH1D* hist_BplusPT_MC_w2D_TM = get_hist_MC_w(hist_BplusPT,"_MC_weights_TM", true);
|
|
TH1D* hist_BplusPT_MC_w2D_TM_rndGamma = get_hist_MC_w(hist_BplusPT,"_MC_weights_TM_rndGamma", true);
|
|
TH1D* hist_BplusPT_MC_w2D_noPi0TM = get_hist_MC_w(hist_BplusPT,"_MC_weights_noPi0TM", true);
|
|
|
|
///////////////////////////////
|
|
/// reweight in nTracks
|
|
///////////////////////////////
|
|
|
|
treeMCTM->GetEntry(0);
|
|
coutInfo("Loop over MC sample from " + year + TheDecay + " to fill histogram for 1D reweighting in " + firstMCweight + "!");
|
|
getWeightHist(treeMCTM,firstMCweight,hist_nTracks_MC,hist_nTracks_MC_w,"TMedBKGCAT",KshortDecayInVelo, false);
|
|
getWeightHist(treeMCTM,firstMCweight,hist_nTracks_MC_TM,hist_nTracks_MC_w_TM,"TMed",KshortDecayInVelo, true);
|
|
if (!Kst2Kspiplus){
|
|
getWeightHist(treeMCTM,firstMCweight,hist_nTracks_MC_TM_rndGamma,hist_nTracks_MC_w_TM_rndGamma,"TMed",KshortDecayInVelo, false);
|
|
getWeightHist(treeMCTM,firstMCweight,hist_nTracks_MC_noPi0TM,hist_nTracks_MC_w_noPi0TM,"TMed_noPi0",KshortDecayInVelo, true);
|
|
}
|
|
|
|
///////////////////////////////
|
|
/// reweight in B_plus_PT
|
|
///////////////////////////////
|
|
|
|
if(ReweightInBplusPT){
|
|
coutInfo("Loop over MC sample from " + year + TheDecay + " to fill histogram for 1D reweighting in " + seconMCweight + "!");
|
|
getWeightHist(treeMCTM,seconMCweight,hist_BplusPT_MC,hist_BplusPT_MC_w2D,"TMedBKGCAT",KshortDecayInVelo, false);
|
|
getWeightHist(treeMCTM,seconMCweight,hist_BplusPT_MC_TM,hist_BplusPT_MC_w2D_TM,"TMed",KshortDecayInVelo, true);
|
|
if (!Kst2Kspiplus){
|
|
getWeightHist(treeMCTM,seconMCweight,hist_BplusPT_MC_TM_rndGamma,hist_BplusPT_MC_w2D_TM_rndGamma,"TMed",KshortDecayInVelo, false);
|
|
getWeightHist(treeMCTM,seconMCweight,hist_BplusPT_MC_noPi0TM,hist_BplusPT_MC_w2D_noPi0TM,"TMed_noPi0",KshortDecayInVelo, true);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
/// Plot the histograms to canvases
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
string canvasPath = "";
|
|
if(!PHSP && !ReferenceChannel){
|
|
canvasPath = GetControlPlots(year,ReferenceChannel,false,KshortDecayInVelo,sWeightUse,1).c_str();
|
|
drawKolmogorovTest(hist_nTracks, hist_nTracks_MC, canvasPath,"_BKGCAT");
|
|
drawKolmogorovTest(hist_nTracks, hist_nTracks_MC_TM, canvasPath,"_TM");
|
|
drawKolmogorovTest(hist_nTracks, hist_nTracks_MC_TM_rndGamma, canvasPath,"_TM_rndGamma");
|
|
//Plot correlation between B_plus and nTracks
|
|
canvasPath = GetControlPlots(year,ReferenceChannel,PHSP,KshortDecayInVelo,sWeightUse,4).c_str();
|
|
drawWeightCorrelation(hCorrelationCheck, CorrelationCoefficent, canvasPath);
|
|
}
|
|
|
|
//Plot the ratio
|
|
canvasPath = GetControlPlots(year,ReferenceChannel,PHSP,KshortDecayInVelo,sWeightUse,2).c_str();
|
|
drawWeightRatio(hist_nTracks_MC_w, canvasPath, false, "_BKGCAT");
|
|
drawWeightRatio(hist_nTracks_MC_w_TM, canvasPath, false, "_TM");
|
|
drawWeightRatio(hist_nTracks_MC_w_TM_rndGamma, canvasPath, false,"_TM_rndGamma");
|
|
|
|
//Plot the ratio for B_plus_PT
|
|
canvasPath = GetControlPlots(year,ReferenceChannel,PHSP,KshortDecayInVelo,sWeightUse,3).c_str();
|
|
drawWeightRatio(hist_BplusPT_MC_w2D, canvasPath, true, "_BKGCAT");
|
|
drawWeightRatio(hist_BplusPT_MC_w2D_TM, canvasPath, true, "_TM");
|
|
drawWeightRatio(hist_BplusPT_MC_w2D_TM_rndGamma, canvasPath, true,"_TM_rndGamma");
|
|
|
|
//////////////////////////////////
|
|
/// SAVE WEIGHTS TO MC
|
|
//////////////////////////////////
|
|
|
|
treeMCTM->ResetBranchAddresses();
|
|
treeMCTM->SetBranchStatus("*",1);
|
|
coutInfo("Copy MC Trees... ");
|
|
if (!ReferenceChannel && !PHSP && year=="2015") return 1; //Skip 2015 signal MC
|
|
TTree * newtreeMCTM;
|
|
TChain * reweightedTreeMCTM;
|
|
//if ReweightByRefChannel == true, the ratios above have been created with Jpsi data and MC
|
|
//but if we don't run for the ReferenceChannel, we want to load the correct Tree (so delete previous treeMCTM and treeMC and load new (Signal MC or PHSP)
|
|
|
|
if(GetWeightsFromJpsiChannel && !ReferenceChannel){
|
|
|
|
//to be safe, close trees of reference channel MC:
|
|
delete treeMCTM;
|
|
reweightedTreeMCTM = new TChain("DecayTreeTruthMatched");
|
|
if (reweightedTreeMCTM == NULL) coutERROR("Failed to create your new tree!");
|
|
|
|
//load trees from Signal MC files:
|
|
reweightedTreeMCTM ->Add(GetInputFile(year,"down",true,true,ReferenceChannel,PHSP,false).c_str());
|
|
reweightedTreeMCTM ->Add(GetInputFile(year,"up", true,true,ReferenceChannel,PHSP,false).c_str());
|
|
|
|
coutDebug("Loading " + GetInputFile(year,"down",true,true,ReferenceChannel,PHSP,false) );
|
|
coutDebug("Loading " + GetInputFile(year,"up", true,true,ReferenceChannel,PHSP,false) );
|
|
|
|
//remove an old BDTresponse branch, that might still be active in the tree after pre-selection:
|
|
TBranch * bTM = (TBranch *)reweightedTreeMCTM->GetBranch(TMVAmethod+"response");
|
|
if(bTM != NULL) reweightedTreeMCTM->SetBranchStatus("*response", 0);
|
|
|
|
//Get new event numbers for the Signal or PHSP trees:
|
|
nEventsMCTM = reweightedTreeMCTM->GetEntries();
|
|
|
|
//copy the loaded tree according to the cuts
|
|
if(Kst2Kspiplus && SplitDDandLL){
|
|
coutDebug("Apply track cut on MC Tree: " + string(KshortDecayInVelo ? "LL tracks!" : "DD tracks!"));
|
|
newtreeMCTM = reweightedTreeMCTM->CopyTree(Form("KshortDecayInVeLo == %i", KshortDecayInVelo ? 1 : 0));
|
|
}
|
|
else{
|
|
newtreeMCTM = reweightedTreeMCTM->CopyTree("");
|
|
}
|
|
coutDebug("Truthmatched Tree completed!");
|
|
|
|
}
|
|
|
|
else{ //if not forced to be reweighted from Jpsi channel, just copy the tree used above for the ratio:
|
|
|
|
//remove an old BDTresponse branch, that might still be active in the tree after pre-selection:
|
|
TBranch * bTM = (TBranch *)treeMCTM->GetBranch(TMVAmethod+"response");
|
|
if(bTM != NULL){
|
|
treeMCTM->SetBranchStatus("*response", 0);
|
|
}
|
|
|
|
if(Kst2Kspiplus && SplitDDandLL){
|
|
coutDebug("Apply track cut on MC Tree: " +string(KshortDecayInVelo ? "LL tracks!" : "DD tracks!"));
|
|
newtreeMCTM = treeMCTM->CopyTree(Form("KshortDecayInVeLo == %i", KshortDecayInVelo ? 1 : 0));
|
|
}
|
|
else{
|
|
coutDebug("Copying tree...");
|
|
newtreeMCTM = treeMCTM->CloneTree();
|
|
}
|
|
coutDebug("Truthmatched Tree completed!");
|
|
}
|
|
|
|
coutDebug("Old TM Tree entries:\t" + to_string(nEventsMCTM));
|
|
coutDebug("Copied TM Tree entries:\t" + to_string(newtreeMCTM->GetEntries()));
|
|
coutInfo("Adding branches to MC tree.");
|
|
|
|
//create new TBranches: each for different TM method and coresponding weight error branch
|
|
double w = 1., w2D = 1., delta_w = 0., delta_w2D = 0.;
|
|
double w_TM = 1., w2D_TM = 1., delta_w_TM = 0., delta_w2D_TM = 0.;
|
|
double w_noPi0TM = 1., w2D_noPi0TM = 1., delta_w_noPi0TM = 0., delta_w2D_noPi0TM = 0.;
|
|
double w_TM_rndGamma = 1., w2D_TM_rndGamma = 1., delta_w_TM_rndGamma = 0., delta_w2D_TM_rndGamma = 0.;
|
|
|
|
TBranch* Bra_w = newtreeMCTM->Branch(Form("weight_%s", firstMCweight.c_str()),&w, Form("weight_%s/D", firstMCweight.c_str()));
|
|
TBranch* Bra_w2D = newtreeMCTM->Branch(Form("weight2D_%s", firstMCweight.c_str()),&w2D,Form("weight2D_%s/D",firstMCweight.c_str()));
|
|
TBranch* Bra_delta_w = newtreeMCTM->Branch(Form("delta_weight_%s", firstMCweight.c_str()),&delta_w, Form("delta_weight_%s/D", firstMCweight.c_str()));
|
|
TBranch* Bra_delta_w2D= newtreeMCTM->Branch(Form("delta_weight2D_%s",firstMCweight.c_str()),&delta_w2D,Form("delta_weight2D_%s/D", firstMCweight.c_str()));
|
|
|
|
TBranch* Bra_w_TM = newtreeMCTM->Branch(Form("weight_%s_TM", firstMCweight.c_str()),&w_TM , Form("weight_%s_TM/D", firstMCweight.c_str()));
|
|
TBranch* Bra_w2D_TM = newtreeMCTM->Branch(Form("weight2D_%s_TM", firstMCweight.c_str()),&w2D_TM ,Form("weight2D_%s_TM/D",firstMCweight.c_str()));
|
|
TBranch* Bra_delta_w_TM = newtreeMCTM->Branch(Form("delta_weight_%s_TM", firstMCweight.c_str()),&delta_w_TM , Form("delta_weight_%s_TM/D", firstMCweight.c_str()));
|
|
TBranch* Bra_delta_w2D_TM= newtreeMCTM->Branch(Form("delta_weight2D_%s_TM",firstMCweight.c_str()),&delta_w2D_TM ,Form("delta_weight2D_%s_TM/D",firstMCweight.c_str()));
|
|
|
|
TBranch* Bra_w_noPi0TM = newtreeMCTM->Branch(Form("weight_%s_noPi0TM", firstMCweight.c_str()),&w_noPi0TM, Form("weight_%s_noPi0TM/D", firstMCweight.c_str()));
|
|
TBranch* Bra_w2D_noPi0TM = newtreeMCTM->Branch(Form("weight2D_%s_noPi0TM", firstMCweight.c_str()),&w2D_noPi0TM,Form("weight2D_%s_noPi0TM/D",firstMCweight.c_str()));
|
|
TBranch* Bra_delta_w_noPi0TM = newtreeMCTM->Branch(Form("delta_weight_%s_noPi0TM", firstMCweight.c_str()),&delta_w_noPi0TM, Form("delta_weight_%s_noPi0TM/D", firstMCweight.c_str()));
|
|
TBranch* Bra_delta_w2D_noPi0TM= newtreeMCTM->Branch(Form("delta_weight2D_%s_noPi0TM", firstMCweight.c_str()),&delta_w2D_noPi0TM,Form("delta_weight2D_%s_noPi0TM/D",firstMCweight.c_str()));
|
|
|
|
TBranch* Bra_w_TM_rndGamma = newtreeMCTM->Branch(Form("weight_%s_TM_rndGamma", firstMCweight.c_str()),&w_TM_rndGamma , Form("weight_%s_TM_rndGamma/D", firstMCweight.c_str()));
|
|
TBranch* Bra_w2D_TM_rndGamma = newtreeMCTM->Branch(Form("weight2D_%s_TM_rndGamma", firstMCweight.c_str()),&w2D_TM_rndGamma ,Form("weight2D_%s_TM_rndGamma/D",firstMCweight.c_str()));
|
|
TBranch* Bra_delta_w_TM_rndGamma = newtreeMCTM->Branch(Form("delta_weight_%s_TM_rndGamma", firstMCweight.c_str()),&delta_w_TM_rndGamma , Form("delta_weight_%s_TM_rndGamma/D", firstMCweight.c_str()));
|
|
TBranch* Bra_delta_w2D_TM_rndGamma= newtreeMCTM->Branch(Form("delta_weight2D_%s_TM_rndGamma",firstMCweight.c_str()),&delta_w2D_TM_rndGamma ,Form("delta_weight2D_%s_TM_rndGamma/D",firstMCweight.c_str()));
|
|
|
|
|
|
nEventsMCTM = newtreeMCTM->GetEntries();
|
|
coutInfo("Looping over MC tree with " + to_string(nEventsMCTM) + " entries.");
|
|
|
|
//renew links to branches in new tree:
|
|
//status is already set to 1 for all
|
|
Int_t TMedBKGCAT, TMed, TMed_noPi0;
|
|
Int_t gammaTMed;
|
|
Int_t nTracksMC;
|
|
Double_t B_plus_PTMC;
|
|
|
|
newtreeMCTM->SetBranchAddress("TMedBKGCAT" , &TMedBKGCAT);
|
|
newtreeMCTM->SetBranchAddress("TMed" , &TMed);
|
|
if (!Kst2Kspiplus){
|
|
newtreeMCTM->SetBranchAddress("TMed_noPi0", &TMed_noPi0);
|
|
newtreeMCTM->SetBranchAddress(gammaTMbranch.c_str() , &gammaTMed);
|
|
}
|
|
newtreeMCTM->SetBranchAddress((firstMCweight).c_str() , &nTracksMC);
|
|
newtreeMCTM->SetBranchAddress((seconMCweight).c_str() , &B_plus_PTMC);
|
|
|
|
Int_t nTrackBin = 1, nBplusBin = 1;
|
|
|
|
//loop over MC events (Only the TruthMatched events get weights!)
|
|
coutInfo("Loop over MC data from " + year + TheDecay + " to get weights for MC");
|
|
for(int i=0; i < nEventsMCTM; i++)
|
|
{
|
|
if (0ul == (i % 10000ul) || nEventsMCTM == i + 1) coutDebug("Read MC event " + to_string(i) + "/" + to_string(nEventsMCTM));
|
|
newtreeMCTM->GetEntry(i);
|
|
|
|
//1D weights
|
|
if(nTracksMC < firstMCrange[0] || nTracksMC > firstMCrange[1]){
|
|
coutInfo(firstMCweight + " out of range: " + to_string(nTracksMC) + " in event: " + to_string(i));
|
|
w = 1.0;
|
|
delta_w = -1.0; //set negative for when no value could be obtained
|
|
w_TM = 1.0;
|
|
delta_w_TM = -1.0;
|
|
w_TM_rndGamma = 1.0;
|
|
delta_w_TM_rndGamma = -1.0;
|
|
w_noPi0TM = 1.0;
|
|
delta_w_noPi0TM = -1.0;
|
|
}
|
|
else{
|
|
nTrackBin = hist_nTracks->FindBin(nTracksMC);
|
|
fillWeightHist(w, delta_w, nTrackBin, TMedBKGCAT, hist_nTracks_MC_w);
|
|
fillWeightHist(w_TM, delta_w_TM, nTrackBin, isTM("TMed",TMed,true, gammaTMed), hist_nTracks_MC_w_TM);
|
|
fillWeightHist(w_TM_rndGamma, delta_w_TM_rndGamma, nTrackBin, isTM("TMed",TMed,false,gammaTMed), hist_nTracks_MC_w_TM_rndGamma);
|
|
fillWeightHist(w_noPi0TM, delta_w_noPi0TM, nTrackBin, isTM("TMed",TMed,true, gammaTMed), hist_nTracks_MC_w_noPi0TM);
|
|
}
|
|
|
|
//2 x 1D weights
|
|
B_plus_PTMC = TMath::Log(B_plus_PTMC);
|
|
if(B_plus_PTMC < seconMCrange[0] || B_plus_PTMC > seconMCrange[1]){
|
|
coutInfo(seconMCweight + " out of range: " + to_string(B_plus_PTMC) + " in event: " + to_string(i));
|
|
w2D = 1.0;
|
|
delta_w2D = -1.0; //set negative for when no value could be obtained
|
|
w2D_TM = 1.0;
|
|
delta_w2D_TM = -1.0;
|
|
w2D_noPi0TM = 1.0;
|
|
delta_w2D_noPi0TM = -1.0;
|
|
}
|
|
else{
|
|
nBplusBin = hist_BplusPT->FindBin(B_plus_PTMC);
|
|
|
|
fillWeightHist(w2D, delta_w2D, nBplusBin, TMedBKGCAT, hist_BplusPT_MC_w2D);
|
|
fillWeightHist(w2D_TM, delta_w2D_TM, nBplusBin, isTM("TMed",TMed,true,gammaTMed), hist_BplusPT_MC_w2D_TM);
|
|
fillWeightHist(w2D_TM_rndGamma, delta_w2D_TM_rndGamma, nBplusBin, isTM("TMed",TMed,false,gammaTMed), hist_BplusPT_MC_w2D_TM_rndGamma);
|
|
fillWeightHist(w2D_noPi0TM, delta_w2D_noPi0TM, nBplusBin, isTM("TMed",TMed,true,gammaTMed), hist_BplusPT_MC_w2D_noPi0TM);
|
|
}
|
|
|
|
//save uncertainties on weights BEFORE weights, as w2D gets overwritten later on:
|
|
delta_w2D = getDelta_w2D(w, delta_w, w2D, delta_w2D);
|
|
delta_w2D_TM = getDelta_w2D(w_TM, delta_w_TM, w2D_TM, delta_w2D_TM);
|
|
delta_w2D_TM_rndGamma = getDelta_w2D(w_TM_rndGamma, delta_w_TM_rndGamma, w2D_TM_rndGamma, delta_w2D_TM_rndGamma);
|
|
delta_w2D_noPi0TM = getDelta_w2D(w_noPi0TM, delta_w_noPi0TM, w2D_noPi0TM, delta_w2D_noPi0TM);
|
|
|
|
//Fill the branches with uncertainties on weights
|
|
Bra_delta_w->Fill();
|
|
Bra_delta_w2D->Fill();
|
|
Bra_delta_w_TM->Fill();
|
|
Bra_delta_w2D_TM->Fill();
|
|
Bra_delta_w_TM_rndGamma->Fill();
|
|
Bra_delta_w2D_TM_rndGamma->Fill();
|
|
Bra_delta_w_noPi0TM->Fill();
|
|
Bra_delta_w2D_noPi0TM->Fill();
|
|
|
|
//prevent weight <= 0!
|
|
if(w<=0.)w=1.;
|
|
if(w2D<=0.)w2D=1.;
|
|
if(w_TM<=0.)w_TM=1.;
|
|
if(w2D_TM<=0.)w2D_TM=1.;
|
|
if(w_TM_rndGamma<=0.)w_TM_rndGamma=1.;
|
|
if(w2D_TM_rndGamma<=0.)w2D_TM_rndGamma=1.;
|
|
if(w_noPi0TM<=0.)w_noPi0TM=1.;
|
|
if(w2D_noPi0TM<=0.)w2D_noPi0TM=1.;
|
|
|
|
//Recalculate 2D weights
|
|
w2D*=w;
|
|
w2D_TM*=w_TM;
|
|
w2D_TM_rndGamma*=w_TM_rndGamma;
|
|
w2D_noPi0TM*=w_noPi0TM;
|
|
|
|
//Fill weights
|
|
Bra_w->Fill();
|
|
Bra_w2D->Fill();
|
|
Bra_w_TM->Fill();
|
|
Bra_w2D_TM->Fill();
|
|
Bra_w_TM_rndGamma->Fill();
|
|
Bra_w2D_TM_rndGamma->Fill();
|
|
Bra_w_noPi0TM->Fill();
|
|
Bra_w2D_noPi0TM->Fill();
|
|
|
|
}
|
|
|
|
//create output file for re-weighted and combined trees (truthmatched and non-truthmatched)
|
|
coutInfo("Save re-weighted tree to file: " + GetBDTinputFile(year,true,ReferenceChannel,PHSP,KshortDecayInVelo));
|
|
output = new TFile(GetBDTinputFile(year,true,ReferenceChannel,PHSP,KshortDecayInVelo).c_str(),"RECREATE");
|
|
|
|
if(!output->IsOpen()){
|
|
coutERROR("Could not create output file. Abort!");
|
|
return 0;
|
|
}
|
|
|
|
output->cd();
|
|
coutInfo("Saving new tree of MC data " + year + TheDecay + " to file!");
|
|
newtreeMCTM->Write("",TObject::kWriteDelete);
|
|
|
|
hist_nTracks_MC_w->Clear();
|
|
hist_nTracks_MC_w_TM->Clear();
|
|
hist_nTracks_MC_w_TM_rndGamma->Clear();
|
|
hist_nTracks_MC_w_noPi0TM->Clear();
|
|
|
|
hist_nTracks->Clear();
|
|
hist_nTracks_MC->Clear();
|
|
hist_nTracks_MC_TM->Clear();
|
|
hist_nTracks_MC_TM_rndGamma->Clear();
|
|
hist_nTracks_MC_noPi0TM->Clear();
|
|
|
|
hist_BplusPT->Clear();
|
|
hist_BplusPT_MC->Clear();
|
|
hist_BplusPT_MC_TM->Clear();
|
|
hist_BplusPT_MC_TM_rndGamma->Clear();
|
|
hist_BplusPT_MC_noPi0TM->Clear();
|
|
|
|
hist_BplusPT_MC_w2D->Clear();
|
|
hist_BplusPT_MC_w2D_TM->Clear();
|
|
hist_BplusPT_MC_w2D_TM_rndGamma->Clear();
|
|
hist_BplusPT_MC_w2D_noPi0TM->Clear();
|
|
|
|
output->Close();
|
|
gROOT->Reset();
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
int NtrackWeightAllKplus(const bool ReferenceChannel = false, bool PHSP = false, bool ReweightInBplusPT = true){
|
|
vector <string> years = yearsVector(true,ReferenceChannel,PHSP,12);
|
|
for (auto year: years)
|
|
if (NtrackWeight(year, ReferenceChannel, PHSP, ReweightInBplusPT, false, true)==0) return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
int WeightYear(string year = "2011", bool WeightBplusPT = true, bool GetShapeFromMC = true, bool sWeight = true){
|
|
|
|
bool ConstrainParameters = KshortChannel ? false : true;
|
|
|
|
string SignalFunction = Kst2Kspiplus ? "OneCB" : "OneCB";
|
|
string BackGroundFunction = Kst2Kspiplus ? "SingleExponential" : "SingleExponential";
|
|
|
|
if((ReweightByRefChannel && (checkRefYear(year) || !KshortChannel)) || AlwaysUseRefChannelData){ //reweight data by RefChannel MC, for Kshort only Run1
|
|
if(Kst2Kspiplus && SplitDDandLL){
|
|
|
|
//fit Jpsi channel only (create sWeights)
|
|
if(quickFit(year, false, sWeight, true, false, true, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " Jpsi data (LL tracks) failed!");
|
|
return 0;
|
|
}
|
|
if(quickFit(year, false, sWeight, true, false, false, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " Jpsi data (DD tracks) failed!");
|
|
return 0;
|
|
}
|
|
|
|
//fit all events (Jpsi + non-resonant, but no sWeights!)
|
|
if(quickFit(year, false, sWeight, false, false, true, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " data (LL tracks) failed!");
|
|
return 0;
|
|
}
|
|
if(quickFit(year, false, sWeight, false, false, false, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " data (DD tracks) failed!");
|
|
return 0;
|
|
}
|
|
|
|
//Apply sWeights from Jpsi channel to MC
|
|
if(NtrackWeight(year, false, false, WeightBplusPT, true, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + " MC (LL tracks) failed!");
|
|
return 0;
|
|
}
|
|
if(NtrackWeight(year, false, false, WeightBplusPT, false, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + " MC (DD tracks) failed!");
|
|
return 0;
|
|
}
|
|
}
|
|
else{
|
|
//fit Jpsi channel only (create sWeights) for pi0 or don't split LL/DD
|
|
if(quickFit(year, false, true, true, false, false, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " Jpsi data failed!");
|
|
return 0;
|
|
}
|
|
//fit all events (Jpsi + non-resonant, but no sWeights!)
|
|
if(quickFit(year, false, true, false, false, false, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " data failed!");
|
|
return 0;
|
|
}
|
|
//Apply sWeights from Jpsi channel to MC (and no need to add RefChannel, since the weights are aded automatically there
|
|
if(NtrackWeight(year, false, false, WeightBplusPT, false, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + " MC failed!");
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
else{ //reweight data by signal MC
|
|
if(Kst2Kspiplus && SplitDDandLL){
|
|
if(quickFit(year, false, sWeight, false, false, true, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " data (LL tracks) failed!");
|
|
return 0;
|
|
}
|
|
if(quickFit(year, false, sWeight, false, false, false, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " data (DD tracks) failed!");
|
|
return 0;
|
|
}
|
|
if(NtrackWeight(year, false, false, WeightBplusPT, true, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + " MC (LL tracks) failed!");
|
|
return 0;
|
|
}
|
|
if(NtrackWeight(year, false, false, WeightBplusPT, false, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + " MC (DD tracks) failed!");
|
|
return 0;
|
|
}
|
|
}
|
|
else{
|
|
//signal channel
|
|
if(quickFit(year, false, sWeight, false, false, false, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " data failed!");
|
|
return 0;
|
|
}
|
|
if(NtrackWeight(year, false, false, WeightBplusPT, false, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + " MC failed!");
|
|
return 0;
|
|
}
|
|
//reference channel
|
|
if(quickFit(year,false, sWeight, true, false, false, GetShapeFromMC, SignalFunction, BackGroundFunction, ConstrainParameters) == 0){
|
|
coutERROR("Fitting the B+ mass for " + year + " data failed!");
|
|
return 0;
|
|
}
|
|
if(NtrackWeight(year, true, false, WeightBplusPT, false, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + " MC failed!");
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
coutInfo("COMPLETED WEIGHTS FOR YEAR " + year);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int WeightAll(bool WeightBplusPT = true, Int_t Run = 1, bool sWeight = true){
|
|
|
|
bool GetShapeFromMC = true;
|
|
|
|
std::vector<string> years = yearsVector(false,false,false, Run);
|
|
for(unsigned int y = 0; y < years.size(); y++){
|
|
if(WeightYear(years.at(y), WeightBplusPT, GetShapeFromMC, sWeight) == 0){
|
|
coutERROR("sWeighting of the year " + years.at(y) + "did not succeed!");
|
|
return 0;
|
|
}
|
|
}
|
|
coutInfo("Weighting of all data and re-weighting of all signalMC was done!");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
int ReweightMCOnly(string year = "2011", bool ReferenceChannel = false, bool PHSP = false, bool WeightBplusPT = true, bool sWeight = true){
|
|
if (checkMC(ReferenceChannel,PHSP)==false) return 0;
|
|
|
|
if(NtrackWeight(year, ReferenceChannel, PHSP, WeightBplusPT, false, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + string(Kst2Kspiplus && SplitDDandLL ? " (DD tracks) " : "") + " MC failed!");
|
|
return 0;
|
|
}
|
|
|
|
if(Kst2Kspiplus && SplitDDandLL){
|
|
if(NtrackWeight(year, ReferenceChannel, PHSP, WeightBplusPT, true, sWeight) == 0){
|
|
coutERROR("Creating weights for nTrack distribution for " + year + " (LL tracks) MC failed!");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int ReweightSignalMC(bool WeightBplusPT = true, Int_t Run = 1, bool sWeight = true){
|
|
|
|
std::vector<string> years = yearsMC(false,false,Run);
|
|
|
|
for(unsigned int y = 0; y < years.size(); y++){
|
|
if(ReweightMCOnly(years.at(y), false, false, WeightBplusPT, sWeight) == 0){
|
|
coutERROR("Could not reweight signal MC for " + years.at(y) + ".Exit program");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
int ReweightPHSPMC(bool WeightBplusPT = true, Int_t Run = 1, bool sWeight = true){
|
|
|
|
std::vector<string> years = yearsMC(false,true,Run);
|
|
|
|
for(unsigned int y = 0; y < years.size(); y++){
|
|
if(ReweightMCOnly(years.at(y), false, true, WeightBplusPT, sWeight) == 0){
|
|
coutERROR("Could not reweight PHSP MC for " + years.at(y) + ".Exit program");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
int ReweightReferenceMC(bool WeightBplusPT = true, Int_t Run = 1, bool sWeight = true){
|
|
|
|
std::vector<string> years = yearsMC(true,false,Run);
|
|
|
|
for(unsigned int y = 0; y < years.size(); y++){
|
|
if(ReweightMCOnly(years.at(y), true, false, WeightBplusPT, sWeight) == 0){
|
|
coutERROR("Could not reweight Reference MC for " + years.at(y) + ".Exit program");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int ReweightAllMC(bool WeightBplusPT = true, Int_t Run = 1, bool sWeight = true){
|
|
if (ReweightSignalMC(WeightBplusPT,Run,sWeight) == 0) return 0;
|
|
if (ReweightReferenceMC(WeightBplusPT,Run,sWeight) == 0) return 0;
|
|
if (ReweightPHSPMC(WeightBplusPT,Run,sWeight) == 0) return 0;
|
|
return 1;
|
|
}
|
|
int ReweightAll(bool WeightBplusPT = true, Int_t Run = 1, bool sWeight = true){
|
|
if (WeightAll(WeightBplusPT,Run,sWeight) == 0) return 0;
|
|
if (ReweightAllMC(WeightBplusPT,Run,sWeight) == 0) return 0;
|
|
return 1;
|
|
}
|
|
|
|
int GetSignalAndBckgndEstimation(bool KshortDecaysInVelo = true, Int_t Run = 1){ //assumes S = N - B
|
|
|
|
std::vector<string> years = yearsData(Run);
|
|
|
|
gStyle -> SetOptStat(0);
|
|
LHCbStyle();
|
|
gROOT->SetBatch(kTRUE);
|
|
//lhcbStyle->SetOptTitle(1);
|
|
|
|
bool ConstrainParameters = false; //maybe not needed for signal estimation
|
|
|
|
if(Kst2Kspiplus){
|
|
ConstrainParameters = true;
|
|
}
|
|
|
|
string SignalFunction = "OneCB";
|
|
string BackGroundFunction;
|
|
if(Kst2Kspiplus){
|
|
if(KshortDecaysInVelo) BackGroundFunction = "SingleExponential";
|
|
else BackGroundFunction = "DoubleExponential";
|
|
}
|
|
else BackGroundFunction = "SingleExponential";
|
|
|
|
|
|
//Get the yield of the reference channel from the quickfit, then scale it via the Branching Ratios of both decays
|
|
Int_t SignalYield = 0;
|
|
for(unsigned int y = 0; y < years.size(); y++)
|
|
SignalYield += quickFit(years.at(y).c_str(), true, false, true, false, KshortDecaysInVelo, false, SignalFunction, BackGroundFunction, ConstrainParameters) * BR_sig / BR_ref;
|
|
|
|
//get number of candidates in the signal channel within the B_plus mass window
|
|
TChain * tree = new TChain("DecayTree");
|
|
|
|
for(unsigned int y = 0; y < years.size(); y++) tree->Add(GetBDTinputFile(years.at(y),false,false,false,KshortDecaysInVelo).c_str());
|
|
|
|
string q2Cuts = getMuMucut();
|
|
string sVariable = (UseDTF ? "B_plus_M_DTF" : "B_plus_M");
|
|
string massCuts = sVariable + "> " + to_string(FitValuesSignal.sig_mean.val - SignalRegionNsigma * FitValuesSignal.sig_effSigma.val)
|
|
+ " && " +
|
|
sVariable + " < " +to_string(FitValuesSignal.sig_mean.val + SignalRegionNsigma * FitValuesSignal.sig_effSigma.val);
|
|
string cut = "(" + q2Cuts + ") && (" + massCuts + ")";
|
|
|
|
|
|
//data: create histograms from tree
|
|
TCanvas * c1 = new TCanvas("c1", "c1");
|
|
tree->Draw(Form("%s>>B_plus_M_plot", sVariable.c_str()), cut.c_str());
|
|
TH1 * histo = ((TH1 *) gPad->GetPrimitive("B_plus_M_plot"));
|
|
|
|
//... get number of entries from histogram as N = B + S (!!!)
|
|
Int_t EventsAfterPreSelection = histo->GetEntries();
|
|
|
|
//correct title and axis labels and save histogram to PDF
|
|
string title = "B^{+} mass after preselection";
|
|
if(Kst2Kspiplus && SplitDDandLL)title.append(KshortDecaysInVelo ? " [LL tracks]" : " [DD tracks]");
|
|
histo->GetXaxis()->SetTitle("m(B^{+}) ( MeV/c^{2} )");
|
|
histo->GetYaxis()->SetTitle(Form("Events / ( %.1f MeV/c^{2} )", histo->GetBinWidth(1)));
|
|
histo->SetTitle(title.c_str());
|
|
histo->Draw();
|
|
if(Kst2Kpluspi0Resolved || Kst2Kpluspi0Merged){
|
|
c1->Print(Form("%s/SignalYieldHistos/%s_Run%i_SignalYield.eps", path_to_output_KplusPizero.c_str(), TheDecay.c_str(), Run));
|
|
c1->SaveAs(Form("%s/SignalYieldHistos/%s_Run%i_SignalYield.root", path_to_output_KplusPizero.c_str(), TheDecay.c_str(), Run));
|
|
}
|
|
else{
|
|
c1->Print(Form("%s/SignalYieldHistos/%s%s_Run%i_SignalYield.eps", path_to_output_KshortPiplus.c_str(), TheDecay.c_str(),(SplitDDandLL ? (KshortDecaysInVelo ? "_LL" : "_DD") : ""), Run));
|
|
c1->SaveAs(Form("%s/SignalYieldHistos/%s%s_Run%i_SignalYield.root", path_to_output_KshortPiplus.c_str(), TheDecay.c_str(),(SplitDDandLL ? (KshortDecaysInVelo ? "_LL" : "_DD") : ""), Run));
|
|
}
|
|
|
|
delete c1;
|
|
delete histo;
|
|
|
|
if (Kst2Kspiplus){
|
|
coutInfo("[SIGNAL]: " + string(Kst2Kspiplus && SplitDDandLL ? (KshortDecaysInVelo ? "LL Tracks: " : "DD Tracks: ") : "") + to_string(SignalYield));
|
|
coutInfo("[BCKGND]: " + string(Kst2Kspiplus && SplitDDandLL ? (KshortDecaysInVelo ? "LL Tracks: " : "DD Tracks: ") : "") + to_string(EventsAfterPreSelection - SignalYield));
|
|
}
|
|
else{
|
|
coutInfo(TheDecay + "[SIGNAL]: " + to_string(SignalYield));
|
|
coutInfo(TheDecay + "[BCKGND]: " + to_string(EventsAfterPreSelection - SignalYield));
|
|
}
|
|
return 1;
|
|
|
|
}
|
|
|
|
|