int main(int argc, char* argv[]) {
// setup
TH1::SetDefaultSumw2();
ProgramOptions options(argc, argv);
double lumi = options.lumi;
std::string iDir = options.iDir;
Datasets datasets(iDir);
datasets.readFile(options.datasetFile);
LeptonWeights lw;
// now do something
for (unsigned i=0; i<datasets.size(); ++i) {
Dataset dataset = datasets.getDataset(i);
TFile* ifile = datasets.getTFile(dataset.name);
TTree* tree = (TTree*) ifile->Get("invHiggsInfo/InvHiggsInfo");
std::string ofilename = iDir + std::string("/") + dataset.name + std::string("_LeptonWeights.root");
lw.createTree(tree, ofilename, dataset.isData);
}
}
void test_for_FFNNBP()
{
FeedForwardNeualNetwokBackPropergation ffnnbp(2, 1);
ffnnbp.add_hidden_layer(5);
ffnnbp.add_hidden_layer(5);
ffnnbp.add_hidden_layer(5);
ffnnbp.add_hidden_layer(5);
ffnnbp.add_hidden_layer(10);
ffnnbp.add_hidden_layer(5);
vector<pair<VectorXd, VectorXd>> datasets(4);
for(auto i=0; i<4; ++i)
{
datasets[i].first.resize(2);
datasets[i].second.resize(1);
}
datasets[0].first<<0,0;
datasets[0].second<<1;
datasets[1].first<<0,1;
datasets[1].second<<0;
datasets[2].first<<1,0;
datasets[2].second<<0;
datasets[3].first<<1,1;
datasets[3].second<<1;
ffnnbp.train(datasets, 10000, 0.1);
cout<<ffnnbp.infer(datasets[0].first)<<endl;
cout<<ffnnbp.infer(datasets[1].first)<<endl;
cout<<ffnnbp.infer(datasets[2].first)<<endl;
cout<<ffnnbp.infer(datasets[3].first)<<endl;
}
void test_for_GP()
{
MatrixXd datasets(4,2);
datasets<<1,1,-1,1,1,-1,-1,-1;
MatrixXd labels(1,4);
labels<<1,1,-1,-1;
GuassianProcessExact gpe(datasets, labels);
cout<<gpe.result(datasets)<<endl;
}
void test_for_PLSI()
{
MatrixXd datasets(5,5);
datasets<<1,2,1,1,5, 2,3,0,1,5, 1,0,4,5,0, 5,6,1,0,5, 0,1,6,6,0;
ProbablisiticLatentSemanticIndex plsi(datasets, 2);
plsi.run(200);
cout<<"Topic Distribution:"<<endl<<plsi.result_topic()<<endl<<endl;
cout<<"Word Distribution:"<<endl<<plsi.result_topic_at_word()<<endl<<endl;
cout<<"Document Distribution:"<<endl<<plsi.result_topic_at_document()<<endl<<endl;
}
void test_for_AE()
{
MatrixXd datasets(4,2);
datasets<<0,0,1,0,0,1,1,1;
AutoEncoder ae(2);
ae.add_layer(5);
ae.add_layer(3);
ae.add_layer(5);
ae.train(datasets, 10000, 0.5, 0.1);
cout<<ae.infer(datasets.row(0))<<endl;
cout<<ae.infer(datasets.row(1))<<endl;
cout<<ae.infer(datasets.row(2))<<endl;
cout<<ae.infer(datasets.row(3))<<endl;
cout<<ae.infer_represent(datasets.row(0))<<endl;
cout<<ae.infer_represent(datasets.row(1))<<endl;
cout<<ae.infer_represent(datasets.row(2))<<endl;
cout<<ae.infer_represent(datasets.row(3))<<endl;
}
int main(int argc, char* argv[]) {
TH1::SetDefaultSumw2();
ProgramOptions options(argc, argv);
double lumi = options.lumi;
// input datasets
Datasets datasets(options.iDir);
datasets.readFile(options.datasetFile);
std::string oDir_Plot = options.oDir+std::string("/ZBackground");
boost::filesystem::path opath(oDir_Plot);
if (!exists(opath)) {
std::cout << "Creating output directory : " << oDir_Plot << std::endl;
boost::filesystem::create_directory(opath);
}
if (options.doMCFMWeights) std::cout << "Going to apply MCFM weights" << std::endl;
// output file
TFile* ofile = TFile::Open( (options.oDir+std::string("/ZBackground.root")).c_str(), "RECREATE");
// cuts
Cuts cuts;
unsigned nCutsZMuMu = cuts.nCutsZMuMu();
TCut puWeight("puWeight");
TCut trigCorr( "(trigCorrWeight>0) ? trigCorrWeight : 1." );
TCut METNoMuon130("metNoMuon>130."); // add here later for VBF efficiency when MET>35, MET>70 (QCD estimation)
TCut METNo2Muon130("metNo2Muon>130.");
TCut cutLoDPhi = cuts.cut("dPhiJJ");
// For lepton weights
TCut lVetoWeight = cuts.elVetoWeight(options.leptCorr) * cuts.muVetoWeight(options.leptCorr);
TCut muTightWeight = cuts.muTightWeight(options.leptCorr);
// histograms
double dphiEdges[4] = { 0., 1.0, 2.6, TMath::Pi() };
//double metEdges[13] = { 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120. };
// signal MET>130
TH1D* hZ_DY_C_DPhi = new TH1D("hZ_DY_C_DPhi", "", 3, dphiEdges); // Z+jets MC ctrl region
TH1D* hZ_BG_C_DPhi = new TH1D("hZ_BG_C_DPhi", "", 3, dphiEdges); // background MC ctrl region
TH1D* hZ_Data_C_DPhi = new TH1D("hZ_Data_C_DPhi", "", 3, dphiEdges); // Data ctrl region
TH1D* hZ_QCD_EffVBFS_D = new TH1D("hZ_QCD_EffVBFS_D", "", 1, 0., 1.);
TH1D* hZ_QCD_EffVBFS_N = new TH1D("hZ_QCD_EffVBFS_N", "", 1, 0., 1.);
TH1D* hZ_EWK_EffVBFS_D = new TH1D("hZ_EWK_EffVBFS_D", "", 1, 0., 1.);
TH1D* hZ_EWK_EffVBFS_N = new TH1D("hZ_EWK_EffVBFS_N", "", 1, 0., 1.);
// combine eps_VBF_C * eps_mumu which remove canceling term (denominator is Z->uu gen level cut)
TH1D* hZ_QCD_EffVBFC_D = new TH1D("hZ_QCD_EffVBFC_D", "", 1, 0., 1.);
TH1D* hZ_QCD_EffVBFC_N = new TH1D("hZ_QCD_EffVBFC_N", "", 1, 0., 1.);
TH1D* hZ_EWK_EffVBFC_D = new TH1D("hZ_EWK_EffVBFC_D", "", 1, 0., 1.);
TH1D* hZ_EWK_EffVBFC_N = new TH1D("hZ_EWK_EffVBFC_N", "", 1, 0., 1.);
// cutflow histograms
TH1D* hZ_CutFlow_Data = new TH1D("hZ_CutFlow_Data", "", nCutsZMuMu, 0., nCutsZMuMu);
TH1D* hZ_CutFlow_DY = new TH1D("hZ_CutFlow_DY", "", nCutsZMuMu, 0., nCutsZMuMu);
TH1D* hZ_CutFlow_SingleTSum = new TH1D("hZ_CutFlow_SingleTSum", "", nCutsZMuMu, 0., nCutsZMuMu);
TH1D* hZ_CutFlow_Diboson = new TH1D("hZ_CutFlow_Diboson", "", nCutsZMuMu, 0., nCutsZMuMu);
// Hists to calculate DY normalisation factor
TH1D* hZ_DY_NoVBFNoWeight = new TH1D("hZ_DY_NoVBFNoWeight","", 1, 0., 1.); // DY MC yield after dimuon and dijet selection without y* and mjj weighting
TH1D* hZ_DY_NoVBFWeight = new TH1D("hZ_DY_NoVBFWeight", "", 1, 0., 1.); // DY MC yield after dimuon and dijet selection with y* and mjj weighting
// loop over MC datasets
for (unsigned i=0; i<datasets.size(); ++i) {
Dataset dataset = datasets.getDataset(i);
TCut cutD = cuts.cutDataset(dataset.name);
TCut yStarWeight("");
TCut mjjWeight("");
// check if it's DYJets
bool isDY = false;
if (dataset.name.compare(0,2,"DY")==0) {
isDY = true;
std::cout << "Analysing DY->ll MC : " << dataset.name << std::endl;
// check if it's QCD
if ( !(dataset.name.length()>11 && dataset.name.compare(11,14,"EWK")==0) ) {
if (options.doMCFMWeights) {
yStarWeight = TCut("(0.849667 + (0.149687*abs(log((sqrt(zgenmass*zgenmass + zgenpt*zgenpt*cosh(zgeneta)*cosh(zgeneta)) + zgenpt*sinh(zgeneta))/sqrt(zgenmass*zgenmass + zgenpt*zgenpt)) - 0.5*(genJet1Eta + genJet2Eta))))");
mjjWeight = TCut("0.392568 + (0.120734*log(genVBFM)) - (0.000255622*genVBFM)");
}
std::cout << "Analysing QCD DY MC " << std::endl;
}
}
else if (dataset.isData) {
std::cout << "Analysing Data : " << dataset.name << std::endl;
}
else {
std::cout << "Analysing BG MC : " << dataset.name << std::endl;
}
TCut otherWeight = puWeight * yStarWeight * mjjWeight;
// get file & tree
TFile* file = datasets.getTFile(dataset.name);
TTree* tree = (TTree*) file->Get("invHiggsInfo/InvHiggsInfo");
// set up cuts
TCut cutZMuMu_C = otherWeight * trigCorr * (cutD + cuts.zMuMuVBF() + METNo2Muon130);
TCut cutEfficiencyMuMu_D = otherWeight * (cutD + cuts.zMuMuGen());
//TCut cutEfficiencyMuMu_N = otherWeight * (cutD + cuts.zMuMuGen() + cuts.zMuMuReco());
TCut cutEfficiencyVBFS_D = otherWeight * (cutD + cuts.zMuMuGenMass());
TCut cutEfficiencyVBFS_N = otherWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGenMass() + cuts.vbf() + METNoMuon130 + cutLoDPhi);
//TCut cutEfficiencyVBFC_D = otherWeight * (cutD + cuts.zMuMuGen() + cuts.zMuMuReco());
TCut cutEfficiencyVBFC_N = otherWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutLoDPhi);
// re-weighting
TCut cutDYNoVBFNoWeight = puWeight * trigCorr * (cutD + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.cutZMuMu("dijet"));
TCut cutDYNoVBFWeight = otherWeight * trigCorr * (cutD + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.cutZMuMu("dijet"));
if(!(dataset.isData)) {
cutZMuMu_C *= muTightWeight;
cutEfficiencyVBFC_N *= muTightWeight;
cutDYNoVBFNoWeight *= muTightWeight;
cutDYNoVBFWeight *= muTightWeight;
}
// fill tmp histograms for BG estimation
TH1D* hZ_C_DPhi = new TH1D("hZ_C_DPhi", "", 3, dphiEdges); // this is for the actual BG estimation
// fill tmp histograms for efficiency calculation
TH1D* hZ_EffVBFS_D = new TH1D("hZ_EffVBFS_D", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_N = new TH1D("hZ_EffVBFS_N", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_D = new TH1D("hZ_EffVBFC_D", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_N = new TH1D("hZ_EffVBFC_N", "", 1, 0., 1.);
TH1D* hZ_DY_NoWeight = new TH1D("hZ_DY_NoWeight", "", 1, 0, 1);
TH1D* hZ_DY_Weight = new TH1D("hZ_DY_Weight", "", 1, 0, 1);
if (isDY) {
tree->Draw("vbfDPhi>>hZ_C_DPhi", cutZMuMu_C);
tree->Draw("0.5>>hZ_EffVBFS_D", cutEfficiencyVBFS_D);
tree->Draw("0.5>>hZ_EffVBFS_N", cutEfficiencyVBFS_N);
tree->Draw("0.5>>hZ_EffVBFC_D", cutEfficiencyMuMu_D);
tree->Draw("0.5>>hZ_EffVBFC_N", cutEfficiencyVBFC_N);
tree->Draw("0.5>>hZ_DY_NoWeight", cutDYNoVBFNoWeight);
tree->Draw("0.5>>hZ_DY_Weight", cutDYNoVBFWeight);
// tree->Draw("abs((log((sqrt(zgenmass*zgenmass + zgenpt*zgenpt*cosh(zgeneta)*cosh(zgeneta)) + zgenpt*sinh(zgeneta))/(sqrt(zgenmass*zgenmass + zgenpt*zgenpt)))) - 0.5*(genJet1Eta + genJet2Eta))>>hYStar", cutDYNoVBFNoWeight);
// tree->Draw("abs((log((sqrt(zgenmass*zgenmass + zgenpt*zgenpt*cosh(zgeneta)*cosh(zgeneta)) + zgenpt*sinh(zgeneta))/(sqrt(zgenmass*zgenmass + zgenpt*zgenpt)))) - 0.5*(genJet1Eta + genJet2Eta))>>hYStarC", cutZMuMu_C);
}
else {
tree->Draw("vbfDPhi>>hZ_C_DPhi", cutZMuMu_C);
//tree->Draw("met:vbfDPhi>>hZ_C_METDPhi", cutZMuMu_MET0_C);
}
// weight to lumi
double weight = (dataset.isData) ? 1. : lumi * dataset.sigma / dataset.nEvents;
hZ_C_DPhi->Scale(weight);
hZ_EffVBFS_D->Scale(weight);
hZ_EffVBFS_N->Scale(weight);
hZ_EffVBFC_D->Scale(weight);
hZ_EffVBFC_N->Scale(weight);
hZ_DY_NoWeight->Scale(weight);
hZ_DY_Weight->Scale(weight);
// add to output histograms
if (dataset.isData) {
hZ_Data_C_DPhi->Add(hZ_C_DPhi);
}
else if (isDY) {
hZ_DY_C_DPhi->Add(hZ_C_DPhi);
hZ_DY_NoVBFNoWeight->Add(hZ_DY_NoWeight);
hZ_DY_NoVBFWeight->Add(hZ_DY_Weight);
if(dataset.name == "DYJetsToLL_NoTrig" || dataset.name == "DYJetsToLL_PtZ-100_NoTrig") {
hZ_QCD_EffVBFS_D->Add(hZ_EffVBFS_D);
hZ_QCD_EffVBFS_N->Add(hZ_EffVBFS_N);
hZ_QCD_EffVBFC_D->Add(hZ_EffVBFC_D);
hZ_QCD_EffVBFC_N->Add(hZ_EffVBFC_N);
}
if(dataset.name == "DYJetsToLL_EWK_NoTrig") {
hZ_EWK_EffVBFS_D->Add(hZ_EffVBFS_D);
hZ_EWK_EffVBFS_N->Add(hZ_EffVBFS_N);
hZ_EWK_EffVBFC_D->Add(hZ_EffVBFC_D);
hZ_EWK_EffVBFC_N->Add(hZ_EffVBFC_N);
}
}
else {
hZ_BG_C_DPhi->Add(hZ_C_DPhi);
}
std::cout << " N ctrl (dphi<1.0) : " << hZ_C_DPhi->GetBinContent(1) << " +/- " << hZ_C_DPhi->GetBinError(1) << std::endl;
delete hZ_C_DPhi;
delete hZ_EffVBFS_D;
delete hZ_EffVBFS_N;
delete hZ_EffVBFC_D;
delete hZ_EffVBFC_N;
delete hZ_DY_NoWeight;
delete hZ_DY_Weight;
ofile->cd();
// cut flow histograms
std::string hname = std::string("hZ_CutFlow_")+dataset.name;
TH1D* hZ_CutFlow = new TH1D(hname.c_str(), "", nCutsZMuMu, 0., nCutsZMuMu);
for (unsigned c=0; c<nCutsZMuMu; ++c) {
TCut cut;
if(c == nCutsZMuMu-1) cut = otherWeight * trigCorr * (cutD + cuts.cutflowZMuMu(c));
else cut = otherWeight * (cutD + cuts.cutflowZMuMu(c));
if(!(dataset.isData)) cut *= muTightWeight;
TH1D* h = new TH1D("h","", 1, 0., 1.);
tree->Draw("0.5>>h", cut);
hZ_CutFlow->SetBinContent(c+1, h->GetBinContent(1));
hZ_CutFlow->SetBinError(c+1, h->GetBinError(1));
delete h;
}
hZ_CutFlow->Scale(weight);
if (dataset.isData) {
hZ_CutFlow_Data->Add(hZ_CutFlow);
}
if (dataset.name.compare(0,2,"DY")==0) {
hZ_CutFlow_DY->Add(hZ_CutFlow);
}
if (dataset.name.compare(0,7,"SingleT")==0) {
hZ_CutFlow_SingleTSum->Add(hZ_CutFlow);
}
if (dataset.name.compare(0,2,"WW")==0 ||
dataset.name.compare(0,2,"WZ")==0 ||
dataset.name.compare(0,2,"ZZ")==0 ||
dataset.name.compare(0,2,"WG")==0) {
hZ_CutFlow_Diboson->Add(hZ_CutFlow);
}
hZ_CutFlow->Write("",TObject::kOverwrite);
delete hZ_CutFlow;
// Z control plots
TCut cutPlots = otherWeight * trigCorr * (cutD + cuts.zMuMuVBFLoose());
if(!(dataset.isData)) cutPlots *= muTightWeight;
TFile* ofile_Plot = TFile::Open( (oDir_Plot+std::string("/")+dataset.name+std::string(".root")).c_str(), "RECREATE");
TH1D* ZCtrlZMass = new TH1D("ZCtrlZMass", "", 30, 60., 120.);
TH1D* ZCtrlZpT = new TH1D("ZCtrlZpT", "", 50, 0., 1000.);
TH1D* ZCtrlJet1pT = new TH1D("ZCtrlJet1pT", "", 50, 0., 1000.);
TH1D* ZCtrlJet1Eta = new TH1D("ZCtrlJet1Eta", "", 50, -5., 5.);
TH1D* ZCtrlJet2pT = new TH1D("ZCtrlJet2pT", "", 50, 0., 1000.);
TH1D* ZCtrlJet2Eta = new TH1D("ZCtrlJet2Eta", "", 50, -5., 5.);
TH1D* ZCtrlCenJetpT = new TH1D("ZCtrlCenJetpT", "", 50, 0., 400.);
TH1D* ZCtrlDEtajj = new TH1D("ZCtrlDEtajj", "", 50, 0., 8.);
TH1D* ZCtrlMjj = new TH1D("ZCtrlMjj", "", 30, 0., 3000.);
TH1D* ZCtrlMET = new TH1D("ZCtrlMET", "", 25, 10., 510.);
TH1D* ZCtrlDPhijj = new TH1D("ZCtrlDPhijj", "", 50, 0., TMath::Pi());
TH1D* ZCtrlYStar = new TH1D("ZCtrlYStar", "", 50, 0., 5.);
TH1D* ZCtrlYStarWt = new TH1D("ZCtrlYStarWt", "", 50, 0., 2.);
TH1D* ZCtrlMjjWt = new TH1D("ZCtrlMjjWt", "", 50, 0., 2.);
TH1D* ZCtrlYStarMjjWt = new TH1D("ZCtrlYStarMjjWt", "", 50, -1., 5.);
tree->Draw("zMass>>ZCtrlZMass" , cutPlots);
tree->Draw("zPt>>ZCtrlZpT" , cutPlots);
tree->Draw("jet1Pt>>ZCtrlJet1pT" , cutPlots);
tree->Draw("jet1Eta>>ZCtrlJet1Eta" , cutPlots);
tree->Draw("jet2Pt>>ZCtrlJet2pT" , cutPlots);
tree->Draw("jet2Eta>>ZCtrlJet2Eta" , cutPlots);
tree->Draw("cenJetEt>>ZCtrlCenJetpT" , cutPlots);
tree->Draw("vbfDEta>>ZCtrlDEtajj" , cutPlots);
tree->Draw("vbfM>>ZCtrlMjj" , cutPlots);
tree->Draw("metNo2Muon>>ZCtrlMET" , cutPlots);
tree->Draw("vbfDPhi>>ZCtrlDPhijj" , cutPlots);
if (options.doMCFMWeights) {
tree->Draw("abs(log((sqrt(zgenmass*zgenmass + zgenpt*zgenpt*cosh(zgeneta)*cosh(zgeneta)) + zgenpt*sinh(zgeneta))/sqrt(zgenmass*zgenmass + zgenpt*zgenpt)) - 0.5*(genJet1Eta + genJet2Eta))>>ZCtrlYStar" , cutPlots);
tree->Draw("(0.849667 + (0.149687*abs(log((sqrt(zgenmass*zgenmass + zgenpt*zgenpt*cosh(zgeneta)*cosh(zgeneta)) + zgenpt*sinh(zgeneta))/sqrt(zgenmass*zgenmass + zgenpt*zgenpt)) - 0.5*(genJet1Eta + genJet2Eta))))>>ZCtrlYStarWt", cutPlots);
tree->Draw("(0.392568 + (0.120734*log(genVBFM)) - (0.000255622*genVBFM))>>ZCtrlMjjWt", cutPlots);
tree->Draw("(0.849667 + (0.149687*abs(log((sqrt(zgenmass*zgenmass + zgenpt*zgenpt*cosh(zgeneta)*cosh(zgeneta)) + zgenpt*sinh(zgeneta))/sqrt(zgenmass*zgenmass + zgenpt*zgenpt)) - 0.5*(genJet1Eta + genJet2Eta))))*(0.392568 + (0.120734*log(genVBFM)) - (0.000255622*genVBFM))>>ZCtrlYStarMjjWt", cutPlots);
}
if (!dataset.isData) {
ZCtrlZMass->Scale(weight);
ZCtrlZpT->Scale(weight);
ZCtrlJet1pT->Scale(weight);
ZCtrlJet1Eta->Scale(weight);
ZCtrlJet2pT->Scale(weight);
ZCtrlJet2Eta->Scale(weight);
ZCtrlCenJetpT->Scale(weight);
ZCtrlDEtajj->Scale(weight);
ZCtrlMjj->Scale(weight);
ZCtrlMET->Scale(weight);
ZCtrlDPhijj->Scale(weight);
ZCtrlYStar->Scale(weight);
ZCtrlYStarWt->Scale(weight);
ZCtrlMjjWt->Scale(weight);
ZCtrlYStarMjjWt->Scale(weight);
}
ofile_Plot->cd();
ZCtrlZMass->Write("",TObject::kOverwrite);
ZCtrlZpT->Write("",TObject::kOverwrite);
ZCtrlJet1pT->Write("",TObject::kOverwrite);
ZCtrlJet1Eta->Write("",TObject::kOverwrite);
ZCtrlJet2pT->Write("",TObject::kOverwrite);
ZCtrlJet2Eta->Write("",TObject::kOverwrite);
ZCtrlCenJetpT->Write("",TObject::kOverwrite);
ZCtrlDEtajj->Write("",TObject::kOverwrite);
ZCtrlMjj->Write("",TObject::kOverwrite);
ZCtrlMET->Write("",TObject::kOverwrite);
ZCtrlDPhijj->Write("",TObject::kOverwrite);
ZCtrlYStar->Write("",TObject::kOverwrite);
ZCtrlYStarWt->Write("",TObject::kOverwrite);
ZCtrlMjjWt->Write("",TObject::kOverwrite);
ZCtrlYStarMjjWt->Write("",TObject::kOverwrite);
ofile_Plot->Close();
// clean up
delete tree;
file->Close();
}
// re-weighting : will be 1 if re-weighting is off
TH1D* hZ_DYNorm = new TH1D("hZ_DYNorm", "", 1, 0, 1);
hZ_DYNorm->Add(hZ_DY_NoVBFNoWeight);
hZ_DYNorm->Divide(hZ_DY_NoVBFWeight);
double dyNorm = hZ_DYNorm->GetBinContent(1);
// numbers - calculate these from MC in this program later!
double ratioBF = constants::ratioZToNuNuZToLL;
// efficiencies (these will all have syst uncertainty only)
TH1D* hZ_QCD_EffVBFS = new TH1D("hZ_QCD_EffVBFS", "", 1, 0., 1.);
TH1D* hZ_QCD_EffVBFC = new TH1D("hZ_QCD_EffVBFC", "", 1, 0., 1.);
TH1D* hZ_EWK_EffVBFS = new TH1D("hZ_EWK_EffVBFS", "", 1, 0., 1.);
TH1D* hZ_EWK_EffVBFC = new TH1D("hZ_EWK_EffVBFC", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFS = new TH1D("hZ_DY_EffVBFS", "", 1, 0., 1.); // epsilon_s_vbf
TH1D* hZ_DY_EffVBFC = new TH1D("hZ_DY_EffVBFC", "", 1, 0., 1.); // epsilon_c_vbf
TH1D* hZ_DY_TotalEff = new TH1D("hZ_DY_TotalEff", "", 1, 0., 1.);
// for stat only calculation
TH1D* hZ_Eff_S_DPhi = new TH1D("hZ_Eff_S_DPhi", "", 3, dphiEdges);
TH1D* hZ_Est_C_DPhi = new TH1D("hZ_Est_C_DPhi", "", 3, dphiEdges);
TH1D* hZ_Est_S_DPhi = new TH1D("hZ_Est_S_DPhi", "", 3, dphiEdges);
// for syst only calculation
TH1D* hZ_BG_C_DPhi_Syst = new TH1D("hZ_BG_C_DPhi_Syst", "", 3, dphiEdges);
TH1D* hZ_Data_C_DPhi_Syst = new TH1D("hZ_Data_C_DPhi_Syst", "", 3, dphiEdges);
TH1D* hZ_Eff_S_DPhi_Syst = new TH1D("hZ_Eff_S_DPhi_Syst", "", 3, dphiEdges);
TH1D* hZ_Est_C_DPhi_Syst = new TH1D("hZ_Est_C_DPhi_Syst", "", 3, dphiEdges);
TH1D* hZ_Est_S_DPhi_Syst = new TH1D("hZ_Est_S_DPhi_Syst", "", 3, dphiEdges);
// calculate efficiencies for QCD and EWK processes
hZ_QCD_EffVBFS->Add(hZ_QCD_EffVBFS_N);
hZ_QCD_EffVBFS->Divide(hZ_QCD_EffVBFS_D);
hZ_EWK_EffVBFS->Add(hZ_EWK_EffVBFS_N);
hZ_EWK_EffVBFS->Divide(hZ_EWK_EffVBFS_D);
hZ_QCD_EffVBFC->Add(hZ_QCD_EffVBFC_N);
hZ_QCD_EffVBFC->Divide(hZ_QCD_EffVBFC_D);
hZ_EWK_EffVBFC->Add(hZ_EWK_EffVBFC_N);
hZ_EWK_EffVBFC->Divide(hZ_EWK_EffVBFC_D);
// combine QCD Zll and EWK Zll with correct weights
hZ_DY_EffVBFS->Add(hZ_QCD_EffVBFS,constants::sigma_Zvv_QCD);
hZ_DY_EffVBFS->Add(hZ_EWK_EffVBFS,constants::sigma_Zvv_EWK);
hZ_DY_EffVBFC->Add(hZ_QCD_EffVBFC,constants::sigma_Zuu_QCD);
hZ_DY_EffVBFC->Add(hZ_EWK_EffVBFC,constants::sigma_Zuu_EWK);
hZ_DY_TotalEff->Add(hZ_DY_EffVBFS);
hZ_DY_TotalEff->Divide(hZ_DY_EffVBFC);
for(int ibin = 1; ibin <= hZ_Eff_S_DPhi->GetNbinsX(); ++ibin) {
hZ_Eff_S_DPhi->SetBinContent(ibin,hZ_DY_TotalEff->GetBinContent(1));
hZ_Eff_S_DPhi->SetBinError(ibin,0.);
hZ_Eff_S_DPhi_Syst->SetBinContent(ibin,hZ_DY_TotalEff->GetBinContent(1));
hZ_Eff_S_DPhi_Syst->SetBinError(ibin,hZ_DY_TotalEff->GetBinError(1));
}
// do stat only version
hZ_BG_C_DPhi_Syst->Add(hZ_BG_C_DPhi, 1.); // copy MC BG histogram for syst calculation
for (int i=1; i<=hZ_BG_C_DPhi->GetNbinsX(); ++i) hZ_BG_C_DPhi->SetBinError(i,0.); // set MC BG errors to zero for stat only
hZ_Est_C_DPhi->Add(hZ_Data_C_DPhi, hZ_BG_C_DPhi, 1., -1.);
hZ_Est_S_DPhi->Add(hZ_Est_C_DPhi);
hZ_Est_S_DPhi->Multiply(hZ_Eff_S_DPhi);
// do syst only version
hZ_Data_C_DPhi_Syst->Add(hZ_Data_C_DPhi, 1.);
for (int i=1; i<=hZ_Data_C_DPhi_Syst->GetNbinsX(); ++i) hZ_Data_C_DPhi_Syst->SetBinError(i,0.);
hZ_Est_C_DPhi_Syst->Add(hZ_Data_C_DPhi_Syst, hZ_BG_C_DPhi, 1., -1.);
hZ_Est_S_DPhi_Syst->Add(hZ_Est_C_DPhi_Syst);
hZ_Est_S_DPhi_Syst->Multiply(hZ_Eff_S_DPhi_Syst);
std::cout << std::endl;
std::cout << "##################################### MET > 130 #####################################" << std::endl;
std::cout << "dphi<1.0" << std::endl;
std::cout << std::endl;
std::cout << " Numerator_s_vbf : " << hZ_QCD_EffVBFS_N->GetBinContent(1) << " +/- " << hZ_QCD_EffVBFS_N->GetBinError(1) << std::endl;
std::cout << " Deno_s_vbf : " << hZ_QCD_EffVBFS_D->GetBinContent(1) << " +/- " << hZ_QCD_EffVBFS_D->GetBinError(1) << std::endl;
std::cout << " eps_s_vbf (QCD) : " << hZ_QCD_EffVBFS->GetBinContent(1) << " +/- " << hZ_QCD_EffVBFS->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " Numerator_s_vbf : " << hZ_EWK_EffVBFS_N->GetBinContent(1) << " +/- " << hZ_EWK_EffVBFS_N->GetBinError(1) << std::endl;
std::cout << " Deno_s_vbf : " << hZ_EWK_EffVBFS_D->GetBinContent(1) << " +/- " << hZ_EWK_EffVBFS_D->GetBinError(1) << std::endl;
std::cout << " eps_s_vbf (EWK) : " << hZ_EWK_EffVBFS->GetBinContent(1) << " +/- " << hZ_EWK_EffVBFS->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " Numerator_c_vbf : " << hZ_QCD_EffVBFC_N->GetBinContent(1) << " +/- " << hZ_QCD_EffVBFC_N->GetBinError(1) << std::endl;
std::cout << " Deno_c_vbf : " << hZ_QCD_EffVBFC_D->GetBinContent(1) << " +/- " << hZ_QCD_EffVBFC_D->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf (QCD) : " << hZ_QCD_EffVBFC->GetBinContent(1) << " +/- " << hZ_QCD_EffVBFC->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " Numerator_c_vbf : " << hZ_EWK_EffVBFC_N->GetBinContent(1) << " +/- " << hZ_EWK_EffVBFC_N->GetBinError(1) << std::endl;
std::cout << " Deno_c_vbf : " << hZ_EWK_EffVBFC_D->GetBinContent(1) << " +/- " << hZ_EWK_EffVBFC_D->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf (EWK) : " << hZ_EWK_EffVBFC->GetBinContent(1) << " +/- " << hZ_EWK_EffVBFC->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf : " << hZ_DY_EffVBFS->GetBinContent(1) << " +/- " << hZ_DY_EffVBFS->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf : " << hZ_DY_EffVBFC->GetBinContent(1) << " +/- " << hZ_DY_EffVBFC->GetBinError(1) << std::endl;
std::cout << " total eff : " << hZ_DY_TotalEff->GetBinContent(1) << " +/- " << hZ_DY_TotalEff->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " DY+jets MC ctrl region : " << hZ_DY_C_DPhi->GetBinContent(1) << " +/- " << hZ_DY_C_DPhi->GetBinError(1) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_C_DPhi->GetBinContent(1) << " +/- " << hZ_BG_C_DPhi->GetBinError(1) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_C_DPhi->GetBinContent(1) << " +/- " << hZ_Data_C_DPhi->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " Z in ctrl region : " << hZ_Est_C_DPhi->GetBinContent(1) << " +/- " << hZ_Est_C_DPhi->GetBinError(1) << " (stat.) + " << hZ_Est_C_DPhi_Syst->GetBinError(1) << " (syst)" << std::endl;
std::cout << " Z in sgnl region : " << hZ_Est_S_DPhi->GetBinContent(1) << " +/- " << hZ_Est_S_DPhi->GetBinError(1) << " (stat.) + " << hZ_Est_S_DPhi_Syst->GetBinError(1) << " (syst)" << std::endl;
std::cout << std::endl;
//std::cout << " N_DY^No VBF (no y* or mjj weight) : " << hZ_DY_NoVBFNoWeight->GetBinContent(1) << " +/- " << hZ_DY_NoVBFNoWeight->GetBinError(1) << std::endl;
//std::cout << " N_DY^No VBF(with y* and mjj weight): " << hZ_DY_NoVBFWeight->GetBinContent(1) << " +/- " << hZ_DY_NoVBFWeight->GetBinError(1) << std::endl;
//std::cout << " norm eff (unweighted DY, no VBF / weighted DY, no VBF): " << dyNorm << std::endl;
std::cout << std::endl;
std::cout << "#####################################################################################" << std::endl;
std::cout << std::endl << std::endl;
// write the cutflow table
std::cout << "Writing cut flow TeX file" << std::endl;
ofstream effFile;
effFile.open(options.oDir+std::string("/cutflowZMuMu.tex"));
effFile << "Cut & N(data) & N(DY\\rightarrow\\ell\\ell) & N($t\\bar{t}$) & N(single $t$) & N(diboson) \\\\" << std::endl;
TH1D* hZ_CutFlow_TTBar = (TH1D*) ofile->Get("hZ_CutFlow_TTBar");
// cutflow table
for (unsigned i=0; i<nCutsZMuMu; ++i) {
effFile << cuts.cutNameZMuMu(i) << " & ";
effFile << "$" << hZ_CutFlow_Data->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_Data->GetBinError(i+1) << "$ & ";
effFile << "$" << hZ_CutFlow_DY->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_DY->GetBinError(i+1) << "$ & ";
effFile << "$" << hZ_CutFlow_TTBar->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_TTBar->GetBinError(i+1) << "$ & ";
effFile << "$" << hZ_CutFlow_SingleTSum->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_SingleTSum->GetBinError(i+1) << "$ & ";
effFile << "$" << hZ_CutFlow_Diboson->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_Diboson->GetBinError(i+1) << "$ & ";
effFile << std::endl;
}
effFile << std::endl << std::endl;
effFile.close();
// list histograms for dataset summing
std::vector<std::string> hists;
hists.push_back("ZCtrlZMass");
hists.push_back("ZCtrlZpT");
hists.push_back("ZCtrlJet1pT");
hists.push_back("ZCtrlJet1Eta");
hists.push_back("ZCtrlJet2pT");
hists.push_back("ZCtrlJet2Eta");
hists.push_back("ZCtrlCenJetpT");
hists.push_back("ZCtrlDEtajj");
hists.push_back("ZCtrlMjj");
hists.push_back("ZCtrlMET");
hists.push_back("ZCtrlDPhijj");
// check whether we have NoTrig histograms or normal
bool noTrig = false;
std::string dyJetsName = oDir_Plot+std::string("/DYJetsToLL.root");
std::string dyJetsPtZName = oDir_Plot+std::string("/DYJetsToLL_PtZ-100.root");
struct stat buffer;
if (stat (dyJetsName.c_str(), &buffer) != 0) {
noTrig = true;
dyJetsName = oDir_Plot+std::string("/DYJetsToLL_NoTrig.root");
dyJetsPtZName = oDir_Plot+std::string("/DYJetsToLL_PtZ-100_NoTrig.root");
}
std::cout << "Getting histograms for plots from " << dyJetsName << " and " << dyJetsPtZName << std::endl;
// re-scale QCD DY histograms
TFile* qcdDYFile = TFile::Open(dyJetsName.c_str(), "UPDATE");
for (std::vector<std::string>::const_iterator hname=hists.begin(); hname!=hists.end(); ++hname) {
TH1D* h = (TH1D*) qcdDYFile->Get(hname->c_str());
//std::cout << "Integral before : " << h->Integral() << std::endl;
h->Scale(dyNorm);
//std::cout << "Integral after : " << h->Integral() << std::endl;
h->Write("",TObject::kOverwrite);
}
qcdDYFile->Close();
qcdDYFile = TFile::Open(dyJetsPtZName.c_str(), "UPDATE");
for (std::vector<std::string>::const_iterator hname=hists.begin(); hname!=hists.end(); ++hname) {
TH1D* h = (TH1D*) qcdDYFile->Get(hname->c_str());
h->Scale(dyNorm);
h->Write("",TObject::kOverwrite);
}
qcdDYFile->Close();
// sum DY datasets
std::vector<std::string> DYDatasets;
if (noTrig) {
DYDatasets.push_back(std::string("DYJetsToLL_NoTrig"));
DYDatasets.push_back(std::string("DYJetsToLL_PtZ-100_NoTrig"));
DYDatasets.push_back(std::string("DYJetsToLL_EWK_NoTrig"));
}
else {
DYDatasets.push_back(std::string("DYJetsToLL"));
DYDatasets.push_back(std::string("DYJetsToLL_PtZ-100"));
DYDatasets.push_back(std::string("DYJetsToLL_EWK"));
}
SumDatasets(oDir_Plot, DYDatasets, hists, "DY+jets");
// sum single top datasets
std::vector<std::string> topDatasets;
topDatasets.push_back(std::string("SingleT_t"));
topDatasets.push_back(std::string("SingleTbar_t"));
topDatasets.push_back(std::string("SingleT_s"));
topDatasets.push_back(std::string("SingleTbar_s"));
topDatasets.push_back(std::string("SingleT_tW"));
topDatasets.push_back(std::string("SingleTbar_tW"));
topDatasets.push_back(std::string("TTBar"));
SumDatasets(oDir_Plot, topDatasets, hists, "SingleT+TTbar");
// sum diboson datasets
std::vector<std::string> dibDatasets;
dibDatasets.push_back(std::string("WW"));
dibDatasets.push_back(std::string("WZ"));
dibDatasets.push_back(std::string("ZZ"));
dibDatasets.push_back(std::string("WG"));
SumDatasets(oDir_Plot, dibDatasets, hists, "DiBoson");
// sum SM backgrounds
std::vector<std::string> bgDatasets;
bgDatasets.push_back(std::string("WW"));
bgDatasets.push_back(std::string("WZ"));
bgDatasets.push_back(std::string("ZZ"));
bgDatasets.push_back(std::string("WG"));
bgDatasets.push_back(std::string("SingleT_t"));
bgDatasets.push_back(std::string("SingleTbar_t"));
bgDatasets.push_back(std::string("SingleT_s"));
bgDatasets.push_back(std::string("SingleTbar_s"));
bgDatasets.push_back(std::string("SingleT_tW"));
bgDatasets.push_back(std::string("SingleTbar_tW"));
bgDatasets.push_back(std::string("TTBar"));
SumDatasets(oDir_Plot, bgDatasets, hists, "tt+VV");
// make plots
std::cout << "Making plots" << std::endl;
StackPlot plots(oDir_Plot);
plots.setLegPos(0.70,0.60,0.93,0.89);
//plots.setLegPos(0.62,0.62,0.89,0.89);
// Note that here I've used the overloaded method addDataset, which allows you to specify a filename for the input ROOT file
// *and* also allows you to specify what to put in the TLegend. (By default, it uses the filename as the TLegend entry)
// This is because the Tlegend entry involves some odd characters, which are best not used in filenames for safety
// plots.addDataset("DiBoson", kViolet-6, 0);
plots.addDataset("tt+VV", "t#bar{t}, tW, VV", kAzure-2, 0);
plots.addDataset("DY+jets", "DY(ll)+jets", kPink-4, 0);
plots.addDataset("METABCD", kBlack, 1);
plots.setScaleMCtoData(true); //rescale MC to data
plots.draw("ZCtrlZpT", "Z_p_{T} [GeV]", "N_{events}" ,1,"RATIO_Z");
plots.draw("ZCtrlJet1pT", "Leading jet p_{T} [GeV]", "N_{events}" ,1,"RATIO_Z");
plots.draw("ZCtrlJet1Eta", "Leading jet #eta", "N_{events}" ,1,"RATIO_Z");
plots.draw("ZCtrlJet2pT", "Sub-leading jet p_{T} [GeV]", "N_{events}" ,1,"RATIO_Z");
plots.draw("ZCtrlJet2Eta", "Sub-leading jet #eta", "N_{events}" ,1,"RATIO_Z");
plots.draw("ZCtrlCenJetpT", "Central jet p_{T} [GeV]", "N_{events}" ,1,"RATIO_Z");
plots.draw("ZCtrlDEtajj", "#Delta #eta_{jj}", "N_{events}" ,1,"RATIO_Z");
plots.setYMax(5.e2);
plots.setXMin(1100.);
plots.setXMax(2600.);
plots.draw("ZCtrlMjj", "M_{jj} [GeV]", "Events / 100 GeV" ,1,"RATIO_Z");
plots.setYMax(5.e2);
plots.setXMin(130.);
plots.draw("ZCtrlMET", "E_{T}^{miss} [GeV]", "Events / 20 GeV" ,1,"RATIO_Z");
plots.draw("ZCtrlDPhijj", "#Delta #phi_{jj}", "Events" ,1,"RATIO_Z");
plots.setYMax(80.);
plots.setYMin(0.);
plots.draw("ZCtrlZMass", "M_{#mu#mu} [GeV]", "Events / 5 GeV" ,0,"RATIO_Z");
//store histograms
ofile->cd();
hZ_DY_C_DPhi->Write("",TObject::kOverwrite);
hZ_BG_C_DPhi->Write("",TObject::kOverwrite);
hZ_Data_C_DPhi->Write("",TObject::kOverwrite);
hZ_Est_C_DPhi->Write("",TObject::kOverwrite);
hZ_Est_C_DPhi_Syst->Write("",TObject::kOverwrite);
hZ_Est_S_DPhi->Write("",TObject::kOverwrite);
hZ_Est_S_DPhi_Syst->Write("",TObject::kOverwrite);
hZ_Eff_S_DPhi->Write("",TObject::kOverwrite);
hZ_Eff_S_DPhi_Syst->Write("",TObject::kOverwrite);
hZ_QCD_EffVBFS_D->Write("",TObject::kOverwrite);
hZ_QCD_EffVBFS_N->Write("",TObject::kOverwrite);
hZ_QCD_EffVBFC_D->Write("",TObject::kOverwrite);
hZ_QCD_EffVBFC_N->Write("",TObject::kOverwrite);
hZ_EWK_EffVBFS_D->Write("",TObject::kOverwrite);
hZ_EWK_EffVBFS_N->Write("",TObject::kOverwrite);
hZ_EWK_EffVBFC_D->Write("",TObject::kOverwrite);
hZ_EWK_EffVBFC_N->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS->Write("",TObject::kOverwrite);
hZ_DY_EffVBFC->Write("",TObject::kOverwrite);
hZ_DY_TotalEff->Write("",TObject::kOverwrite);
hZ_CutFlow_Data->Write("",TObject::kOverwrite);
hZ_CutFlow_DY->Write("",TObject::kOverwrite);
hZ_CutFlow_SingleTSum->Write("",TObject::kOverwrite);
hZ_CutFlow_Diboson->Write("",TObject::kOverwrite);
ofile->Close();
}
FullModelComposition<Vec,Mat>::FullModelComposition( int argc, char** argv,
const QUESO::BaseEnvironment& queso_env,
const GetPot& model_input )
: _model(ModelBuilder<Vec,Mat>::build_model(queso_env,model_input)),
_comm_handler(queso_env.subComm().Comm(),
model_input.vector_variable_size("Likelihood/datasets") )
{
// Grab the datasets we'll be working with
unsigned int n_datasets = model_input.vector_variable_size("Likelihood/datasets");
std::vector<std::string> datasets(n_datasets);
for( unsigned int d = 0; d < n_datasets; d++ )
{
datasets[d] = model_input( "Likelihood/datasets", "DIE!", d );
}
// This is the dataset the current set of processors is going to work on
int dataset_index = this->_comm_handler.get_dataset_index();
// Input for this dataset
_forward_run_input.reset( new GetPot(datasets[dataset_index]) );
// Setup data space, 2 datapoints per dataset
unsigned int n_datapoints = 2*n_datasets;
QUESO::VectorSpace<Vec,Mat> data_space( queso_env, "data_", n_datapoints, NULL);
_observations.reset( data_space.newVector() );
_covariance.reset( data_space.newVector() );
// Now parse data values and the corresponding covariances
// Each processor parses its own dataset
// Then we'll gather/broadcast to everyone
std::vector<double> local_values(2);
std::vector<double> all_values(n_datapoints);
// Convention, mass_loss is first, then avg_N
local_values[0] = (*_forward_run_input)("MassLossLikelihood/data_value", 0.0);
local_values[1] = (*_forward_run_input)("AverageNLikelihood/data_value", 0.0);
if( _comm_handler.get_inter0_rank() >= 0 )
MPI_Gather( &local_values[0], 2, MPI_DOUBLE,
&all_values[0], 2, MPI_DOUBLE, 0,
_comm_handler.get_inter_chain_0_comm() );
MPI_Bcast( &all_values[0], n_datapoints, MPI_DOUBLE,
0, _comm_handler.get_inter_chain_comm() );
for( unsigned int i = 0; i < n_datapoints; i++ )
(*_observations)[i] = all_values[i];
local_values[0] = (*_forward_run_input)("MassLossLikelihood/sigma", -1.0);
local_values[1] = (*_forward_run_input)("AverageNLikelihood/sigma", -1.0);
if( _comm_handler.get_inter0_rank() >= 0 )
MPI_Gather( &local_values[0], 2, MPI_DOUBLE,
&all_values[0], 2, MPI_DOUBLE, 0,
_comm_handler.get_inter_chain_0_comm() );
MPI_Bcast( &all_values[0], n_datapoints, MPI_DOUBLE,
0, _comm_handler.get_inter_chain_comm() );
for( unsigned int i = 0; i < n_datapoints; i++ )
(*_covariance)[i] = all_values[i];
// Now setup model to be evaluated on this set of processors
// We do this last because of the UFO check in GRINS
_model_evaluator.reset( new FullModelEvaluator<Vec,Mat>(argc,argv,
queso_env,
*(_forward_run_input.get()),
_comm_handler.get_split_chain_comm(),
*(_model.get())) );
}
int main(int argc, char* argv[]) {
TH1::SetDefaultSumw2();
ProgramOptions options(argc, argv);
double lumi = options.lumi;
// input datasets
Datasets datasets(options.iDir);
datasets.readFile(options.datasetFile);
//std::string oDir_Plot = options.oDir+std::string("/ZBackground");
//boost::filesystem::path opath(oDir_Plot);
//if (!exists(opath)) {
// std::cout << "Creating output directory : " << oDir_Plot << std::endl;
// boost::filesystem::create_directory(opath);
//}
// output file
TFile* ofile = TFile::Open( (options.oDir+std::string("/ZBackgroundBins.root")).c_str(), "RECREATE");
// cuts
Cuts cuts;
unsigned nCutsZMuMu = cuts.nCutsZMuMu();
TCut puWeight("puWeight");
TCut trigCorr( "(trigCorrWeight>0) ? trigCorrWeight : 1." );
TCut METNoMuon130("metNoMuon>130."); // add here later for VBF efficiency when MET>35, MET>70 (QCD estimation)
TCut METNo2Muon130("metNo2Muon>130.");
TCut cutLoDPhi = cuts.cut("dPhiJJ");
TCut cutHiDPhi("vbfDPhi>2.6");
TCut cutMe1DPhi("vbfDPhi>1.0 && vbfDPhi<=1.8");
TCut cutMe2DPhi("vbfDPhi>1.8 && vbfDPhi<=2.6");
// histograms
double dphiEdges[5] = { 0., 1.0, 1.8, 2.6, TMath::Pi() };
//double metEdges[13] = { 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120. };
// signal MET>130
//TH1D* hZ_DY_C_noDPhi = new TH1D("hZ_DY_C_noDPhi", "", 1, 0., 1.); // Z+jets MC ctrl region
//TH1D* hZ_BG_C_noDPhi = new TH1D("hZ_BG_C_noDPhi", "", 1, 0., 1.); // background MC ctrl region
//TH1D* hZ_Data_C_noDPhi = new TH1D("hZ_Data_C_noDPhi", "", 1, 0., 1.); // Data ctrl region
TH1D* hZ_DY_C_DPhi = new TH1D("hZ_DY_C_DPhi", "", 4, dphiEdges); // Z+jets MC ctrl region
TH1D* hZ_BG_C_DPhi = new TH1D("hZ_BG_C_DPhi", "", 4, dphiEdges); // background MC ctrl region
TH1D* hZ_Data_C_DPhi = new TH1D("hZ_Data_C_DPhi", "", 4, dphiEdges); // Data ctrl region
TH1D* hZ_DY_EffMuMu_D = new TH1D("hZ_DY_EffMuMu_D", "", 1, 0., 1.); // denominator of MuMu efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
TH1D* hZ_DY_EffMuMu_N = new TH1D("hZ_DY_EffMuMu_N", "", 1, 0., 1.); // numerator of MuMu efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
TH1D* hZ_DY_EffVBFS_D = new TH1D("hZ_DY_EffVBFS_D", "", 1, 0., 1.); // denominator of VBF(S) efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
//TH1D* hZ_DY_EffVBFS_N = new TH1D("hZ_DY_EffVBFS_N", "", 1, 0., 1.); // numerator of VBF(S) efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
//TH1D* hZ_DY_EffVBFS_NDPhi = new TH1D("hZ_DY_EffVBFS_NDPhi", "", 4, dphiEdges);
TH1D* hZ_DY_EffVBFS_NLo = new TH1D("hZ_DY_EffVBFS_NLo", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFS_NHi = new TH1D("hZ_DY_EffVBFS_NHi", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFS_NMe1 = new TH1D("hZ_DY_EffVBFS_NMe1", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFS_NMe2 = new TH1D("hZ_DY_EffVBFS_NMe2", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFC_D = new TH1D("hZ_DY_EffVBFC_D", "", 1, 0., 1.); // denominator of VBF(C) efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
//TH1D* hZ_DY_EffVBFC_N = new TH1D("hZ_DY_EffVBFC_N", "", 1, 0., 1.); // numerator of VBF(C) efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
//TH1D* hZ_DY_EffVBFC_NDPhi = new TH1D("hZ_DY_EffVBFC_NDPhi", "", 4, dphiEdges);
TH1D* hZ_DY_EffVBFC_NLo = new TH1D("hZ_DY_EffVBFC_NLo", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFC_NHi = new TH1D("hZ_DY_EffVBFC_NHi", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFC_NMe1 = new TH1D("hZ_DY_EffVBFC_NMe1", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFC_NMe2 = new TH1D("hZ_DY_EffVBFC_NMe2", "", 1, 0., 1.);
// cutflow histograms
//TH1D* hZ_CutFlow_Data = new TH1D("hZ_CutFlow_Data", "", nCutsZMuMu, 0., nCutsZMuMu);
//TH1D* hZ_CutFlow_DY = new TH1D("hZ_CutFlow_DY", "", nCutsZMuMu, 0., nCutsZMuMu);
//TH1D* hZ_CutFlow_SingleTSum = new TH1D("hZ_CutFlow_SingleTSum", "", nCutsZMuMu, 0., nCutsZMuMu);
//TH1D* hZ_CutFlow_Diboson = new TH1D("hZ_CutFlow_Diboson", "", nCutsZMuMu, 0., nCutsZMuMu);
// loop over MC datasets
for (unsigned i=0; i<datasets.size(); ++i) {
Dataset dataset = datasets.getDataset(i);
TCut cutD = cuts.cutDataset(dataset.name);
// check if it's DYJets
bool isDY = false;
if (dataset.name.compare(0,2,"DY")==0) {
isDY = true;
std::cout << "Analysing DY->ll MC : " << dataset.name << std::endl;
}
else if (dataset.isData) {
std::cout << "Analysing Data : " << dataset.name << std::endl;
}
else {
std::cout << "Analysing BG MC : " << dataset.name << std::endl;
}
// get file & tree
TFile* file = datasets.getTFile(dataset.name);
TTree* tree = (TTree*) file->Get("invHiggsInfo/InvHiggsInfo");
// set up cuts
TCut cutZMuMu_C = puWeight * trigCorr * (cutD + cuts.zMuMuVBF() + METNo2Muon130);
TCut cutEfficiencyMuMu_D = puWeight * (cutD + cuts.zMuMuGen());
TCut cutEfficiencyMuMu_N = puWeight * (cutD + cuts.zMuMuGen() + cuts.zMuMuReco());
TCut cutEfficiencyVBFS_D = puWeight * (cutD + cuts.zMuMuGenMass());
//TCut cutEfficiencyVBFS_N = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGenMass() + cuts.vbf() + METNoMuon130);
TCut cutEfficiencyVBFS_NLoDPhi = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGenMass() + cuts.vbf() + METNoMuon130 + cutLoDPhi);
TCut cutEfficiencyVBFS_NHiDPhi = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGenMass() + cuts.vbf() + METNoMuon130 + cutHiDPhi);
TCut cutEfficiencyVBFS_NMe1DPhi = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGenMass() + cuts.vbf() + METNoMuon130 + cutMe1DPhi);
TCut cutEfficiencyVBFS_NMe2DPhi = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGenMass() + cuts.vbf() + METNoMuon130 + cutMe2DPhi);
TCut cutEfficiencyVBFC_D = puWeight * (cutD + cuts.zMuMuGen() + cuts.zMuMuReco());
//TCut cutEfficiencyVBFC_N = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130);
TCut cutEfficiencyVBFC_NLoDPhi = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutLoDPhi);
TCut cutEfficiencyVBFC_NHiDPhi = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutHiDPhi);
TCut cutEfficiencyVBFC_NMe1DPhi = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutMe1DPhi);
TCut cutEfficiencyVBFC_NMe2DPhi = puWeight * trigCorr * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutMe2DPhi);
// fill tmp histograms for BG estimation
//TH1D* hZ_C_noDPhi = new TH1D("hZ_C_noDPhi", "", 1, 0., 1.);
TH1D* hZ_C_DPhi = new TH1D("hZ_C_DPhi", "", 4, dphiEdges); // this is for the actual BG estimation
// fill tmp histograms for efficiency calculation
TH1D* hZ_EffMuMu_D = new TH1D("hZ_EffMuMu_D", "", 1, 0., 1.);
TH1D* hZ_EffMuMu_N = new TH1D("hZ_EffMuMu_N", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_D = new TH1D("hZ_EffVBFS_D", "", 1, 0., 1.);
//TH1D* hZ_EffVBFS_N = new TH1D("hZ_EffVBFS_N", "", 1, 0., 1.);
//TH1D* hZ_EffVBFS_NDPhi = new TH1D("hZ_EffVBFS_NDPhi", "", 4, dphiEdges);
TH1D* hZ_EffVBFS_NLo = new TH1D("hZ_EffVBFS_NLo", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_NMe1 = new TH1D("hZ_EffVBFS_NMe1", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_NMe2 = new TH1D("hZ_EffVBFS_NMe2", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_NHi = new TH1D("hZ_EffVBFS_NHi", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_D = new TH1D("hZ_EffVBFC_D", "", 1, 0., 1.);
//TH1D* hZ_EffVBFC_N = new TH1D("hZ_EffVBFC_N", "", 1, 0., 1.);
//TH1D* hZ_EffVBFC_NDPhi = new TH1D("hZ_EffVBFC_NDPhi", "", 4, dphiEdges);
TH1D* hZ_EffVBFC_NLo = new TH1D("hZ_EffVBFC_NLo", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_NMe1 = new TH1D("hZ_EffVBFC_NMe1", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_NMe2 = new TH1D("hZ_EffVBFC_NMe2", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_NHi = new TH1D("hZ_EffVBFC_NHi", "", 1, 0., 1.);
if (isDY) {
//tree->Draw("0.5>>hZ_C_noDPhi", cutZMuMu_C);
tree->Draw("vbfDPhi>>hZ_C_DPhi", cutZMuMu_C);
tree->Draw("0.5>>hZ_EffMuMu_D", cutEfficiencyMuMu_D);
tree->Draw("0.5>>hZ_EffMuMu_N", cutEfficiencyMuMu_N);
tree->Draw("0.5>>hZ_EffVBFS_D", cutEfficiencyVBFS_D);
//tree->Draw("0.5>>hZ_EffVBFS_N", cutEfficiencyVBFS_N);
//tree->Draw("vbfDPhi>>hZ_EffVBFS_NDPhi", cutEfficiencyVBFS_N);
tree->Draw("0.5>>hZ_EffVBFS_NLo", cutEfficiencyVBFS_NLoDPhi);
tree->Draw("0.5>>hZ_EffVBFS_NHi", cutEfficiencyVBFS_NHiDPhi);
tree->Draw("0.5>>hZ_EffVBFS_NMe1", cutEfficiencyVBFS_NMe1DPhi);
tree->Draw("0.5>>hZ_EffVBFS_NMe2", cutEfficiencyVBFS_NMe2DPhi);
tree->Draw("0.5>>hZ_EffVBFC_D", cutEfficiencyVBFC_D);
//tree->Draw("0.5>>hZ_EffVBFC_N", cutEfficiencyVBFC_N);
//tree->Draw("vbfDPhi>>hZ_EffVBFC_NDPhi", cutEfficiencyVBFC_N);
tree->Draw("0.5>>hZ_EffVBFC_NLo", cutEfficiencyVBFC_NLoDPhi);
tree->Draw("0.5>>hZ_EffVBFC_NHi", cutEfficiencyVBFC_NHiDPhi);
tree->Draw("0.5>>hZ_EffVBFC_NMe1", cutEfficiencyVBFC_NMe1DPhi);
tree->Draw("0.5>>hZ_EffVBFC_NMe2", cutEfficiencyVBFC_NMe2DPhi);
}
else {
tree->Draw("0.5>>hZ_C_noDPhi", cutZMuMu_C);
tree->Draw("vbfDPhi>>hZ_C_DPhi", cutZMuMu_C);
}
// weight to lumi
double weight = (dataset.isData) ? 1. : lumi * dataset.sigma / dataset.nEvents;
//hZ_C_noDPhi->Scale(weight);
hZ_C_DPhi->Scale(weight);
hZ_EffVBFS_D->Scale(weight);
//hZ_EffVBFS_N->Scale(weight);
//hZ_EffVBFS_NDPhi->Scale(weight);
hZ_EffVBFS_NLo->Scale(weight);
hZ_EffVBFS_NMe1->Scale(weight);
hZ_EffVBFS_NMe2->Scale(weight);
hZ_EffVBFS_NHi->Scale(weight);
hZ_EffVBFC_D->Scale(weight);
//hZ_EffVBFC_N->Scale(weight);
//hZ_EffVBFC_NDPhi->Scale(weight);
hZ_EffVBFC_NLo->Scale(weight);
hZ_EffVBFC_NMe1->Scale(weight);
hZ_EffVBFC_NMe2->Scale(weight);
hZ_EffVBFC_NHi->Scale(weight);
hZ_EffMuMu_D->Scale(weight);
hZ_EffMuMu_N->Scale(weight);
// add to output histograms
if (dataset.isData) {
//hZ_Data_C_noDPhi->Add(hZ_C_noDPhi);
hZ_Data_C_DPhi->Add(hZ_C_DPhi);
}
else if (isDY) {
//hZ_DY_C_noDPhi->Add(hZ_C_noDPhi);
hZ_DY_C_DPhi->Add(hZ_C_DPhi);
hZ_DY_EffVBFS_D->Add(hZ_EffVBFS_D);
//hZ_DY_EffVBFS_N->Add(hZ_EffVBFS_N);
//hZ_DY_EffVBFS_NDPhi->Add(hZ_EffVBFS_NDPhi);
hZ_DY_EffVBFS_NLo->Add(hZ_EffVBFS_NLo);
hZ_DY_EffVBFS_NMe1->Add(hZ_EffVBFS_NMe1);
hZ_DY_EffVBFS_NMe2->Add(hZ_EffVBFS_NMe2);
hZ_DY_EffVBFS_NHi->Add(hZ_EffVBFS_NHi);
hZ_DY_EffVBFC_D->Add(hZ_EffVBFC_D);
//hZ_DY_EffVBFC_N->Add(hZ_EffVBFC_N);
//hZ_DY_EffVBFC_NDPhi->Add(hZ_EffVBFC_NDPhi);
hZ_DY_EffVBFC_NLo->Add(hZ_EffVBFC_NLo);
hZ_DY_EffVBFC_NMe1->Add(hZ_EffVBFC_NMe1);
hZ_DY_EffVBFC_NMe2->Add(hZ_EffVBFC_NMe2);
hZ_DY_EffVBFC_NHi->Add(hZ_EffVBFC_NHi);
hZ_DY_EffMuMu_D->Add(hZ_EffMuMu_D);
hZ_DY_EffMuMu_N->Add(hZ_EffMuMu_N);
}
else {
//hZ_BG_C_noDPhi->Add(hZ_C_noDPhi);
hZ_BG_C_DPhi->Add(hZ_C_DPhi);
}
std::cout << " N ctrl (dphi<1.0) : " << hZ_C_DPhi->GetBinContent(1) << " +/- " << hZ_C_DPhi->GetBinError(1) << std::endl;
//std::cout << " N ctrl (dphi>2.6) : " << hZ_C_DPhi->GetBinContent(3) << " +/- " << hZ_C_DPhi->GetBinError(3) << std::endl;
//delete hZ_C_noDPhi;
delete hZ_C_DPhi;
delete hZ_EffMuMu_D;
delete hZ_EffMuMu_N;
delete hZ_EffVBFS_D;
//delete hZ_EffVBFS_N;
//delete hZ_EffVBFS_NDPhi;
delete hZ_EffVBFS_NLo;
delete hZ_EffVBFS_NMe1;
delete hZ_EffVBFS_NMe2;
delete hZ_EffVBFS_NHi;
delete hZ_EffVBFC_D;
//delete hZ_EffVBFC_N;
//delete hZ_EffVBFC_NDPhi;
delete hZ_EffVBFC_NLo;
delete hZ_EffVBFC_NMe1;
delete hZ_EffVBFC_NMe2;
delete hZ_EffVBFC_NHi;
/*
ofile->cd();
// cut flow histograms
std::string hname = std::string("hZ_CutFlow_")+dataset.name;
TH1D* hZ_CutFlow = new TH1D(hname.c_str(), "", nCutsZMuMu, 0., nCutsZMuMu);
for (unsigned c=0; c<nCutsZMuMu; ++c) {
TCut cut;
if(c == nCutsZMuMu-1) cut = puWeight * trigCorr * (cutD + cuts.cutflowZMuMu(c));
else cut = puWeight * (cutD + cuts.cutflowZMuMu(c));
TH1D* h = new TH1D("h","", 1, 0., 1.);
tree->Draw("0.5>>h", cut);
hZ_CutFlow->SetBinContent(c+1, h->GetBinContent(1));
hZ_CutFlow->SetBinError(c+1, h->GetBinError(1));
delete h;
}
hZ_CutFlow->Scale(weight);
if (dataset.isData) {
hZ_CutFlow_Data->Add(hZ_CutFlow);
}
if (dataset.name.compare(0,2,"DY")==0) {
hZ_CutFlow_DY->Add(hZ_CutFlow);
}
if (dataset.name.compare(0,7,"SingleT")==0) {
hZ_CutFlow_SingleTSum->Add(hZ_CutFlow);
}
if (dataset.name.compare(0,2,"WW")==0 ||
dataset.name.compare(0,2,"WZ")==0 ||
dataset.name.compare(0,2,"ZZ")==0 ) {
hZ_CutFlow_Diboson->Add(hZ_CutFlow);
}
hZ_CutFlow->Write("",TObject::kOverwrite);
delete hZ_CutFlow;
// Z control plots
TCut cutPlots = puWeight * trigCorr * (cutD + cuts.zMuMuVBFLoose());
TFile* ofile_Plot = TFile::Open( (oDir_Plot+std::string("/")+dataset.name+std::string(".root")).c_str(), "RECREATE");
TH1D* ZCtrlZMass = new TH1D("ZCtrlZMass", "", 30, 60., 120.);
TH1D* ZCtrlZpT = new TH1D("ZCtrlZpT", "", 50, 0., 1000.);
TH1D* ZCtrlJet1pT = new TH1D("ZCtrlJet1pT", "", 50, 0., 1000.);
TH1D* ZCtrlJet1Eta = new TH1D("ZCtrlJet1Eta", "", 50, -5., 5.);
TH1D* ZCtrlJet2pT = new TH1D("ZCtrlJet2pT", "", 50, 0., 1000.);
TH1D* ZCtrlJet2Eta = new TH1D("ZCtrlJet2Eta", "", 50, -5., 5.);
TH1D* ZCtrlCenJetpT = new TH1D("ZCtrlCenJetpT", "", 50, 0., 400.);
TH1D* ZCtrlDEtajj = new TH1D("ZCtrlDEtajj", "", 50, 0., 8.);
TH1D* ZCtrlMjj = new TH1D("ZCtrlMjj", "", 50, 0., 4000.);
TH1D* ZCtrlMET = new TH1D("ZCtrlMET", "", 50, 0., 500.);
TH1D* ZCtrlDPhijj = new TH1D("ZCtrlDPhijj", "", 50, 0., TMath::Pi());
tree->Draw("zMass>>ZCtrlZMass" , cutPlots);
tree->Draw("zPt>>ZCtrlZpT" , cutPlots);
tree->Draw("jet1Pt>>ZCtrlJet1pT" , cutPlots);
tree->Draw("jet1Eta>>ZCtrlJet1Eta" , cutPlots);
tree->Draw("jet2Pt>>ZCtrlJet2pT" , cutPlots);
tree->Draw("jet2Eta>>ZCtrlJet2Eta" , cutPlots);
tree->Draw("cenJetEt>>ZCtrlCenJetpT", cutPlots);
tree->Draw("vbfDEta>>ZCtrlDEtajj" , cutPlots);
tree->Draw("vbfM>>ZCtrlMjj" , cutPlots);
tree->Draw("metNo2Muon>>ZCtrlMET" , cutPlots);
tree->Draw("vbfDPhi>>ZCtrlDPhijj" , cutPlots);
if (!dataset.isData) {
ZCtrlZMass->Scale(weight);
ZCtrlZpT->Scale(weight);
ZCtrlJet1pT->Scale(weight);
ZCtrlJet1Eta->Scale(weight);
ZCtrlJet2pT->Scale(weight);
ZCtrlJet2Eta->Scale(weight);
ZCtrlCenJetpT->Scale(weight);
ZCtrlDEtajj->Scale(weight);
ZCtrlMjj->Scale(weight);
ZCtrlMET->Scale(weight);
ZCtrlDPhijj->Scale(weight);
}
ofile_Plot->cd();
ZCtrlZMass->Write("",TObject::kOverwrite);
ZCtrlZpT->Write("",TObject::kOverwrite);
ZCtrlJet1pT->Write("",TObject::kOverwrite);
ZCtrlJet1Eta->Write("",TObject::kOverwrite);
ZCtrlJet2pT->Write("",TObject::kOverwrite);
ZCtrlJet2Eta->Write("",TObject::kOverwrite);
ZCtrlCenJetpT->Write("",TObject::kOverwrite);
ZCtrlDEtajj->Write("",TObject::kOverwrite);
ZCtrlMjj->Write("",TObject::kOverwrite);
ZCtrlMET->Write("",TObject::kOverwrite);
ZCtrlDPhijj->Write("",TObject::kOverwrite);
ofile_Plot->Close();
*/
// clean up
delete tree;
file->Close();
}
// numbers - calculate these from MC in this program later!
double ratioBF = 5.626; // MCFM + NLO
//no dPhi cut
//TH1D* hZ_Est_C_noDPhi = new TH1D("hZ_Est_C_noDPhi", "", 1, 0., 1.); // estimated Z in ctrl region
//TH1D* hZ_Est_S_noDPhi = new TH1D("hZ_Est_S_noDPhi", "", 1, 0., 1.); // estimated Z in bkgrnd region
//TH1D* hZ_Eff_S_noDPhi = new TH1D("hZ_Eff_S_noDPhi", "", 1, 0., 1.);
// bins dPhi
TH1D* hZ_Est_C_DPhi = new TH1D("hZ_Est_C_DPhi", "", 4, dphiEdges); // estimated Z in ctrl region
TH1D* hZ_Est_S_DPhi = new TH1D("hZ_Est_S_DPhi", "", 4, dphiEdges); // estimated Z in bkgrnd region
TH1D* hZ_Eff_S_DPhi = new TH1D("hZ_Eff_S_DPhi", "", 4, dphiEdges);
TH1D* hZ_DY_EffMuMu = new TH1D("hZ_DY_EffMuMu", "", 1, 0., 1.); // epsilon mumu
hZ_DY_EffMuMu->Add(hZ_DY_EffMuMu_N);
hZ_DY_EffMuMu->Divide(hZ_DY_EffMuMu_D);
double mu_syst = 0.025*hZ_DY_EffMuMu->GetBinContent(1); //2.5% Muon ID/Iso efficiency uncertainty from EWK-10-002
hZ_DY_EffMuMu->SetBinError(1,TMath::Sqrt(hZ_DY_EffMuMu->GetBinError(1)*hZ_DY_EffMuMu->GetBinError(1) + mu_syst*mu_syst));
//TH1D* hZ_DY_EffVBFS = new TH1D("hZ_DY_EffVBFS", "", 1, 0., 1.); // epsilon_s_vbf
TH1D* hZ_DY_EffVBFSLo = new TH1D("hZ_DY_EffVBFSLo", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFSMe1 = new TH1D("hZ_DY_EffVBFSMe1", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFSMe2 = new TH1D("hZ_DY_EffVBFSMe2", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFSHi = new TH1D("hZ_DY_EffVBFSHi", "", 1, 0., 1.);
//TH1D* hZ_DY_EffVBFS_DPhi = new TH1D("hZ_DY_EffVBFS_DPhi", "", 4, dphiEdges);
//hZ_DY_EffVBFS->Add(hZ_DY_EffVBFS_N);
//hZ_DY_EffVBFS->Divide(hZ_DY_EffVBFS_D);
hZ_DY_EffVBFSLo->Add(hZ_DY_EffVBFS_NLo);
hZ_DY_EffVBFSLo->Divide(hZ_DY_EffVBFS_D);
hZ_DY_EffVBFSMe1->Add(hZ_DY_EffVBFS_NMe1);
hZ_DY_EffVBFSMe1->Divide(hZ_DY_EffVBFS_D);
hZ_DY_EffVBFSMe2->Add(hZ_DY_EffVBFS_NMe2);
hZ_DY_EffVBFSMe2->Divide(hZ_DY_EffVBFS_D);
hZ_DY_EffVBFSHi->Add(hZ_DY_EffVBFS_NHi);
hZ_DY_EffVBFSHi->Divide(hZ_DY_EffVBFS_D);
//for(int ibin = 1; ibin <= hZ_DY_EffVBFS_DPhi->GetNbinsX(); ++ibin) {
// hZ_DY_EffVBFS_DPhi->SetBinContent(ibin,hZ_DY_EffVBFS_NDPhi->GetBinContent(ibin)/hZ_DY_EffVBFS_D->GetBinContent(1));
// hZ_DY_EffVBFS_DPhi->SetBinError(ibin,TMath::Sqrt(pow(hZ_DY_EffVBFS_NDPhi->GetBinError(ibin)/hZ_DY_EffVBFS_NDPhi->GetBinContent(ibin),2) + pow(hZ_DY_EffVBFS_D->GetBinError(1)/hZ_DY_EffVBFS_D->GetBinContent(1),2)));
//}
//TH1D* hZ_DY_EffVBFC = new TH1D("hZ_DY_EffVBFC", "", 1, 0., 1.); // epsilon_c_vbf
TH1D* hZ_DY_EffVBFCLo = new TH1D("hZ_DY_EffVBFCLo", "", 1, 0., 1.); // epsilon_c_vbf
TH1D* hZ_DY_EffVBFCMe1 = new TH1D("hZ_DY_EffVBFCMe1", "", 1, 0., 1.); // epsilon_c_vbf
TH1D* hZ_DY_EffVBFCMe2 = new TH1D("hZ_DY_EffVBFCMe2", "", 1, 0., 1.); // epsilon_c_vbf
TH1D* hZ_DY_EffVBFCHi = new TH1D("hZ_DY_EffVBFCHi", "", 1, 0., 1.); // epsilon_c_vbf
//TH1D* hZ_DY_EffVBFC_DPhi = new TH1D("hZ_DY_EffVBFC_DPhi", "", 4, dphiEdges);
//hZ_DY_EffVBFC->Add(hZ_DY_EffVBFC_N);
//hZ_DY_EffVBFC->Divide(hZ_DY_EffVBFC_D);
hZ_DY_EffVBFCLo->Add(hZ_DY_EffVBFC_NLo);
hZ_DY_EffVBFCLo->Divide(hZ_DY_EffVBFC_D);
hZ_DY_EffVBFCMe1->Add(hZ_DY_EffVBFC_NMe1);
hZ_DY_EffVBFCMe1->Divide(hZ_DY_EffVBFC_D);
hZ_DY_EffVBFCMe2->Add(hZ_DY_EffVBFC_NMe2);
hZ_DY_EffVBFCMe2->Divide(hZ_DY_EffVBFC_D);
hZ_DY_EffVBFCHi->Add(hZ_DY_EffVBFC_NHi);
hZ_DY_EffVBFCHi->Divide(hZ_DY_EffVBFC_D);
//for(int ibin = 1; ibin <= hZ_DY_EffVBFC_DPhi->GetNbinsX(); ++ibin) {
// hZ_DY_EffVBFC_DPhi->SetBinContent(ibin,hZ_DY_EffVBFC_NDPhi->GetBinContent(ibin)/hZ_DY_EffVBFC_D->GetBinContent(1));
// hZ_DY_EffVBFC_DPhi->SetBinError (ibin,TMath::Sqrt(pow(hZ_DY_EffVBFC_NDPhi->GetBinError(ibin)/hZ_DY_EffVBFC_NDPhi->GetBinContent(ibin),2) + pow(hZ_DY_EffVBFC_D->GetBinError(1)/hZ_DY_EffVBFC_D->GetBinContent(1),2)));
//}
//TH1D* hZ_DY_RatioVBF = new TH1D("hZ_DY_RatioVBF", "", 1, 0., 1.); // epsilon_s_vbf/epsilon_c_vbf
//TH1D* hZ_DY_RatioVBF_DPhi = new TH1D("hZ_DY_RatioVBF_DPhi", "", 4, dphiEdges);
TH1D* hZ_DY_RatioVBFLo = new TH1D("hZ_DY_RatioVBFLo", "", 1, 0., 1.);
TH1D* hZ_DY_RatioVBFMe1 = new TH1D("hZ_DY_RatioVBFMe1", "", 1, 0., 1.);
TH1D* hZ_DY_RatioVBFMe2 = new TH1D("hZ_DY_RatioVBFMe2", "", 1, 0., 1.);
TH1D* hZ_DY_RatioVBFHi = new TH1D("hZ_DY_RatioVBFHi", "", 1, 0., 1.);
//hZ_DY_RatioVBF->Add(hZ_DY_EffVBFS);
//hZ_DY_RatioVBF->Divide(hZ_DY_EffVBFC);
hZ_DY_RatioVBFLo->Add(hZ_DY_EffVBFSLo);
hZ_DY_RatioVBFLo->Divide(hZ_DY_EffVBFCLo);
hZ_DY_RatioVBFMe1->Add(hZ_DY_EffVBFSMe1);
hZ_DY_RatioVBFMe1->Divide(hZ_DY_EffVBFCMe1);
hZ_DY_RatioVBFMe2->Add(hZ_DY_EffVBFSMe2);
hZ_DY_RatioVBFMe2->Divide(hZ_DY_EffVBFCMe2);
hZ_DY_RatioVBFHi->Add(hZ_DY_EffVBFSHi);
hZ_DY_RatioVBFHi->Divide(hZ_DY_EffVBFCHi);
//hZ_DY_RatioVBF_DPhi->Add(hZ_DY_EffVBFS_DPhi);
//hZ_DY_RatioVBF_DPhi->Divide(hZ_DY_EffVBFC_DPhi);
//TH1D* hZ_DY_TotalEff = new TH1D("hZ_DY_TotalEff", "", 1, 0., 1.);
//TH1D* hZ_DY_TotalEff_DPhi = new TH1D("hZ_DY_TotalEff_DPhi", "", 4, dphiEdges);
TH1D* hZ_DY_TotalEffLo = new TH1D("hZ_DY_TotalEffLo", "", 1, 0., 1.);
TH1D* hZ_DY_TotalEffMe1 = new TH1D("hZ_DY_TotalEffMe1", "", 1, 0., 1.);
TH1D* hZ_DY_TotalEffMe2 = new TH1D("hZ_DY_TotalEffMe2", "", 1, 0., 1.);
TH1D* hZ_DY_TotalEffHi = new TH1D("hZ_DY_TotalEffHi", "", 1, 0., 1.);
hZ_DY_TotalEffLo->Add(hZ_DY_RatioVBFLo);
hZ_DY_TotalEffLo->Divide(hZ_DY_EffMuMu);
hZ_DY_TotalEffMe1->Add(hZ_DY_RatioVBFMe1);
hZ_DY_TotalEffMe1->Divide(hZ_DY_EffMuMu);
hZ_DY_TotalEffMe2->Add(hZ_DY_RatioVBFMe2);
hZ_DY_TotalEffMe2->Divide(hZ_DY_EffMuMu);
hZ_DY_TotalEffHi->Add(hZ_DY_RatioVBFHi);
hZ_DY_TotalEffHi->Divide(hZ_DY_EffMuMu);
//hZ_Eff_S_noDPhi->Add(hZ_DY_RatioVBF);
//hZ_Eff_S_noDPhi->Divide(hZ_DY_EffMuMu);
hZ_Eff_S_DPhi->SetBinContent(1,hZ_DY_TotalEffLo->GetBinContent(1));
hZ_Eff_S_DPhi->SetBinError(1,hZ_DY_TotalEffLo->GetBinError(1));
hZ_Eff_S_DPhi->SetBinContent(2,hZ_DY_TotalEffMe1->GetBinContent(1));
hZ_Eff_S_DPhi->SetBinError(2,hZ_DY_TotalEffMe1->GetBinError(1));
hZ_Eff_S_DPhi->SetBinContent(3,hZ_DY_TotalEffMe2->GetBinContent(1));
hZ_Eff_S_DPhi->SetBinError(3,hZ_DY_TotalEffMe2->GetBinError(1));
hZ_Eff_S_DPhi->SetBinContent(4,hZ_DY_TotalEffHi->GetBinContent(1));
hZ_Eff_S_DPhi->SetBinError(4,hZ_DY_TotalEffHi->GetBinError(1));
//for(int ibin = 1; ibin <= hZ_Eff_S_DPhi->GetNbinsX(); ++ibin) {
// hZ_Eff_S_DPhi->SetBinContent(ibin,hZ_DY_RatioVBF_DPhi->GetBinContent(ibin)/hZ_DY_EffMuMu->GetBinContent(1));
// hZ_Eff_S_DPhi->SetBinError (ibin,TMath::Sqrt(pow(hZ_DY_RatioVBF_DPhi->GetBinError(ibin)/hZ_DY_RatioVBF_DPhi->GetBinContent(ibin),2) + pow(hZ_DY_EffMuMu->GetBinError(1)/hZ_DY_EffMuMu->GetBinContent(1),2)));
//}
// no dPhi
//hZ_Est_C_noDPhi->Add(hZ_Data_C_noDPhi, hZ_BG_C_noDPhi, 1., -1.);
//hZ_Est_S_noDPhi->Add(hZ_Est_C_noDPhi,ratioBF);
//hZ_Est_S_noDPhi->Multiply(hZ_Eff_S_noDPhi);
// bin dPhi
hZ_Est_C_DPhi->Add(hZ_Data_C_DPhi, hZ_BG_C_DPhi, 1., -1.);
hZ_Est_S_DPhi->Add(hZ_Est_C_DPhi,ratioBF);
hZ_Est_S_DPhi->Multiply(hZ_Eff_S_DPhi);
// print out
std::cout << std::endl;
std::cout << "##################################### Z BG from Zmumu in bins of dPhijj #####################################" << std::endl;
//std::cout << "no dphi cut" << std::endl;
//std::cout << std::endl;
std::cout << " eps_mumu by histogram : " << hZ_DY_EffMuMu->GetBinContent(1) << " +/- " << hZ_DY_EffMuMu->GetBinError(1) << std::endl;
//std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFS->GetBinContent(1) << " +/- " << hZ_DY_EffVBFS->GetBinError(1) << std::endl;
//std::cout << " eps_c_vbf by histogram : " << hZ_DY_EffVBFC->GetBinContent(1) << " +/- " << hZ_DY_EffVBFC->GetBinError(1) << std::endl;
//std::cout << " ratio_vbf by histogram : " << hZ_DY_RatioVBF->GetBinContent(1) << " +/- " << hZ_DY_RatioVBF->GetBinError(1) << std::endl;
//std::cout << " total eff by histogram : " << hZ_Eff_S_noDPhi->GetBinContent(1) << " +/- " << hZ_Eff_S_noDPhi->GetBinError(1) << std::endl;
//std::cout << std::endl;
//std::cout << " DY+jets MC ctrl region : " << hZ_DY_C_noDPhi->GetBinContent(1) << " +/- " << hZ_DY_C_noDPhi->GetBinError(1) << std::endl;
//std::cout << " Background ctrl region : " << hZ_BG_C_noDPhi->GetBinContent(1) << " +/- " << hZ_BG_C_noDPhi->GetBinError(1) << std::endl;
//std::cout << " Data ctrl region : " << hZ_Data_C_noDPhi->GetBinContent(1) << " +/- " << hZ_Data_C_noDPhi->GetBinError(1) << std::endl;
//std::cout << std::endl;
//std::cout << " Z in ctrl region : " << hZ_Est_C_noDPhi->GetBinContent(1) << " +/- " << hZ_Est_C_noDPhi->GetBinError(1) << std::endl;
//std::cout << " Z in sgnl region : " << hZ_Est_S_noDPhi->GetBinContent(1) << " +/- " << hZ_Est_S_noDPhi->GetBinError(1) << std::endl;
//"(stat.) + " << 0.0169 * hZ_Est_S_DPhi->GetBinContent(1) << ", - " << 0.0311 * hZ_Est_S_DPhi->GetBinContent(1) << "(syst.)" << std::endl;
std::cout << std::endl;
std::cout << "dphi < 1.0" << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFSLo->GetBinContent(1) << " +/- " << hZ_DY_EffVBFSLo->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf by histogram : " << hZ_DY_EffVBFCLo->GetBinContent(1) << " +/- " << hZ_DY_EffVBFCLo->GetBinError(1) << std::endl;
std::cout << " ratio_vbf by histogram : " << hZ_DY_RatioVBFLo->GetBinContent(1) << " +/- " << hZ_DY_RatioVBFLo->GetBinError(1) << std::endl;
std::cout << " total eff by histogram : " << hZ_Eff_S_DPhi->GetBinContent(1) << " +/- " << hZ_Eff_S_DPhi->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " DY+jets MC ctrl region : " << hZ_DY_C_DPhi->GetBinContent(1) << " +/- " << hZ_DY_C_DPhi->GetBinError(1) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_C_DPhi->GetBinContent(1) << " +/- " << hZ_BG_C_DPhi->GetBinError(1) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_C_DPhi->GetBinContent(1) << " +/- " << hZ_Data_C_DPhi->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " Z in ctrl region : " << hZ_Est_C_DPhi->GetBinContent(1) << " +/- " << hZ_Est_C_DPhi->GetBinError(1) << std::endl;
std::cout << " Z in sgnl region : " << hZ_Est_S_DPhi->GetBinContent(1) << " +/- " << hZ_Est_S_DPhi->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << "dphi > 1.0 dphi < 1.8" << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFSMe1->GetBinContent(1) << " +/- " << hZ_DY_EffVBFSMe1->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf by histogram : " << hZ_DY_EffVBFCMe1->GetBinContent(1) << " +/- " << hZ_DY_EffVBFCMe1->GetBinError(1) << std::endl;
std::cout << " ratio_vbf by histogram : " << hZ_DY_RatioVBFMe1->GetBinContent(1) << " +/- " << hZ_DY_RatioVBFMe1->GetBinError(1) << std::endl;
std::cout << " total eff by histogram : " << hZ_Eff_S_DPhi->GetBinContent(2) << " +/- " << hZ_Eff_S_DPhi->GetBinError(2) << std::endl;
std::cout << std::endl;
std::cout << " DY+jets MC ctrl region : " << hZ_DY_C_DPhi->GetBinContent(2) << " +/- " << hZ_DY_C_DPhi->GetBinError(2) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_C_DPhi->GetBinContent(2) << " +/- " << hZ_BG_C_DPhi->GetBinError(2) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_C_DPhi->GetBinContent(2) << " +/- " << hZ_Data_C_DPhi->GetBinError(2) << std::endl;
std::cout << std::endl;
std::cout << " Z in ctrl region : " << hZ_Est_C_DPhi->GetBinContent(2) << " +/- " << hZ_Est_C_DPhi->GetBinError(2) << std::endl;
std::cout << " Z in sgnl region : " << hZ_Est_S_DPhi->GetBinContent(2) << " +/- " << hZ_Est_S_DPhi->GetBinError(2) << std::endl;
std::cout << std::endl;
std::cout << "dphi > 1.8 dphi < 2.6" << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFSMe2->GetBinContent(1) << " +/- " << hZ_DY_EffVBFSMe2->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf by histogram : " << hZ_DY_EffVBFCMe2->GetBinContent(1) << " +/- " << hZ_DY_EffVBFCMe2->GetBinError(1) << std::endl;
std::cout << " ratio_vbf by histogram : " << hZ_DY_RatioVBFMe2->GetBinContent(1) << " +/- " << hZ_DY_RatioVBFMe2->GetBinError(1) << std::endl;
std::cout << " total eff by histogram : " << hZ_Eff_S_DPhi->GetBinContent(3) << " +/- " << hZ_Eff_S_DPhi->GetBinError(3) << std::endl;
std::cout << std::endl;
std::cout << " DY+jets MC ctrl region : " << hZ_DY_C_DPhi->GetBinContent(3) << " +/- " << hZ_DY_C_DPhi->GetBinError(3) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_C_DPhi->GetBinContent(3) << " +/- " << hZ_BG_C_DPhi->GetBinError(3) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_C_DPhi->GetBinContent(3) << " +/- " << hZ_Data_C_DPhi->GetBinError(3) << std::endl;
std::cout << std::endl;
std::cout << " Z in ctrl region : " << hZ_Est_C_DPhi->GetBinContent(3) << " +/- " << hZ_Est_C_DPhi->GetBinError(3) << std::endl;
std::cout << " Z in sgnl region : " << hZ_Est_S_DPhi->GetBinContent(3) << " +/- " << hZ_Est_S_DPhi->GetBinError(3) << std::endl;
std::cout << std::endl;
std::cout << "dphi > 2.6" << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFSHi->GetBinContent(1) << " +/- " << hZ_DY_EffVBFSHi->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf by histogram : " << hZ_DY_EffVBFCHi->GetBinContent(1) << " +/- " << hZ_DY_EffVBFCHi->GetBinError(1) << std::endl;
std::cout << " ratio_vbf by histogram : " << hZ_DY_RatioVBFHi->GetBinContent(1) << " +/- " << hZ_DY_RatioVBFHi->GetBinError(1) << std::endl;
std::cout << " total eff by histogram : " << hZ_Eff_S_DPhi->GetBinContent(4) << " +/- " << hZ_Eff_S_DPhi->GetBinError(4) << std::endl;
std::cout << std::endl;
std::cout << " DY+jets MC ctrl region : " << hZ_DY_C_DPhi->GetBinContent(4) << " +/- " << hZ_DY_C_DPhi->GetBinError(4) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_C_DPhi->GetBinContent(4) << " +/- " << hZ_BG_C_DPhi->GetBinError(4) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_C_DPhi->GetBinContent(4) << " +/- " << hZ_Data_C_DPhi->GetBinError(4) << std::endl;
std::cout << std::endl;
std::cout << " Z in ctrl region : " << hZ_Est_C_DPhi->GetBinContent(4) << " +/- " << hZ_Est_C_DPhi->GetBinError(4) << std::endl;
std::cout << " Z in sgnl region : " << hZ_Est_S_DPhi->GetBinContent(4) << " +/- " << hZ_Est_S_DPhi->GetBinError(4) << std::endl;
std::cout << std::endl;
std::cout << "#####################################################################################" << std::endl;
std::cout << std::endl << std::endl;
/*
// write the cutflow table
std::cout << "Writing cut flow TeX file" << std::endl;
ofstream effFile;
effFile.open(options.oDir+std::string("/cutflowZMuMu.tex"));
effFile << "Cut & N(data) & N(DY\\rightarrow\\ell\\ell) & N($t\\bar{t}$) & N(single $t$) & N(diboson) \\\\" << std::endl;
TH1D* hZ_CutFlow_TTBar = (TH1D*) ofile->Get("hZ_CutFlow_TTBar");
// cutflow table
for (unsigned i=0; i<nCutsZMuMu; ++i) {
effFile << cuts.cutNameZMuMu(i) << " & ";
effFile << "$" << hZ_CutFlow_Data->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_Data->GetBinError(i+1) << "$ & ";
effFile << "$" << hZ_CutFlow_DY->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_DY->GetBinError(i+1) << "$ & ";
effFile << "$" << hZ_CutFlow_TTBar->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_TTBar->GetBinError(i+1) << "$ & ";
effFile << "$" << hZ_CutFlow_SingleTSum->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_SingleTSum->GetBinError(i+1) << "$ & ";
effFile << "$" << hZ_CutFlow_Diboson->GetBinContent(i+1) << " \\pm " << hZ_CutFlow_Diboson->GetBinError(i+1) << "$ & ";
effFile << std::endl;
}
effFile << std::endl << std::endl;
effFile.close();
// list histograms for dataset summing
std::vector<std::string> hists;
hists.push_back("ZCtrlZMass");
hists.push_back("ZCtrlZpT");
hists.push_back("ZCtrlJet1pT");
hists.push_back("ZCtrlJet1Eta");
hists.push_back("ZCtrlJet2pT");
hists.push_back("ZCtrlJet2Eta");
hists.push_back("ZCtrlCenJetpT");
hists.push_back("ZCtrlDEtajj");
hists.push_back("ZCtrlMjj");
hists.push_back("ZCtrlMET");
hists.push_back("ZCtrlDPhijj");
// sum DY datasets
std::vector<std::string> DYDatasets;
DYDatasets.push_back(std::string("DYJetsToLL_NoTrig"));
DYDatasets.push_back(std::string("DYJetsToLL_PtZ-100_NoTrig"));
DYDatasets.push_back(std::string("DYJetsToLL_EWK_NoTrig"));
SumDatasets(oDir_Plot, DYDatasets, hists, "DYJets");
// sum single top datasets
std::vector<std::string> topDatasets;
topDatasets.push_back(std::string("SingleT_t"));
topDatasets.push_back(std::string("SingleTbar_t"));
topDatasets.push_back(std::string("SingleT_s"));
topDatasets.push_back(std::string("SingleTbar_s"));
topDatasets.push_back(std::string("SingleT_tW"));
topDatasets.push_back(std::string("SingleTbar_tW"));
topDatasets.push_back(std::string("TTBar"));
SumDatasets(oDir_Plot, topDatasets, hists, "SingleT+TTbar");
// sum single top datasets
std::vector<std::string> dibDatasets;
dibDatasets.push_back(std::string("WW"));
dibDatasets.push_back(std::string("WZ"));
dibDatasets.push_back(std::string("ZZ"));
SumDatasets(oDir_Plot, dibDatasets, hists, "DiBoson");
// make plots
std::cout << "Making plots" << std::endl;
StackPlot plots(oDir_Plot);
plots.setLegPos(0.62,0.62,0.89,0.89);
plots.addDataset("DiBoson", kViolet-6, 0);
plots.addDataset("SingleT+TTbar", kAzure-2, 0);
plots.addDataset("DYJets", kPink-4,0);
plots.addDataset("METABCD", kBlack, 1);
plots.draw("ZCtrlZpT", "Z_p_{T} [GeV]", "N_{events}" ,1,1);
plots.draw("ZCtrlJet1pT", "Leading jet p_{T} [GeV]", "N_{events}" ,1,1);
plots.draw("ZCtrlJet1Eta", "Leading jet #eta", "N_{events}" ,1,1);
plots.draw("ZCtrlJet2pT", "Sub-leading jet p_{T} [GeV]", "N_{events}" ,1,1);
plots.draw("ZCtrlJet2Eta", "Sub-leading jet #eta", "N_{events}" ,1,1);
plots.draw("ZCtrlCenJetpT", "Central jet p_{T} [GeV]", "N_{events}" ,1,1);
plots.draw("ZCtrlDEtajj", "#Delta #eta_{jj}", "N_{events}" ,1,1);
plots.draw("ZCtrlMjj", "M_{jj} [GeV]", "N_{events}" ,1,1);
plots.draw("ZCtrlMET", "E_{T}^{miss} [GeV]", "N_{events}" ,1,1);
plots.draw("ZCtrlDPhijj", "#Delta #phi_{jj}", "N_{events}" ,1,1);
plots.setYMax(90.);
plots.setYMin(0.);
plots.draw("ZCtrlZMass", "M_{#mu#mu} [GeV/c^{2}]", "N_{events}" ,0,1);
*/
//store histograms
ofile->cd();
//hZ_DY_C_noDPhi->Write("",TObject::kOverwrite);
//hZ_BG_C_noDPhi->Write("",TObject::kOverwrite);
//hZ_Data_C_noDPhi->Write("",TObject::kOverwrite);
//hZ_Est_C_noDPhi->Write("",TObject::kOverwrite);
//hZ_Est_S_noDPhi->Write("",TObject::kOverwrite);
//hZ_Eff_S_noDPhi->Write("",TObject::kOverwrite);
hZ_DY_C_DPhi->Write("",TObject::kOverwrite);
hZ_BG_C_DPhi->Write("",TObject::kOverwrite);
hZ_Data_C_DPhi->Write("",TObject::kOverwrite);
hZ_Est_C_DPhi->Write("",TObject::kOverwrite);
hZ_Est_S_DPhi->Write("",TObject::kOverwrite);
hZ_Eff_S_DPhi->Write("",TObject::kOverwrite);
hZ_DY_EffMuMu_D->Write("",TObject::kOverwrite);
hZ_DY_EffMuMu_N->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_D->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_NLo->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_NMe1->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_NMe2->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_NHi->Write("",TObject::kOverwrite);
//hZ_DY_EffVBFS_N->Write("",TObject::kOverwrite);
//hZ_DY_EffVBFS_NDPhi->Write("",TObject::kOverwrite);
hZ_DY_EffVBFC_D->Write("",TObject::kOverwrite);
hZ_DY_EffVBFC_NLo->Write("",TObject::kOverwrite);
hZ_DY_EffVBFC_NMe1->Write("",TObject::kOverwrite);
hZ_DY_EffVBFC_NMe2->Write("",TObject::kOverwrite);
hZ_DY_EffVBFC_NHi->Write("",TObject::kOverwrite);
//hZ_DY_EffVBFC_N->Write("",TObject::kOverwrite);
//hZ_DY_EffVBFC_NDPhi->Write("",TObject::kOverwrite);
hZ_DY_EffMuMu->Write("",TObject::kOverwrite);
hZ_DY_EffVBFSLo->Write("",TObject::kOverwrite);
hZ_DY_EffVBFSMe1->Write("",TObject::kOverwrite);
hZ_DY_EffVBFSMe2->Write("",TObject::kOverwrite);
hZ_DY_EffVBFSHi->Write("",TObject::kOverwrite);
hZ_DY_EffVBFCLo->Write("",TObject::kOverwrite);
hZ_DY_EffVBFCMe1->Write("",TObject::kOverwrite);
hZ_DY_EffVBFCMe2->Write("",TObject::kOverwrite);
hZ_DY_EffVBFCHi->Write("",TObject::kOverwrite);
hZ_DY_RatioVBFLo->Write("",TObject::kOverwrite);
hZ_DY_RatioVBFMe1->Write("",TObject::kOverwrite);
hZ_DY_RatioVBFMe2->Write("",TObject::kOverwrite);
hZ_DY_RatioVBFHi->Write("",TObject::kOverwrite);
//hZ_DY_EffVBFS_DPhi->Write("",TObject::kOverwrite);
//hZ_DY_EffVBFC_DPhi->Write("",TObject::kOverwrite);
//hZ_DY_RatioVBF_DPhi->Write("",TObject::kOverwrite);
//hZ_DY_TotalEff->Write("",TObject::kOverwrite);
//hZ_CutFlow_Data->Write("",TObject::kOverwrite);
//hZ_CutFlow_DY->Write("",TObject::kOverwrite);
//hZ_CutFlow_SingleTSum->Write("",TObject::kOverwrite);
//hZ_CutFlow_Diboson->Write("",TObject::kOverwrite);
ofile->Close();
}
int main(int argc, char* argv[]) {
TH1::SetDefaultSumw2();
ProgramOptions options(argc, argv);
double lumi = options.lumi;
// input datasets
Datasets datasets(options.iDir);
datasets.readFile(options.datasetFile);
// output file
TFile* ofile = TFile::Open( (options.oDir+std::string("/ZMuMufromW.root")).c_str(), "RECREATE");
std::string oDir = options.oDir + std::string("/ZmumuFromW");
if (oDir!="") {
boost::filesystem::path opath(oDir);
if (!exists(opath)) {
std::cout << "Creating output directory : " << oDir << std::endl;
boost::filesystem::create_directory(opath);
}
std::cout << "Writing results to " << oDir << std::endl;
}
// cuts
Cuts cuts;
unsigned nCutsZMuMu = cuts.nCutsZMuMu();
TCut puWeight("puWeight");
TCut trigCorr( "(trigCorrWeight>0) ? trigCorrWeight : 1." );
// For lepton weights
TCut muTightWeight = cuts.muTightWeight(options.leptCorr);
TCut lVetoWeight = cuts.elVetoWeight(options.leptCorr) * cuts.muVetoWeight(options.leptCorr);
TCut METNo2Muon130("metNo2Muon>130.");
TCut cutLoDPhi = cuts.cut("dPhiJJ");
TCut cutHiDPhi("vbfDPhi>2.6");
TCut cutMe1DPhi("vbfDPhi>1.0 && vbfDPhi<=1.8");
TCut cutMe2DPhi("vbfDPhi>1.8 && vbfDPhi<=2.6");
// histograms
double dphiEdges[5] = { 0., 1.0, 1.8, 2.6, TMath::Pi() };
// Observed signal MET>130
TH1D* hZ_DY_C_DPhi = new TH1D("hZ_DY_C_DPhi", "", 4, dphiEdges); // Z+jets MC ctrl region
TH1D* hZ_BG_ZC_DPhi = new TH1D("hZ_BG_ZC_DPhi", "", 4, dphiEdges); // background MC ctrl region
TH1D* hZ_Data_ZC_DPhi = new TH1D("hZ_Data_ZC_DPhi", "", 4, dphiEdges); // Data ctrl region
// Predicted from Wmunu
TH1D* hZ_W_C_DPhi = new TH1D("hZ_W_C_DPhi", "", 4, dphiEdges); // W+jets MC ctrl region
TH1D* hZ_BG_WC_DPhi = new TH1D("hZ_BG_WC_DPhi", "", 4, dphiEdges); // background MC ctrl region
TH1D* hZ_Data_WC_DPhi = new TH1D("hZ_Data_WC_DPhi", "", 4, dphiEdges); // Data W ctrl region
TH1D* hZ_W_EffMu_D = new TH1D("hZ_W_EffMu_D", "", 1, 0., 1.); // denominator of MuMu efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
TH1D* hZ_W_EffMu_N = new TH1D("hZ_W_EffMu_N", "", 1, 0., 1.); // numerator of MuMu efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
TH1D* hZ_DY_EffMuMu_D = new TH1D("hZ_DY_EffMuMu_D", "", 1, 0., 1.); // denominator of MuMu efficiency from DY + DY_EWK samples
TH1D* hZ_DY_EffMuMu_N = new TH1D("hZ_DY_EffMuMu_N", "", 1, 0., 1.); // numerator of MuMu efficiency from DY + DY_EWK samples
TH1D* hZ_DY_EffVBFS_D = new TH1D("hZ_DY_EffVBFS_D", "", 1, 0., 1.); // denominator of VBF(S) efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
//TH1D* hZ_DY_EffVBFS_N = new TH1D("hZ_DY_EffVBFS_N", "", 1, 0., 1.); // numerator of VBF(S) efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
TH1D* hZ_DY_EffVBFS_NLo = new TH1D("hZ_DY_EffVBFS_NLo", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFS_NHi = new TH1D("hZ_DY_EffVBFS_NHi", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFS_NMe1 = new TH1D("hZ_DY_EffVBFS_NMe1", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFS_NMe2 = new TH1D("hZ_DY_EffVBFS_NMe2", "", 1, 0., 1.);
TH1D* hZ_W_EffVBFC_D = new TH1D("hZ_W_EffVBFC_D", "", 1, 0., 1.); // denominator of VBF(C) efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
//TH1D* hZ_W_EffVBFC_N = new TH1D("hZ_W_EffVBFC_N", "", 1, 0., 1.); // numerator of VBF(C) efficiency from DY(pT<100) + DY(pT>100) + DY_EWK samples
TH1D* hZ_W_EffVBFC_NLo = new TH1D("hZ_W_EffVBFC_NLo", "", 1, 0., 1.);
TH1D* hZ_W_EffVBFC_NHi = new TH1D("hZ_W_EffVBFC_NHi", "", 1, 0., 1.);
TH1D* hZ_W_EffVBFC_NMe1 = new TH1D("hZ_W_EffVBFC_NMe1", "", 1, 0., 1.);
TH1D* hZ_W_EffVBFC_NMe2 = new TH1D("hZ_W_EffVBFC_NMe2", "", 1, 0., 1.);
// loop over MC datasets
for (unsigned i=0; i<datasets.size(); ++i) {
Dataset dataset = datasets.getDataset(i);
TCut cutD = cuts.cutDataset(dataset.name);
TCut wWeight("");
// bit of a fudge for mutight weight - data doesn't have the var in it, so need to add an exception (see below)
// and then restore it for all other MC
muTightWeight=cuts.muTightWeight(options.leptCorr);
// check if it's DYJets
bool isDY = false;
bool isWJets = false;
bool isQCD = false;
bool isEwkW = false;
if (dataset.name.compare(0,2,"DY")==0) {
isDY = true;
std::cout << "Analysing DY->ll MC : " << dataset.name << std::endl;
}
else if (dataset.name == "WJets" ||
dataset.name == "W1Jets" ||
dataset.name == "W2Jets" ||
dataset.name == "W3Jets" ||
dataset.name == "W4Jets" ||
dataset.name == "EWK_Wp2Jets" ||
dataset.name == "EWK_Wm2Jets") {
if (dataset.name == "EWK_Wp2Jets" || dataset.name == "EWK_Wm2Jets") isEwkW = true;
else isWJets = true;
if(isWJets) wWeight = cuts.wWeight();
std::cout << "Analysing W MC : " << dataset.name << std::endl;
}
else if (dataset.name.compare(0,3,"QCD")==0) {
isQCD = true;
std::cout << "Analysing QCD : " << dataset.name << std::endl;
}
else if (dataset.isData) {
muTightWeight="";
std::cout << "Analysing Data : " << dataset.name << std::endl;
}
else {
std::cout << "Analysing BG MC : " << dataset.name << std::endl;
}
// get file & tree
TFile* file = datasets.getTFile(dataset.name);
TTree* tree = (TTree*) file->Get("invHiggsInfo/InvHiggsInfo");
// set up cuts
TCut otherCuts = puWeight * trigCorr * wWeight;
TCut cutZMuMu_C = otherCuts * muTightWeight * (cutD + cuts.zMuMuVBF() + METNo2Muon130);
TCut cutWMuNu_C = otherCuts * muTightWeight * (cutD + cuts.wMuVBF() + cuts.cutWMu("MET"));
// eps_mu from W trigger samples
TCut cutEfficiencyMu_D = otherCuts * (cutD + cuts.HLTandMETFilters() + cuts.wMuGen());
TCut cutEfficiencyMu_N = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.wMuGen() + cuts.cutWMu("wMu"));
TCut cutEfficiencyMuMu_D = otherCuts * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen());
TCut cutEfficiencyMuMu_N = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco());
// eps_VBFS from DY-Trig
TCut cutEfficiencyVBFS_D = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco());
//TCut cutEfficiencyVBFS_N = otherCuts * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130);
TCut cutEfficiencyVBFS_NLoDPhi = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutLoDPhi);
TCut cutEfficiencyVBFS_NHiDPhi = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutHiDPhi);
TCut cutEfficiencyVBFS_NMe1DPhi = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutMe1DPhi);
TCut cutEfficiencyVBFS_NMe2DPhi = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.zMuMuGen() + cuts.zMuMuReco() + cuts.vbf() + METNo2Muon130 + cutMe2DPhi);
// eps_VBFC from W
TCut cutEfficiencyVBFC_D = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.wMuGen() + cuts.cutWMu("wMu"));
//TCut cutEfficiencyVBFC_N = otherCuts * (cutD + cuts.HLTandMETFilters() + cuts.wMuGen() + cuts.cutWMu("wMu") + cuts.vbf() + cuts.cutWMu("MET"));
TCut cutEfficiencyVBFC_NLoDPhi = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.wMuGen() + cuts.cutWMu("wMu") + cuts.vbf() + cuts.cutWMu("MET") + cutLoDPhi);
TCut cutEfficiencyVBFC_NHiDPhi = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.wMuGen() + cuts.cutWMu("wMu") + cuts.vbf() + cuts.cutWMu("MET") + cutHiDPhi);
TCut cutEfficiencyVBFC_NMe1DPhi = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.wMuGen() + cuts.cutWMu("wMu") + cuts.vbf() + cuts.cutWMu("MET") + cutMe1DPhi);
TCut cutEfficiencyVBFC_NMe2DPhi = otherCuts * muTightWeight * (cutD + cuts.HLTandMETFilters() + cuts.wMuGen() + cuts.cutWMu("wMu") + cuts.vbf() + cuts.cutWMu("MET") + cutMe2DPhi);
// fill tmp histograms for BG estimation
//observed
//TH1D* hZ_ZC_noDPhi = new TH1D("hZ_ZC_noDPhi", "", 1, 0., 1.);
TH1D* hZ_ZC_DPhi = new TH1D("hZ_ZC_DPhi", "", 4, dphiEdges);
//predicted
//TH1D* hZ_WC_noDPhi = new TH1D("hZ_WC_noDPhi", "", 1, 0., 1.);
TH1D* hZ_WC_DPhi = new TH1D("hZ_WC_DPhi", "", 4, dphiEdges); // this is for the actual BG estimation
// fill tmp histograms for efficiency calculation
TH1D* hZ_EffMuMu_D = new TH1D("hZ_EffMuMu_D", "", 1, 0., 1.);
TH1D* hZ_EffMuMu_N = new TH1D("hZ_EffMuMu_N", "", 1, 0., 1.);
TH1D* hZ_EffMu_D = new TH1D("hZ_EffMu_D", "", 1, 0., 1.);
TH1D* hZ_EffMu_N = new TH1D("hZ_EffMu_N", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_D = new TH1D("hZ_EffVBFS_D", "", 1, 0., 1.);
//TH1D* hZ_EffVBFS_N = new TH1D("hZ_EffVBFS_N", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_NLo = new TH1D("hZ_EffVBFS_NLo", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_NHi = new TH1D("hZ_EffVBFS_NHi", "", 1, 0., 1.);
TH1D* hZ_EffVBFS_NMe1 = new TH1D("hZ_EffVBFS_NMe1","", 1, 0., 1.);
TH1D* hZ_EffVBFS_NMe2 = new TH1D("hZ_EffVBFS_NMe2","", 1, 0., 1.);
TH1D* hZ_EffVBFC_D = new TH1D("hZ_EffVBFC_D", "", 1, 0., 1.);
//TH1D* hZ_EffVBFC_N = new TH1D("hZ_EffVBFC_N", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_NLo = new TH1D("hZ_EffVBFC_NLo", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_NHi = new TH1D("hZ_EffVBFC_NHi", "", 1, 0., 1.);
TH1D* hZ_EffVBFC_NMe1 = new TH1D("hZ_EffVBFC_NMe1","", 1, 0., 1.);
TH1D* hZ_EffVBFC_NMe2 = new TH1D("hZ_EffVBFC_NMe2","", 1, 0., 1.);
// W control region DY is BG
if (isDY) {
//tree->Draw("0.5>>hZ_ZC_noDPhi", cutZMuMu_C);
tree->Draw("vbfDPhi>>hZ_ZC_DPhi", cutZMuMu_C);
//tree->Draw("0.5>>hZ_WC_noDPhi", cutWMuNu_C);
tree->Draw("vbfDPhi>>hZ_WC_DPhi", cutWMuNu_C);
tree->Draw("0.5>>hZ_EffMuMu_D", cutEfficiencyMuMu_D);
tree->Draw("0.5>>hZ_EffMuMu_N", cutEfficiencyMuMu_N);
tree->Draw("0.5>>hZ_EffVBFS_D", cutEfficiencyVBFS_D);
//tree->Draw("0.5>>hZ_EffVBFS_N", cutEfficiencyVBFS_N);
tree->Draw("0.5>>hZ_EffVBFS_NLo", cutEfficiencyVBFS_NLoDPhi);
tree->Draw("0.5>>hZ_EffVBFS_NHi", cutEfficiencyVBFS_NHiDPhi);
tree->Draw("0.5>>hZ_EffVBFS_NMe1", cutEfficiencyVBFS_NMe1DPhi);
tree->Draw("0.5>>hZ_EffVBFS_NMe2", cutEfficiencyVBFS_NMe2DPhi);
}
else if(isWJets || isEwkW) {
//tree->Draw("0.5>>hZ_WC_noDPhi", cutWMuNu_C);
tree->Draw("vbfDPhi>>hZ_WC_DPhi", cutWMuNu_C);
tree->Draw("0.5>>hZ_EffMu_D", cutEfficiencyMu_D);
tree->Draw("0.5>>hZ_EffMu_N", cutEfficiencyMu_N);
tree->Draw("0.5>>hZ_EffVBFC_D", cutEfficiencyVBFC_D);
//tree->Draw("0.5>>hZ_EffVBFC_N", cutEfficiencyVBFC_N);
tree->Draw("0.5>>hZ_EffVBFC_NLo", cutEfficiencyVBFC_NLoDPhi);
tree->Draw("0.5>>hZ_EffVBFC_NHi", cutEfficiencyVBFC_NHiDPhi);
tree->Draw("0.5>>hZ_EffVBFC_NMe1", cutEfficiencyVBFC_NMe1DPhi);
tree->Draw("0.5>>hZ_EffVBFC_NMe2", cutEfficiencyVBFC_NMe2DPhi);
}
else if(isQCD) {
//tree->Draw("0.5>>hZ_C_noDPhi", cutWMuNu_C);
tree->Draw("vbfDPhi>>hZ_WC_DPhi", cutWMuNu_C);
}
else {
tree->Draw("vbfDPhi>>hZ_ZC_DPhi", cutZMuMu_C);
tree->Draw("vbfDPhi>>hZ_WC_DPhi", cutWMuNu_C);
}
// weight to lumi
double weight = (dataset.isData) ? 1. : lumi * dataset.sigma / dataset.nEvents;
hZ_ZC_DPhi->Scale(weight);
hZ_WC_DPhi->Scale(weight);
hZ_EffVBFS_D->Scale(weight);
//hZ_EffVBFS_N->Scale(weight);
hZ_EffVBFS_NLo->Scale(weight);
hZ_EffVBFS_NHi->Scale(weight);
hZ_EffVBFS_NMe1->Scale(weight);
hZ_EffVBFS_NMe2->Scale(weight);
hZ_EffVBFC_D->Scale(weight);
//hZ_EffVBFC_N->Scale(weight);
hZ_EffVBFC_NLo->Scale(weight);
hZ_EffVBFC_NHi->Scale(weight);
hZ_EffVBFC_NMe1->Scale(weight);
hZ_EffVBFC_NMe2->Scale(weight);
hZ_EffMu_D->Scale(weight);
hZ_EffMu_N->Scale(weight);
hZ_EffMuMu_D->Scale(weight);
hZ_EffMuMu_N->Scale(weight);
// add to output histograms
if (dataset.isData) {
hZ_Data_ZC_DPhi->Add(hZ_ZC_DPhi);
hZ_Data_WC_DPhi->Add(hZ_WC_DPhi);
}
else if (isWJets || isEwkW) {
//hZ_W_C_noDPhi->Add(hZ_C_noDPhi);
hZ_W_C_DPhi->Add(hZ_WC_DPhi);
hZ_W_EffMu_D->Add(hZ_EffMu_D);
hZ_W_EffMu_N->Add(hZ_EffMu_N);
hZ_W_EffVBFC_D->Add(hZ_EffVBFC_D);
//hZ_W_EffVBFC_N->Add(hZ_EffVBFC_N);
hZ_W_EffVBFC_NLo->Add(hZ_EffVBFC_NLo);
hZ_W_EffVBFC_NHi->Add(hZ_EffVBFC_NHi);
hZ_W_EffVBFC_NMe1->Add(hZ_EffVBFC_NMe1);
hZ_W_EffVBFC_NMe2->Add(hZ_EffVBFC_NMe2);
}
else if (isDY) {
hZ_DY_C_DPhi->Add(hZ_ZC_DPhi);
hZ_BG_WC_DPhi->Add(hZ_WC_DPhi);
hZ_DY_EffMuMu_D->Add(hZ_EffMuMu_D);
hZ_DY_EffMuMu_N->Add(hZ_EffMuMu_N);
hZ_DY_EffVBFS_D->Add(hZ_EffVBFS_D);
//hZ_DY_EffVBFS_N->Add(hZ_EffVBFS_N);
hZ_DY_EffVBFS_NLo->Add(hZ_EffVBFS_NLo);
hZ_DY_EffVBFS_NHi->Add(hZ_EffVBFS_NHi);
hZ_DY_EffVBFS_NMe1->Add(hZ_EffVBFS_NMe1);
hZ_DY_EffVBFS_NMe2->Add(hZ_EffVBFS_NMe2);
}
else if (isQCD) {
//hZ_BG_WC_DPhi->Add(hZ_WC_DPhi);
}
else {
hZ_BG_WC_DPhi->Add(hZ_WC_DPhi);
hZ_BG_ZC_DPhi->Add(hZ_ZC_DPhi);
}
std::cout << " N_Z ctrl (dphi<1.0) : " << hZ_ZC_DPhi->GetBinContent(1) << " +/- " << hZ_ZC_DPhi->GetBinError(1) << std::endl;
std::cout << " N_W ctrl (dphi<1.0) : " << hZ_WC_DPhi->GetBinContent(1) << " +/- " << hZ_WC_DPhi->GetBinError(1) << std::endl;
delete hZ_WC_DPhi;
delete hZ_ZC_DPhi;
delete hZ_EffMuMu_D;
delete hZ_EffMuMu_N;
delete hZ_EffMu_D;
delete hZ_EffMu_N;
delete hZ_EffVBFS_D;
//delete hZ_EffVBFS_N;
delete hZ_EffVBFS_NLo;
delete hZ_EffVBFS_NMe1;
delete hZ_EffVBFS_NMe2;
delete hZ_EffVBFS_NHi;
delete hZ_EffVBFC_D;
//delete hZ_EffVBFC_N;
delete hZ_EffVBFC_NLo;
delete hZ_EffVBFC_NMe1;
delete hZ_EffVBFC_NMe2;
delete hZ_EffVBFC_NHi;
// clean up
delete tree;
file->Close();
}
// numbers - calculate these from MC in this program later!
//double ratioBF = 5.626; // MCFM + NLO
double ratioBF = 1144./14428.;
TH1D* hZ_Est_ZC_DPhi = new TH1D("hZ_Est_ZC_DPhi", "", 4, dphiEdges);
// bins dPhi
TH1D* hZ_Est_WC_DPhi = new TH1D("hZ_Est_WC_DPhi", "", 4, dphiEdges);
TH1D* hZ_Est_WS_DPhi = new TH1D("hZ_Est_WS_DPhi", "", 4, dphiEdges);
TH1D* hZ_Eff_WS_DPhi = new TH1D("hZ_Eff_WS_DPhi", "", 4, dphiEdges);
TH1D* hZ_W_EffMu = new TH1D("hZ_W_EffMu", "", 1, 0., 1.); // epsilon mumu
hZ_W_EffMu->Add(hZ_W_EffMu_N);
hZ_W_EffMu->Divide(hZ_W_EffMu_D);
//double mu_syst = 0.025*hZ_W_EffMu->GetBinContent(1); //2.5% Muon ID/Iso efficiency uncertainty from EWK-10-002
//hZ_W_EffMu->SetBinError(1,TMath::Sqrt(hZ_W_EffMu->GetBinError(1)*hZ_W_EffMu->GetBinError(1) + mu_syst*mu_syst));
TH1D* hZ_DY_EffMuMu = new TH1D("hZ_DY_EffMuMu", "", 1, 0., 1.); // epsilon mumu
hZ_DY_EffMuMu->Add(hZ_DY_EffMuMu_N);
hZ_DY_EffMuMu->Divide(hZ_DY_EffMuMu_D);
//mu_syst = 0.025*hZ_DY_EffMuMu->GetBinContent(1); //2.5% Muon ID/Iso efficiency uncertainty from EWK-10-002
//hZ_DY_EffMuMu->SetBinError(1,TMath::Sqrt(hZ_DY_EffMuMu->GetBinError(1)*hZ_DY_EffMuMu->GetBinError(1) + mu_syst*mu_syst));
//TH1D* hZ_DY_EffVBFS = new TH1D("hZ_DY_EffVBFS", "", 1, 0., 1.); // epsilon_s_vbf
TH1D* hZ_DY_EffVBFSLo = new TH1D("hZ_DY_EffVBFSLo", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFSHi = new TH1D("hZ_DY_EffVBFSHi", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFSMe1 = new TH1D("hZ_DY_EffVBFSMe1", "", 1, 0., 1.);
TH1D* hZ_DY_EffVBFSMe2 = new TH1D("hZ_DY_EffVBFSMe2", "", 1, 0., 1.);
//TH1D* hZ_W_EffVBFC = new TH1D("hZ_W_EffVBFC", "", 1, 0., 1.); // epsilon_c_vbf
TH1D* hZ_W_EffVBFCLo = new TH1D("hZ_W_EffVBFCLo", "", 1, 0., 1.);
TH1D* hZ_W_EffVBFCHi = new TH1D("hZ_W_EffVBFCHi", "", 1, 0., 1.);
TH1D* hZ_W_EffVBFCMe1 = new TH1D("hZ_W_EffVBFCMe1", "", 1, 0., 1.);
TH1D* hZ_W_EffVBFCMe2 = new TH1D("hZ_W_EffVBFCMe2", "", 1, 0., 1.);
//TH1D* hZ_W_RatioVBF = new TH1D("hZ_W_RatioVBF", "", 1, 0., 1.); // epsilon_s_vbf/epsilon_c_vbf
TH1D* hZ_W_RatioVBFLo = new TH1D("hZ_W_RatioVBFLo", "", 1, 0., 1.);
TH1D* hZ_W_RatioVBFHi = new TH1D("hZ_W_RatioVBFHi", "", 1, 0., 1.);
TH1D* hZ_W_RatioVBFMe1 = new TH1D("hZ_W_RatioVBFMe1", "", 1, 0., 1.);
TH1D* hZ_W_RatioVBFMe2 = new TH1D("hZ_W_RatioVBFMe2", "", 1, 0., 1.);
//TH1D* hZ_W_TotalEff = new TH1D("hZ_W_TotalEff", "", 1, 0., 1.);
TH1D* hZ_W_TotalEffLo = new TH1D("hZ_W_TotalEffLo", "", 1, 0., 1.);
TH1D* hZ_W_TotalEffMe1 = new TH1D("hZ_W_TotalEffMe1", "", 1, 0., 1.);
TH1D* hZ_W_TotalEffMe2 = new TH1D("hZ_W_TotalEffMe2", "", 1, 0., 1.);
TH1D* hZ_W_TotalEffHi = new TH1D("hZ_W_TotalEffHi", "", 1, 0., 1.);
//hZ_DY_EffVBFS->Add(hZ_DY_EffVBFS_N);
//hZ_DY_EffVBFS->Divide(hZ_DY_EffVBFS_D);
hZ_DY_EffVBFSLo->Add(hZ_DY_EffVBFS_NLo);
hZ_DY_EffVBFSLo->Divide(hZ_DY_EffVBFS_D);
hZ_DY_EffVBFSHi->Add(hZ_DY_EffVBFS_NHi);
hZ_DY_EffVBFSHi->Divide(hZ_DY_EffVBFS_D);
hZ_DY_EffVBFSMe1->Add(hZ_DY_EffVBFS_NMe1);
hZ_DY_EffVBFSMe1->Divide(hZ_DY_EffVBFS_D);
hZ_DY_EffVBFSMe2->Add(hZ_DY_EffVBFS_NMe2);
hZ_DY_EffVBFSMe2->Divide(hZ_DY_EffVBFS_D);
//hZ_W_EffVBFC->Add(hZ_W_EffVBFC_N);
//hZ_W_EffVBFC->Divide(hZ_W_EffVBFC_D);
hZ_W_EffVBFCLo->Add(hZ_W_EffVBFC_NLo);
hZ_W_EffVBFCLo->Divide(hZ_W_EffVBFC_D);
hZ_W_EffVBFCMe1->Add(hZ_W_EffVBFC_NMe1);
hZ_W_EffVBFCMe1->Divide(hZ_W_EffVBFC_D);
hZ_W_EffVBFCMe2->Add(hZ_W_EffVBFC_NMe2);
hZ_W_EffVBFCMe2->Divide(hZ_W_EffVBFC_D);
hZ_W_EffVBFCHi->Add(hZ_W_EffVBFC_NHi);
hZ_W_EffVBFCHi->Divide(hZ_W_EffVBFC_D);
//hZ_W_RatioVBF->Add(hZ_DY_EffVBFS);
//hZ_W_RatioVBF->Divide(hZ_W_EffVBFC);
hZ_W_RatioVBFLo->Add(hZ_DY_EffVBFSLo);
hZ_W_RatioVBFLo->Divide(hZ_W_EffVBFCLo);
hZ_W_RatioVBFMe1->Add(hZ_DY_EffVBFSMe1);
hZ_W_RatioVBFMe1->Divide(hZ_W_EffVBFCMe1);
hZ_W_RatioVBFMe2->Add(hZ_DY_EffVBFSMe2);
hZ_W_RatioVBFMe2->Divide(hZ_W_EffVBFCMe2);
hZ_W_RatioVBFHi->Add(hZ_DY_EffVBFSHi);
hZ_W_RatioVBFHi->Divide(hZ_W_EffVBFCHi);
hZ_W_TotalEffLo->Add(hZ_W_RatioVBFLo);
hZ_W_TotalEffLo->Multiply(hZ_DY_EffMuMu);
hZ_W_TotalEffLo->Divide(hZ_W_EffMu);
hZ_W_TotalEffMe1->Add(hZ_W_RatioVBFMe1);
hZ_W_TotalEffMe1->Multiply(hZ_DY_EffMuMu);
hZ_W_TotalEffMe1->Divide(hZ_W_EffMu);
hZ_W_TotalEffMe2->Add(hZ_W_RatioVBFMe2);
hZ_W_TotalEffMe2->Multiply(hZ_DY_EffMuMu);
hZ_W_TotalEffMe2->Divide(hZ_W_EffMu);
hZ_W_TotalEffHi->Add(hZ_W_RatioVBFHi);
hZ_W_TotalEffHi->Multiply(hZ_DY_EffMuMu);
hZ_W_TotalEffHi->Divide(hZ_W_EffMu);
//hZ_Eff_S_noDPhi->Add(hZ_W_RatioVBF);
//hZ_Eff_S_noDPhi->Divide(hZ_W_EffMu);
hZ_Eff_WS_DPhi->SetBinContent(1,hZ_W_TotalEffLo->GetBinContent(1));
hZ_Eff_WS_DPhi->SetBinError(1,hZ_W_TotalEffLo->GetBinError(1));
hZ_Eff_WS_DPhi->SetBinContent(2,hZ_W_TotalEffMe1->GetBinContent(1));
hZ_Eff_WS_DPhi->SetBinError(2,hZ_W_TotalEffMe1->GetBinError(1));
hZ_Eff_WS_DPhi->SetBinContent(3,hZ_W_TotalEffMe2->GetBinContent(1));
hZ_Eff_WS_DPhi->SetBinError(3,hZ_W_TotalEffMe2->GetBinError(1));
hZ_Eff_WS_DPhi->SetBinContent(4,hZ_W_TotalEffHi->GetBinContent(1));
hZ_Eff_WS_DPhi->SetBinError(4,hZ_W_TotalEffHi->GetBinError(1));
//for(int ibin = 1; ibin <= hZ_Eff_S_DPhi->GetNbinsX(); ++ibin) {
// hZ_Eff_S_DPhi->SetBinContent(ibin,hZ_W_TotalEff->GetBinContent(1));
// hZ_Eff_S_DPhi->SetBinError (ibin,hZ_W_TotalEff->GetBinError(1));
//}
// Observed
hZ_Est_ZC_DPhi->Add(hZ_Data_ZC_DPhi, hZ_BG_ZC_DPhi, 1., -1.);
// Predicted
hZ_Est_WC_DPhi->Add(hZ_Data_WC_DPhi, hZ_BG_WC_DPhi, 1., -1.);
hZ_Est_WS_DPhi->Add(hZ_Est_WC_DPhi,ratioBF);
hZ_Est_WS_DPhi->Multiply(hZ_Eff_WS_DPhi);
// print out
std::cout << std::endl;
std::cout << "##################################### Cross-check with W mu ctrl region #####################################" << std::endl;
std::cout << std::endl;
std::cout << " eps_mumu by histogram : " << hZ_DY_EffMuMu->GetBinContent(1) << " +/- " << hZ_DY_EffMuMu->GetBinError(1) << std::endl;
std::cout << " eps_mu by histogram : " << hZ_W_EffMu->GetBinContent(1) << " +/- " << hZ_W_EffMu->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << "dphi < 1.0" << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFSLo->GetBinContent(1) << " +/- " << hZ_DY_EffVBFSLo->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf by histogram : " << hZ_W_EffVBFCLo->GetBinContent(1) << " +/- " << hZ_W_EffVBFCLo->GetBinError(1) << std::endl;
std::cout << " ratio_vbf by histogram : " << hZ_W_RatioVBFLo->GetBinContent(1) << " +/- " << hZ_W_RatioVBFLo->GetBinError(1) << std::endl;
std::cout << " total eff by histogram : " << hZ_Eff_WS_DPhi->GetBinContent(1) << " +/- " << hZ_Eff_WS_DPhi->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " W+jets MC ctrl region : " << hZ_W_C_DPhi->GetBinContent(1) << " +/- " << hZ_W_C_DPhi->GetBinError(1) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_WC_DPhi->GetBinContent(1) << " +/- " << hZ_BG_WC_DPhi->GetBinError(1) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_WC_DPhi->GetBinContent(1) << " +/- " << hZ_Data_WC_DPhi->GetBinError(1) << std::endl;
std::cout << " Data - BG : " << hZ_Est_WC_DPhi->GetBinContent(1) << " +/- " << hZ_Est_WC_DPhi->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << " Predicted Zmumu : " << hZ_Est_WS_DPhi->GetBinContent(1) << " +/- " << hZ_Est_WS_DPhi->GetBinError(1) << std::endl;
std::cout << " Observed Zmumu : " << hZ_Est_ZC_DPhi->GetBinContent(1) << " +/- " << hZ_Est_ZC_DPhi->GetBinError(1) << std::endl;
std::cout << std::endl;
std::cout << "dphi > 1.0 dphi < 1.8" << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFSMe1->GetBinContent(1) << " +/- " << hZ_DY_EffVBFSMe1->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf by histogram : " << hZ_W_EffVBFCMe1->GetBinContent(1) << " +/- " << hZ_W_EffVBFCMe1->GetBinError(1) << std::endl;
std::cout << " ratio_vbf by histogram : " << hZ_W_RatioVBFMe1->GetBinContent(1) << " +/- " << hZ_W_RatioVBFMe1->GetBinError(1) << std::endl;
std::cout << " total eff by histogram : " << hZ_Eff_WS_DPhi->GetBinContent(2) << " +/- " << hZ_Eff_WS_DPhi->GetBinError(2) << std::endl;
std::cout << std::endl;
std::cout << " W+jets MC ctrl region : " << hZ_W_C_DPhi->GetBinContent(2) << " +/- " << hZ_W_C_DPhi->GetBinError(2) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_WC_DPhi->GetBinContent(2) << " +/- " << hZ_BG_WC_DPhi->GetBinError(2) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_WC_DPhi->GetBinContent(2) << " +/- " << hZ_Data_WC_DPhi->GetBinError(2) << std::endl;
std::cout << " Data - BG : " << hZ_Est_WC_DPhi->GetBinContent(2) << " +/- " << hZ_Est_WC_DPhi->GetBinError(2) << std::endl;
std::cout << std::endl;
std::cout << " Predicted Zmumu : " << hZ_Est_WS_DPhi->GetBinContent(2) << " +/- " << hZ_Est_WS_DPhi->GetBinError(2) << std::endl;
std::cout << " Observed Zmumu : " << hZ_Est_ZC_DPhi->GetBinContent(2) << " +/- " << hZ_Est_ZC_DPhi->GetBinError(2) << std::endl;
std::cout << std::endl;
std::cout << "dphi > 1.8 dphi < 2.6" << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFSMe2->GetBinContent(1) << " +/- " << hZ_DY_EffVBFSMe2->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf by histogram : " << hZ_W_EffVBFCMe2->GetBinContent(1) << " +/- " << hZ_W_EffVBFCMe2->GetBinError(1) << std::endl;
std::cout << " ratio_vbf by histogram : " << hZ_W_RatioVBFMe2->GetBinContent(1) << " +/- " << hZ_W_RatioVBFMe2->GetBinError(1) << std::endl;
std::cout << " total eff by histogram : " << hZ_Eff_WS_DPhi->GetBinContent(3) << " +/- " << hZ_Eff_WS_DPhi->GetBinError(3) << std::endl;
std::cout << std::endl;
std::cout << " W+jets MC ctrl region : " << hZ_W_C_DPhi->GetBinContent(3) << " +/- " << hZ_W_C_DPhi->GetBinError(3) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_WC_DPhi->GetBinContent(3) << " +/- " << hZ_BG_WC_DPhi->GetBinError(3) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_WC_DPhi->GetBinContent(3) << " +/- " << hZ_Data_WC_DPhi->GetBinError(3) << std::endl;
std::cout << " Data - BG : " << hZ_Est_WC_DPhi->GetBinContent(3) << " +/- " << hZ_Est_WC_DPhi->GetBinError(3) << std::endl;
std::cout << std::endl;
std::cout << " Predicted Zmumu : " << hZ_Est_WS_DPhi->GetBinContent(3) << " +/- " << hZ_Est_WS_DPhi->GetBinError(3) << std::endl;
std::cout << " Observed Zmumu : " << hZ_Est_ZC_DPhi->GetBinContent(3) << " +/- " << hZ_Est_ZC_DPhi->GetBinError(3) << std::endl;
std::cout << std::endl;
std::cout << "dphi > 2.6" << std::endl;
std::cout << std::endl;
std::cout << " eps_s_vbf by histogram : " << hZ_DY_EffVBFSHi->GetBinContent(1) << " +/- " << hZ_DY_EffVBFSHi->GetBinError(1) << std::endl;
std::cout << " eps_c_vbf by histogram : " << hZ_W_EffVBFCHi->GetBinContent(1) << " +/- " << hZ_W_EffVBFCHi->GetBinError(1) << std::endl;
std::cout << " ratio_vbf by histogram : " << hZ_W_RatioVBFHi->GetBinContent(1) << " +/- " << hZ_W_RatioVBFHi->GetBinError(1) << std::endl;
std::cout << " total eff by histogram : " << hZ_Eff_WS_DPhi->GetBinContent(4) << " +/- " << hZ_Eff_WS_DPhi->GetBinError(4) << std::endl;
std::cout << std::endl;
std::cout << " W+jets MC ctrl region : " << hZ_W_C_DPhi->GetBinContent(4) << " +/- " << hZ_W_C_DPhi->GetBinError(4) << std::endl;
std::cout << " Background ctrl region : " << hZ_BG_WC_DPhi->GetBinContent(4) << " +/- " << hZ_BG_WC_DPhi->GetBinError(4) << std::endl;
std::cout << " Data ctrl region : " << hZ_Data_WC_DPhi->GetBinContent(4) << " +/- " << hZ_Data_WC_DPhi->GetBinError(4) << std::endl;
std::cout << " Data - BG region : " << hZ_Est_WC_DPhi->GetBinContent(4) << " +/- " << hZ_Est_WC_DPhi->GetBinError(4) << std::endl;
std::cout << std::endl;
std::cout << " Predicted Zmumu : " << hZ_Est_WS_DPhi->GetBinContent(4) << " +/- " << hZ_Est_WS_DPhi->GetBinError(4) << std::endl;
std::cout << " Observed Zmumu : " << hZ_Est_ZC_DPhi->GetBinContent(4) << " +/- " << hZ_Est_ZC_DPhi->GetBinError(4) << std::endl;
std::cout << std::endl;
std::cout << "#####################################################################################" << std::endl;
std::cout << std::endl;
// draw control plots
std::string pdfName;
gStyle->SetOptStat(0);
gStyle->SetOptFit(111111111);
double x1[4] = {0.5, 1.4, 2.2, 2.6 + (TMath::Pi()-2.6)/2};
double ex1[4] = {0.5, 0.4, 0.4, (TMath::Pi()-2.6)/2};
double y1[4],ey1[4],y2[4],ey2[4],y3[4],ey3[4];
double diff[4],ediff[4];
double frac[4],efrac[4];
double y_syst[4],e_syst[4];
for(int i=0; i<4; ++i) {
y1[i] = hZ_Est_WS_DPhi->GetBinContent(i+1); //Prediction
ey1[i] = hZ_Est_WS_DPhi->GetBinError(i+1);
y2[i] = hZ_Est_ZC_DPhi->GetBinContent(i+1); //Observation
ey2[i] = hZ_Est_ZC_DPhi->GetBinError(i+1);
y3[i] = hZ_DY_C_DPhi->GetBinContent(i+1); //MC Prediction
ey3[i] = hZ_DY_C_DPhi->GetBinError(i+1);
diff[i] = y1[i]-y2[i];
ediff[i] = sqrt(ey1[i]*ey1[i] + ey2[i]*ey2[i]);
y_syst[i] = 0.;
e_syst[i] = 0.21;
if(y1[i] > 0) frac[i] = (y1[i]-y2[i])/y2[i];
efrac[i] = (y1[i]/y2[i])*sqrt(pow(ey1[i]/y1[i],2) + pow(ey2[i]/y2[i],2));
}
TGraphErrors *graph1 = new TGraphErrors(4,x1,y1,ex1,ey1);
TGraphErrors *graph2 = new TGraphErrors(4,x1,y2,ex1,ey2);
TGraphErrors *graph6 = new TGraphErrors(4,x1,y3,ex1,ey3);
TGraphErrors *graph3 = new TGraphErrors(4,x1,diff,ex1,ediff);
TGraphErrors *graph4 = new TGraphErrors(4,x1,frac,ex1,efrac);
TGraphErrors *graph5 = new TGraphErrors(4,x1,y_syst,ex1,e_syst);
TH1D *h = new TH1D("h", "", 1, 0, TMath::Pi());
TCanvas canvas;
canvas.SetCanvasSize(canvas.GetWindowWidth(), 1.2*canvas.GetWindowHeight());
graph1->SetTitle("");
graph1->SetMarkerStyle(20);
graph1->SetMarkerSize(0.9);
graph1->SetLineColor(kRed);
graph1->SetMarkerColor(kRed);
graph1->GetXaxis()->SetTitle("#Delta #phi_{jj}");
graph1->GetXaxis()->SetRangeUser(0,TMath::Pi());
graph1->GetYaxis()->SetTitle("N(Z#rightarrow #mu#mu)");
graph1->GetYaxis()->SetRangeUser(0,45);
graph1->Draw("AP");
graph2->SetMarkerStyle(20);
graph2->SetMarkerSize(0.9);
graph2->SetLineColor(kBlue);
graph2->SetMarkerColor(kBlue);
graph2->Draw("P same");
graph6->SetMarkerStyle(20);
graph6->SetMarkerSize(0.9);
graph6->SetLineColor(kViolet);
graph6->SetMarkerColor(kViolet);
graph6->Draw("P same");
TLegend leg(0.12,0.67,0.37,0.88);
leg.SetBorderSize(0);
leg.SetFillColor(0);
leg.AddEntry(graph1,"predicted (data)","P");
leg.AddEntry(graph2,"observed (data)","P");
leg.AddEntry(graph6,"predicted (MC)","P");
leg.Draw();
pdfName= oDir + std::string("/Zmumu_num.pdf");
canvas.Print(pdfName.c_str());
h->GetXaxis()->SetTitle("#Delta #phi_{jj}");
h->GetYaxis()->SetTitle("Predicted - Observed");
h->GetYaxis()->SetRangeUser(-20,20);
h->SetLineColor(kBlue);
h->Draw();
graph3->SetMarkerStyle(20);
graph3->SetMarkerSize(0.9);
graph3->SetMarkerColor(kGreen-2);
TF1 *f1 = new TF1("f1","pol0",0,TMath::Pi());
graph3->Fit("f1","R");
h->Draw();
graph3->Draw("SAMEP");
pdfName= oDir + std::string("/Zmumu_diff.pdf");
canvas.Print(pdfName.c_str());
h->GetXaxis()->SetTitle("#Delta #phi_{jj}");
h->GetYaxis()->SetTitle("#frac{Predicted - Observed}{Observed}");
h->GetYaxis()->SetTitleOffset(1.2);
h->GetYaxis()->SetRangeUser(-2,2);
h->SetLineColor(kBlue);
h->SetLineWidth(2);
h->Draw();
graph5->SetLineColor(kGray+2);
graph5->SetLineWidth(0);
graph5->SetFillColor(kGray+2);
graph5->SetFillStyle(3002);
graph4->SetMarkerStyle(20);
graph4->SetMarkerSize(1.2);
graph4->SetMarkerColor(kGreen-2);
graph4->Fit("f1","R");
h->Draw();
graph5->Draw("2 same");
graph4->Draw("P same");
TLegend leg2(0.12,0.67,0.40,0.87);
leg2.SetBorderSize(0);
leg2.SetFillColor(0);
leg2.AddEntry(f1,"pol0 fit (0 < #Delta #phi_{jj} < #pi)","l");
leg2.AddEntry(graph5,"Systematic error","f");
leg2.Draw();
pdfName= oDir + std::string("/Zmumu_frac.pdf");
canvas.Print(pdfName.c_str());
//store histograms
ofile->cd();
hZ_DY_C_DPhi->Write("",TObject::kOverwrite);
hZ_BG_ZC_DPhi->Write("",TObject::kOverwrite);
hZ_Data_ZC_DPhi->Write("",TObject::kOverwrite);
hZ_W_C_DPhi->Write("",TObject::kOverwrite);
hZ_BG_WC_DPhi->Write("",TObject::kOverwrite);
hZ_Data_WC_DPhi->Write("",TObject::kOverwrite);
hZ_Est_ZC_DPhi->Write("",TObject::kOverwrite);
hZ_Est_WC_DPhi->Write("",TObject::kOverwrite);
hZ_Est_WS_DPhi->Write("",TObject::kOverwrite);
hZ_Eff_WS_DPhi->Write("",TObject::kOverwrite);
hZ_DY_EffMuMu_D->Write("",TObject::kOverwrite);
hZ_DY_EffMuMu_N->Write("",TObject::kOverwrite);
hZ_W_EffMu_D->Write("",TObject::kOverwrite);
hZ_W_EffMu_N->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_D->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_NLo->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_NMe1->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_NMe2->Write("",TObject::kOverwrite);
hZ_DY_EffVBFS_NHi->Write("",TObject::kOverwrite);
hZ_W_EffVBFC_D->Write("",TObject::kOverwrite);
hZ_W_EffVBFC_NLo->Write("",TObject::kOverwrite);
hZ_W_EffVBFC_NMe1->Write("",TObject::kOverwrite);
hZ_W_EffVBFC_NMe2->Write("",TObject::kOverwrite);
hZ_W_EffVBFC_NHi->Write("",TObject::kOverwrite);
hZ_W_EffMu->Write("",TObject::kOverwrite);
//hZ_DY_EffVBFS->Write("",TObject::kOverwrite);
//hZ_W_EffVBFC->Write("",TObject::kOverwrite);
//hZ_W_RatioVBF->Write("",TObject::kOverwrite);
//hZ_W_TotalEff->Write("",TObject::kOverwrite);
ofile->Close();
}
int main(int argc, char* argv[]) {
TH1::SetDefaultSumw2();
ProgramOptions options(argc, argv);
double lumi = options.lumi;
// input datasets
Datasets datasets(options.iDir);
datasets.readFile(options.datasetFile);
std::string oDir_Plot = options.oDir+std::string("/QCDBackground");
boost::filesystem::path opath(oDir_Plot);
if (!exists(opath)) {
std::cout << "Creating output directory : " << oDir_Plot << std::endl;
boost::filesystem::create_directory(opath);
}
// output file
TFile* ofile = TFile::Open( (options.oDir+std::string("/QCDBackground.root")).c_str(), "RECREATE");
// cuts
Cuts cuts;
TCut puWeight("puWeight");
TCut trigCorr( "(trigCorrWeight>0.) ? trigCorrWeight : 1." );
// histograms
double dphiEdges[4] = { 0., 1.0, 2.6, TMath::Pi() };
double metEdges[14] = { 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120., 10000. };
TH2D* hQCD_BG_METDPhi = new TH2D("hQCD_BG_METDPhi", "", 3, dphiEdges, 13, metEdges); // BG in NoMET region
TH1D* hQCD_BG_Tight_DPhi = new TH1D("hQCD_BG_Tight_DPhi", "", 3, dphiEdges); // BG in tight region
TH2D* hQCD_WTau_METDPhi = new TH2D("hQCD_WTau_METDPhi", "", 3, dphiEdges, 13, metEdges); // BG in NoMET region
TH1D* hQCD_WTau_Tight_DPhi = new TH1D("hQCD_WTau_Tight_DPhi", "", 3, dphiEdges); // BG in tight region
TH2D* hQCD_TTBar_METDPhi = new TH2D("hQCD_TTBar_METDPhi", "", 3, dphiEdges, 13, metEdges); // BG in NoMET region
TH1D* hQCD_TTBar_Tight_DPhi = new TH1D("hQCD_TTBar_Tight_DPhi", "", 3, dphiEdges); // BG in tight region
TH2D* hQCD_SingleTSum_METDPhi = new TH2D("hQCD_SingleTSum_METDPhi", "", 3, dphiEdges, 13, metEdges); // BG in NoMET region
TH1D* hQCD_SingleTSum_Tight_DPhi = new TH1D("hQCD_SingleTSum_Tight_DPhi", "", 3, dphiEdges); // BG in tight region
TH2D* hQCD_DY_METDPhi = new TH2D("hQCD_DY_METDPhi", "", 3, dphiEdges, 13, metEdges); // BG in NoMET region
TH1D* hQCD_DY_Tight_DPhi = new TH1D("hQCD_DY_Tight_DPhi", "", 3, dphiEdges); // BG in tight region
TH2D* hQCD_Diboson_METDPhi = new TH2D("hQCD_Diboson_METDPhi", "", 3, dphiEdges, 13, metEdges); // BG in NoMET region
TH1D* hQCD_Diboson_Tight_DPhi = new TH1D("hQCD_Diboson_Tight_DPhi", "", 3, dphiEdges); // BG in tight region
TH2D* hQCD_Data_METDPhi = new TH2D("hQCD_Data_METDPhi", "", 3, dphiEdges, 13, metEdges); // Data in NoMET region
TH1D* hQCD_Data_Tight_DPhi = new TH1D("hQCD_Data_Tight_DPhi", "", 3, dphiEdges); // Data in tight region
// loop over MC datasets
for (unsigned i=0; i<datasets.size(); ++i) {
Dataset dataset = datasets.getDataset(i);
TCut cutD = cuts.cutDataset(dataset.name);
// check if it's ZToNuNuJets
bool isZvv = false;
if (dataset.isData) {
std::cout << "Analysing Data : " << dataset.name << std::endl;
}
else if (dataset.name.compare(0,3,"Zvv")==0) {
isZvv = true;
std::cout << "Analysing Zvv MC : " << dataset.name << std::endl;
}
else {
std::cout << "Analysing BG MC : " << dataset.name << std::endl;
}
// get file & tree
TFile* file = datasets.getTFile(dataset.name);
TTree* tree = (TTree*) file->Get("invHiggsInfo/InvHiggsInfo");
// cuts
TCut cutQCDNoMET = puWeight * trigCorr * cuts.qcdNoMET();
TCut cutQCDTightHiDPhi = puWeight * trigCorr * cuts.qcdTightHiDPhi();
TCut cutWQCDNoMET = puWeight * trigCorr * cuts.wWeight() * (cuts.wTauGen() + cuts.qcdNoMET());
TCut cutWQCDTightHiDPhi = puWeight * trigCorr * cuts.wWeight() * (cuts.wTauGen() + cuts.qcdTightHiDPhi());
// fill tmp histograms for BG estimation
TH2D* hQCD_METDPhi = new TH2D("hQCD_METDPhi", "", 3, dphiEdges, 13, metEdges); //
TH1D* hQCD_Tight_DPhi = new TH1D("hQCD_Tight_DPhi", "", 3, dphiEdges); // this is for the actual BG estimation
if (dataset.name=="WJets" ||
dataset.name=="W1Jets" ||
dataset.name=="W2Jets" ||
dataset.name=="W3Jets" ||
dataset.name=="W4Jets") {
tree->Draw("met:vbfDPhi>>hQCD_METDPhi", cutWQCDNoMET);
tree->Draw("vbfDPhi>>hQCD_Tight_DPhi", cutWQCDTightHiDPhi);
}
else {
tree->Draw("met:vbfDPhi>>hQCD_METDPhi", cutQCDNoMET);
tree->Draw("vbfDPhi>>hQCD_Tight_DPhi", cutQCDTightHiDPhi);
}
// weight to lumi
double weight = (dataset.isData ? 1. : lumi * dataset.sigma / dataset.nEvents);
hQCD_METDPhi->Scale(weight);
hQCD_Tight_DPhi->Scale(weight);
// add to output histograms
if (dataset.isData) {
hQCD_Data_METDPhi->Add(hQCD_METDPhi);
hQCD_Data_Tight_DPhi->Add(hQCD_Tight_DPhi);
}
else {
if (!isZvv) hQCD_BG_Tight_DPhi->Add(hQCD_Tight_DPhi); // do not include Z->vv samples we use data-driven number
hQCD_BG_METDPhi->Add(hQCD_METDPhi);
}
if (dataset.name=="WJets" ||
dataset.name=="W1Jets" ||
dataset.name=="W2Jets" ||
dataset.name=="W3Jets" ||
dataset.name=="W4Jets" ) {
hQCD_WTau_METDPhi->Add(hQCD_METDPhi);
hQCD_WTau_Tight_DPhi->Add(hQCD_Tight_DPhi);
}
if (dataset.name=="TTBar") {
hQCD_TTBar_METDPhi->Add(hQCD_METDPhi);
hQCD_TTBar_Tight_DPhi->Add(hQCD_Tight_DPhi);
}
if (dataset.name.compare(0,7,"SingleT")==0) {
hQCD_SingleTSum_METDPhi->Add(hQCD_METDPhi);
hQCD_SingleTSum_Tight_DPhi->Add(hQCD_Tight_DPhi);
}
if (dataset.name.compare(0,2,"DY")==0) {
hQCD_DY_METDPhi->Add(hQCD_METDPhi);
hQCD_DY_Tight_DPhi->Add(hQCD_Tight_DPhi);
}
if (dataset.name == "WW" ||
dataset.name == "WZ" ||
dataset.name == "ZZ") {
hQCD_Diboson_METDPhi->Add(hQCD_METDPhi);
hQCD_Diboson_Tight_DPhi->Add(hQCD_Tight_DPhi);
}
std::cout << " N (met>130, dphi>2.6) : " << hQCD_Tight_DPhi->GetBinContent(3) << std::endl;
delete hQCD_METDPhi;
delete hQCD_Tight_DPhi;
// QCD Figure 13 in AN
TCut cutPlots("");
if (dataset.name == "WJets" ||
dataset.name == "W1Jets" ||
dataset.name == "W2Jets" ||
dataset.name == "W3Jets" ||
dataset.name == "W4Jets") {
cutPlots = puWeight * trigCorr * cuts.wWeight() * (cuts.HLTandMETFilters() + cuts.leptonVeto() + cuts.vbf()); //no MET and dPhijj
}
else cutPlots = puWeight * trigCorr * (cuts.HLTandMETFilters() + cuts.leptonVeto() + cuts.vbf()); //no MET and dPhijj
TFile* ofile_Plot = TFile::Open( (oDir_Plot+std::string("/")+dataset.name+std::string(".root")).c_str(), "RECREATE");
TH1D* QCD_DPhijj = new TH1D("QCD_DPhijj", "", 50, 0., TMath::Pi());
TH1D* QCD_MET = new TH1D("QCD_MET", "", 50, 0., 1000.);
tree->Draw("vbfDPhi>>QCD_DPhijj" , cutPlots);
tree->Draw("met>>QCD_MET" , cutPlots);
if (!dataset.isData) {
QCD_DPhijj->Scale(weight);
QCD_MET->Scale(weight);
}
ofile_Plot->cd();
QCD_DPhijj->Write("",TObject::kOverwrite);
QCD_MET->Write("",TObject::kOverwrite);
ofile_Plot->Close();
// clean up
delete tree;
file->Close();
}
// get data-driven background estimates
std::cout << "Reading Z backgrounds from : " << options.oDir+std::string("/ZBackground.root") << std::endl;
TFile* zfile = TFile::Open( (options.oDir+std::string("/ZBackground.root")).c_str(), "READ");
TH2D* hQCD_Z_METDPhi = (TH2D*) zfile->Get("hZ_Est_S_METDPhi");
TH1D* hQCD_Z_Tight_DPhi = (TH1D*) zfile->Get("hZ_Est_S_DPhi");
if (hQCD_Z_Tight_DPhi == 0) {
std::cerr << "Could not read Z background histogram" << std::endl;
std::exit(1);
}
std::cout << " N (met>130, dphi>2.6) : " << hQCD_Z_Tight_DPhi->GetBinContent(3) << std::endl;
std::cout << std::endl;
std::cout << "Reading W backgrounds from : " << options.oDir+std::string("/WBackground.root") << std::endl;
TFile* wfile = TFile::Open( (options.oDir+std::string("/WBackground.root")).c_str(), "READ");
TH2D* hQCD_W_METDPhi = (TH2D*) wfile->Get("hW_Est_S_METDPhi");
TH1D* hQCD_W_Tight_DPhi = (TH1D*) wfile->Get("hW_Est_S_DPhi");
if (hQCD_W_Tight_DPhi == 0) {
std::cerr << "Could not read W background histogram" << std::endl;
std::exit(1);
}
std::cout << " N (met>130, dphi>2.6) : " << hQCD_W_Tight_DPhi->GetBinContent(3) << std::endl;
std::cout << std::endl;
// create output histograms
TH2D* hQCD_Est_METDPhi = new TH2D("hQCD_Est_METDPhi", "", 3, dphiEdges, 13, metEdges);
TH1D* hQCD_Est_S_DPhi = new TH1D("hQCD_Est_S_DPhi", "", 3, dphiEdges);
// do the background estimation
hQCD_Est_METDPhi->Add(hQCD_Data_METDPhi, hQCD_BG_METDPhi, 1., -1.);
hQCD_Est_S_DPhi->Add(hQCD_Data_Tight_DPhi, hQCD_BG_Tight_DPhi, 1., -1.);
// hQCD_Est_METDPhi->Add(hQCD_Z_METDPhi, -1.);
hQCD_Est_S_DPhi->Add(hQCD_Z_Tight_DPhi, -1.);
// hQCD_Est_METDPhi->Add(hQCD_W_METDPhi, -1.);
hQCD_Est_S_DPhi->Add(hQCD_W_Tight_DPhi, -1.);
// calculate ratios
// double rNoMET = hQCD_Est_METDPhi->GetBinContent(1) / hQCD_Est_METDPhi->GetBinContent(3);
// double err_rNoMET = rNoMET * sqrt(pow(hQCD_Est_METDPhi->GetBinError(1)/hQCD_Est_METDPhi->GetBinContent(1),2) + pow(hQCD_Est_METDPhi->GetBinError(3)/hQCD_Est_METDPhi->GetBinContent(3),2));
// double rLoose2 = hQCD_Est_Loose2_DPhi->GetBinContent(1) / hQCD_Est_Loose2_DPhi->GetBinContent(3);
// double err_rLoose2 = rLoose2 * sqrt(pow(hQCD_Est_Loose2_DPhi->GetBinError(1)/hQCD_Est_Loose2_DPhi->GetBinContent(1),2) + pow(hQCD_Est_Loose2_DPhi->GetBinError(3)/hQCD_Est_Loose2_DPhi->GetBinContent(3),2));
// double rLoose = hQCD_Est_Loose_DPhi->GetBinContent(1) / hQCD_Est_Loose_DPhi->GetBinContent(3);
// double err_rLoose = rLoose * sqrt(pow(hQCD_Est_Loose_DPhi->GetBinError(1)/hQCD_Est_Loose_DPhi->GetBinContent(1),2) + pow(hQCD_Est_Loose_DPhi->GetBinError(3)/hQCD_Est_Loose_DPhi->GetBinContent(3),2));
// // linear extrapolation using MET>80 and MET>100 bins
double rTight = 0.0046;
double err_rTight = 0.0046 * 1.5;
// predict signal
double nQCD_Est_S_HiDPhi = rTight * hQCD_Est_S_DPhi->GetBinContent(3);
double err_nQCD_Est_S_HiDPhi = nQCD_Est_S_HiDPhi * sqrt(pow(err_rTight/rTight,2)+pow(hQCD_Est_S_DPhi->GetBinError(3)/hQCD_Est_S_DPhi->GetBinContent(3),2));
// set bins in output histogram
hQCD_Est_S_DPhi->SetBinContent(1, nQCD_Est_S_HiDPhi);
hQCD_Est_S_DPhi->SetBinError(1, err_nQCD_Est_S_HiDPhi);
// print results
std::cout << std::endl;
std::cout << "QCD Background estimate" << std::endl << std::endl;
std::cout << std::endl;
std::cout <<" Ratios" << std::endl;
// std::cout << " R(MET>80) : " << rNoMET << " +/- " << err_rNoMET << std::endl;
// std::cout << " R(MET>90) : " << rLoose2 << " +/- " << err_rLoose2 << std::endl;
// std::cout << " R(MET>100) : " << rLoose << " +/- " << err_rLoose << std::endl;
// std::cout << " R(MET>130) : " << rTight << " +/- " << err_rTight << std::endl;
// std::cout << std::endl;
std::cout << "Control region (MET>130, dphi>2.6)" << std::endl;
std::cout << " N data : " << hQCD_Data_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_Data_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N Z (data) : " << hQCD_Z_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_Z_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N W (data) : " << hQCD_W_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_W_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N BG (MC) : " << hQCD_BG_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_BG_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N WTau (MC) : " << hQCD_WTau_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_WTau_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N TTbar (MC) : " << hQCD_TTBar_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_TTBar_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N SingleT (MC) : " << hQCD_SingleTSum_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_SingleTSum_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N DY (MC) : " << hQCD_DY_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_DY_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N Diboson (MC) : " << hQCD_Diboson_Tight_DPhi->GetBinContent(3) << " +/- " << hQCD_Diboson_Tight_DPhi->GetBinError(3) << std::endl;
std::cout << " N QCD (est) : " << hQCD_Est_S_DPhi->GetBinContent(3) << " +/- " << hQCD_Est_S_DPhi->GetBinError(3) << std::endl;
std::cout << std::endl;
std::cout << "Signal region (MET>130, dphi<1.0)" << std::endl;
std::cout << " N QCD (est): " << hQCD_Est_S_DPhi->GetBinContent(1) << " +/- " << hQCD_Est_S_DPhi->GetBinError(1) << std::endl;
// list histograms for dataset summing
std::vector<std::string> hists;
hists.push_back("QCD_DPhijj");
hists.push_back("QCD_MET");
// sum Z+jets datasets
std::vector<std::string> zjetsDatasets;
zjetsDatasets.push_back(std::string("Zvv_50to100"));
zjetsDatasets.push_back(std::string("Zvv_100to200"));
zjetsDatasets.push_back(std::string("Zvv_200to400"));
zjetsDatasets.push_back(std::string("Zvv_400toinf"));
SumDatasets(oDir_Plot, zjetsDatasets, hists, "ZJets");
// sum W+jets datasets
std::vector<std::string> wjetsDatasets;
wjetsDatasets.push_back(std::string("WJets"));
wjetsDatasets.push_back(std::string("W1Jets"));
wjetsDatasets.push_back(std::string("W2Jets"));
wjetsDatasets.push_back(std::string("W3Jets"));
wjetsDatasets.push_back(std::string("W4Jets"));
SumDatasets(oDir_Plot, wjetsDatasets, hists, "WNJets");
// sum single top datasets
std::vector<std::string> topDatasets;
topDatasets.push_back(std::string("SingleT_t"));
topDatasets.push_back(std::string("SingleTbar_t"));
topDatasets.push_back(std::string("SingleT_s"));
topDatasets.push_back(std::string("SingleTbar_s"));
topDatasets.push_back(std::string("SingleT_tW"));
topDatasets.push_back(std::string("SingleTbar_tW"));
topDatasets.push_back(std::string("TTBar"));
SumDatasets(oDir_Plot, topDatasets, hists, "SingleT+TTbar");
// sum DY contributions
std::cout << "Summing histograms for DYJetsToLL" << std::endl;
std::vector<std::string> dyjets;
dyjets.push_back("DYJetsToLL");
dyjets.push_back("DYJetsToLL_EWK");
SumDatasets(oDir_Plot,dyjets,hists,"DYJets");
// sum diboson datasets
std::vector<std::string> dibDatasets;
dibDatasets.push_back(std::string("WW"));
dibDatasets.push_back(std::string("WZ"));
dibDatasets.push_back(std::string("ZZ"));
SumDatasets(oDir_Plot, dibDatasets, hists, "DiBoson");
// make plots
std::cout << "Making plots" << std::endl;
StackPlot plots(oDir_Plot);
plots.setLegPos(0.66,0.60,0.89,0.89);
plots.addDataset("DiBoson", kViolet-6, 0);
plots.addDataset("DYJets", kPink-4,0);
plots.addDataset("SingleT+TTbar", kAzure-2, 0);
plots.addDataset("ZJets", kOrange-2, 0);
plots.addDataset("WNJets", kGreen-3, 0);
plots.addDataset("METABCD", kBlack, 1);
plots.setYMax(1e+8);
plots.draw("QCD_DPhijj", "#Delta #phi_{jj}", "N_{events}" ,1,"RATIO");
plots.draw("QCD_MET", "E_{T}^{miss} [GeV]", "N_{events}" ,1,"RATIO");
// write out histograms
ofile->cd();
hQCD_Data_METDPhi->Write("", TObject::kOverwrite);
hQCD_Data_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_BG_METDPhi->Write("", TObject::kOverwrite);
hQCD_BG_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_Z_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_W_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_WTau_METDPhi->Write("", TObject::kOverwrite);
hQCD_WTau_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_TTBar_METDPhi->Write("", TObject::kOverwrite);
hQCD_TTBar_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_SingleTSum_METDPhi->Write("", TObject::kOverwrite);
hQCD_SingleTSum_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_DY_METDPhi->Write("", TObject::kOverwrite);
hQCD_DY_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_Diboson_METDPhi->Write("", TObject::kOverwrite);
hQCD_Diboson_Tight_DPhi->Write("", TObject::kOverwrite);
hQCD_Est_METDPhi->Write("", TObject::kOverwrite);
hQCD_Est_S_DPhi->Write("", TObject::kOverwrite);
// clean up
ofile->Close();
}
