void markerwarning()
{
const int Nph = 14;
double np_ph[Nph] = {353.4,300.2,254.3,215.2,181.0,151.3,125.2,102.7, 83.3, 66.7, 52.5, 40.2, 30.2, 22.0};
double nc_ph[Nph] = {3.890,3.734,3.592,3.453,3.342,3.247,3.151,3.047,2.965,2.858,2.701,2.599,2.486,2.328};
double npe_ph[Nph] = {10.068,9.004,8.086,7.304,6.620,6.026,5.504,5.054,4.666,4.334,4.050,3.804,3.604,3.440};
double nce_ph[Nph] = {0.235,0.217,0.210,0.206,0.213,0.223,0.239,0.260,0.283,0.318,0.356,0.405,0.465,0.545};
const int Nbr = 6;
double np_br[Nbr] = {357.0,306.0,239.0,168.0,114.0, 73.0};
double nc_br[Nbr] = {3.501,3.275,3.155,3.060,3.053,3.014};
double npe_br[Nbr] = {8.000,11.000,10.000,9.000,9.000,8.000};
double nce_br[Nbr] = {0.318,0.311,0.306,0.319,0.370,0.429};
TGraphErrors *phUP = new TGraphErrors(Nph,np_ph,nc_ph,npe_ph,nce_ph);
TGraphErrors *phDN = new TGraphErrors(Nph,np_ph,nc_ph,npe_ph,nce_ph);
TGraphErrors *brUP = new TGraphErrors(Nbr,np_br,nc_br,npe_br,nce_br);
TGraphErrors *brDN = new TGraphErrors(Nbr,np_br,nc_br,npe_br,nce_br);
float Top_margin = 0.;
float Left_margin = 0.025;
float Right_margin = 0.005;
float maxPlotPart = 395;
float Marker_Size = 1.3;
int Marker_Style = 8;
float Et_200_Min = 0.71;
float Et_200_Max = 3.80;
float Et_130_Min = 1.21;
float Et_130_Max = 3.29;
float Nc_200_Min = 1.31;
float Nc_200_Max = 4.30;
float Nc_130_Min = 1.51;
float Nc_130_Max = 3.89;
TCanvas *canvasNc = new TCanvas("canvasNc", "Multiplicity",630,10,600,500);
gStyle->SetOptStat(0);
canvasNc->SetFillColor(10);
canvasNc->SetBorderSize(0);
// Primitives in Nc200 pad
TPad *padNcUP = new TPad("padNcUP","200 GeV",0.07,0.60,1.,1.00);
padNcUP->Draw();
padNcUP->cd();
padNcUP->SetFillColor(10);
padNcUP->SetFrameFillColor(10);
padNcUP->SetBorderSize(0);
padNcUP->SetLeftMargin(Left_margin);
padNcUP->SetRightMargin(Right_margin);
padNcUP->SetTopMargin(Top_margin+0.005);
padNcUP->SetBottomMargin(0.00);
TH1F* frameNcUP = new TH1F("frameNcUP","",100,0,maxPlotPart);
frameNcUP->GetYaxis()->SetLabelOffset(0.005);
frameNcUP->GetYaxis()->SetLabelSize(0.10);
frameNcUP->SetMinimum(Nc_200_Min);
frameNcUP->SetMaximum(Nc_200_Max);
frameNcUP->SetNdivisions(505,"Y");
frameNcUP->SetNdivisions(505,"X");
frameNcUP->Draw();
brUP->SetMarkerStyle(22);
brUP->SetMarkerSize (2.0);
brUP->Draw("P");
phDN->SetMarkerStyle(23);
phDN->SetMarkerSize (2);
phDN->Draw("P");
canvasNc->cd();
// Primitives in Nc130 pad
TPad *padNcDN = new TPad("padNcDN","130 GeV",0.07,0.02,1.,0.60);
padNcDN->Draw();
padNcDN->cd();
padNcDN->SetFillColor(10);
padNcDN->SetFrameFillColor(10);
padNcDN->SetBorderSize(0);
padNcDN->SetLeftMargin(Left_margin);
padNcDN->SetRightMargin(Right_margin);
padNcDN->SetTopMargin(Top_margin+0.005);
padNcDN->SetBottomMargin(0.30);
TH1F* frameNcDN = new TH1F("frameNcDN","",100,0,maxPlotPart);
frameNcDN->GetYaxis()->SetLabelOffset(0.005);
frameNcDN->GetYaxis()->SetLabelSize(0.07);
frameNcDN->GetXaxis()->SetLabelOffset(0.005);
frameNcDN->GetXaxis()->SetLabelSize(0.07);
frameNcDN->SetMinimum(Nc_200_Min);
frameNcDN->SetMaximum(Nc_200_Max);
frameNcDN->SetNdivisions(505,"Y");
frameNcDN->SetNdivisions(505,"X");
frameNcDN->Draw();
brDN->SetMarkerStyle(23);
brDN->SetMarkerSize (2.0);
brDN->Draw("P");
phUP->SetMarkerStyle(22);
phUP->SetMarkerSize (2);
phUP->Draw("P");
TLatex t1;
t1.SetTextFont(12); t1.SetTextSize(0.0525);
t1.DrawLatex(-5,0.6,"Non-symmetric symbols should be used carefully in plotting.�These two graphs show how misleading");
t1.DrawLatex(-5,0.4,"a careless use of symbols can be.�The two plots represent the same data sets but because of a bad");
t1.DrawLatex(-5,0.2,"symbol choice, the two plots on the top appear further apart than for the bottom example.");
canvasNc->cd();
}
void second() {
TCanvas *nut = new TCanvas("nut", "Second Session",100,10,750,1000);
nut->Range(0,0,20,24);
nut->SetFillColor(18);
TPaveLabel *pl = new TPaveLabel(3,22,17,23.7,"My second ROOT interactive session","br");
pl->SetFillColor(18);
pl->Draw();
TText t(0,0,"a");
t.SetTextFont(62);
t.SetTextSize(0.025);
t.SetTextAlign(12);
t.DrawText(2,21,"Very large C/C++ files can be interpreted (50,000 lines+).");
t.DrawText(2,20,"Functions in macros can reference other functions, etc.");
t.DrawText(2,19,"Let's make a file \"graph.C\" with the following statements:");
TPaveText *macro = new TPaveText(2,11,18,18);
macro->SetFillColor(10);
macro->SetTextColor(kBlue);
macro->SetBorderSize(6);
macro->SetTextAlign(12);
macro->SetTextFont(61);
macro->AddText("{");
macro->AddText(" TCanvas *c1 = new TCanvas(\"c1\",\"A Simple Graph Example\",200,10,700,500);");
macro->AddText(" c1->Range(-0.5,-2,2.5,12);");
macro->AddText(" const Int_t n = 20");
macro->AddText(" Float_t x[n], y[n];");
macro->AddText(" for (Int_t i=0;i<n;i++) {");
macro->AddText(" x[i] = i*0.1;");
macro->AddText(" y[i] = 10*sin(x[i]+0.2);");
macro->AddText(" }");
macro->AddText(" gr = new TGraph(n,x,y);");
macro->AddText(" gr->Draw(\"AC*\");");
macro->AddText("}");
macro->AddText(" ");
macro->Draw();
t.SetTextFont(72);
t.SetTextColor(kRed);
t.SetTextSize(0.026);
t.DrawText(3,10,"Root > .x graph.C");
TPad *pad = new TPad("pad","pad",.15,.05,.85,.40);
pad->SetFillColor(41);
pad->SetFrameFillColor(33);
pad->Draw();
pad->cd();
pad->SetGrid();
pad->Range(-0.5,-2,2.5,12);
const Int_t n = 20;
Float_t x[n], y[n];
for (Int_t i=0;i<n;i++) {
x[i] = i*0.1;
y[i] = 10*sin(x[i]+0.2);
}
gr = new TGraph(n,x,y);
gr->Draw("AC*");
nut->cd();
}
void AccTimesEff::Loop()
{
TStopwatch timer;
timer.Start();
// parameters /////////////////////////////////////////////////////////////
vector<TString> files;
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-500_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9999ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-750_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_10000ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-1000_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9998ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-1250_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9998ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-1500_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9997ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-1750_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9997ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-2000_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9999ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-2500_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9999ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-3000_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_10000ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-3500_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9898ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-4000_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9998ev.root");
files.push_back("file:////user/treis/mcsamples/ZprimeToEMu_M-5000_noAccCuts_TuneZ2star_8TeV_madgraph_treis-Summer12_DR53X_PU_S10_START53_V7C1-v1_9966ev.root");
string outfileName = "accTimesEffHistos";
// output file formats
const bool saveSpec = 0;
const bool saveAsPdf = 0;
const bool saveAsPng = 1;
const bool saveAsRoot = 0;
TString plotDir = "./plots/";
int font = 42; //62
// selection cuts /////////////////////////////////////////////////////////
float elePtCut = 35.;
float muPtCut = 35.;
float minInvMass = 0.;
TH1::SetDefaultSumw2(kTRUE);
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
TH1F *hGenEvts = new TH1F("hGenEvts", "hGenEvts", 145, 0., 5010.);
hGenEvts->GetXaxis()->SetTitle("M_{Z'}^{truth}");
hGenEvts->GetXaxis()->SetTitleFont(font);
hGenEvts->GetXaxis()->SetLabelFont(font);
hGenEvts->GetYaxis()->SetTitle("Events");
hGenEvts->GetYaxis()->SetTitleFont(font);
hGenEvts->GetYaxis()->SetLabelFont(font);
hGenEvts->GetYaxis()->SetTitleOffset(1.2);
hGenEvts->SetLineColor(kBlack);
hGenEvts->SetLineWidth(2);
hGenEvts->SetMarkerStyle(20);
hGenEvts->SetMarkerColor(kBlack);
TH1F *hGenEvtsEleInAcc = (TH1F*)hGenEvts->Clone("hGenEvtsEleInAcc");
TH1F *hGenEvtsEleInAccEB = (TH1F*)hGenEvts->Clone("hGenEvtsEleInAccEB");
TH1F *hGenEvtsEleInAccEE = (TH1F*)hGenEvts->Clone("hGenEvtsEleInAccEE");
TH1F *hGenEvtsMuInAcc = (TH1F*)hGenEvts->Clone("hGenEvtsMuInAcc");
TH1F *hGenEvtsInAcc = (TH1F*)hGenEvts->Clone("hGenEvtsInAcc");
TH1F *hTrgEvts = (TH1F*)hGenEvts->Clone("hTrgEvts");
hTrgEvts->SetTitle("hTrgEvts");
TH1F *hRecoEvts = (TH1F*)hGenEvts->Clone("hRecoEvts");
hRecoEvts->SetTitle("hRecoEvts");
TH1F *hRecoEvtsEB = (TH1F*)hRecoEvts->Clone("hRecoEvtsEB");
TH1F *hRecoEvtsEE = (TH1F*)hRecoEvts->Clone("hRecoEvtsEE");
TH1F *hRecoEleEvts = (TH1F*)hRecoEvts->Clone("hRecoEleEvts");
TH1F *hRecoEleEvtsEB = (TH1F*)hRecoEvts->Clone("hRecoEleEvtsEB");
TH1F *hRecoEleEvtsEE = (TH1F*)hRecoEvts->Clone("hRecoEleEvtsEE");
TH1F *hRecoMuEvts = (TH1F*)hRecoEvts->Clone("hRecoMuEvts");
TH1F *hRecoNoTrgEvts = (TH1F*)hGenEvts->Clone("hRecoNoTrgEvts");
hRecoNoTrgEvts->SetTitle("hRecoNoTrgEvts");
TH1F *hRecoNoTrgEvtsEB = (TH1F*)hRecoNoTrgEvts->Clone("hRecoNoTrgEvtsEB");
TH1F *hRecoNoTrgEvtsEE = (TH1F*)hRecoNoTrgEvts->Clone("hRecoNoTrgEvtsEE");
TH1F *hRecoNoTrgEleEvts = (TH1F*)hRecoNoTrgEvts->Clone("hRecoNoTrgEleEvts");
TH1F *hRecoNoTrgEleEvtsEB = (TH1F*)hRecoNoTrgEvts->Clone("hRecoNoTrgEleEvtsEB");
TH1F *hRecoNoTrgEleEvtsEE = (TH1F*)hRecoNoTrgEvts->Clone("hRecoNoTrgEleEvtsEE");
TH1F *hRecoNoTrgMuEvts = (TH1F*)hRecoNoTrgEvts->Clone("hRecoNoTrgMuEvts");
TH1F* hAcc;
TH1F* hAccEle;
TH1F* hAccEleEB;
TH1F* hAccEleEE;
TH1F* hAccMu;
TH1F* hAccTimesTrgEff;
TH1F* hTrgEff;
TH1F* hAccTimesEff;
TH1F* hAccTimesEffEB;
TH1F* hAccTimesEffEE;
TH1F* hAccTimesEffEle;
TH1F* hAccTimesEffEleEB;
TH1F* hAccTimesEffEleEE;
TH1F* hAccTimesEffMu;
TH1F* hAccTimesEffNoTrg;
//TH1F* hAccTimesEffNoTrgEB;
//TH1F* hAccTimesEffNoTrgEE;
TH1F* hAccTimesEffNoTrgEle;
TH1F* hAccTimesEffNoTrgEleEB;
TH1F* hAccTimesEffNoTrgEleEE;
TH1F* hAccTimesEffNoTrgMu;
TH1F* hEffAftTrg;
TH1F* hEffAftTrgEle;
TH1F* hEffAftTrgEleEB;
TH1F* hEffAftTrgEleEE;
TH1F* hEffAftTrgMu;
TH1F* hTrgRecoVsReco;
//TH1F* hTrgRecoVsRecoEB;
//TH1F* hTrgRecoVsRecoEE;
TH1F* hTrgRecoVsRecoEle;
TH1F* hTrgRecoVsRecoEleEB;
TH1F* hTrgRecoVsRecoEleEE;
TH1F* hTrgRecoVsRecoMu;
// output file
stringstream ssOutfile;
ssOutfile << outfileName << ".root";
TFile *output = new TFile(ssOutfile.str().c_str(), "recreate");
///////////////////////////////////////////////////////////////////////////
//LOOP OVER FILES
///////////////////////////////////////////////////////////////////////////
for (unsigned int p = 0; p < files.size(); ++p) {
TFile* input = new TFile(files[p]);
TTree *thetree = (TTree*)input->Get("gsfcheckerjob/tree");
Init(thetree);
Long64_t nentries = fChain->GetEntriesFast();
cout << nentries << " events" << endl;
unsigned int evCounter = 0;
/////////////////////////////////////////////////////////////////////////////////////////////
//LOOP OVER EVENTS
/////////////////////////////////////////////////////////////////////////////////////////////
//nentries = 10000;
for (Long64_t jentry = 0; jentry < nentries; ++jentry) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
fChain->GetEntry(jentry);
// if (Cut(ientry) < 0) continue;
//if (jentry % 50000 == 0) cout << "Processing event " << jentry << endl;
thetree->GetEntry(jentry);
// fill the gen histograms
hGenEvts->Fill(genelemom_mass[0]);
// fill the acc histograms
if (hardGenEle_pt[0] > elePtCut) {
if (fabs(hardGenEle_eta[0]) < 1.442) {
hGenEvtsEleInAcc->Fill(genelemom_mass[0]);
hGenEvtsEleInAccEB->Fill(genelemom_mass[0]);
}
else if (fabs(hardGenEle_eta[0]) > 1.56 && fabs(hardGenEle_eta[0]) < 2.5) {
hGenEvtsEleInAcc->Fill(genelemom_mass[0]);
hGenEvtsEleInAccEE->Fill(genelemom_mass[0]);
}
}
if (hardGenMu_pt[0] > muPtCut && fabs(hardGenMu_eta[0]) < 2.4) {
hGenEvtsMuInAcc->Fill(genelemom_mass[0]);
if (fabs(hardGenEle_eta[0]) < 1.442 || (fabs(hardGenEle_eta[0]) > 1.56 && fabs(hardGenEle_eta[0]) < 2.5)) {
if (hardGenEle_pt[0] > elePtCut) hGenEvtsInAcc->Fill(genelemom_mass[0]);
}
}
// trigger?
if (HLT_Mu22_Photon22_CaloIdL) hTrgEvts->Fill(genelemom_mass[0]);
// at least one gsf electron and one muon above the threshold
if (gsf_size < 1 || muon_size < 1) continue;
vector<int> GSF_passHEEP;
vector<int> MU_passGOOD;
/////////////////////////////////////////////////////////////////////////////////////////////
//loop over electrons
for (int j = 0; j < gsf_size; ++j) {
//cleaning: fake electrons from muons
bool fakeEle = false;
for (int k = 0; k < muon_size; ++k) {
float DeltaR = deltaR(gsf_eta[j], gsf_phi[j], muon_eta[k], muon_phi[k]);
if (DeltaR < 0.1) {
fakeEle = true;
break;
}
}
if (fakeEle) continue;
if (PassHEEP(j)) GSF_passHEEP.push_back(j);
}
//loop over muons
for (int j = 0; j < muon_size; ++j) {
if (PassHighPtMu(j)) MU_passGOOD.push_back(j);
}
if (GSF_passHEEP.size() == 1) {
if (HLT_Mu22_Photon22_CaloIdL) {
hRecoEleEvts->Fill(genelemom_mass[0]);
if (fabs(gsfsc_eta[GSF_passHEEP[0]]) < 1.5) hRecoEleEvtsEB->Fill(genelemom_mass[0]);
if (fabs(gsfsc_eta[GSF_passHEEP[0]]) > 1.5) hRecoEleEvtsEE->Fill(genelemom_mass[0]);
}
hRecoNoTrgEleEvts->Fill(genelemom_mass[0]);
if (fabs(gsfsc_eta[GSF_passHEEP[0]]) < 1.5) hRecoNoTrgEleEvtsEB->Fill(genelemom_mass[0]);
if (fabs(gsfsc_eta[GSF_passHEEP[0]]) > 1.5) hRecoNoTrgEleEvtsEE->Fill(genelemom_mass[0]);
}
if (MU_passGOOD.size() == 1) {
if (HLT_Mu22_Photon22_CaloIdL) hRecoMuEvts->Fill(genelemom_mass[0]);
hRecoNoTrgMuEvts->Fill(genelemom_mass[0]);
}
// veto when there are more than one good candidates
if (GSF_passHEEP.size() != 1 || MU_passGOOD.size() != 1) continue;
//HEEP ele + GOOD muon
TLorentzVector ele1;
TLorentzVector mu1;
ele1.SetPtEtaPhiM(gsf_gsfet[GSF_passHEEP[0]], gsf_eta[GSF_passHEEP[0]], gsf_phi[GSF_passHEEP[0]], 0.000511);
mu1.SetPtEtaPhiM(muon_pt[MU_passGOOD[0]], muon_eta[MU_passGOOD[0]], muon_phi[MU_passGOOD[0]], 0.10566);
double invMass = (ele1 + mu1).M();
//MASS CUT
if (invMass < minInvMass) continue;
if (HLT_Mu22_Photon22_CaloIdL) {
hRecoEvts->Fill(genelemom_mass[0]);
if (fabs(gsfsc_eta[GSF_passHEEP[0]]) < 1.5) hRecoEvtsEB->Fill(genelemom_mass[0]);
if (fabs(gsfsc_eta[GSF_passHEEP[0]]) > 1.5) hRecoEvtsEE->Fill(genelemom_mass[0]);
}
hRecoNoTrgEvts->Fill(genelemom_mass[0]);
if (fabs(gsfsc_eta[GSF_passHEEP[0]]) < 1.5) hRecoNoTrgEvtsEB->Fill(genelemom_mass[0]);
if (fabs(gsfsc_eta[GSF_passHEEP[0]]) > 1.5) hRecoNoTrgEvtsEE->Fill(genelemom_mass[0]);
++evCounter;
///////////////////////////////////////////////////////////////////////
} //END LOOP OVER EVENTS
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
} //END LOOP OVER FILES
//////////////////////////////////////////////////////////////////////////
hAcc = (TH1F*)hGenEvtsInAcc->Clone("hAcc");
hAccEle = (TH1F*)hGenEvtsEleInAcc->Clone("hAccEle");
hAccEleEB = (TH1F*)hGenEvtsEleInAccEB->Clone("hAccEleEB");
hAccEleEE = (TH1F*)hGenEvtsEleInAccEE->Clone("hAccEleEE");
hAccMu = (TH1F*)hGenEvtsMuInAcc->Clone("hAccMu");
hAccTimesTrgEff = (TH1F*)hTrgEvts->Clone("hAccTimesTrgEff");
hTrgEff = (TH1F*)hTrgEvts->Clone("hTrgEff");
hAccTimesEff = (TH1F*)hRecoEvts->Clone("hAccTimesEff");
hAccTimesEffEB = (TH1F*)hRecoEvtsEB->Clone("hAccTimesEffEB");
hAccTimesEffEE = (TH1F*)hRecoEvtsEE->Clone("hAccTimesEffEE");
hAccTimesEffEle = (TH1F*)hRecoEleEvts->Clone("hAccTimesEffEle");
hAccTimesEffEleEB = (TH1F*)hRecoEleEvtsEB->Clone("hAccTimesEffEleEB");
hAccTimesEffEleEE = (TH1F*)hRecoEleEvtsEE->Clone("hAccTimesEffEleEE");
hAccTimesEffMu = (TH1F*)hRecoMuEvts->Clone("hAccTimesEffMu");
hAccTimesEffNoTrg = (TH1F*)hRecoNoTrgEvts->Clone("hAccTimesEffNoTrg");
//hAccTimesEffNoTrgEB = (TH1F*)hRecoNoTrgEvtsEB->Clone("hAccTimesEffNoTrgEB");
//hAccTimesEffNoTrgEE = (TH1F*)hRecoNoTrgEvtsEE->Clone("hAccTimesEffNoTrgEE");
hAccTimesEffNoTrgEle = (TH1F*)hRecoNoTrgEleEvts->Clone("hAccTimesEffNoTrgEle");
hAccTimesEffNoTrgEleEB = (TH1F*)hRecoNoTrgEleEvtsEB->Clone("hAccTimesEffNoTrgEleEB");
hAccTimesEffNoTrgEleEE = (TH1F*)hRecoNoTrgEleEvtsEE->Clone("hAccTimesEffNoTrgEleEE");
hAccTimesEffNoTrgMu = (TH1F*)hRecoNoTrgMuEvts->Clone("hAccTimesEffNoTrgMu");
hEffAftTrg = (TH1F*)hRecoEvts->Clone("hAccTimesEff");
hEffAftTrgEle = (TH1F*)hRecoEleEvts->Clone("hAccTimesEffEle");
hEffAftTrgEleEB = (TH1F*)hRecoEleEvtsEB->Clone("hAccTimesEffEleEB");
hEffAftTrgEleEE = (TH1F*)hRecoEleEvtsEE->Clone("hAccTimesEffEleEE");
hEffAftTrgMu = (TH1F*)hRecoMuEvts->Clone("hAccTimesEffMu");
hTrgRecoVsReco = (TH1F*)hRecoEvts->Clone("hTrgRecoVsReco");
//hTrgRecoVsRecoEB = (TH1F*)hRecoEvtsEB->Clone("hTrgRecoVsRecoEB");
//hTrgRecoVsRecoEE = (TH1F*)hRecoEvtsEE->Clone("hTrgRecoVsRecoEE");
hTrgRecoVsRecoEle = (TH1F*)hRecoEleEvts->Clone("hTrgRecoVsRecoEle");
hTrgRecoVsRecoEleEB = (TH1F*)hRecoEleEvtsEB->Clone("hTrgRecoVsRecoEleEB");
hTrgRecoVsRecoEleEE = (TH1F*)hRecoEleEvtsEE->Clone("hTrgRecoVsRecoEleEE");
hTrgRecoVsRecoMu = (TH1F*)hRecoMuEvts->Clone("hTrgRecoVsRecoMu");
hAcc->Divide(hGenEvts);
hAccEle->Divide(hGenEvts);
hAccEleEB->Divide(hGenEvts);
hAccEleEE->Divide(hGenEvts);
hAccMu->Divide(hGenEvts);
hAccTimesTrgEff->Divide(hGenEvts);
hTrgEff->Divide(hGenEvtsInAcc);
hAccTimesEff->Divide(hGenEvts);
hAccTimesEffEB->Divide(hGenEvts);
hAccTimesEffEE->Divide(hGenEvts);
hAccTimesEffEle->Divide(hGenEvts);
hAccTimesEffEleEB->Divide(hGenEvts);
hAccTimesEffEleEE->Divide(hGenEvts);
hAccTimesEffMu->Divide(hGenEvts);
hAccTimesEffNoTrg->Divide(hGenEvts);
//hAccTimesEffNoTrgEB->Divide(hGenEvts);
//hAccTimesEffNoTrgEE->Divide(hGenEvts);
hAccTimesEffNoTrgEle->Divide(hGenEvts);
hAccTimesEffNoTrgEleEB->Divide(hGenEvts);
hAccTimesEffNoTrgEleEE->Divide(hGenEvts);
hAccTimesEffNoTrgMu->Divide(hGenEvts);
hEffAftTrg->Divide(hTrgEvts);
hEffAftTrgEle->Divide(hTrgEvts);
hEffAftTrgEleEB->Divide(hTrgEvts);
hEffAftTrgEleEE->Divide(hTrgEvts);
hEffAftTrgMu->Divide(hTrgEvts);
hTrgRecoVsReco->Divide(hRecoNoTrgEvts);
//hTrgRecoVsRecoEB->Divide(hRecoNoTrgEvtsEB);
//hTrgRecoVsRecoEE->Divide(hRecoNoTrgEvtsEE);
hTrgRecoVsRecoEle->Divide(hRecoNoTrgEleEvts);
hTrgRecoVsRecoEleEB->Divide(hRecoNoTrgEleEvtsEB);
hTrgRecoVsRecoEleEE->Divide(hRecoNoTrgEleEvtsEE);
hTrgRecoVsRecoMu->Divide(hRecoNoTrgMuEvts);
// plot
TCanvas *accTimesEffPlot = new TCanvas("accTimesEffPlot", "acc x eff", 100, 100, 600, 600);
TPad *accTimesEffPad = new TPad("accTimesEffPad", "acc x eff pad", 0., 0., 1., 1.);
accTimesEffPad->SetBottomMargin(0.12);
accTimesEffPad->SetBorderMode(0);
accTimesEffPad->SetBorderSize(2);
accTimesEffPad->SetFrameBorderMode(0);
accTimesEffPad->SetFillColor(0);
accTimesEffPad->SetFrameFillColor(0);
accTimesEffPad->SetLeftMargin(0.11);
accTimesEffPad->SetRightMargin(0.09);
accTimesEffPad->SetTopMargin(0.08);
accTimesEffPad->SetTickx(1);
accTimesEffPad->SetTicky(1);
accTimesEffPad->Draw();
accTimesEffPad->cd();
gStyle->SetTitleFont(font);
gStyle->SetLabelFont(font);
gStyle->SetLegendFont(font);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetOptFit(1111);
gStyle->SetTitleXOffset(1.);
gStyle->SetTitleYOffset(1.3);
gPad->SetTicks(1, 1);
gPad->SetGrid(1, 1);
TH1F* hAccTimesEff2 = (TH1F*)hAccTimesEff->Clone("hAccTimesEff2");
TF1 *fitFunc = new TF1("fitFunc", "[0] + [1]/ (x + [2]) + [3]*x", 10., 5010.);
//TF1 *fitFuncEB = new TF1("fitFuncEB", "[0] + [1]/ (x + [2])", 10., 5010.);
TF1 *fitFuncEB = new TF1("fitFuncEB", "[0] + [1]/ (x + [2]) + [3]*x", 10., 5010.);
TF1 *fitFuncEE = new TF1("fitFuncEE", "[0] + [1]/ (x*x + [2])", 10., 5010.);
fitFunc->SetLineColor(kBlue);
fitFuncEB->SetLineColor(kBlue);
fitFuncEE->SetLineColor(kBlue);
hAccTimesEff->Fit("fitFunc", "", "", 480., 5010.);
hAccTimesEffEB->Fit("fitFuncEB", "", "", 480., 5010.);
hAccTimesEffEE->Fit("fitFuncEE", "", "", 480., 5010.);
cout << "Chi^2 / NDF: " << fitFunc->GetChisquare() << " / " << fitFunc->GetNDF() << ", prob: " << fitFunc->GetProb() << endl;
cout << "Chi^2 / NDF EB: " << fitFuncEB->GetChisquare() << " / " << fitFuncEB->GetNDF() << ", prob: " << fitFuncEB->GetProb() << endl;
cout << "Chi^2 / NDF EE: " << fitFuncEE->GetChisquare() << " / " << fitFuncEE->GetNDF() << ", prob: " << fitFuncEE->GetProb() << endl;
hAccTimesEff->GetYaxis()->SetTitle("acc x eff");
hAccTimesEff->GetYaxis()->SetRangeUser(0., 1.);
hAccTimesEff->Draw();
TLatex *tex = new TLatex(0.22, 0.21, "P(M|p0,p1,p2,p3) = p0 + #frac{p1}{M+p2} + p3*M");
tex->SetNDC();
tex->SetTextFont(font);
tex->SetLineWidth(2);
tex->SetTextSize(0.03);
tex->Draw();
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
tex->DrawLatex(0.17, 0.85, "trg + electron + muon");
TCanvas *accTimesEffPlotEB = new TCanvas("accTimesEffPlotEB", "acc x eff, barrel electron + muon", 100, 100, 600, 600);
TPad *accTimesEffPadEB = (TPad*)accTimesEffPad->Clone("accTimesEffPadEB");
accTimesEffPadEB->Draw();
accTimesEffPadEB->cd();
hAccTimesEffEB->GetYaxis()->SetTitle("acc x eff");
hAccTimesEffEB->GetYaxis()->SetRangeUser(0., 1.);
hAccTimesEffEB->Draw();
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
//tex->DrawLatex(0.46, 0.21, "P(M|p0,p1,p2) = p0 + #frac{p1}{M+p2}");
tex->DrawLatex(0.22, 0.21, "P(M|p0,p1,p2,p3) = p0 + #frac{p1}{M+p2} + p3*M");
tex->DrawLatex(0.17, 0.85, "trg + barrel electron + muon");
TCanvas *accTimesEffPlotEE = new TCanvas("accTimesEffPlotEE", "acc x eff, endcap electron + muon", 100, 100, 600, 600);
TPad *accTimesEffPadEE = (TPad*)accTimesEffPad->Clone("accTimesEffPadEE");
accTimesEffPadEE->Draw();
accTimesEffPadEE->cd();
hAccTimesEffEE->GetYaxis()->SetTitle("acc x eff");
hAccTimesEffEE->GetYaxis()->SetRangeUser(0., 1.);
hAccTimesEffEE->Draw();
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
tex->DrawLatex(0.45, 0.38, "P(M|p0,p1,p2) = p0 + #frac{p1}{M^{2}+p2}");
tex->DrawLatex(0.17, 0.85, "trg + endcap electron + muon");
TCanvas *accTimesEffObjPlot = new TCanvas("accTimesEffObjPlot", "acc x eff, objects", 100, 100, 600, 600);
TPad *accTimesEffObjPad = (TPad*)accTimesEffPad->Clone("accTimesEffObjPad");
accTimesEffObjPad->Draw();
accTimesEffObjPad->cd();
hAccTimesEffEle->GetYaxis()->SetTitle("acc x eff");
hAccTimesEffEle->GetYaxis()->SetRangeUser(0., 1.);
hAccTimesEffEle->SetMarkerStyle(kFullSquare);
hAccTimesEffEle->SetMarkerColor(kViolet);
hAccTimesEffEle->SetLineColor(kViolet);
hAccTimesEffEle->Draw();
hAccTimesEffEleEB->SetMarkerStyle(kFullTriangleUp);
hAccTimesEffEleEB->SetMarkerColor(kRed);
hAccTimesEffEleEB->SetLineColor(kRed);
hAccTimesEffEleEB->Draw("same");
hAccTimesEffEleEE->SetMarkerStyle(kFullTriangleDown);
hAccTimesEffEleEE->SetMarkerColor(kBlue);
hAccTimesEffEleEE->SetLineColor(kBlue);
hAccTimesEffEleEE->Draw("same");
hAccTimesEffMu->SetMarkerStyle(34);
hAccTimesEffMu->SetMarkerColor(kGreen+1);
hAccTimesEffMu->SetLineColor(kGreen+1);
hAccTimesEffMu->Draw("same");
hAccTimesEff2->Draw("same");
TLegend* legend = new TLegend(0.592, 0.279, 0.881, 0.467);
legend->SetTextFont(font);
legend->SetTextSize(0.03);
legend->SetBorderSize(0);
legend->SetLineColor(1);
legend->SetLineStyle(1);
legend->SetLineWidth(1);
legend->SetFillColor(19);
legend->SetFillStyle(0);
legend->AddEntry(hAccTimesEff, "total acc x eff");
legend->AddEntry(hAccTimesEffMu, "muons");
legend->AddEntry(hAccTimesEffEle, "all electrons");
legend->AddEntry(hAccTimesEffEleEB, "barrel electrons");
legend->AddEntry(hAccTimesEffEleEE, "endcap electrons");
legend->Draw("same");
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
tex->DrawLatex(0.17, 0.85, "trg: HLT_Mu22_Photon22_CaloIdL");
// acc x eff with no trg applied
TCanvas *accTimesEffNoTrgObjPlot = new TCanvas("accTimesEffNoTrgObjPlot", "acc x eff, no trigger, objects", 100, 100, 600, 600);
TPad *accTimesEffNoTrgObjPad = (TPad*)accTimesEffPad->Clone("accTimesEffNoTrgObjPad");
accTimesEffNoTrgObjPad->Draw();
accTimesEffNoTrgObjPad->cd();
hAccTimesEffNoTrgEle->GetYaxis()->SetTitle("acc x eff");
hAccTimesEffNoTrgEle->GetYaxis()->SetRangeUser(0., 1.);
hAccTimesEffNoTrgEle->SetMarkerStyle(kFullSquare);
hAccTimesEffNoTrgEle->SetMarkerColor(kViolet);
hAccTimesEffNoTrgEle->SetLineColor(kViolet);
hAccTimesEffNoTrgEle->Draw();
hAccTimesEffNoTrgEleEB->SetMarkerStyle(kFullTriangleUp);
hAccTimesEffNoTrgEleEB->SetMarkerColor(kRed);
hAccTimesEffNoTrgEleEB->SetLineColor(kRed);
hAccTimesEffNoTrgEleEB->Draw("same");
hAccTimesEffNoTrgEleEE->SetMarkerStyle(kFullTriangleDown);
hAccTimesEffNoTrgEleEE->SetMarkerColor(kBlue);
hAccTimesEffNoTrgEleEE->SetLineColor(kBlue);
hAccTimesEffNoTrgEleEE->Draw("same");
hAccTimesEffNoTrgMu->SetMarkerStyle(34);
hAccTimesEffNoTrgMu->SetMarkerColor(kGreen+1);
hAccTimesEffNoTrgMu->SetLineColor(kGreen+1);
hAccTimesEffNoTrgMu->Draw("same");
hAccTimesEffNoTrg->Draw("same");
TLegend* accXeffNoTrg = (TLegend*)legend->Clone("effAftTrgLegend");
accXeffNoTrg->Clear();
accXeffNoTrg->AddEntry(hAccTimesEffNoTrg, "total acc x eff");
accXeffNoTrg->AddEntry(hAccTimesEffNoTrgMu, "muons");
accXeffNoTrg->AddEntry(hAccTimesEffNoTrgEle, "all electrons");
accXeffNoTrg->AddEntry(hAccTimesEffNoTrgEleEB, "barrel electrons");
accXeffNoTrg->AddEntry(hAccTimesEffNoTrgEleEE, "endcap electrons");
accXeffNoTrg->Draw("same");
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
tex->DrawLatex(0.17, 0.85, "trg: none");
// efficiency on triggered events
TCanvas *effAftTrgPlot = new TCanvas("effAftTrgPlot", "efficiency after trigger", 100, 100, 600, 600);
TPad *effAftTrgPad = (TPad*)accTimesEffPad->Clone("effAftTrgPad");
effAftTrgPad->Draw();
effAftTrgPad->cd();
hEffAftTrgEle->GetYaxis()->SetTitle("eff");
hEffAftTrgEle->GetYaxis()->SetRangeUser(0., 1.);
hEffAftTrgEle->SetMarkerStyle(kFullSquare);
hEffAftTrgEle->SetMarkerColor(kViolet);
hEffAftTrgEle->SetLineColor(kViolet);
hEffAftTrgEle->Draw();
hEffAftTrgEleEB->SetMarkerStyle(kFullTriangleUp);
hEffAftTrgEleEB->SetMarkerColor(kRed);
hEffAftTrgEleEB->SetLineColor(kRed);
hEffAftTrgEleEB->Draw("same");
hEffAftTrgEleEE->SetMarkerStyle(kFullTriangleDown);
hEffAftTrgEleEE->SetMarkerColor(kBlue);
hEffAftTrgEleEE->SetLineColor(kBlue);
hEffAftTrgEleEE->Draw("same");
hEffAftTrgMu->SetMarkerStyle(34);
hEffAftTrgMu->SetMarkerColor(kGreen+1);
hEffAftTrgMu->SetLineColor(kGreen+1);
hEffAftTrgMu->Draw("same");
hEffAftTrg->Draw("same");
TLegend* effAftTrgLegend = (TLegend*)legend->Clone("effAftTrgLegend");
effAftTrgLegend->Clear();
effAftTrgLegend->AddEntry(hEffAftTrg, "total eff after trigger");
effAftTrgLegend->AddEntry(hEffAftTrgMu, "muons");
effAftTrgLegend->AddEntry(hEffAftTrgEle, "all electrons");
effAftTrgLegend->AddEntry(hEffAftTrgEleEB, "barrel electrons");
effAftTrgLegend->AddEntry(hEffAftTrgEleEE, "endcap electrons");
effAftTrgLegend->Draw("same");
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
tex->DrawLatex(0.14, 0.15, "trg: HLT_Mu22_Photon22_CaloIdL");
// acceptance
TCanvas *accPlot = new TCanvas("accPlot", "acc", 100, 100, 600, 600);
TPad *accPad = (TPad*)accTimesEffPad->Clone("accPad");
accPad->Draw();
accPad->cd();
hAcc->GetYaxis()->SetTitle("acc");
hAcc->GetYaxis()->SetRangeUser(0., 1.);
hAccEle->SetMarkerStyle(kFullSquare);
hAccEle->SetMarkerColor(kViolet);
hAccEle->SetLineColor(kViolet);
hAccEle->Draw();
hAccEleEB->SetMarkerStyle(kFullTriangleUp);
hAccEleEB->SetMarkerColor(kRed);
hAccEleEB->SetLineColor(kRed);
hAccEleEB->Draw("same");
hAccEleEE->SetMarkerStyle(kFullTriangleDown);
hAccEleEE->SetMarkerColor(kBlue);
hAccEleEE->SetLineColor(kBlue);
hAccEleEE->Draw("same");
hAccMu->SetMarkerStyle(34);
hAccMu->SetMarkerColor(kGreen+1);
hAccMu->SetLineColor(kGreen+1);
hAccMu->Draw("same");
hAcc->Draw("same");
TLegend* accLegend = (TLegend*)legend->Clone("accLegend");
accLegend->Clear();
accLegend->AddEntry(hAcc, "total acceptance");
accLegend->AddEntry(hAccMu, "muons");
accLegend->AddEntry(hAccEle, "all electrons");
accLegend->AddEntry(hAccEleEB, "barrel electrons");
accLegend->AddEntry(hAccEleEE, "endcap electrons");
accLegend->Draw("same");
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
// reco with trg vs. reco
TCanvas *trgRecoVsRecoPlot = new TCanvas("trgRecoVsRecoPlot", "reco with trg vs. reco", 100, 100, 600, 600);
TPad *trgRecoVsRecoPad = (TPad*)accTimesEffPad->Clone("trgRecoVsRecoPad");
trgRecoVsRecoPad->Draw();
trgRecoVsRecoPad->cd();
hTrgRecoVsRecoEle->GetYaxis()->SetTitle("eff");
hTrgRecoVsRecoEle->GetYaxis()->SetRangeUser(0., 1.);
hTrgRecoVsRecoEle->SetMarkerStyle(kFullSquare);
hTrgRecoVsRecoEle->SetMarkerColor(kViolet);
hTrgRecoVsRecoEle->SetLineColor(kViolet);
hTrgRecoVsRecoEle->Draw();
//hTrgRecoVsRecoEleEB->SetMarkerStyle(kFullTriangleUp);
//hTrgRecoVsRecoEleEB->SetMarkerColor(kRed);
//hTrgRecoVsRecoEleEB->SetLineColor(kRed);
//hTrgRecoVsRecoEleEB->Draw("same");
//hTrgRecoVsRecoEleEE->SetMarkerStyle(kFullTriangleDown);
//hTrgRecoVsRecoEleEE->SetMarkerColor(kBlue);
//hTrgRecoVsRecoEleEE->SetLineColor(kBlue);
//hTrgRecoVsRecoEleEE->Draw("same");
hTrgRecoVsRecoMu->SetMarkerStyle(34);
hTrgRecoVsRecoMu->SetMarkerColor(kGreen+1);
hTrgRecoVsRecoMu->SetLineColor(kGreen+1);
hTrgRecoVsRecoMu->Draw("same");
hTrgRecoVsReco->Draw("same");
TLegend* trgRecoVsRecoLegend = (TLegend*)legend->Clone("trgRecoVsRecoLegend");
trgRecoVsRecoLegend->Clear();
trgRecoVsRecoLegend->AddEntry(hTrgRecoVsReco, "total");
trgRecoVsRecoLegend->AddEntry(hTrgRecoVsRecoMu, "muons");
trgRecoVsRecoLegend->AddEntry(hTrgRecoVsRecoEle, "electrons");
//trgRecoVsRecoLegend->AddEntry(hTrgRecoVsRecoEleEB, "barrel electrons");
//trgRecoVsRecoLegend->AddEntry(hTrgRecoVsRecoEleEE, "endcap electrons");
trgRecoVsRecoLegend->Draw("same");
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
TCanvas *accTimesTrgEffPlot = new TCanvas("accTimesTrgEffPlot", "acc x trigger eff", 100, 100, 600, 600);
TPad *accTimesTrgEffPad = (TPad*)accTimesEffPad->Clone("accTimesTrgEffPad");
accTimesTrgEffPad->Draw();
accTimesTrgEffPad->cd();
hAccTimesTrgEff->GetYaxis()->SetTitle("acc x trg eff");
hAccTimesTrgEff->GetYaxis()->SetRangeUser(0., 1.);
hAccTimesTrgEff->SetMarkerStyle(20);
hAccTimesTrgEff->SetMarkerColor(kCyan);
hAccTimesTrgEff->SetLineColor(kCyan);
hAccTimesTrgEff->Draw();
hTrgEff->SetMarkerStyle(21);
hTrgEff->SetMarkerColor(kMagenta);
hTrgEff->SetLineColor(kMagenta);
hTrgEff->Draw("same");
TLegend* trgLegend = (TLegend*)legend->Clone("trgLegend");
trgLegend->Clear();
trgLegend->AddEntry(hTrgEff, "trigger eff in acc");
trgLegend->AddEntry(hAccTimesTrgEff, "acc x trigger eff");
trgLegend->Draw("same");
tex->DrawLatex(0.109, 0.935, "CMS Simulation, 8 TeV");
// safe in various file formats
if (saveSpec) {
if (saveAsPdf) {
accTimesTrgEffPlot->Print(plotDir + accTimesTrgEffPlot->GetName() + ".pdf", "pdf");
accTimesEffPlot->Print(plotDir + accTimesEffPlot->GetName() + ".pdf", "pdf");
accTimesEffPlotEB->Print(plotDir + accTimesEffPlotEB->GetName() + ".pdf", "pdf");
accTimesEffPlotEE->Print(plotDir + accTimesEffPlotEE->GetName() + ".pdf", "pdf");
accTimesEffObjPlot->Print(plotDir + accTimesEffObjPlot->GetName() + ".pdf", "pdf");
accTimesEffNoTrgObjPlot->Print(plotDir + accTimesEffNoTrgObjPlot->GetName() + ".pdf", "pdf");
effAftTrgPlot->Print(plotDir + effAftTrgPlot->GetName() + ".pdf", "pdf");
trgRecoVsRecoPlot->Print(plotDir + trgRecoVsRecoPlot->GetName() + ".pdf", "pdf");
accPlot->Print(plotDir + accPlot->GetName() + ".pdf", "pdf");
}
if (saveAsPng) {
accTimesTrgEffPlot->Print(plotDir + accTimesTrgEffPlot->GetName() + ".png", "png");
accTimesEffPlot->Print(plotDir + accTimesEffPlot->GetName() + ".png", "png");
accTimesEffPlotEB->Print(plotDir + accTimesEffPlotEB->GetName() + ".png", "png");
accTimesEffPlotEE->Print(plotDir + accTimesEffPlotEE->GetName() + ".png", "png");
accTimesEffObjPlot->Print(plotDir + accTimesEffObjPlot->GetName() + ".png", "png");
accTimesEffNoTrgObjPlot->Print(plotDir + accTimesEffNoTrgObjPlot->GetName() + ".png", "png");
effAftTrgPlot->Print(plotDir + effAftTrgPlot->GetName() + ".png", "png");
trgRecoVsRecoPlot->Print(plotDir + trgRecoVsRecoPlot->GetName() + ".png", "png");
accPlot->Print(plotDir + accPlot->GetName() + ".png", "png");
}
if (saveAsRoot) {
accTimesTrgEffPlot->Print(plotDir + accTimesTrgEffPlot->GetName() + ".root", "root");
accTimesEffPlot->Print(plotDir + accTimesEffPlot->GetName() + ".root", "root");
accTimesEffPlotEB->Print(plotDir + accTimesEffPlotEB->GetName() + ".root", "root");
accTimesEffPlotEE->Print(plotDir + accTimesEffPlotEE->GetName() + ".root", "root");
accTimesEffObjPlot->Print(plotDir + accTimesEffObjPlot->GetName() + ".root", "root");
accTimesEffNoTrgObjPlot->Print(plotDir + accTimesEffNoTrgObjPlot->GetName() + ".root", "root");
effAftTrgPlot->Print(plotDir + effAftTrgPlot->GetName() + ".root", "root");
trgRecoVsRecoPlot->Print(plotDir + trgRecoVsRecoPlot->GetName() + ".root", "root");
accPlot->Print(plotDir + accPlot->GetName() + ".root", "root");
}
}
// write histos to file
output->cd();
hGenEvts->Write();
hGenEvtsEleInAcc->Write();
hGenEvtsEleInAccEB->Write();
hGenEvtsEleInAccEE->Write();
hGenEvtsMuInAcc->Write();
hGenEvtsInAcc->Write();
hTrgEvts->Write();
hRecoEvts->Write();
hRecoEvtsEB->Write();
hRecoEvtsEE->Write();
hRecoEleEvts->Write();
hRecoEleEvtsEB->Write();
hRecoEleEvtsEE->Write();
hRecoMuEvts->Write();
hAccEle->Write();
hAccEleEB->Write();
hAccEleEE->Write();
hAccMu->Write();
hAccTimesTrgEff->Write();
hTrgEff->Write();
hAccTimesEff->Write();
hAccTimesEffEB->Write();
hAccTimesEffEE->Write();
hAccTimesEffEle->Write();
hAccTimesEffEleEB->Write();
hAccTimesEffEleEE->Write();
hAccTimesEffMu->Write();
hEffAftTrg->Write();
hEffAftTrgEle->Write();
hEffAftTrgEleEB->Write();
hEffAftTrgEleEE->Write();
hEffAftTrgMu->Write();
fitFunc->Write();
fitFuncEB->Write();
fitFuncEE->Write();
output->Close();
timer.Stop();
timer.Print();
}
void vs_PlotQCDcomp() {
Bool_t saveC = false;
Bool_t diJets = true;
Bool_t isMC = false;
TString vsSave;
vsSave = "_T07w";
TString jSave;
if(diJets) jSave = "2j";
else jSave = "3j";
TString sample;
if(diJets) sample = "select_1ph_2jets";
else sample = "select_1ph_3jets";
TString FOtag;
if(isMC) FOtag = "_FO_CorrMC";
// else FOtag = "_FO_Corr";
else FOtag = "_FO";
TString sysu = "SYSTUP_";
TString sysd = "SYSTDOWN_";
TString outDir;
outDir = "Plots_PhotonSusyAnalysis/QCDweights/";
// string inputFile1 = "/data/user/vsola/CMSSW_Releases/CMSSW_5_3_9/src/Plots_PhotonSusyAnalysis/Merged_QCD_PhotonJet_T07w_PAT/mergedHistos.root";
// string inputFile1 = "/data/user/vsola/CMSSW_Releases/CMSSW_5_3_9/src/Plots_PhotonSusyAnalysis/Merged_Data_V05w_PAT/mergedHistos.root";
string inputFile1 = "/data/user/vsola/CMSSW_Releases/CMSSW_5_3_9/src/Plots_PhotonSusyAnalysis/PhotonHadReReco_22Jan2013_V05_PAT/mergedHistos.root";
setMyTDRStyle();
gROOT->SetStyle("mytdrStyle");
// gStyle->SetHistMinimumZero();
// gStyle->SetPaintTextFormat("4.2f");
gStyle->SetHistLineWidth(2);
gStyle->UseCurrentStyle();
// gStyle->SetPadTopMargin(1.0);
// gStyle->SetPadLeftMargin(3.2);
// gStyle->SetPadRightMargin(4.5);
// gStyle->SetPadBottomMargin(3.2);
gROOT->ForceStyle(1);
static const Int_t nHt = 7;
static const Int_t nPt = 13;
static const Int_t nMet = 16;
static const Int_t nJet = 15;
Double_t binPt[nPt+1] = {0.,75.,90.,120.,160.,210.,260.,320.,400.,500.,650.,800.,1000.,1500.};
Double_t binHt[nHt+1] = {0.,400.,450.,550.,700.,900.,1200.,1500.};
Double_t binMet[nMet+1] = {0.,10.,20.,30.,40.,50.,60.,70.,80.,90.,100.,120.,160.,200.,270.,350.,500.};
Double_t binJet[nJet+1] = {0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15};
TLatex *as = new TLatex();
as->SetNDC(true);
as->SetTextColor(12);
as->SetTextFont(43);
as->SetTextSize(19);
TLegend *legend = new TLegend(0.60, 0.70, 0.75, 0.85, "");
legend->SetFillColor(10);
legend->SetFillStyle(1001);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetShadowColor(0);
std::string outLumi = "CMS Work in Progress - QCD MC #sqrt{s} = 8 TeV - #geq 1 #gamma, #geq 2 j";
TFile* f1 = TFile::Open( inputFile1.c_str() );
//photon Pt
TCanvas * cPt = new TCanvas("cPt","cPt");
TH1F* hpt = (TH1F*) f1->Get( sample+"/PreselCut_photonPt" );
TH1F* hptFO = (TH1F*) f1->Get( sample+FOtag+"/PreselCut_photonPt" );
TH1F *hptR = (TH1F*) hpt->Rebin(nPt,hpt->GetTitle(),binPt);
if (hptR->GetSumw2N() == 0)
hptR->Sumw2();
TH1F *hptFOR = (TH1F*) hptFO->Rebin(nPt,hptFO->GetTitle(),binPt);
if (hptFOR->GetSumw2N() == 0)
hptFOR->Sumw2();
TH1F* hptSU = (TH1F*) f1->Get( sample+FOtag+"/PreselCut_"+sysu+"photonPt" );
TH1F* hptSD = (TH1F*) f1->Get( sample+FOtag+"/PreselCut_"+sysd+"photonPt" );
TH1F *hptSUR = (TH1F*) hptSU->Rebin(nPt,hptSU->GetTitle(),binPt);
if (hptSUR->GetSumw2N() == 0)
hptSUR->Sumw2();
TH1F *hptSDR = (TH1F*) hptSD->Rebin(nPt,hptSD->GetTitle(),binPt);
if (hptSDR->GetSumw2N() == 0)
hptSDR->Sumw2();
if ( hptFOR != 0 ) {
for (int b = 0; b < hptFOR->GetNbinsX(); b++) {
Double_t mainHistoContent = hptFOR->GetBinContent(b);
Double_t systUpHistoContent = hptSUR->GetBinContent(b);
Double_t systDnHistoContent = hptSDR->GetBinContent(b);
Double_t systDiffUp = fabs( (double) systUpHistoContent - mainHistoContent );
Double_t systDiffDn = fabs( (double) mainHistoContent - systDnHistoContent );
// use average error for histogram
Double_t systDiff = ( systDiffUp + systDiffDn ) / 2.;
Double_t statErr = hptFOR->GetBinError(b);
Double_t combError = sqrt( systDiff * systDiff + statErr * statErr );
hptFOR->SetBinError(b, combError);
} //for
}//if
cPt->SetLogy(1);
gPad->Update();
cPt->Update();
// hptR->Scale(1,"width");
// hptR->SetMinimum(0.02);
// hptR->SetMaximum(1000);
hptR->GetXaxis()->SetTitle("1^{st} photon p_{T} [GeV]");
hptR->GetYaxis()->SetTitle("Number of Events / GeV");
if(isMC) hptR->SetMarkerSize(0);
if(isMC) hptR->Draw("histE");
else hptR->Draw("E X0");
hptFOR->SetMarkerSize(0);
hptFOR->SetLineColor(2);
hptFOR->SetFillColor(2);
hptFOR->SetFillStyle(3004);
hptFOR->Draw("same hist ][ E2");
legend->Clear();
if(isMC) legend->SetHeader("#gamma/QCD (Sim)");
else legend->SetHeader("#gamma/QCD (Data)");
if(isMC) legend->AddEntry(hptR, "#gamma", "l");
else legend->AddEntry(hptR, "#gamma", "p");
legend->AddEntry(hptFOR, "Pred (from #gamma_{jet})", "f");
legend->Draw();
as->DrawLatex(0.17, 0.93, outLumi.c_str() );
cPt->Update();
cPt->SetBottomMargin(0.2 + 0.8 * cPt->GetBottomMargin() - 0.2 * cPt->GetTopMargin());
TPad *ratioPt = new TPad("BottomPad", "", 0, 0, 1, 1);
ratioPt->SetTopMargin(0.8 - 0.8 * ratioPt->GetBottomMargin() + 0.2 * ratioPt->GetTopMargin());
ratioPt->SetFillStyle(0);
ratioPt->SetFrameFillColor(10);
ratioPt->SetFrameBorderMode(0);
ratioPt->Draw();
ratioPt->cd();
ratioPt->SetLogy(0);
TH1F *hptRat = (TH1F*) divideHistosForRatio(hptR,hptFOR);
hptRat->SetMinimum(0.);
hptRat->SetMaximum(10.);
hptRat->GetXaxis()->SetNdivisions(505);
if(isMC) hptRat->GetYaxis()->SetTitle("Sim/Pred");
else hptRat->GetYaxis()->SetTitle("Data/Pred");
hptRat->GetYaxis()->SetTitleSize(0.04);
hptRat->GetYaxis()->SetLabelSize(0.03);
hptRat->GetYaxis()->SetTitleOffset(1.3);
hptRat->GetYaxis()->SetNdivisions(505);
hptRat->SetMarkerStyle(20);
hptRat->SetMarkerSize(1);
hptRat->SetMarkerColor(1);
hptRat->SetLineColor(1);
hptRat->Draw("E X0");
TH1F *hptFRat = (TH1F*) getSystErrForRatio(hptFOR);
hptFRat->SetLineColor(2);
hptFRat->SetFillColor(2);
hptFRat->SetFillStyle(3004);
hptFRat->Draw("same hist ][ E2");
TLine * line = new TLine( hptRat->GetXaxis()->GetXmin(), 1., hptRat->GetXaxis()->GetXmax(), 1. );
line->SetLineColor(1);
line->SetLineWidth(0.5);
line->SetLineStyle(1);
line->Draw("same");
hptR->GetXaxis()->SetLabelSize(0);
hptR->GetXaxis()->SetTitle("");
cPt->RedrawAxis();
gPad->Update();
cPt->Update();
return;
}
void macro_MakeQcdClosureTest()
{
// parameters //////////////////////////////////////////////////////////////
//TFile input("./emuSpec_19619pb-1.root", "open");
TFile input("test_19619pb-1.root", "open");
input.cd();
TParameter<float> *lumi = (TParameter<float> *)input.Get("lumi");
const int nBins = 75;
const bool usePu = 1;
const bool useWeight = 1;
const int qcdEst = 1; // estimation method of QCD contribution. none(0), from SS spectrum(1), from fake rate(2)
int eRegion = 2; // electron region EB(0), EE(1), EB+EE(2)
bool plotSign[3];
plotSign[0] = 1; // all
plotSign[1] = 1; // SS same sign
plotSign[2] = 1; // OS opposite sign
bool plotType[2];
plotType[0] = 1; // emu spectrum
plotType[1] = 1; // cumulative emu spectrum
const bool plotPull = 0; // plot (data-bkg)/bkg
const bool plotPullBelowSpec = 0; // plot (data-bkg)/bkg below spectrum
const bool logPlotX = 0;
const bool logPlotY = 1;
const bool prelim = 1;
const bool groupedPlot = 0;
const bool overflowBin = 1;
float xRangeMin = 60.;
float xRangeMax = 1200.;
//float xRangeMin = 0.;
//float xRangeMax = 1500.;
float yRangeMin[6] = {0.002, 0.002, 0.002, 0.4, 0.4, 0.4};
float yRangeMax[6] = {30, 10, 30, 3000, 1000, 3000};
float yRangeMinRatio[3] = {-0.7, -0.7, -0.7};
float yRangeMaxRatio[3] = {0.7, 0.7, 0.7};
float fitMin = xRangeMin;
float fitMax = 1100.; // set to highest bin with a data point
float xRangeMinRatio = fitMin;
float xRangeMaxRatio = fitMax;
// output file formats
const bool savePull = 0;
const bool saveSpec = 0;
const bool saveCumSpec = 0;
const bool saveAsPdf = 0;
const bool saveAsPng = 1;
const bool saveAsRoot = 0;
const char *fileNameExtra = "";
//const char *fileNameExtra = "madgraphTTbar_";
const char *plotDir = "./plottemp/";
// plot style
int wjetColour= TColor::GetColor("#ffd324");
int jetBkgColour = TColor::GetColor("#ffff66");
int font = 42; //62
////////////////////////////////////////////////////////////////////////////
// systematic errors
float systErrLumi = ((TParameter<float> *)input.Get("systErrLumi"))->GetVal();
systErrLumi = 0.; // since we normalize to the Z peak
float systErrEff = ((TParameter<float> *)input.Get("systErrEff"))->GetVal(); // muon err & ele err
THashList *systErrMCs = (THashList *)input.Get("systErrMCs");
vector<float> systErrMC;
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcTtbar"))->GetVal()); // NNLO ttbar
//systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcTtbar700to1000"))->GetVal()); // NLO ttbar700to1000
//systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcTtbar1000up"))->GetVal()); // NLO ttbar1000up
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcDyTauTau"))->GetVal()); //z->tt
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcWW"))->GetVal()); //WW
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcWZ"))->GetVal()); //WZ
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcZZ"))->GetVal()); //ZZ
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcTW"))->GetVal()); //tW
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcDyMuMu"))->GetVal()); //Z->mm
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcDyEE"))->GetVal()); //Z->ee
if (qcdEst == 2) systErrMC.push_back(0.4); // qcd error
else systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcWJets"))->GetVal()); //WJets
// to keep the histogram when the file is closed
TH1::AddDirectory(kFALSE);
TH1::SetDefaultSumw2(kTRUE);
TString histoSign[3] = {"", "SS_", "OS_"};
TString xAxisTitle[3] = {"m(e#mu)", "m(e^{#pm}#mu^{#pm})", "m(e^{#pm}#mu^{#mp})"};
TString nameSuffix[2] = {"", "cumul"};
TString titleSuffix[2] = {"", " - Cumulative"};
vector<TH1F *> emuMass_wjets;
vector<TH1F *> emuMass_qcd;
vector<TH1F *> emuMass_qcdFromFake;
// define the binning
vector<float> binning;
if (logPlotX) {
//for (float bin = 0.; bin < 100.; bin += 5.)
// binning.push_back(bin);
for (float bin = 0.; bin < 200.; bin += 10.)
binning.push_back(bin);
for (float bin = 200.; bin < 400.; bin += 20.)
binning.push_back(bin);
for (float bin = 400.; bin < 500.; bin += 25.)
binning.push_back(bin);
for (float bin = 500.; bin <= 620.; bin += 40.)
binning.push_back(bin);
binning.push_back(670.);
binning.push_back(720.);
binning.push_back(780.);
binning.push_back(840.);
binning.push_back(920.);
binning.push_back(1000.);
binning.push_back(1100.);
binning.push_back(1220.);
binning.push_back(1380.);
binning.push_back(1500.);
} else {
//for (float bin = 0.; bin <= 1500.; bin += 20.)
// binning.push_back(bin);
for (float bin = 0.; bin < 200.; bin += 20.)
binning.push_back(bin);
for (float bin = 200.; bin < 400.; bin += 40.)
binning.push_back(bin);
for (float bin = 400.; bin < 700.; bin += 50.)
binning.push_back(bin);
for (float bin = 700.; bin < 1000.; bin += 75.)
binning.push_back(bin);
for (float bin = 1000.; bin < 1200.; bin += 100.)
binning.push_back(bin);
for (float bin = 1200.; bin <= 1500.; bin += 150.)
binning.push_back(bin);
}
THashList *mcWeights = (THashList *)input.Get("mcWeights");
TParameter<float> *mcWeight = (TParameter<float> *)mcWeights->FindObject("ttbar");
TParameter<float> *mcWeight700to1000 = (TParameter<float> *)mcWeights->FindObject("ttbar700to1000");
TParameter<float> *mcWeight1000up = (TParameter<float> *)mcWeights->FindObject("ttbar1000up");
float totMcWeight = 1.;
// determine qcd contribution
TH1F *qcdContrib;
TH1F *ssData = MakeHistoFromBranch(&input, "emuTree_data", "mass", SS, eRegion, "", 0., 0., binning, 0x100);
TH1F *ssBg = MakeHistoFromBranch(&input, "emuTree_ttbar", "mass", SS, eRegion, "genMTtbar", 0., 700., binning, 0x1DF);
totMcWeight = 1. / (1 / mcWeight->GetVal() + 1 / mcWeight700to1000->GetVal());
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ttbar", "mass", SS, eRegion, "genMTtbar", 700., 1000., binning, 0x19F), totMcWeight);
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ttbar700to1000", "mass", SS, eRegion, "genMTtbar", 700., 1000., binning, 0x19F), totMcWeight);
totMcWeight = 1. / (1 / mcWeight->GetVal() + 1 / mcWeight1000up->GetVal());
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ttbar", "mass", SS, eRegion, "genMTtbar", 1000., 1000000000., binning, 0x19F), totMcWeight);
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ttbar1000up", "mass", SS, eRegion, "genMTtbar", 1000., 1000000000., binning, 0x19F), totMcWeight);
//TH1F *ssBg = MakeHistoFromBranch(&input, "emuTree_ttbar", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF);
//TH1F *ssBg = MakeHistoFromBranch(&input, "emuTree_ttbarto2l", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF);
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ztautau", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ww", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_wz", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_zz", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_tw", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_zmumu", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_zee", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_wjets", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
qcdContrib = (TH1F *)ssData->Clone("qcdContrib_SS");
qcdContrib->Add(ssBg, -1);
for (int i = 0; i < qcdContrib->GetNbinsX() + 2; ++i) {
if (qcdContrib->GetBinContent(i) < 0) qcdContrib->SetBinContent(i, 0.);
}
cout << "expected SS QCD events: " << ssData->Integral() - ssBg->Integral() << endl;
cout << "derived SS QCD events: " << qcdContrib->Integral() << endl;
cout << "scale factor: " << (ssData->Integral() - ssBg->Integral()) / qcdContrib->Integral()<< endl;
qcdContrib->Scale((ssData->Integral() - ssBg->Integral()) / qcdContrib->Integral());
// loop over full spectrum, SS and OS
for (int k = 0; k < 3; ++k) {
// loop to get normal and cumulated spectrum
for (unsigned int j = 0; j < 2; ++j) {
input.cd();
bool normToBin = true;
if (j > 0) normToBin = false;
if (k == 2) k = -1;
// make the histograms
emuMass_wjets.push_back(MakeHistoFromBranch(&input, "emuTree_wjets", "mass", k, eRegion, "", 0., 0., binning, 0x1DF, normToBin));
if (k == -1) k = 2;
emuMass_wjets.back()->SetName("emuMass_" + histoSign[k] + "wjets" + nameSuffix[j]);
// qcd contribution
if (k == 2) k = -1;
emuMass_qcdFromFake.push_back((TH1F *)MakeHistoFromBranch(&input, "frEmuTree_data", "mass", k, eRegion, "", 0., 0., binning, 0x300));
emuMass_qcd.push_back((TH1F *)qcdContrib->Clone("emuMass_" + histoSign[k] + "qcd"));
if (k == ALL) emuMass_qcd.back()->Scale(2.);
// normalize to bin width
if (j < 1) {
for (int i = 1; i < emuMass_qcd.back()->GetNbinsX() + 1; ++i) {
emuMass_qcd.back()->SetBinContent(i, emuMass_qcd.back()->GetBinContent(i) / emuMass_qcd.back()->GetBinWidth(i));
emuMass_qcd.back()->SetBinError(i, emuMass_qcd.back()->GetBinError(i) / emuMass_qcd.back()->GetBinWidth(i));
emuMass_qcdFromFake.back()->SetBinContent(i, emuMass_qcdFromFake.back()->GetBinContent(i) / emuMass_qcdFromFake.back()->GetBinWidth(i));
emuMass_qcdFromFake.back()->SetBinError(i, emuMass_qcdFromFake.back()->GetBinError(i) / emuMass_qcdFromFake.back()->GetBinWidth(i));
}
}
if (k == -1) k = 2;
// add overflow in last bin
if (j == 0 && overflowBin) {
emuMass_wjets.back()->SetBinContent(emuMass_wjets.back()->GetNbinsX(), emuMass_wjets.back()->GetBinContent(emuMass_wjets.back()->GetNbinsX()) + emuMass_wjets.back()->GetBinContent(emuMass_wjets.back()->GetNbinsX() + 1));
emuMass_qcd.back()->SetBinContent(emuMass_qcd.back()->GetNbinsX(), emuMass_qcd.back()->GetBinContent(emuMass_qcd.back()->GetNbinsX()) + emuMass_qcd.back()->GetBinContent(emuMass_qcd.back()->GetNbinsX() + 1));
emuMass_qcdFromFake.back()->SetBinContent(emuMass_qcdFromFake.back()->GetNbinsX(), emuMass_qcdFromFake.back()->GetBinContent(emuMass_qcdFromFake.back()->GetNbinsX()) + emuMass_qcdFromFake.back()->GetBinContent(emuMass_qcdFromFake.back()->GetNbinsX() + 1));
}
// integrate from the right side
if (j == 1) {
// loop over bins
double error;
for (int i = 1; i < nBins + 1; ++i) {
emuMass_wjets.back()->SetBinContent(i, emuMass_wjets.back()->IntegralAndError(i, nBins, error));
emuMass_wjets.back()->SetBinError(i, error);
emuMass_qcd.back()->SetBinContent(i, emuMass_qcd.back()->IntegralAndError(i, nBins, error));
emuMass_qcd.back()->SetBinError(i, error);
emuMass_qcdFromFake.back()->SetBinContent(i, emuMass_qcdFromFake.back()->IntegralAndError(i, nBins, error));
emuMass_qcdFromFake.back()->SetBinError(i, error);
}
}
if (!plotSign[k]) continue;
if (!plotType[j]) continue;
TCanvas *emuPlot;
TPad *specPad;
if (plotPullBelowSpec && j == 0) {
emuPlot = new TCanvas("emuPlot" + histoSign[k] + nameSuffix[j], "emu Spectrum" + titleSuffix[j], 100, 100, 900, 900);
specPad = new TPad("specPad" + histoSign[k] + nameSuffix[j], "emu Spectrum" + titleSuffix[j], 0., 0.33, 1., 1.);
specPad->SetBottomMargin(0.06);
} else {
emuPlot = new TCanvas("emuPlot" + histoSign[k] + nameSuffix[j], "emu Spectrum" + titleSuffix[j], 100, 100, 900, 600);
specPad = new TPad("specPad" + histoSign[k] + nameSuffix[j], "emu Spectrum" + titleSuffix[j], 0., 0., 1., 1.);
specPad->SetBottomMargin(0.12);
}
specPad->SetBorderMode(0);
specPad->SetBorderSize(2);
specPad->SetFrameBorderMode(0);
specPad->SetFillColor(0);
specPad->SetFrameFillColor(0);
if (logPlotX) specPad->SetLogx();
if (logPlotY) specPad->SetLogy();
specPad->SetLeftMargin(0.11);
specPad->SetRightMargin(0.09);
specPad->SetTopMargin(0.08);
specPad->SetTickx(1);
specPad->SetTicky(1);
specPad->Draw();
specPad->cd();
gStyle->SetTitleFont(font);
gStyle->SetLabelFont(font);
gStyle->SetLegendFont(font);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetTitleXOffset(1.);
gStyle->SetTitleYOffset(1.3);
gPad->SetTicks(1, 1);
// make a histogram stack with the bg
THStack *bgStack = new THStack("bgStack" + histoSign[k] + nameSuffix[j], "Invariant Mass" + titleSuffix[j]);
bgStack->Add(emuMass_qcd.back());
bgStack->Add(emuMass_wjets.back());
// plot spectrum
emuMass_wjets.back()->SetFillColor(wjetColour);
emuMass_wjets.back()->SetMarkerColor(wjetColour);
emuMass_wjets.back()->SetLineColor(kBlack);
emuMass_wjets.back()->SetLineWidth(2);
//emuMass_wjets.back()->Draw("HISTsames");
emuMass_qcd.back()->SetFillColor(jetBkgColour);
emuMass_qcd.back()->SetMarkerColor(jetBkgColour);
emuMass_qcd.back()->SetLineColor(kBlack);
emuMass_qcd.back()->SetLineWidth(2);
//emuMass_qcd.back()->Draw("HISTsames");
bgStack->Draw("hist");
emuMass_qcdFromFake.back()->SetLineColor(kRed);
emuMass_qcdFromFake.back()->SetLineWidth(2);
emuMass_qcdFromFake.back()->Draw("esame");
if (plotPullBelowSpec && j == 0) {
bgStack->GetXaxis()->SetTitle("");
} else {
bgStack->GetXaxis()->SetTitle(xAxisTitle[k] + " [GeV]");
}
bgStack->GetXaxis()->SetTitleFont(font);
bgStack->GetXaxis()->SetTitleSize(0.047);
bgStack->GetXaxis()->SetTitleOffset(0.9);
bgStack->GetXaxis()->SetLabelFont(font);
bgStack->GetXaxis()->SetLabelSize(0.05);
bgStack->GetXaxis()->SetMoreLogLabels();
bgStack->GetXaxis()->SetNoExponent();
//bgStack->GetXaxis()->SetRangeUser(xRangeMin, xRangeMax);
bgStack->GetXaxis()->SetLimits(xRangeMin, xRangeMax);
if (j == 1) bgStack->GetYaxis()->SetTitle("Events #geq " + xAxisTitle[k]);
else bgStack->GetYaxis()->SetTitle("Events / GeV");
bgStack->GetYaxis()->SetTitleFont(font);
bgStack->GetYaxis()->SetTitleSize(0.047);
bgStack->GetYaxis()->SetTitleOffset(1.1);
bgStack->GetYaxis()->SetLabelFont(font);
bgStack->GetYaxis()->SetLabelSize(0.05);
bgStack->SetMinimum(yRangeMin[k + j * 3]);
bgStack->SetMaximum(yRangeMax[k + j * 3]);
// redraw axis
emuMass_qcd.back()->Draw("sameaxis");
// legend and labels
TLegend legend(0.710, 0.646, 0.901, 0.885);
legend.SetTextFont(font);
legend.SetTextSize(0.03);
legend.SetBorderSize(0);
legend.SetLineColor(1);
legend.SetLineStyle(1);
legend.SetLineWidth(1);
legend.SetFillColor(19);
legend.SetFillStyle(0);
legend.AddEntry(emuMass_wjets.back(), "W+jets (MC)" ,"F");
legend.AddEntry(emuMass_qcd.back(), "jets (SS data)" ,"F");
legend.AddEntry(emuMass_qcdFromFake.back(), "jets (Fake Rate)" ,"le");
legend.DrawClone("sames");
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextFont(font);
tex->SetLineWidth(2);
tex->SetTextSize(0.042);
if (prelim) tex->DrawLatex(0.325, 0.853, "CMS Preliminary, 8 TeV, 19.6 fb^{-1}");
else tex->DrawLatex(0.405, 0.853, "CMS, 8 TeV, 19.6 fb^{-1}");
if (eRegion == 0) tex->DrawLatex(0.325, 0.775, "e in barrel");
if (eRegion == 1) tex->DrawLatex(0.325, 0.775, "e in endcap");
// safe in various file formats
stringstream sStream;
if (!plotPullBelowSpec || j > 0) {
sStream << plotDir << "qcdClosureTestSpec";
if (k == 0) sStream << "_";
sStream << histoSign[k];
if (eRegion == 0) sStream << "EB_";
if (eRegion == 1) sStream << "EE_";
sStream << fileNameExtra << nameSuffix[j];
if (j > 0) sStream << "_";
if (groupedPlot) sStream << "grouped_";
if (!logPlotY) sStream << "lin_";
sStream << lumi->GetVal() << "pb-1";
TString saveFileName = sStream.str();
if ((j == 0 && saveSpec) || (j > 0 && saveCumSpec)) {
if (saveAsPdf) emuPlot->Print(saveFileName + ".pdf", "pdf");
if (saveAsPng) emuPlot->Print(saveFileName + ".png", "png");
if (saveAsRoot) emuPlot->Print(saveFileName + ".root", "root");
}
}
} // end loop over normal or cumulated
} // end loop over full, SS and OS
// generate one object containing everything
vector<vector<TH1F *> > emuMasses;
emuMasses.push_back(emuMass_wjets);
emuMasses.push_back(emuMass_qcd);
// // define groups of MC samples
// vector<bool> ttLikeSamples(6, true);
// vector<bool> contamSamples(6, false);
// contamSamples.push_back(true); // Zmm
// contamSamples.push_back(true); // Zee
// contamSamples.push_back(true); // WJets or QCD
// vector<bool> contamSamplesNoQcd(contamSamples);
// vector<bool> allSamples(9, true);
// vector<bool> onlyQCD(emuMasses.size() - 1, false);
// if (qcdEst > 0) {
// onlyQCD.back() = true;
// if (qcdEst != 2) {
// allSamples.push_back(true);
// contamSamples.push_back(true);
// contamSamplesNoQcd.push_back(false);
// systErrMC.push_back(0.); // QCD error will be calculated later
// } else {
// contamSamplesNoQcd.back() = false;
// }
// }
// vector<bool> allSamplesNoQcd(allSamples);
// if (qcdEst > 0) allSamplesNoQcd.back() = false;
// unsigned int qcdInd = onlyQCD.size();
// unsigned int qcdErrInd = qcdInd - 1;
//
// // calculate rate of syst errors
// float systErrLuEff = sqrt(systErrLumi*systErrLumi + systErrEff*systErrEff);
// vector<float> systErrMCLuEff;
// for (unsigned int it = 0; it < systErrMC.size(); ++it)
// systErrMCLuEff.push_back(sqrt(systErrMC[it]*systErrMC[it] + systErrLuEff*systErrLuEff));
//
// bool calcQcdErr = false;
// if (qcdEst == 1) calcQcdErr = true;
//
// //cout << "qcdInd " << qcdInd << ", emuMasses.size() " << emuMasses.size() << ", systErrMC.size() " << systErrMC.size()
// // << ", systErrMCLuEff.size() " << systErrMCLuEff.size() << ", allSamples.size() " << allSamples.size()
// // << ", allSamplesNoQcd.size() " << allSamplesNoQcd.size() << ", contamSamplesNoQcd.size() " << contamSamplesNoQcd.size()
// // << ", contamSamples.size() " << contamSamples.size() << ", onlyQCD.size() " << onlyQCD.size() << endl;
// //for (unsigned int sIt = 0; sIt < emuMasses.size() - 1; ++sIt) {
// // cout << "allSamples " << allSamples[sIt] << ", allSamplesNoQcd " << allSamplesNoQcd[sIt]
// // << ", contamSamples " << contamSamples[sIt] << ", contamSamplesNoQcd " << contamSamplesNoQcd[sIt]
// // << ", onlyQCD " << onlyQCD[sIt] << ", systErrMC " << systErrMC[sIt] << ", systErrMCLuEff " << systErrMCLuEff[sIt] << endl;
// //}
//
// // define special bins corresponding to specific masses
// int bin60 = emuMass_data.at(ALL)->FindBin(60.);
// int bin120 = emuMass_data.at(ALL)->FindBin(120.);
// int bin200 = emuMass_data.at(ALL)->FindBin(200.);
// int bin400 = emuMass_data.at(ALL)->FindBin(400.);
// int bin500 = emuMass_data.at(ALL)->FindBin(500.);
//
// vector<const char *> sampleNames;
// sampleNames.push_back("data ");
// sampleNames.push_back("ttbar ");
// sampleNames.push_back("Ztautau");
// sampleNames.push_back("WW ");
// sampleNames.push_back("WZ ");
// sampleNames.push_back("ZZ ");
// sampleNames.push_back("tW ");
// sampleNames.push_back("Zmumu ");
// sampleNames.push_back("Zee ");
// if (qcdEst != 2) sampleNames.push_back("WJets ");
// if (qcdEst > 0) sampleNames.push_back("QCD ");
//
// // write numbers
// cout << endl;
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// cout << "HEEP - TIGHT MU Lumi = " << lumi->GetVal() << "pb-1" << endl;
// //cout << " e pT EB > " << bar_et << "GeV/c" << endl;
// //cout << " e pT EE > " << end_et << "GeV/c" << endl;
// //cout << " mu pT > " << muon_et << "GeV/c" << endl;
// //cout << " mu |eta| < " << muon_etaMax << endl;
// cout << endl;
// cout << "Systematic errors" << endl;
// cout << " Luminosity: " << systErrLumi * 100 << "%" << endl;
// cout << " Efficiency: " << systErrEff * 100 << "%" << endl;
// cout << " ttbar: " << systErrMC[TTBAR-1] * 100 << "%" << endl;
// cout << " Z->tautau: " << systErrMC[ZTT-1] * 100 << "%" << endl;
// cout << " WW: " << systErrMC[WW-1] * 100 << "%" << endl;
// cout << " WZ: " << systErrMC[WZ-1] * 100 << "%" << endl;
// cout << " ZZ: " << systErrMC[ZZ-1] * 100 << "%" << endl;
// cout << " tW, tbarW: " << systErrMC[TW-1] * 100 << "%" << endl;
// cout << " Z->mumu: " << systErrMC[ZMM-1] * 100 << "%" << endl;
// cout << " Z->ee: " << systErrMC[ZEE-1] * 100 << "%" << endl;
// if (qcdEst != 2) cout << " W+Jets: " << systErrMC[WJET-1] * 100 << "%" << endl;
// else cout << " QCD: " << systErrMC.back() * 100 << "%" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int signIt = 1; signIt < 6; signIt += 2) {
// if (signIt == 3) cout << "-SS--------------------------------------------------------------------------------------------------------" << endl;
// if (signIt == 5) cout << "-OS--------------------------------------------------------------------------------------------------------" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << "M_emu | > 60GeV/c^2 | > 120GeV/c^2 | > 200GeV/c^2 | > 400GeV/c^2 |" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------------------------------------" << endl;
//
// printf("nb data | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) |\n",
// emuMass_data.at(signIt)->GetBinContent(bin60), sqrt(emuMass_data.at(signIt)->GetBinContent(bin60)),
// emuMass_data.at(signIt)->GetBinContent(bin120), sqrt(emuMass_data.at(signIt)->GetBinContent(bin120)),
// emuMass_data.at(signIt)->GetBinContent(bin200), sqrt(emuMass_data.at(signIt)->GetBinContent(bin200)),
// emuMass_data.at(signIt)->GetBinContent(bin400), sqrt(emuMass_data.at(signIt)->GetBinContent(bin400)));
// cout << "----------------------------------------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int sampleIt = 1; sampleIt < sampleNames.size(); ++sampleIt) {
// if (sampleIt == 7) cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
// if (qcdEst == 1 && sampleIt == sampleNames.size() - 1) {
// printf("nb %7s | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n", sampleNames[sampleIt],
// emuMass_qcd.at(signIt)->GetBinContent(bin60), emuMass_qcd.at(signIt)->GetBinContent(bin60) * CalcSSQcdErr(emuMasses, systErrMCLuEff, bin60),
// emuMass_qcd.at(signIt)->GetBinContent(bin120), emuMass_qcd.at(signIt)->GetBinContent(bin120) * CalcSSQcdErr(emuMasses, systErrMCLuEff, bin120),
// emuMass_qcd.at(signIt)->GetBinContent(bin200), emuMass_qcd.at(signIt)->GetBinContent(bin200) * CalcSSQcdErr(emuMasses, systErrMCLuEff, bin200),
// emuMass_qcd.at(signIt)->GetBinContent(bin400), emuMass_qcd.at(signIt)->GetBinContent(bin400) * CalcSSQcdErr(emuMasses, systErrMCLuEff, bin400));
// } else {
// printf("nb %7s | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n", sampleNames[sampleIt],
// emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin60), emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin60) * systErrMCLuEff[sampleIt-1],
// emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin120), emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin120) * systErrMCLuEff[sampleIt-1],
// emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin200), emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin200) * systErrMCLuEff[sampleIt-1],
// emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin400), emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin400) * systErrMCLuEff[sampleIt-1]);
// }
// }
// cout << endl;
// cout << "----------------------------------------------------------------------------------------------------------------------------------------" << endl;
// printf("TOT ttlike | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, ttLikeSamples, signIt, bin60), CalcSystErr(emuMasses, systErrMCLuEff, ttLikeSamples, signIt, bin60),
// CalcBgSum(emuMasses, ttLikeSamples, signIt, bin120), CalcSystErr(emuMasses, systErrMCLuEff, ttLikeSamples, signIt, bin120),
// CalcBgSum(emuMasses, ttLikeSamples, signIt, bin200), CalcSystErr(emuMasses, systErrMCLuEff, ttLikeSamples, signIt, bin200),
// CalcBgSum(emuMasses, ttLikeSamples, signIt, bin400), CalcSystErr(emuMasses, systErrMCLuEff, ttLikeSamples, signIt, bin400));
// printf("TOT contam | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, contamSamples, signIt, bin60), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, contamSamples, signIt, bin60, -1, calcQcdErr),
// CalcBgSum(emuMasses, contamSamples, signIt, bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, contamSamples, signIt, bin120, -1, calcQcdErr),
// CalcBgSum(emuMasses, contamSamples, signIt, bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, contamSamples, signIt, bin200, -1, calcQcdErr),
// CalcBgSum(emuMasses, contamSamples, signIt, bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, contamSamples, signIt, bin400, -1, calcQcdErr));
// cout << "----------------------------------------------------------------------------------------------------------------------------------------" << endl;
//
// printf("TOT Bkg | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, allSamples, signIt, bin60), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin60, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin120, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin200, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin400, -1, calcQcdErr));
// cout << "----------------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << endl << endl;
// }
// cout << endl;
//
// cout << "--Without adding QCD contribution:--------------------------------------------------------------------------------------------------------" << endl;
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << "M_emu | > 60GeV/c^2 | > 120GeV/c^2 | > 200GeV/c^2 | > 400GeV/c^2 |" << endl;
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int signIt = 1; signIt < 6; signIt += 2) {
// if (signIt == 3) cout << "-SS-------------------------------------------------------------------------------------------------------------------------------------" << endl;
// if (signIt == 5) cout << "-OS-------------------------------------------------------------------------------------------------------------------------------------" << endl;
// printf("nb data | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) |\n",
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin60), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin60)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin120), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin120)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin200), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin200)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin400), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin400)));
// printf("nb MC | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, allSamplesNoQcd, signIt, bin60), CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, signIt, bin60),
// CalcBgSum(emuMasses, allSamplesNoQcd, signIt, bin120), CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, signIt, bin120),
// CalcBgSum(emuMasses, allSamplesNoQcd, signIt, bin200), CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, signIt, bin200),
// CalcBgSum(emuMasses, allSamplesNoQcd, signIt, bin400), CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, signIt, bin400));
// }
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//
// if (qcdEst == 1) {
// //systErrMC.back() = 2 * sqrt(emuMasses.at(DATA).at(SS)->Integral() + pow(CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, SS, 1), 2)) / emuMasses.at(qcdInd).at(ALL)->Integral();
// //systErrMC.back() = CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, SSCUM, 1) / emuMass_qcd.at(SSCUM)->GetBinContent(1);
// //systErrMCLuEff.back() = systErrMC[qcdErrInd];
//
// cout << endl;
// cout << "---QCD events from SS spectrum:----------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// printf("nb QCD SS+OS | %9.3f +- %8.3f (%.1f%%) (syst) | %9.3f +- %8.3f (%.1f%%) (syst) | %9.3f +- %8.3f (%.1f%%) (syst) | %9.3f +- %8.3f (%.1f%%) (syst) |\n",
// emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin60), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin60, -1, calcQcdErr),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin60, -1, calcQcdErr) / emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin60),
// emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin120, -1, calcQcdErr),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin120, -1, calcQcdErr) / emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin120),
// emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin200, -1, calcQcdErr),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin200, -1, calcQcdErr) / emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin200),
// emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin400, -1, calcQcdErr),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin400, -1, calcQcdErr) / emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin400));
// printf("%% of total MC | %7.3f%% +- %7.3f%% (syst) | %7.3f%% +- %7.3f%% (syst) | %7.3f%% +- %7.3f%% (syst) | %7.3f%% +- %7.3f%% (syst) |\n",
// 100 * emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin60) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin60),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin60, -1, calcQcdErr) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin60),
// 100 * emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin120) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin120),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin120, -1, calcQcdErr) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin120),
// 100 * emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin200) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin200),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin200, -1, calcQcdErr) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin200),
// 100 * emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin400) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin400),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin400, -1, calcQcdErr) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin400));
// cout << "-----------------------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// }
//
// // top up bg contribution with qcd
// if (qcdEst > 0) {
// cout << endl;
// cout << "--After adding QCD contribution:----------------------------------------------------------------------------------------------------------" << endl;
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << "M_emu | > 60GeV/c^2 | > 120GeV/c^2 | > 200GeV/c^2 | > 400GeV/c^2 |" << endl;
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int signIt = 1; signIt < 6; signIt += 2) {
// if (signIt == 3) cout << "-SS-------------------------------------------------------------------------------------------------------------------------------------" << endl;
// if (signIt == 5) cout << "-OS-------------------------------------------------------------------------------------------------------------------------------------" << endl;
// printf("nb data | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) |\n",
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin60), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin60)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin120), sqrt((emuMasses.at(DATA).at(signIt))->GetBinContent(bin120)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin200), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin200)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin400), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin400)));
// printf("nb MC | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, allSamples, signIt, bin60), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin60, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin120, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin200, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin400, -1, calcQcdErr));
// }
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// }
//
// cout << endl;
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// cout << "M_emu | 60 - 120GeV/c^2 | 120 - 200GeV/c^2 | 200 - 400GeV/c^2 |" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int signIt = 1; signIt < 6; signIt += 2) {
// printf("nb data | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) |\n",
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin60) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin120),
// sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin60) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin120)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin120) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin200),
// sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin120) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin200)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin200) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin400),
// sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin200) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin400)));
// printf("nb MC | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, allSamples, signIt, bin60, bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin60, bin120, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin120, bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin120, bin200, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin200, bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin200, bin400, calcQcdErr));
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// }
}
