void FileWatcherWin32::handleAction(Watcher* watch, const std::string& filename, unsigned long action, std::string oldFilename) { Action fwAction; switch(action) { case FILE_ACTION_RENAMED_OLD_NAME: watch->OldFileName = filename; return; case FILE_ACTION_ADDED: fwAction = Actions::Add; break; case FILE_ACTION_RENAMED_NEW_NAME: { fwAction = Actions::Moved; std::string fpath( watch->Directory + filename ); // Update the directory path if ( watch->Recursive && FileSystem::isDirectory( fpath ) ) { // Update the new directory path std::string opath( watch->Directory + watch->OldFileName ); FileSystem::dirAddSlashAtEnd( opath ); FileSystem::dirAddSlashAtEnd( fpath ); for ( WatchVector::iterator it = mWatches.begin(); it != mWatches.end(); it++ ) { if ( (*it)->Watch->Directory == opath ) { (*it)->Watch->Directory = fpath; break; } } } watch->Listener->handleFileAction(watch->ID, static_cast<WatcherWin32*>( watch )->DirName, filename, fwAction, watch->OldFileName); return; } case FILE_ACTION_REMOVED: fwAction = Actions::Delete; break; case FILE_ACTION_MODIFIED: fwAction = Actions::Modified; break; }; watch->Listener->handleFileAction(watch->ID, static_cast<WatcherWin32*>( watch )->DirName, filename, fwAction); }
void Config::ReplaceIncludesWithIni(const std::string& original_ini_filename, const std::string& iniStr, std::string& with_includes) { std::istringstream iss(iniStr); std::string line; while (std::getline(iss, line)) { // Handle cases like // #include "" // ##includefoo barbaz"myconfig.ini" how weird is that // Anything that is not a syntactically correct #include "file" after // this pre-processing, will be treated as an ini comment and processed // as such in the ini parser auto pos = line.find_first_not_of(" "); if (pos == std::string::npos || line.compare(pos, strlen("#include"), "#include") != 0) { // treat as normal ini line, including comment that doesn't start with // #include with_includes += line + "\n"; continue; } pos += strlen("#include"); auto start = line.find_first_not_of(" ", pos); auto end = line.find_last_not_of(" "); if ((start == std::string::npos || line[start] != '"') || (end == start || line[end] != '"')) { with_includes += line + "\n"; // treat as normal comment continue; } std::string file = line.substr(start + 1, end - start - 1); const std::string logger_file = file; boost::filesystem::path p(file); if (!p.is_absolute()) { boost::filesystem::path opath(original_ini_filename); p = opath.parent_path()/p; } if (boost::filesystem::exists(p)) { std::ifstream ifs(p.string()); const std::string contents((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>()); Config::ReplaceIncludesWithIni(p.string(), contents, with_includes); } else { Logger::Warning("ini include file %s not found", logger_file.c_str()); } } }
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(); }
int main( int argc, char** argv, char** envp ) { if( argc != 3 ) { std::cerr << "syntax: cat-parts DIR OUTFILE" << std::endl; return 1; } boost::filesystem::path p(argv[1]); try { std::vector< boost::filesystem::path > v; for( boost::filesystem::directory_iterator it(p); it != boost::filesystem::directory_iterator(); ++it ) { boost::filesystem::path pit = it->path(); std::string spit = pit.generic_string(); size_t n = spit.length(); if( n <= 3 ) continue; if( spit.substr(n-3, 3) != ".hf" ) continue; v.push_back( pit ); } std::sort( v.begin(), v.end() ); // open each file and grab its contents, concatenating into single stringstream std::stringstream ss_data; for( const boost::filesystem::path& p : v ) { boost::filesystem::ifstream ifs(p); ss_data << ifs.rdbuf(); } std::string new_data = ss_data.str(); boost::filesystem::path opath(argv[2]); if( boost::filesystem::exists( opath ) ) { boost::filesystem::ifstream ifs(opath); std::stringstream ss_old_data; ss_old_data << ifs.rdbuf(); std::string old_data = ss_old_data.str(); if( old_data == new_data ) { std::cerr << "File " << opath << " up-to-date with .d directory" << std::endl; return 0; } } { boost::filesystem::create_directories(opath.parent_path()); boost::filesystem::ofstream ofs(opath); ofs.write( new_data.c_str(), new_data.length() ); } std::cerr << "Built " << opath << " from .d directory" << std::endl; } catch( const boost::filesystem::filesystem_error& e ) { std::cout << e.what() << std::endl; return 1; } return 0; }
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(); }