int main (int argc, char **argv)
{
gROOT->SetStyle ("Plain") ;
// Open a stream connected to an event file:
if (argc < 3) exit (1) ;
TNtuple ggFntuple ("ggFntuple", "ggFntuple", "Minv:Deta:DR:Dphi") ;
fillHistos (argv[1], ggFntuple) ;
TNtuple vbFntuple ("vbFntuple", "vbFntuple", "Minv:Deta:DR:Dphi") ;
fillHistos (argv[2], vbFntuple) ;
int bins = 50 ;
TH2F Minv_vs_deta_cont ("Minv_vs_deta_cont", "contamination in VBF selections",
bins, 0, 1500, bins, 0, 5) ;
Minv_vs_deta_cont.SetStats (0) ;
Minv_vs_deta_cont.GetXaxis ()->SetTitle ("M_{inv}") ;
Minv_vs_deta_cont.GetYaxis ()->SetTitle ("#Delta#eta") ;
double num_ggF = ggFntuple.GetEntries () ;
double num_vbF = vbFntuple.GetEntries () ;
double ggF_Xsec = 14.761 ; // pb NNLO
double vbF_Xsec = 1.6864 ; // pb NLO
for (double iMinv = 0.5 * (1500./bins) ; iMinv < 1500. ; iMinv += 1500./bins)
for (double iDeta = 0.5 * (5./bins) ; iDeta < 5. ; iDeta += 5./bins)
{
char cut[20] ;
sprintf (cut, "Minv>%f&&Deta>%f", iMinv, iDeta) ;
// std::cout << cut << std::endl ;
double num_ggF_sel = ggFntuple.GetEntries (cut) ;
double num_vbF_sel = vbFntuple.GetEntries (cut) ;
double val = (ggF_Xsec * num_ggF_sel / num_ggF) /
(ggF_Xsec * num_ggF_sel / num_ggF + vbF_Xsec * num_vbF_sel / num_vbF) ;
Minv_vs_deta_cont.Fill (iMinv, iDeta, val) ;
}
std::cout << "out of loop" << std::endl ;
TCanvas c1 ;
Minv_vs_deta_cont.Draw ("COLZ") ;
c1.Print ("Minv_vs_deta_cont.gif","gif") ;
TFile output ("ouptut.root","recreate") ;
output.cd () ;
Minv_vs_deta_cont.Write () ;
output.Close () ;
return 0 ;
}
void dataMC_ratio(int mBins = 30, // Z mass
double mLow = 60, // Z mass
double mHigh = 120, // Z mass
int ptBins = 120, // 195,
double ptLow = 0, // 50, // 50,
double ptHigh = 600, // 950, // 2000,
int rBins = 48, // Z rapidity
double rLow = -2.4, // Z rapidity
double rHigh = 2.4, // Z rapidity
bool isSave = true) {
//double xbins_pt[nptBins+1] = {0.001, 2.5, 5, 7.5, 10, 12.5, 15, 17.5, 20, 30, 40, 50, 70, 90, 110, 150, 190, 250, 600};
//double xbins_pt[nptBins+1] = {0.001, 2.5, 5, 7.5, 10, 12.5, 15, 17.5, 20, 30}; // From bin1
double xbins_pt[nptBins+1] = {30, 40, 50, 70, 90, 110, 150, 190, 250, 600}; // After bin9
TFile *Hist_out = new TFile("histo_withecalreprocessing.root","RECREATE");
gROOT->Clear();
gStyle->SetOptStat(0);
//gStyle->SetOptStat(111111);
loadGeneral();
// ---------------------------------------------------------------------------
// local variables
TString png = "png/";
TString root= "root/";
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// Fill the data
// TFile* fileData = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_5_ecalpatch1/Data/ntuplesWITHdz/SingleMuRun2012A_190949_191090_191367_193112_193116.root");
//TFile* fileData = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_5_ecalpatch1/Data/ntuplesWITHdz/fullselection/data2012A_LowPU.root");
TFile* fileData = new TFile("./fullselection/data2012A_LowPU.root");
TTree* treeData = (TTree*) fileData -> Get("tree");
TH1F* hMassData = new TH1F("hMassData", "", mBins, mLow, mHigh);
TH1F* hPtData = new TH1F("hPtData" , "", nptBins, xbins_pt);
TH1F* hPt20BData = new TH1F("hPt20BData" , "", ptBins, ptLow, ptHigh);
TH1F* hRapidityData = new TH1F("hRapidityData", "", rBins, rLow, rHigh);
TH1F* hVertexData = new TH1F("hVertexData", "", 25, 0, 25);
std::cout << "Filling Collisions Data Events\n";
fillHistos(treeData, hMassData, hPtData, hPt20BData, hRapidityData, hVertexData, mLow, mHigh, ptLow, ptHigh, 0);
hPtData->SetBinContent(1,hPtData->GetBinContent(1)/2.5);
hPtData->SetBinContent(2,hPtData->GetBinContent(2)/2.5);
hPtData->SetBinContent(3,hPtData->GetBinContent(3)/2.5);
hPtData->SetBinContent(4,hPtData->GetBinContent(4)/2.5);
hPtData->SetBinContent(5,hPtData->GetBinContent(5)/2.5);
hPtData->SetBinContent(6,hPtData->GetBinContent(6)/2.5);
hPtData->SetBinContent(7,hPtData->GetBinContent(7)/2.5);
hPtData->SetBinContent(8,hPtData->GetBinContent(8)/2.5);
hPtData->SetBinContent(9,hPtData->GetBinContent(9)/10.0);
hPtData->SetBinContent(10,hPtData->GetBinContent(10)/10.0);
hPtData->SetBinContent(11,hPtData->GetBinContent(11)/10.0);
hPtData->SetBinContent(12,hPtData->GetBinContent(12)/20.0);
hPtData->SetBinContent(13,hPtData->GetBinContent(13)/20.0);
hPtData->SetBinContent(14,hPtData->GetBinContent(14)/20.0);
hPtData->SetBinContent(15,hPtData->GetBinContent(15)/40.0);
hPtData->SetBinContent(16,hPtData->GetBinContent(16)/40.0);
hPtData->SetBinContent(17,hPtData->GetBinContent(17)/60.0);
hPtData->SetBinContent(18,hPtData->GetBinContent(18)/350.0);
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// Fill the DYToMuMu MC
// TFile* fileMC_dymumu = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/DYToMuMu/mergeFile/DYToMuMu_merged.root");
//TFile* fileMC_dymumu = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/fullselection/DYToMuMu.root");
TFile* fileMC_dymumu = new TFile("./fullselection/DYToMuMu.root");
//TFile* fileMC_dymumu = new TFile("./DYToMuMu_merged.root");
TTree* treeMC_dymumu = (TTree*) fileMC_dymumu -> Get("tree");
TH1F* hMassMC_dymumu = new TH1F("hMassMC_dymumu", "", mBins, mLow, mHigh);
TH1F* hPtMC_dymumu = new TH1F("hPtMC_dymumu", "", nptBins, xbins_pt);
TH1F* hPt20BMC_dymumu = new TH1F("hPt20BMC_dymumu", "", ptBins, ptLow, ptHigh);
TH1F* hRapidityMC_dymumu = new TH1F("hRapidityMC_dymumu", "", rBins, rLow, rHigh);
TH1F* hVertexMC_dymumu = new TH1F("hVertexMC_dymumu", "", 25, 0, 25);
std::cout << "filling DYToMuMu events\n";
fillHistos(treeMC_dymumu, hMassMC_dymumu, hPtMC_dymumu, hPt20BMC_dymumu, hRapidityMC_dymumu, hVertexMC_dymumu, mLow, mHigh, ptLow, ptHigh, 0);
hPtMC_dymumu->SetBinContent(1,hPtMC_dymumu->GetBinContent(1)/2.5);
hPtMC_dymumu->SetBinContent(2,hPtMC_dymumu->GetBinContent(2)/2.5);
hPtMC_dymumu->SetBinContent(3,hPtMC_dymumu->GetBinContent(3)/2.5);
hPtMC_dymumu->SetBinContent(4,hPtMC_dymumu->GetBinContent(4)/2.5);
hPtMC_dymumu->SetBinContent(5,hPtMC_dymumu->GetBinContent(5)/2.5);
hPtMC_dymumu->SetBinContent(6,hPtMC_dymumu->GetBinContent(6)/2.5);
hPtMC_dymumu->SetBinContent(7,hPtMC_dymumu->GetBinContent(7)/2.5);
hPtMC_dymumu->SetBinContent(8,hPtMC_dymumu->GetBinContent(8)/2.5);
hPtMC_dymumu->SetBinContent(9,hPtMC_dymumu->GetBinContent(9)/10.0);
hPtMC_dymumu->SetBinContent(10,hPtMC_dymumu->GetBinContent(10)/10.0);
hPtMC_dymumu->SetBinContent(11,hPtMC_dymumu->GetBinContent(11)/10.0);
hPtMC_dymumu->SetBinContent(12,hPtMC_dymumu->GetBinContent(12)/20.0);
hPtMC_dymumu->SetBinContent(13,hPtMC_dymumu->GetBinContent(13)/20.0);
hPtMC_dymumu->SetBinContent(14,hPtMC_dymumu->GetBinContent(14)/20.0);
hPtMC_dymumu->SetBinContent(15,hPtMC_dymumu->GetBinContent(15)/40.0);
hPtMC_dymumu->SetBinContent(16,hPtMC_dymumu->GetBinContent(16)/40.0);
hPtMC_dymumu->SetBinContent(17,hPtMC_dymumu->GetBinContent(17)/60.0);
hPtMC_dymumu->SetBinContent(18,hPtMC_dymumu->GetBinContent(18)/350.0);
// Fill the TTbarJets MC
// TFile* fileMC_ttbarjets = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/TTJets/mergeFile/TTJets_merged.root");
//TFile* fileMC_ttbarjets = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/fullselection/TTJets.root");
TFile* fileMC_ttbarjets = new TFile("./fullselection/TTJets.root");
TTree* treeMC_ttbarjets = (TTree*) fileMC_ttbarjets -> Get("tree");
TH1F* hMassMC_ttbarjets = new TH1F("hMassMC_ttbarjets", "", mBins, mLow, mHigh);
TH1F* hPtMC_ttbarjets = new TH1F("hPtMC_ttbarjets", "", nptBins, xbins_pt);
TH1F* hPt20BMC_ttbarjets = new TH1F("hPt20BMC_ttbarjets", "", ptBins, ptLow, ptHigh);
TH1F* hRapidityMC_ttbarjets = new TH1F("hRapidityMC_ttbarjets", "", rBins, rLow, rHigh);
TH1F* hVertexMC_ttbarjets = new TH1F("hVertexMC_ttbarjets", "", 25, 0, 25);
std::cout << "filling TTbar+Jets events\n";
fillHistos(treeMC_ttbarjets, hMassMC_ttbarjets, hPtMC_ttbarjets, hPt20BMC_ttbarjets, hRapidityMC_ttbarjets, hVertexMC_ttbarjets, mLow, mHigh, ptLow, ptHigh, 0);
hPtMC_ttbarjets->SetBinContent(1,hPtMC_ttbarjets->GetBinContent(1)/2.5);
hPtMC_ttbarjets->SetBinContent(2,hPtMC_ttbarjets->GetBinContent(2)/2.5);
hPtMC_ttbarjets->SetBinContent(3,hPtMC_ttbarjets->GetBinContent(3)/2.5);
hPtMC_ttbarjets->SetBinContent(4,hPtMC_ttbarjets->GetBinContent(4)/2.5);
hPtMC_ttbarjets->SetBinContent(5,hPtMC_ttbarjets->GetBinContent(5)/2.5);
hPtMC_ttbarjets->SetBinContent(6,hPtMC_ttbarjets->GetBinContent(6)/2.5);
hPtMC_ttbarjets->SetBinContent(7,hPtMC_ttbarjets->GetBinContent(7)/2.5);
hPtMC_ttbarjets->SetBinContent(8,hPtMC_ttbarjets->GetBinContent(8)/2.5);
hPtMC_ttbarjets->SetBinContent(9,hPtMC_ttbarjets->GetBinContent(9)/10.0);
hPtMC_ttbarjets->SetBinContent(10,hPtMC_ttbarjets->GetBinContent(10)/10.0);
hPtMC_ttbarjets->SetBinContent(11,hPtMC_ttbarjets->GetBinContent(11)/10.0);
hPtMC_ttbarjets->SetBinContent(12,hPtMC_ttbarjets->GetBinContent(12)/20.0);
hPtMC_ttbarjets->SetBinContent(13,hPtMC_ttbarjets->GetBinContent(13)/20.0);
hPtMC_ttbarjets->SetBinContent(14,hPtMC_ttbarjets->GetBinContent(14)/20.0);
hPtMC_ttbarjets->SetBinContent(15,hPtMC_ttbarjets->GetBinContent(15)/40.0);
hPtMC_ttbarjets->SetBinContent(16,hPtMC_ttbarjets->GetBinContent(16)/40.0);
hPtMC_ttbarjets->SetBinContent(17,hPtMC_ttbarjets->GetBinContent(17)/60.0);
hPtMC_ttbarjets->SetBinContent(18,hPtMC_ttbarjets->GetBinContent(18)/350.0);
//// Fill the ZTauTau MC
// TFile* fileMC_ztautau = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/DYToTauTau/mergeFile/DYToTauTau_merged.root");
//TFile* fileMC_ztautau = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/fullselection/DYToTauTau.root");
TFile* fileMC_ztautau = new TFile("./fullselection/DYToTauTau.root");
TTree* treeMC_ztautau = (TTree*) fileMC_ztautau -> Get("tree");
TH1F* hMassMC_ztautau = new TH1F("hMassMC_ztautau", "", mBins, mLow, mHigh);
TH1F* hPtMC_ztautau = new TH1F("hPtMC_ztautau", "", nptBins, xbins_pt);
TH1F* hPt20BMC_ztautau = new TH1F("hPt20BMC_ztautau", "", ptBins, ptLow, ptHigh);
TH1F* hRapidityMC_ztautau = new TH1F("hRapidityMC_ztautau", "", rBins, rLow, rHigh);
TH1F* hVertexMC_ztautau = new TH1F("hVertexMC_ztautau", "", 25, 0, 25);
std::cout << "filling ZToTauTau events\n";
fillHistos(treeMC_ztautau, hMassMC_ztautau, hPtMC_ztautau, hPt20BMC_ztautau, hRapidityMC_ztautau, hVertexMC_ztautau, mLow, mHigh, ptLow, ptHigh, 0);
hPtMC_ztautau->SetBinContent(1,hPtMC_ztautau->GetBinContent(1)/2.5);
hPtMC_ztautau->SetBinContent(2,hPtMC_ztautau->GetBinContent(2)/2.5);
hPtMC_ztautau->SetBinContent(3,hPtMC_ztautau->GetBinContent(3)/2.5);
hPtMC_ztautau->SetBinContent(4,hPtMC_ztautau->GetBinContent(4)/2.5);
hPtMC_ztautau->SetBinContent(5,hPtMC_ztautau->GetBinContent(5)/2.5);
hPtMC_ztautau->SetBinContent(6,hPtMC_ztautau->GetBinContent(6)/2.5);
hPtMC_ztautau->SetBinContent(7,hPtMC_ztautau->GetBinContent(7)/2.5);
hPtMC_ztautau->SetBinContent(8,hPtMC_ztautau->GetBinContent(8)/2.5);
hPtMC_ztautau->SetBinContent(9,hPtMC_ztautau->GetBinContent(9)/10.0);
hPtMC_ztautau->SetBinContent(10,hPtMC_ztautau->GetBinContent(10)/10.0);
hPtMC_ztautau->SetBinContent(11,hPtMC_ztautau->GetBinContent(11)/10.0);
hPtMC_ztautau->SetBinContent(12,hPtMC_ztautau->GetBinContent(12)/20.0);
hPtMC_ztautau->SetBinContent(13,hPtMC_ztautau->GetBinContent(13)/20.0);
hPtMC_ztautau->SetBinContent(14,hPtMC_ztautau->GetBinContent(14)/20.0);
hPtMC_ztautau->SetBinContent(15,hPtMC_ztautau->GetBinContent(15)/40.0);
hPtMC_ztautau->SetBinContent(16,hPtMC_ztautau->GetBinContent(16)/40.0);
hPtMC_ztautau->SetBinContent(17,hPtMC_ztautau->GetBinContent(17)/60.0);
hPtMC_ztautau->SetBinContent(18,hPtMC_ztautau->GetBinContent(18)/350.0);
// Fill the WZ MC
// TFile* fileMC_WZ = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/WZ/mergeFile/WZ_merged.root");
//TFile* fileMC_WZ = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/fullselection/WZ.root");
TFile* fileMC_WZ = new TFile("./fullselection/WZ.root");
TTree* treeMC_WZ = (TTree*) fileMC_WZ -> Get("tree");
TH1F* hMassMC_WZ = new TH1F("hMassMC_WZ", "", mBins, mLow, mHigh);
TH1F* hPtMC_WZ = new TH1F("hPtMC_WZ", "", nptBins, xbins_pt);
TH1F* hPt20BMC_WZ = new TH1F("hPt20BMC_WZ", "", ptBins, ptLow, ptHigh);
TH1F* hRapidityMC_WZ = new TH1F("hRapidityMC_WZ", "", rBins, rLow, rHigh);
TH1F* hVertexMC_WZ = new TH1F("hVertexMC_WZ", "", 25, 0, 25);
std::cout << "filling WZ events\n";
fillHistos(treeMC_WZ, hMassMC_WZ, hPtMC_WZ, hPt20BMC_WZ, hRapidityMC_WZ, hVertexMC_WZ, mLow, mHigh, ptLow, ptHigh, 0);
hPtMC_WZ->SetBinContent(1,hPtMC_WZ->GetBinContent(1)/2.5);
hPtMC_WZ->SetBinContent(2,hPtMC_WZ->GetBinContent(2)/2.5);
hPtMC_WZ->SetBinContent(3,hPtMC_WZ->GetBinContent(3)/2.5);
hPtMC_WZ->SetBinContent(4,hPtMC_WZ->GetBinContent(4)/2.5);
hPtMC_WZ->SetBinContent(5,hPtMC_WZ->GetBinContent(5)/2.5);
hPtMC_WZ->SetBinContent(6,hPtMC_WZ->GetBinContent(6)/2.5);
hPtMC_WZ->SetBinContent(7,hPtMC_WZ->GetBinContent(7)/2.5);
hPtMC_WZ->SetBinContent(8,hPtMC_WZ->GetBinContent(8)/2.5);
hPtMC_WZ->SetBinContent(9,hPtMC_WZ->GetBinContent(9)/10.0);
hPtMC_WZ->SetBinContent(10,hPtMC_WZ->GetBinContent(10)/10.0);
hPtMC_WZ->SetBinContent(11,hPtMC_WZ->GetBinContent(11)/10.0);
hPtMC_WZ->SetBinContent(12,hPtMC_WZ->GetBinContent(12)/20.0);
hPtMC_WZ->SetBinContent(13,hPtMC_WZ->GetBinContent(13)/20.0);
hPtMC_WZ->SetBinContent(14,hPtMC_WZ->GetBinContent(14)/20.0);
hPtMC_WZ->SetBinContent(15,hPtMC_WZ->GetBinContent(15)/40.0);
hPtMC_WZ->SetBinContent(16,hPtMC_WZ->GetBinContent(16)/40.0);
hPtMC_WZ->SetBinContent(17,hPtMC_WZ->GetBinContent(17)/60.0);
hPtMC_WZ->SetBinContent(18,hPtMC_WZ->GetBinContent(18)/350.0);
// Fill the ZZ MC
// TFile* fileMC_ZZ = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/ZZ/mergeFile/ZZ_merged.root");
//TFile* fileMC_ZZ = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/fullselection/ZZ.root");
TFile* fileMC_ZZ = new TFile("./fullselection/ZZ.root");
TTree* treeMC_ZZ = (TTree*) fileMC_ZZ -> Get("tree");
TH1F* hMassMC_ZZ = new TH1F("hMassMC_ZZ", "", mBins, mLow, mHigh);
TH1F* hPtMC_ZZ = new TH1F("hPtMC_ZZ", "", nptBins, xbins_pt);
TH1F* hPt20BMC_ZZ = new TH1F("hPt20BMC_ZZ", "", ptBins, ptLow, ptHigh);
TH1F* hRapidityMC_ZZ = new TH1F("hRapidityMC_ZZ", "", rBins, rLow, rHigh);
TH1F* hVertexMC_ZZ = new TH1F("hVertexMC_ZZ", "", 25, 0, 25);
std::cout << "filling ZZ events\n";
fillHistos(treeMC_ZZ, hMassMC_ZZ, hPtMC_ZZ, hPt20BMC_ZZ, hRapidityMC_ZZ, hVertexMC_ZZ, mLow, mHigh, ptLow, ptHigh, 0);
hPtMC_ZZ->SetBinContent(1,hPtMC_ZZ->GetBinContent(1)/2.5);
hPtMC_ZZ->SetBinContent(2,hPtMC_ZZ->GetBinContent(2)/2.5);
hPtMC_ZZ->SetBinContent(3,hPtMC_ZZ->GetBinContent(3)/2.5);
hPtMC_ZZ->SetBinContent(4,hPtMC_ZZ->GetBinContent(4)/2.5);
hPtMC_ZZ->SetBinContent(5,hPtMC_ZZ->GetBinContent(5)/2.5);
hPtMC_ZZ->SetBinContent(6,hPtMC_ZZ->GetBinContent(6)/2.5);
hPtMC_ZZ->SetBinContent(7,hPtMC_ZZ->GetBinContent(7)/2.5);
hPtMC_ZZ->SetBinContent(8,hPtMC_ZZ->GetBinContent(8)/2.5);
hPtMC_ZZ->SetBinContent(9,hPtMC_ZZ->GetBinContent(9)/10.0);
hPtMC_ZZ->SetBinContent(10,hPtMC_ZZ->GetBinContent(10)/10.0);
hPtMC_ZZ->SetBinContent(11,hPtMC_ZZ->GetBinContent(11)/10.0);
hPtMC_ZZ->SetBinContent(12,hPtMC_ZZ->GetBinContent(12)/20.0);
hPtMC_ZZ->SetBinContent(13,hPtMC_ZZ->GetBinContent(13)/20.0);
hPtMC_ZZ->SetBinContent(14,hPtMC_ZZ->GetBinContent(14)/20.0);
hPtMC_ZZ->SetBinContent(15,hPtMC_ZZ->GetBinContent(15)/40.0);
hPtMC_ZZ->SetBinContent(16,hPtMC_ZZ->GetBinContent(16)/40.0);
hPtMC_ZZ->SetBinContent(17,hPtMC_ZZ->GetBinContent(17)/60.0);
hPtMC_ZZ->SetBinContent(18,hPtMC_ZZ->GetBinContent(18)/350.0);
// Fill the WW MC
// TFile* fileMC_WW = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/WW/mergeFile/WW_merged.root");
//TFile* fileMC_WW = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/fullselection/WW.root");
TFile* fileMC_WW = new TFile("./fullselection/WW.root");
TTree* treeMC_WW = (TTree*) fileMC_WW -> Get("tree");
TH1F* hMassMC_WW = new TH1F("hMassMC_WW", "", mBins, mLow, mHigh);
TH1F* hPtMC_WW = new TH1F("hPtMC_WW", "", nptBins, xbins_pt);
TH1F* hPt20BMC_WW = new TH1F("hPt20BMC_WW", "", ptBins, ptLow, ptHigh);
TH1F* hRapidityMC_WW = new TH1F("hRapidityMC_WW", "", rBins, rLow, rHigh);
TH1F* hVertexMC_WW = new TH1F("hVertexMC_WW", "", 25, 0, 25);
std::cout << "filling WW events\n";
fillHistos(treeMC_WW, hMassMC_WW, hPtMC_WW, hPt20BMC_WW, hRapidityMC_WW, hVertexMC_WW, mLow, mHigh, ptLow, ptHigh, 0);
hPtMC_WW->SetBinContent(1,hPtMC_WW->GetBinContent(1)/2.5);
hPtMC_WW->SetBinContent(2,hPtMC_WW->GetBinContent(2)/2.5);
hPtMC_WW->SetBinContent(3,hPtMC_WW->GetBinContent(3)/2.5);
hPtMC_WW->SetBinContent(4,hPtMC_WW->GetBinContent(4)/2.5);
hPtMC_WW->SetBinContent(5,hPtMC_WW->GetBinContent(5)/2.5);
hPtMC_WW->SetBinContent(6,hPtMC_WW->GetBinContent(6)/2.5);
hPtMC_WW->SetBinContent(7,hPtMC_WW->GetBinContent(7)/2.5);
hPtMC_WW->SetBinContent(8,hPtMC_WW->GetBinContent(8)/2.5);
hPtMC_WW->SetBinContent(9,hPtMC_WW->GetBinContent(9)/10.0);
hPtMC_WW->SetBinContent(10,hPtMC_WW->GetBinContent(10)/10.0);
hPtMC_WW->SetBinContent(11,hPtMC_WW->GetBinContent(11)/10.0);
hPtMC_WW->SetBinContent(12,hPtMC_WW->GetBinContent(12)/20.0);
hPtMC_WW->SetBinContent(13,hPtMC_WW->GetBinContent(13)/20.0);
hPtMC_WW->SetBinContent(14,hPtMC_WW->GetBinContent(14)/20.0);
hPtMC_WW->SetBinContent(15,hPtMC_WW->GetBinContent(15)/40.0);
hPtMC_WW->SetBinContent(16,hPtMC_WW->GetBinContent(16)/40.0);
hPtMC_WW->SetBinContent(17,hPtMC_WW->GetBinContent(17)/60.0);
hPtMC_WW->SetBinContent(18,hPtMC_WW->GetBinContent(18)/350.0);
// Fill the WJetsToLNu MC
// TFile* fileMC_WJetsToLNu = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/WJetsToLNu/mergeFile/WJetsToLNu_merged.root");
//TFile* fileMC_WJetsToLNu = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/fullselection/WJetsToLNu.root");
TFile* fileMC_WJetsToLNu = new TFile("./fullselection/WJetsToLNu.root");
TTree* treeMC_WJetsToLNu = (TTree*) fileMC_WJetsToLNu -> Get("tree");
TH1F* hMassMC_WJetsToLNu = new TH1F("hMassMC_WJetsToLNu", "", mBins, mLow, mHigh);
TH1F* hPtMC_WJetsToLNu = new TH1F("hPtMC_WJetsToLNu", "", nptBins, xbins_pt);
TH1F* hPt20BMC_WJetsToLNu = new TH1F("hPt20BMC_WJetsToLNu", "", ptBins, ptLow, ptHigh);
TH1F* hRapidityMC_WJetsToLNu = new TH1F("hRapidityMC_WJetsToLNu", "", rBins, rLow, rHigh);
TH1F* hVertexMC_WJetsToLNu = new TH1F("hVertexMC_WJetsToLNu", "", 25, 0, 25);
std::cout << "filling WJetsToLNu events\n";
fillHistos(treeMC_WJetsToLNu, hMassMC_WJetsToLNu, hPtMC_WJetsToLNu, hPt20BMC_WJetsToLNu, hRapidityMC_WJetsToLNu, hVertexMC_WJetsToLNu, mLow, mHigh, ptLow, ptHigh, 0);
hPtMC_WJetsToLNu->SetBinContent(1,hPtMC_WJetsToLNu->GetBinContent(1)/2.5);
hPtMC_WJetsToLNu->SetBinContent(2,hPtMC_WJetsToLNu->GetBinContent(2)/2.5);
hPtMC_WJetsToLNu->SetBinContent(3,hPtMC_WJetsToLNu->GetBinContent(3)/2.5);
hPtMC_WJetsToLNu->SetBinContent(4,hPtMC_WJetsToLNu->GetBinContent(4)/2.5);
hPtMC_WJetsToLNu->SetBinContent(5,hPtMC_WJetsToLNu->GetBinContent(5)/2.5);
hPtMC_WJetsToLNu->SetBinContent(6,hPtMC_WJetsToLNu->GetBinContent(6)/2.5);
hPtMC_WJetsToLNu->SetBinContent(7,hPtMC_WJetsToLNu->GetBinContent(7)/2.5);
hPtMC_WJetsToLNu->SetBinContent(8,hPtMC_WJetsToLNu->GetBinContent(8)/2.5);
hPtMC_WJetsToLNu->SetBinContent(9,hPtMC_WJetsToLNu->GetBinContent(9)/10.0);
hPtMC_WJetsToLNu->SetBinContent(10,hPtMC_WJetsToLNu->GetBinContent(10)/10.0);
hPtMC_WJetsToLNu->SetBinContent(11,hPtMC_WJetsToLNu->GetBinContent(11)/10.0);
hPtMC_WJetsToLNu->SetBinContent(12,hPtMC_WJetsToLNu->GetBinContent(12)/20.0);
hPtMC_WJetsToLNu->SetBinContent(13,hPtMC_WJetsToLNu->GetBinContent(13)/20.0);
hPtMC_WJetsToLNu->SetBinContent(14,hPtMC_WJetsToLNu->GetBinContent(14)/20.0);
hPtMC_WJetsToLNu->SetBinContent(15,hPtMC_WJetsToLNu->GetBinContent(15)/40.0);
hPtMC_WJetsToLNu->SetBinContent(16,hPtMC_WJetsToLNu->GetBinContent(16)/40.0);
hPtMC_WJetsToLNu->SetBinContent(17,hPtMC_WJetsToLNu->GetBinContent(17)/60.0);
hPtMC_WJetsToLNu->SetBinContent(18,hPtMC_WJetsToLNu->GetBinContent(18)/350.0);
//Fill QCD MC
// TFile* fileMC_QCD = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/QCD/mergeFile/QCD_Pt_20_MuEnrichedPt_15_merged.root");
//TFile* fileMC_QCD = new TFile("/data/uftrig01b/nwickram/root/CMSSW_5_2_4_patch3/MC/ntuplesWITHdz/fullselection/QCD.root");
TFile* fileMC_QCD = new TFile("./fullselection/QCD.root");
TTree* treeMC_QCD = (TTree*) fileMC_QCD -> Get("tree");
TH1F* hMassMC_QCD = new TH1F("hMassMC_QCD", "", mBins, mLow, mHigh);
TH1F* hPtMC_QCD = new TH1F("hPtMC_QCD", "", nptBins, xbins_pt);
TH1F* hPt20BMC_QCD = new TH1F("hPt20BMC_QCD", "", ptBins, ptLow, ptHigh);
TH1F* hRapidityMC_QCD = new TH1F("hRapidityMC_QCD", "", rBins, rLow, rHigh);
TH1F* hVertexMC_QCD = new TH1F("hVertexMC_QCD", "", 25, 0, 25);
std::cout << "filling QCD events\n";
fillHistos(treeMC_QCD, hMassMC_QCD, hPtMC_QCD, hPt20BMC_QCD, hRapidityMC_QCD, hVertexMC_QCD, mLow, mHigh, ptLow, ptHigh, 0);
hPtMC_QCD->SetBinContent(1,hPtMC_QCD->GetBinContent(1)/2.5);
hPtMC_QCD->SetBinContent(2,hPtMC_QCD->GetBinContent(2)/2.5);
hPtMC_QCD->SetBinContent(3,hPtMC_QCD->GetBinContent(3)/2.5);
hPtMC_QCD->SetBinContent(4,hPtMC_QCD->GetBinContent(4)/2.5);
hPtMC_QCD->SetBinContent(5,hPtMC_QCD->GetBinContent(5)/2.5);
hPtMC_QCD->SetBinContent(6,hPtMC_QCD->GetBinContent(6)/2.5);
hPtMC_QCD->SetBinContent(7,hPtMC_QCD->GetBinContent(7)/2.5);
hPtMC_QCD->SetBinContent(8,hPtMC_QCD->GetBinContent(8)/2.5);
hPtMC_QCD->SetBinContent(9,hPtMC_QCD->GetBinContent(9)/10.0);
hPtMC_QCD->SetBinContent(10,hPtMC_QCD->GetBinContent(10)/10.0);
hPtMC_QCD->SetBinContent(11,hPtMC_QCD->GetBinContent(11)/10.0);
hPtMC_QCD->SetBinContent(12,hPtMC_QCD->GetBinContent(12)/20.0);
hPtMC_QCD->SetBinContent(13,hPtMC_QCD->GetBinContent(13)/20.0);
hPtMC_QCD->SetBinContent(14,hPtMC_QCD->GetBinContent(14)/20.0);
hPtMC_QCD->SetBinContent(15,hPtMC_QCD->GetBinContent(15)/40.0);
hPtMC_QCD->SetBinContent(16,hPtMC_QCD->GetBinContent(16)/40.0);
hPtMC_QCD->SetBinContent(17,hPtMC_QCD->GetBinContent(17)/60.0);
hPtMC_QCD->SetBinContent(18,hPtMC_QCD->GetBinContent(18)/350.0);
TH1F* hMassMC_allBkg = new TH1F("hMassMC_allBkg", "", mBins, mLow, mHigh);
THStack* sMassMC_allBkg = new THStack("sMassMC_allBkg","");
TH1F* hPt20BMC_allBkg = new TH1F("hPt20BMC_allBkg", "", ptBins, ptLow, ptHigh);
THStack* sPt20BMC_allBkg = new THStack("sPt20BMC_allBkg","");
TH1F* hPtMC_allBkg = new TH1F("hPtMC_allBkg", "", nptBins, xbins_pt);
TH1F* hPtMC_EWKBkg = new TH1F("hPtMC_EWKBkg", "", nptBins, xbins_pt);
THStack* sPtMC_allBkg = new THStack("sPtMC_allBkg","");
THStack* sPtMC_EWKBkg = new THStack("sPtMC_EWKBkg","");
TH1F* hRapidityMC_allBkg = new TH1F("hRapidityMC_allBkg", "", rBins, rLow, rHigh);
THStack* sRapidityMC_allBkg = new THStack("sRapidityMC_allBkg","");
TH1F* hVertexMC_allBkg = new TH1F("hVertexMC_allBkg", "", 25, 0, 25);
THStack* sVertexMC_allBkg = new THStack("sVertexMC_allBkg","");
//-------------------------------------------------------
//event counting before scaling
std::cout << "Event Counting before luminosity rescaling:" << std::endl;
outLatex(hMassData, "data");
outLatex(hMassMC_dymumu, "DYToMuMu");
outLatex(hMassMC_ttbarjets, "TTJets");
outLatex(hMassMC_ztautau, "Ztautau");
outLatex(hMassMC_WW, "WW");
outLatex(hMassMC_WZ, "WZ");
outLatex(hMassMC_ZZ, "ZZ");
outLatex(hMassMC_WJetsToLNu, "WJetsToLNu");
outLatex(hMassMC_QCD, "QCD");
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// Rescaling the MC to match the luminosity
std::cout << "xsec (Z/gamma + Jets, M_ll>50 GeV): " << xsec_dymumu << " pb" << std::endl;
hMassMC_dymumu -> Scale(intLumi_invpb*xsec_dymumu/nMCEvDYToMuMu);
hMassMC_ttbarjets -> Scale(intLumi_invpb*xsec_ttbarjets/nMCEvTTbarJets);
hMassMC_ztautau -> Scale(intLumi_invpb*xsec_ztautau/nMCEvZtautau);
hMassMC_WW -> Scale(intLumi_invpb*xsec_WW/nMCEvWW);
hMassMC_WZ -> Scale(intLumi_invpb*xsec_WZ/nMCEvWZ);
hMassMC_ZZ -> Scale(intLumi_invpb*xsec_ZZ/nMCEvZZ);
hMassMC_WJetsToLNu -> Scale(intLumi_invpb*xsec_WJetsToLNu/nMCEvWJetsToLNu);
hMassMC_QCD -> Scale(intLumi_invpb*xsec_QCD/nMCEvQCD);
hPtMC_dymumu -> Scale(intLumi_invpb*xsec_dymumu/nMCEvDYToMuMu);
hPtMC_ttbarjets -> Scale(intLumi_invpb*xsec_ttbarjets/nMCEvTTbarJets);
hPtMC_ztautau -> Scale(intLumi_invpb*xsec_ztautau/nMCEvZtautau);
hPtMC_WW -> Scale(intLumi_invpb*xsec_WW/nMCEvWW);
hPtMC_WZ -> Scale(intLumi_invpb*xsec_WZ/nMCEvWZ);
hPtMC_ZZ -> Scale(intLumi_invpb*xsec_ZZ/nMCEvZZ);
hPtMC_WJetsToLNu -> Scale(intLumi_invpb*xsec_WJetsToLNu/nMCEvWJetsToLNu);
hPtMC_QCD -> Scale(intLumi_invpb*xsec_QCD/nMCEvQCD);
hPt20BMC_dymumu -> Scale(intLumi_invpb*xsec_dymumu/nMCEvDYToMuMu);
hPt20BMC_ttbarjets -> Scale(intLumi_invpb*xsec_ttbarjets/nMCEvTTbarJets);
hPt20BMC_ztautau -> Scale(intLumi_invpb*xsec_ztautau/nMCEvZtautau);
hPt20BMC_WW -> Scale(intLumi_invpb*xsec_WW/nMCEvWW);
hPt20BMC_WZ -> Scale(intLumi_invpb*xsec_WZ/nMCEvWZ);
hPt20BMC_ZZ -> Scale(intLumi_invpb*xsec_ZZ/nMCEvZZ);
hPt20BMC_WJetsToLNu -> Scale(intLumi_invpb*xsec_WJetsToLNu/nMCEvWJetsToLNu);
hPt20BMC_QCD -> Scale(intLumi_invpb*xsec_QCD/nMCEvQCD);
hRapidityMC_dymumu -> Scale(intLumi_invpb*xsec_dymumu/nMCEvDYToMuMu);
hRapidityMC_ttbarjets -> Scale(intLumi_invpb*xsec_ttbarjets/nMCEvTTbarJets);
hRapidityMC_ztautau -> Scale(intLumi_invpb*xsec_ztautau/nMCEvZtautau);
hRapidityMC_WW -> Scale(intLumi_invpb*xsec_WW/nMCEvWW);
hRapidityMC_WZ -> Scale(intLumi_invpb*xsec_WZ/nMCEvWZ);
hRapidityMC_ZZ -> Scale(intLumi_invpb*xsec_ZZ/nMCEvZZ);
hRapidityMC_WJetsToLNu -> Scale(intLumi_invpb*xsec_WJetsToLNu/nMCEvWJetsToLNu);
hRapidityMC_QCD -> Scale(intLumi_invpb*xsec_QCD/nMCEvQCD);
hVertexMC_dymumu -> Scale(intLumi_invpb*xsec_dymumu/nMCEvDYToMuMu);
hVertexMC_ttbarjets -> Scale(intLumi_invpb*xsec_ttbarjets/nMCEvTTbarJets);
hVertexMC_ztautau -> Scale(intLumi_invpb*xsec_ztautau/nMCEvZtautau);
hVertexMC_WW -> Scale(intLumi_invpb*xsec_WW/nMCEvWW);
hVertexMC_WZ -> Scale(intLumi_invpb*xsec_WZ/nMCEvWZ);
hVertexMC_ZZ -> Scale(intLumi_invpb*xsec_ZZ/nMCEvZZ);
hVertexMC_WJetsToLNu -> Scale(intLumi_invpb*xsec_WJetsToLNu/nMCEvWJetsToLNu);
hVertexMC_QCD -> Scale(intLumi_invpb*xsec_QCD/nMCEvQCD);
/*
double bkgSum = hMassMC_dyjets -> Integral()+
hMassMC_ttbarjets -> Integral()+
hMassMC_ztautau -> Integral()+
hMassMC_WW -> Integral()+
hMassMC_WZ -> Integral()+
hMassMC_ZZ -> Integral();
//rescale to the number of events found in data
double rescale = hMassData -> Integral()/bkgSum;
hMassMC_dyjets -> Scale(rescale);
hMassMC_ttbarjets -> Scale(rescale);
hMassMC_ztautau -> Scale(rescale);
hMassMC_WW -> Scale(rescale);
hMassMC_WZ -> Scale(rescale);
hMassMC_ZZ -> Scale(rescale);
// end rescaling
*/
std::cout << "Event Counting after luminosity rescaling:" << std::endl;
outLatex(hMassData, "data");
outLatex(hMassMC_dymumu, "DYToMuMu");
outLatex(hMassMC_ttbarjets, "TTJets");
outLatex(hMassMC_ztautau, "Ztautau");
outLatex(hMassMC_WW, "WW");
outLatex(hMassMC_WZ, "WZ");
outLatex(hMassMC_ZZ, "ZZ");
outLatex(hMassMC_WJetsToLNu, "WJetsToLNu");
outLatex(hMassMC_QCD, "QCD");
// ------------------------------------------------------------------------------
double entriesPerBinMass = (mHigh-mLow)/mBins;
char yAxisNameMass[128];
sprintf(yAxisNameMass,"Entries/%3.2f GeV/c^{2}",entriesPerBinMass);
double entriesPerBinPt = (ptHigh-ptLow)/ptBins;
char yAxisNamePt[128];
sprintf(yAxisNamePt,"Entries/%3.2f GeV",entriesPerBinPt);
double entriesPerBinRapidity = (rHigh-rLow)/rBins;
char yAxisNameRapidity[128];
sprintf(yAxisNameRapidity,"Entries/%3.2f",entriesPerBinRapidity);
double entriesPerBinVertex = 1;
char yAxisNameVertex[128];
sprintf(yAxisNameVertex,"Entries/%3.2f",entriesPerBinVertex);
hPtMC_EWKBkg->Add(hPtMC_ttbarjets); sPtMC_EWKBkg->Add(hPtMC_ttbarjets);
hPtMC_EWKBkg->Add(hPtMC_ztautau); sPtMC_EWKBkg->Add(hPtMC_ztautau);
hPtMC_EWKBkg->Add(hPtMC_WJetsToLNu); sPtMC_EWKBkg->Add(hPtMC_WJetsToLNu);
hPtMC_EWKBkg->Add(hPtMC_ZZ); sPtMC_EWKBkg->Add(hPtMC_ZZ);
hPtMC_EWKBkg->Add(hPtMC_WZ); sPtMC_EWKBkg->Add(hPtMC_WZ);
hPtMC_EWKBkg->Add(hPtMC_WW); sPtMC_EWKBkg->Add(hPtMC_WW);
// define the tlegend
//TLegend* tl = new TLegend(0.71, 0.62, 0.90, 0.90);
//TLegend* tl = new TLegend(0.60, 0.57, 0.86, 0.86);
TLegend* tl = new TLegend(0.60, 0.47, 0.86, 0.76);
tl->SetFillColor(0);
tl->SetLineColor(0);
tl->AddEntry(hPtData ,"Data","lpe");
//tl->AddEntry(hPtMC_dymumu,"DYToMuMu","f");
tl->AddEntry(hPtMC_dymumu,"DY#rightarrow #mu^{+}#mu^{-}","f");
//tl->AddEntry(hPtMC_QCD," QCD","f");
tl->AddEntry(hPtMC_EWKBkg,"EW+t#bar{t}","f");
//tl->AddEntry(hPtMC_WW," WW","f");
//tl->AddEntry(hPtMC_WZ," WZ","f");
//tl->AddEntry(hPtMC_ZZ," ZZ","f");
//tl->AddEntry(hPtMC_WJetsToLNu," WJets","f");
//tl->AddEntry(hPtMC_ztautau ,"DYToTauTau","f");
//tl->AddEntry(hPtMC_ttbarjets," t #bar{t}","f");
// define MC contribution color and style
//mass
hMassMC_dymumu -> SetFillColor(798);//yellow
hMassMC_dymumu -> SetFillStyle(1001);
hMassMC_ttbarjets -> SetFillColor(30);//green
hMassMC_ttbarjets -> SetFillStyle(1001);
hMassMC_ztautau -> SetFillColor(51);//violet
hMassMC_ztautau -> SetFillStyle(1001);
hMassMC_WW -> SetFillColor(41);//brown
hMassMC_WW -> SetFillStyle(1001);
hMassMC_WZ -> SetFillColor(44);//
hMassMC_WZ -> SetFillStyle(1001);
hMassMC_ZZ -> SetFillColor(47);//
hMassMC_ZZ -> SetFillStyle(1001);
hMassMC_WJetsToLNu ->SetFillColor(2); //red
hMassMC_WJetsToLNu ->SetFillStyle(1001);
hMassMC_QCD -> SetFillColor(kMagenta+3);//
hMassMC_QCD -> SetFillStyle(1001);
//pt
hPtMC_dymumu -> SetFillColor(798);//yellow
hPtMC_dymumu -> SetFillStyle(1001);
hPtMC_ttbarjets -> SetFillColor(30);//green
hPtMC_ttbarjets -> SetFillStyle(1001);
hPtMC_ztautau -> SetFillColor(51);//violet
hPtMC_ztautau -> SetFillStyle(1001);
hPtMC_WW -> SetFillColor(41);//brown
hPtMC_WW -> SetFillStyle(1001);
hPtMC_WZ -> SetFillColor(44);//
hPtMC_WZ -> SetFillStyle(1001);
hPtMC_ZZ -> SetFillColor(47);//
hPtMC_ZZ -> SetFillStyle(1001);
hPtMC_WJetsToLNu ->SetFillColor(2); //red
hPtMC_WJetsToLNu ->SetFillStyle(1001);
hPtMC_QCD -> SetFillColor(kMagenta+3);//
hPtMC_QCD -> SetFillStyle(1001);
hPtMC_EWKBkg -> SetFillColor(kOrange+7);//
hPtMC_EWKBkg -> SetFillStyle(1001);
//pt 20 bin
hPt20BMC_dymumu -> SetFillColor(798);//yellow
hPt20BMC_dymumu -> SetFillStyle(1001);
hPt20BMC_ttbarjets -> SetFillColor(30);//green
hPt20BMC_ttbarjets -> SetFillStyle(1001);
hPt20BMC_ztautau -> SetFillColor(51);//violet
hPt20BMC_ztautau -> SetFillStyle(1001);
hPt20BMC_WW -> SetFillColor(41);//brown
hPt20BMC_WW -> SetFillStyle(1001);
hPt20BMC_WZ -> SetFillColor(44);//
hPt20BMC_WZ -> SetFillStyle(1001);
hPt20BMC_ZZ -> SetFillColor(47);//
hPt20BMC_ZZ -> SetFillStyle(1001);
hPt20BMC_WJetsToLNu ->SetFillColor(2); //red
hPt20BMC_WJetsToLNu ->SetFillStyle(1001);
hPt20BMC_QCD -> SetFillColor(kMagenta+3);//
hPt20BMC_QCD -> SetFillStyle(1001);
//Rapidity
hRapidityMC_dymumu -> SetFillColor(798);//yellow
hRapidityMC_dymumu -> SetFillStyle(1001);
hRapidityMC_ttbarjets -> SetFillColor(30);//green
hRapidityMC_ttbarjets -> SetFillStyle(1001);
hRapidityMC_ztautau -> SetFillColor(51);//violet
hRapidityMC_ztautau -> SetFillStyle(1001);
hRapidityMC_WW -> SetFillColor(41);//brown
hRapidityMC_WW -> SetFillStyle(1001);
hRapidityMC_WZ -> SetFillColor(44);//
hRapidityMC_WZ -> SetFillStyle(1001);
hRapidityMC_ZZ -> SetFillColor(47);//
hRapidityMC_ZZ -> SetFillStyle(1001);
hRapidityMC_WJetsToLNu ->SetFillColor(2); //red
hRapidityMC_WJetsToLNu ->SetFillStyle(1001);
hRapidityMC_QCD -> SetFillColor(kMagenta+3);//
hRapidityMC_QCD -> SetFillStyle(1001);
//Vertex
hVertexMC_dymumu -> SetFillColor(798);//yellow
hVertexMC_dymumu -> SetFillStyle(1001);
hVertexMC_ttbarjets -> SetFillColor(30);//green
hVertexMC_ttbarjets -> SetFillStyle(1001);
hVertexMC_ztautau -> SetFillColor(51);//violet
hVertexMC_ztautau -> SetFillStyle(1001);
hVertexMC_WW -> SetFillColor(41);//brown
hVertexMC_WW -> SetFillStyle(1001);
hVertexMC_WZ -> SetFillColor(44);//
hVertexMC_WZ -> SetFillStyle(1001);
hVertexMC_ZZ -> SetFillColor(47);//
hVertexMC_ZZ -> SetFillStyle(1001);
hVertexMC_WJetsToLNu ->SetFillColor(2); //red
hVertexMC_WJetsToLNu ->SetFillStyle(1001);
hVertexMC_QCD -> SetFillColor(kMagenta+3);//
hVertexMC_QCD -> SetFillStyle(1001);
// ------------------------------------------------------------------------------
// Mass Plot Linear Scale
//TCanvas* cmass1 = new TCanvas("cmass1","",0,0,750,700);
TCanvas* cmass1 = new TCanvas("cmass1","",800,800);
cmass1->cd();
cmass1 -> SetLogy();
// gPad->SetLogy(); // Log plots on both axes.
// gPad->SetLogx();
hMassData -> SetTitle("CMS Preliminary, 18.4 pb^{-1} at #sqrt{s}=8 TeV");
hMassData -> SetTitle("#int 18.4 pb^{-1} at #sqrt{s}=8 TeV");
hMassData -> GetXaxis() -> SetTitle("Mass (#mu#mu) [GeV/c^{2}]");
hMassData -> GetYaxis() -> SetTitle(yAxisNameMass);
hMassData -> GetYaxis() -> SetTitleOffset(1.5);
hMassData -> SetMarkerSize(1);
hMassData -> SetMarkerStyle(20);
hMassData -> SetMinimum(0.01);
//hMassData -> Draw("pe");
//sMassMC_allBkg -> Draw("same");
//hMassData -> Draw("pe same");
//hMassData -> Draw("AXIS same");
zrap_Prelim(0.85,0.9,0.4,0.17);
zrap_Lumi(0.35,0.89,36);
//tl->Draw("same");
hMassMC_allBkg->Add(hMassMC_ttbarjets); sMassMC_allBkg->Add(hMassMC_ttbarjets);
hMassMC_allBkg->Add(hMassMC_ztautau); sMassMC_allBkg->Add(hMassMC_ztautau);
hMassMC_allBkg->Add(hMassMC_WJetsToLNu); sMassMC_allBkg->Add(hMassMC_WJetsToLNu);
hMassMC_allBkg->Add(hMassMC_QCD); sMassMC_allBkg->Add(hMassMC_QCD);
hMassMC_allBkg->Add(hMassMC_ZZ); sMassMC_allBkg->Add(hMassMC_ZZ);
hMassMC_allBkg->Add(hMassMC_WZ); sMassMC_allBkg->Add(hMassMC_WZ);
hMassMC_allBkg->Add(hMassMC_WW); sMassMC_allBkg->Add(hMassMC_WW);
hMassMC_allBkg->Add(hMassMC_dymumu); sMassMC_allBkg->Add(hMassMC_dymumu);
// Mass Plot With Pulls
TCanvas* cmass2 = new TCanvas("cmass2","",700,0,750,700);
//DrawWithRes(cmass2, cmspreliminary,"", hMassData, hMassMC_allBkg, sMassMC_allBkg, tl, true);
// ------------------------------------------------------------------------------
// Pt with equal bin with 5GeV
TCanvas* cpt20B1 = new TCanvas("cpt20B1","",0,0,600,500);
cpt20B1->cd();
cpt20B1 -> SetLogy();
cpt20B1 -> SetTicky(1);
cpt20B1 -> SetTickx(1);
//hPt20BData -> GetXaxis() -> SetTitle("q_{T} [GeV/c]");
hPt20BData -> GetXaxis() -> SetTitle("p_{T}^{Z} [GeV]");
hPt20BData -> GetYaxis() -> SetTitle(yAxisNamePt);
hPt20BData -> GetYaxis() -> SetTitleOffset(1.2);
hPt20BData -> SetMarkerSize(0.7);
hPt20BData -> SetMarkerStyle(20);
hPt20BData -> SetMinimum(0.01);
//hPt20BData -> Draw("pe");
//sPt20BMC_allBkg -> Draw("same");
//hPt20BData -> Draw("pe same");
//hPt20BData -> Draw("AXIS same");
//tl->Draw("same");
hPt20BMC_allBkg->Add(hPt20BMC_ttbarjets); sPt20BMC_allBkg->Add(hPt20BMC_ttbarjets);
hPt20BMC_allBkg->Add(hPt20BMC_ztautau); sPt20BMC_allBkg->Add(hPt20BMC_ztautau);
hPt20BMC_allBkg->Add(hPt20BMC_WJetsToLNu); sPt20BMC_allBkg->Add(hPt20BMC_WJetsToLNu);
hPt20BMC_allBkg->Add(hPt20BMC_QCD); sPt20BMC_allBkg->Add(hPt20BMC_QCD);
hPt20BMC_allBkg->Add(hPt20BMC_ZZ); sPt20BMC_allBkg->Add(hPt20BMC_ZZ);
hPt20BMC_allBkg->Add(hPt20BMC_WZ); sPt20BMC_allBkg->Add(hPt20BMC_WZ);
hPt20BMC_allBkg->Add(hPt20BMC_WW); sPt20BMC_allBkg->Add(hPt20BMC_WW);
hPt20BMC_allBkg->Add(hPt20BMC_dymumu); sPt20BMC_allBkg->Add(hPt20BMC_dymumu);
// pt Plot With Pulls
// TCanvas* cpt20B2 = new TCanvas("cpt20B2","",700,0,600,500);
// DrawWithRes(cpt20B2, cmspreliminaryextd, hPt20BData, hPt20BMC_allBkg, sPt20BMC_allBkg, tl, true, true);
// ------------------------------------------------------------------------------
// Pt with dynamic binning
//TCanvas* cpt1 = new TCanvas("cpt1","",0,0,750,600);
TCanvas* cpt1 = new TCanvas("cpt1","",0,0,800,800);
cpt1->cd();
cpt1 -> SetLogy();
cpt1 -> SetTicky(1);
cpt1 -> SetTickx(1);
//hPtData -> SetTitle("#int 18.4 pb^{-1} at #sqrt{s}=8 TeV");
//hPtData -> SetTitle("L = 18.4 pb^{-1}, #sqrt{s}=8 TeV");
//hPtData -> SetTitle("18.4 pb^{-1} (8 TeV)");
//hPtData -> SetTitleSize(0.0);
//hPtData -> GetXaxis() -> SetTitle("q_{T} [GeV/c]");
hPtData -> GetXaxis() -> SetLabelSize(0);
hPtData -> GetXaxis() -> SetTitle("p_{T}^{Z} [GeV]");
hPtData -> GetYaxis() -> SetTitle("Events");
//hPtData -> GetYaxis() -> SetTitleSize(0.05);
hPtData -> GetYaxis() -> SetTitleSize(0.07);
//hPtData -> GetYaxis() -> SetTitleOffset(1.0);
hPtData -> GetYaxis() -> SetTitleOffset(0.8);
hPtData -> GetYaxis() -> SetLabelSize(0.05);
hPtData -> SetMarkerSize(1);
hPtData -> SetMarkerStyle(20);
hPtData -> SetMinimum(5*0.001);
hPtData -> Draw("pe");
sPtMC_allBkg -> Draw("same");
hPtData -> Draw("pe same");
hPtData -> Draw("AXIS same");
//tl->Draw("same");
hPtMC_allBkg->Add(hPtMC_QCD); sPtMC_allBkg->Add(hPtMC_QCD);
hPtMC_allBkg->Add(hPtMC_EWKBkg); sPtMC_allBkg->Add(hPtMC_EWKBkg);
hPtMC_allBkg->Add(hPtMC_dymumu); sPtMC_allBkg->Add(hPtMC_dymumu);
/*
hPtMC_allBkg->Add(hPtMC_ttbarjets); sPtMC_allBkg->Add(hPtMC_ttbarjets);
hPtMC_allBkg->Add(hPtMC_ztautau); sPtMC_allBkg->Add(hPtMC_ztautau);
hPtMC_allBkg->Add(hPtMC_WJetsToLNu); sPtMC_allBkg->Add(hPtMC_WJetsToLNu);
hPtMC_allBkg->Add(hPtMC_QCD); sPtMC_allBkg->Add(hPtMC_QCD);
hPtMC_allBkg->Add(hPtMC_ZZ); sPtMC_allBkg->Add(hPtMC_ZZ);
hPtMC_allBkg->Add(hPtMC_WZ); sPtMC_allBkg->Add(hPtMC_WZ);
hPtMC_allBkg->Add(hPtMC_WW); sPtMC_allBkg->Add(hPtMC_WW);
hPtMC_allBkg->Add(hPtMC_dymumu); sPtMC_allBkg->Add(hPtMC_dymumu);
*/
// pt Plot With Pulls
TCanvas* cpt2 = new TCanvas("cpt2","",700,0,750,700);
cpt2 -> SetTicky(1);
cpt2 -> SetTickx(1);
//DrawWithRes(cpt2, cmspreliminary, hPtData, hPtMC_allBkg, sPtMC_allBkg, tl);
//DrawWithRes(cpt2, "#font[61]{CMS}", "", hPtData, hPtMC_allBkg, sPtMC_allBkg, tl);
DrawWithRes(cpt2, "#font[61]{CMS}", "18.4 pb^{-1} (8 TeV)", hPtData, hPtMC_allBkg, sPtMC_allBkg, tl);
// ------------------------------------------------------------------------------
// Rapidity plots
TCanvas* cra1 = new TCanvas("cra1","",0,0,600,500);
cra1->cd();
cra1 -> SetLogy();
cra1 -> SetTicky(1);
cra1 -> SetTickx(1);
hRapidityData -> GetXaxis() -> SetTitle("Y (#mu#mu) ");
hRapidityData -> GetYaxis() -> SetTitle(yAxisNameRapidity);
hRapidityData -> GetYaxis() -> SetTitleOffset(1.2);
hRapidityData -> SetMarkerSize(0.7);
hRapidityData -> SetMarkerStyle(20);
hRapidityData -> SetMinimum(0.01);
//hRapidityData -> Draw("pe");
//sRapidityMC_allBkg -> Draw("same");
//hRapidityData -> Draw("pe same");
//hRapidityData -> Draw("AXIS same");
//tl->Draw("same");
hRapidityMC_allBkg->Add(hRapidityMC_ttbarjets); sRapidityMC_allBkg->Add(hRapidityMC_ttbarjets);
hRapidityMC_allBkg->Add(hRapidityMC_ztautau); sRapidityMC_allBkg->Add(hRapidityMC_ztautau);
hRapidityMC_allBkg->Add(hRapidityMC_WJetsToLNu); sRapidityMC_allBkg->Add(hRapidityMC_WJetsToLNu);
hRapidityMC_allBkg->Add(hRapidityMC_QCD); sRapidityMC_allBkg->Add(hRapidityMC_QCD);
hRapidityMC_allBkg->Add(hRapidityMC_ZZ); sRapidityMC_allBkg->Add(hRapidityMC_ZZ);
hRapidityMC_allBkg->Add(hRapidityMC_WZ); sRapidityMC_allBkg->Add(hRapidityMC_WZ);
hRapidityMC_allBkg->Add(hRapidityMC_WW); sRapidityMC_allBkg->Add(hRapidityMC_WW);
hRapidityMC_allBkg->Add(hRapidityMC_dymumu); sRapidityMC_allBkg->Add(hRapidityMC_dymumu);
// Rapidity Plot With Pulls
// TCanvas* cra2 = new TCanvas("cra2","",700,0,600,500);
// DrawWithRes(cra2, cmspreliminaryextd, hRapidityData, hRapidityMC_allBkg, sRapidityMC_allBkg, tl, true);
// ------------------------------------------------------------------------------
// # of Vertices plots
TCanvas* cv1 = new TCanvas("cv1","",0,0,600,500);
cv1->cd();
cv1 -> SetLogy();
hVertexData -> SetTitle("#int 18.4 pb^{-1} at #sqrt{s}=8 TeV");
hVertexData -> GetXaxis() -> SetTitle("number of Vertices ");
hVertexData -> GetYaxis() -> SetTitle(yAxisNameVertex);
hVertexData -> GetYaxis() -> SetTitleOffset(1.2);
hVertexData -> SetMarkerSize(0.7);
hVertexData -> SetMarkerStyle(20);
hVertexData -> SetMinimum(0.01);
//hVertexData -> Draw("pe");
//sVertexMC_allBkg -> Draw("same");
//hVertexData -> Draw("pe same");
//hVertexData -> Draw("AXIS same");
//tl->Draw("same");
hVertexMC_allBkg->Add(hVertexMC_ttbarjets); sVertexMC_allBkg->Add(hVertexMC_ttbarjets);
hVertexMC_allBkg->Add(hVertexMC_ztautau); sVertexMC_allBkg->Add(hVertexMC_ztautau);
hVertexMC_allBkg->Add(hVertexMC_WJetsToLNu); sVertexMC_allBkg->Add(hVertexMC_WJetsToLNu);
hVertexMC_allBkg->Add(hVertexMC_QCD); sVertexMC_allBkg->Add(hVertexMC_QCD);
hVertexMC_allBkg->Add(hVertexMC_ZZ); sVertexMC_allBkg->Add(hVertexMC_ZZ);
hVertexMC_allBkg->Add(hVertexMC_WZ); sVertexMC_allBkg->Add(hVertexMC_WZ);
hVertexMC_allBkg->Add(hVertexMC_WW); sVertexMC_allBkg->Add(hVertexMC_WW);
hVertexMC_allBkg->Add(hVertexMC_dymumu); sVertexMC_allBkg->Add(hVertexMC_dymumu);
// Vertex Plot With Pulls
// TCanvas* cv2 = new TCanvas("cv2","",700,0,750,700);
// DrawWithRes(cv2, cmspreliminary, hVertexData, hVertexMC_allBkg, sVertexMC_allBkg, tl, true);
/*
//lumi->SetNDC();
//energy->SetNDC();
//lumi ->DrawLatex(0.35,0.70, lumiString);
//energy->DrawLatex(0.35,0.60, energyString);
// time (&end);
// dif = difftime (end,start);
// std::cout << "the macro took " << dif << " secs to terminate\n";
// if (!isSave) return;
// char mSave[128];
// c1 ->SaveAs(png+"dimuonMass.png");
*/
Hist_out->Write();
Hist_out->Close();
}
void B0_ch4::Loop(Long64_t maxEv)
{
TRandom* random1 = new TRandom;
// In a ROOT session, you can do:
// Root > .L B0_ch4.C
// Root > B0_ch4 t
// Root > t.GetEntry(12); // Fill t data members with entry number 12
// Root > t.Show(); // Show values of entry 12
// Root > t.Show(16); // Read and show values of entry 16
// Root > t.Loop(); // Loop on all entries
//
// This is the loop skeleton where:
// jentry is the global entry number in the chain
// ientry is the entry number in the current Tree
// Note that the argument to GetEntry must be:
// jentry for TChain::GetEntry
// ientry for TTree::GetEntry and TBranch::GetEntry
//
// To read only selected branches, Insert statements like:
// METHOD1:
// fChain->SetBranchStatus("*",0); // disable all branches
// fChain->SetBranchStatus("branchname",1); // activate branchname
// METHOD2: replace line
// fChain->GetEntry(jentry); //read all branches
//by b_branchname->GetEntry(ientry); //read only this branch
if (fChain == 0) return;
Long64_t nentries = fChain->GetEntriesFast();
TH1F *hNCands= new TH1F("hNCands",";N candidates", 100, 0, 100);
TH1F *hNGoodCands= new TH1F("hNGoodCands",";N good candidates", 20, 0, 20);
TH1F *hEvents= new TH1F("hEvents","Events statistics", 20, 1, 21);
createHisto("AllCandidates");
// isSignal
createHisto("AllCandidatesIsSignal");
// is good candidate
createHisto("AllGoodCandidates");
// isGood candidate and isSignal
createHisto("AllGoodCandidatesIsSignal");
// is best candidate
createHisto("BestCandidates");
// isBest candidate and isSignal
createHisto("BestCandidatesIsSignal");
// isBest candidate and NOT isSignal
createHisto("BestCandidatesIsNotSignal");
// Dt plots
TH1F *hDT_best = new TH1F("hDT_best",";#Deltat (ps)", 100, -20., 20.);
TH1F *hDeltaDT_best = new TH1F("hDeltaDT_best",";#Deltat-#Deltat_{true} (ps)", 200, -20., 20.);
TH1F *hDT_TrueB0_best = new TH1F("hDT_TrueB0_best",";#Deltat (ps)", 20, -10., 10.);
TH1F *hDT_TrueB0bar_best = new TH1F("hDT_TrueB0bar_best",";#Deltat (ps)", 20, -10., 10.);
TH1F *hDT_TagB0_best = new TH1F("hDT_TagB0_best",";#Deltat (ps)", 20, -10., 10.);
TH1F *hDT_TagB0bar_best = new TH1F("hDT_TagB0bar_best",";#Deltat (ps)", 20, -10., 10.);
TH1F *hTrueDT_best = new TH1F("hTrueDT_best",";#Deltat (ps)", 100, -20., 20.);
TH1F *hTrueDT_TrueB0_best = new TH1F("hTrueDT_TrueB0_best",";#Deltat (ps)", 20, -10., 10.);
TH1F *hTrueDT_TrueB0bar_best = new TH1F("hTrueDT_TrueB0bar_best",";#Deltat (ps)", 20, -10., 10.);
TH1F *hTrueDT_TagB0_best = new TH1F("hTrueDT_TagB0_best",";#Deltat (ps)", 20, -10., 10.);
TH1F *hTrueDT_TagB0bar_best = new TH1F("hTrueDT_TagB0bar_best",";#Deltat (ps)", 20, -10., 10.);
Long64_t nbytes = 0, nb = 0;
int lastEvt=0;
int nCandsLast=0;
int nGoodCands=0;
int nev=0;
int nevGood=0;
int nevGoodSignal=0;
for (Long64_t jentry=0; jentry<nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
// Count number of candidates
if (evt_no!=lastEvt) { // new event
nev++;
static int j=1;
if ((nev%j)==0) {
if ((nev/j)==9) j*=10;
cout << "Run:Event analyzed " << run_no << ":" << evt_no << " Num " << nev << endl;
}
if (maxEv>0 && nev > maxEv) break;
hNCands->Fill(nCandsLast);
hEvents->Fill(1);
if (nGoodCands) {
hNGoodCands->Fill(nGoodCands);
hEvents->Fill(2);
}
//cout << " nCands " << nCandsLast << " good " << nGoodCands << endl;
nGoodCands=0;
lastEvt=evt_no;
}
nCandsLast=nCands;
if (_skipIfSignal && B0__isSignal) continue;
fillHistos("AllCandidates");
if (B0__isSignal) fillHistos("AllCandidatesIsSignal");
// apply cuts
if (Cut(ientry) > 0) {
// cout << " Good " ;
nGoodCands++;
fillHistos("AllGoodCandidates");
if (B0__isSignal) fillHistos("AllGoodCandidatesIsSignal");
}
}
hNCands->Write();
hNGoodCands->Write();
saveHisto("AllCandidates");
saveHisto("AllCandidatesIsSignal");
saveHisto("AllGoodCandidates");
saveHisto("AllGoodCandidatesIsSignal");
// Now do again the loop over the events, selection the best candidates in
// the event among the good ones.
if (true) {
cout << "############################### " << endl;
cout << "Selecting best Candidates " << endl;
Long64_t nbytes = 0, nb = 0;
bool isNewEvent=false;
int oldEvno=-999;
double bestB0Mass=0;
double bestB0PVtx=9999;
Long64_t jentry=0;
int nev=0;
do {
//cout << "jentry " << jentry << endl;
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
hEvents->Fill(10);
nb = fChain->GetEntry(jentry); nbytes += nb;
Long64_t nCandsCurrent=nCands;
// cout << "nCands = " << nCandsCurrent << endl;
if (!(_skipIfSignal && B0__isSignal)) {
Long64_t iBest = selectBestCand(jentry, nCandsCurrent);
if (iBest>=0) {
hEvents->Fill(11);
// cout << "Best: " << iBest << endl;
nb = fChain->GetEntry(iBest);
//cout << "MB " << B0_M<< endl;
fillHistos("BestCandidates");
// Plot Dt, reco and MC
hDT_best->Fill(B0_DeltaT);
double DDt=B0_DeltaT-B0_TruthDeltaT;
hDeltaDT_best->Fill(DDt);
hTrueDT_best->Fill(B0_TruthDeltaT);
// Plot Dt for B0 and B0bar tag (MC)
if (B0__isSignal) {
if (B0_mcTagPDG>0) {
hDT_TrueB0_best->Fill(B0_DeltaT);
hTrueDT_TrueB0_best->Fill(B0_TruthDeltaT);
} else {
hDT_TrueB0bar_best->Fill(B0_DeltaT);
hTrueDT_TrueB0bar_best->Fill(B0_TruthDeltaT);
}
// same, but with a diluition factor of e(1-2w)^2=0.32, namely eff=1. and
// mis-tag rate =0.217, with a random decision
int recoFlavourTag=B0_mcTagPDG;
// mistag
if (random1->Rndm() < 0.217) recoFlavourTag=-recoFlavourTag;
if (recoFlavourTag>0) {
hDT_TagB0_best->Fill(B0_DeltaT);
hTrueDT_TagB0_best->Fill(B0_TruthDeltaT);
} else {
hDT_TagB0bar_best->Fill(B0_DeltaT);
hTrueDT_TagB0bar_best->Fill(B0_TruthDeltaT);
}
}
if (B0__isSignal) {
hEvents->Fill(12);
fillHistos("BestCandidatesIsSignal");
} else {
hEvents->Fill(13);
fillHistos("BestCandidatesIsNotSignal");
}
//Show(iBest);
}
}
// next events
jentry+=nCandsCurrent;
nev++;
static int jj=1;
if ((nev%jj)==0) {
if ((nev/jj)==9) jj*=10;
cout << "Run:Event analyzed " << run_no << ":" << evt_no << " Num " << nev << endl;
}
} while ((maxEv<0 || nev< maxEv) && jentry <nentries);
ofile->cd();
hEvents->Write();
saveHisto("BestCandidates");
saveHisto("BestCandidatesIsSignal");
saveHisto("BestCandidatesIsNotSignal");
ofile->cd();
ofile->mkdir("BestCandidatesDeltaT");
ofile->cd("BestCandidatesDeltaT");
hDT_best->Write();
hDeltaDT_best->Write();
hDT_TrueB0_best->Write();
hDT_TrueB0bar_best->Write();
hDT_TagB0_best->Write();
hDT_TagB0bar_best->Write();
hTrueDT_best->Write();
hTrueDT_TrueB0_best->Write();
hTrueDT_TrueB0bar_best->Write();
hTrueDT_TagB0_best->Write();
hTrueDT_TagB0bar_best->Write();
}
ofile->Close();
}
