|
|
//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;
}
|