From 33c08002d7266b1d916e4de8fc05363fa45468c2 Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Fri, 9 Jun 2017 18:35:04 +0200 Subject: [PATCH 1/9] Update Prompt DQM for HLT Jet --- DQMOffline/Trigger/plugins/JetMonitor.cc | 594 ++++++++++++++++++ DQMOffline/Trigger/plugins/JetMonitor.h | 146 +++++ .../python/DQMOffline_HLT_Client_cff.py | 4 +- .../Trigger/python/DQMOffline_Trigger_cff.py | 5 +- .../Trigger/python/JetMETPromptMonitor_cff.py | 7 + .../JetMETPromptMonitoring_Client_cff.py | 172 +++++ 6 files changed, 926 insertions(+), 2 deletions(-) create mode 100644 DQMOffline/Trigger/plugins/JetMonitor.cc create mode 100644 DQMOffline/Trigger/plugins/JetMonitor.h create mode 100644 DQMOffline/Trigger/python/JetMETPromptMonitor_cff.py create mode 100644 DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py diff --git a/DQMOffline/Trigger/plugins/JetMonitor.cc b/DQMOffline/Trigger/plugins/JetMonitor.cc new file mode 100644 index 0000000000000..01e3d9d083b69 --- /dev/null +++ b/DQMOffline/Trigger/plugins/JetMonitor.cc @@ -0,0 +1,594 @@ +#include "DQMOffline/Trigger/plugins/JetMonitor.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +#include "DQM/TrackingMonitor/interface/GetLumi.h" + +#include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h" + + +// Define Phi Bin // +double Jet_MAX_PHI = 3.2; +int Jet_N_PHI = 64; +MEbinning jet_phi_binning_{ + Jet_N_PHI, -Jet_MAX_PHI, Jet_MAX_PHI +}; +// Define Eta Bin // +double Jet_MAX_ETA = 5; +int Jet_N_ETA = 50; +MEbinning jet_eta_binning_{ + Jet_N_ETA, -Jet_MAX_ETA, Jet_MAX_ETA +}; +// Define HEP17 for PHI +double Jet_MAX_PHI_HEP17 = -0.52; +double Jet_MIN_PHI_HEP17 = -0.87; +int N_PHI_HEP17 = 7; +const MEbinning phi_binning_hep17_{ + N_PHI_HEP17, Jet_MIN_PHI_HEP17, Jet_MAX_PHI_HEP17 +}; +// Define HEP18 for PHI +double Jet_MAX_PHI_HEP18 = -0.17; +double Jet_MIN_PHI_HEP18 = -0.52; +int N_PHI_HEP18 = 7; +const MEbinning phi_binning_hep18_{ + N_PHI_HEP18, Jet_MIN_PHI_HEP18, Jet_MAX_PHI_HEP18 +}; +// Define HEP17 for ETA +double Jet_MAX_ETA_HEP17 = 3.0; +double Jet_MIN_ETA_HEP17 = 1.3; +int N_ETA_HEP17 = 6; +const MEbinning eta_binning_hep17_{ + N_ETA_HEP17, Jet_MIN_ETA_HEP17, Jet_MAX_ETA_HEP17 +}; + +const MEbinning eta_binning_hem17_{ + N_ETA_HEP17, -Jet_MAX_ETA_HEP17, Jet_MIN_ETA_HEP17 +}; + + +// ----------------------------- +// constructors and destructor +// ----------------------------- + +JetMonitor::JetMonitor( const edm::ParameterSet& iConfig ): + metSelection_ ( iConfig.getParameter("metSelection") ) + , jetSelection_ ( iConfig.getParameter("jetSelection") ) + , calojetSelection_ ( iConfig.getParameter("calojetSelection") ) + , eleSelection_ ( iConfig.getParameter("eleSelection") ) + , muoSelection_ ( iConfig.getParameter("muoSelection") ) +{ + folderName_ = iConfig.getParameter("FolderName"); + metToken_ = consumes (iConfig.getParameter("met") ); + pfjetToken_ = mayConsume (iConfig.getParameter("pfjets") ); + calojetToken_ = mayConsume (iConfig.getParameter("calojets") ); + eleToken_ = mayConsume(iConfig.getParameter("electrons") ); + muoToken_ = mayConsume (iConfig.getParameter("muons") ); + met_variable_binning_ = iConfig.getParameter("histoPSet").getParameter >("jetptBinning"); + met_binning_ = getHistoPSet (iConfig.getParameter("histoPSet").getParameter ("metPSet") ); + jetptThr_binning_ = getHistoPSet (iConfig.getParameter("histoPSet").getParameter ("jetPtThrPSet") ); + ls_binning_ = getHistoLSPSet (iConfig.getParameter("histoPSet").getParameter ("lsPSet") ); + + num_genTriggerEventFlag_ = new GenericTriggerEventFlag(iConfig.getParameter("numGenericTriggerEventPSet"),consumesCollector(), *this); + den_genTriggerEventFlag_ = new GenericTriggerEventFlag(iConfig.getParameter("denGenericTriggerEventPSet"),consumesCollector(), *this); + + njets_ = iConfig.getParameter("njets" ); + nelectrons_ = iConfig.getParameter("nelectrons" ); + nmuons_ = iConfig.getParameter("nmuons" ); + ptcut_ = iConfig.getParameter("ptcut" ); // for HLT Jet + isPFJetTrig = iConfig.getParameter("ispfjettrg" ); + isCaloJetTrig = iConfig.getParameter("iscalojettrg" ); + +// jetHEP18_EtaVsPhi_.numerator = nullptr; +// jetHEP18_EtaVsPhi_.denominator = nullptr; + + // test a_ME + AutoNullPtr(a_ME,sizeof(a_ME)/sizeof(a_ME[0])); + AutoNullPtr(a_ME_HB,sizeof(a_ME_HB)/sizeof(a_ME_HB[0])); + AutoNullPtr(a_ME_HE,sizeof(a_ME_HE)/sizeof(a_ME_HE[0])); + AutoNullPtr(a_ME_HF,sizeof(a_ME_HF)/sizeof(a_ME_HF[0])); + AutoNullPtr(a_ME_HE_p,sizeof(a_ME_HE_p)/sizeof(a_ME_HE_p[0])); + AutoNullPtr(a_ME_HE_m,sizeof(a_ME_HE_m)/sizeof(a_ME_HE_m[0])); + AutoNullPtr(a_ME_HEP17,sizeof(a_ME_HEP17)/sizeof(a_ME_HEP17[0])); + AutoNullPtr(a_ME_HEM17,sizeof(a_ME_HEM17)/sizeof(a_ME_HEM17[0])); + AutoNullPtr(a_ME_HEP18,sizeof(a_ME_HEP18)/sizeof(a_ME_HEP18[0])); +} + +JetMonitor::~JetMonitor() +{ + if (num_genTriggerEventFlag_) delete num_genTriggerEventFlag_; + if (den_genTriggerEventFlag_) delete den_genTriggerEventFlag_; +} + +MEbinning JetMonitor::getHistoPSet(edm::ParameterSet pset) +{ + return MEbinning{ + pset.getParameter("nbins"), + pset.getParameter("xmin"), + pset.getParameter("xmax"), + }; +} + +MEbinning JetMonitor::getHistoLSPSet(edm::ParameterSet pset) +{ + return MEbinning{ + pset.getParameter("nbins"), + 0., + double(pset.getParameter("nbins")) + }; +} + +void JetMonitor::setMETitle(JetME& me, std::string titleX, std::string titleY) +{ + me.numerator->setAxisTitle(titleX,1); + me.numerator->setAxisTitle(titleY,2); + me.denominator->setAxisTitle(titleX,1); + me.denominator->setAxisTitle(titleY,2); +} +void JetMonitor::bookME(DQMStore::IBooker &ibooker, JetME& me, std::string& histname, std::string& histtitle, int& nbins, double& min, double& max) +{ + me.numerator = ibooker.book1D(histname+"_numerator", histtitle+" (numerator)", nbins, min, max); + me.denominator = ibooker.book1D(histname+"_denominator", histtitle+" (denominator)", nbins, min, max); +} +void JetMonitor::bookME(DQMStore::IBooker &ibooker, JetME& me, std::string& histname, std::string& histtitle, std::vector binning) +{ + int nbins = binning.size()-1; + std::vector fbinning(binning.begin(),binning.end()); + float* arr = &fbinning[0]; + me.numerator = ibooker.book1D(histname+"_numerator", histtitle+" (numerator)", nbins, arr); + me.denominator = ibooker.book1D(histname+"_denominator", histtitle+" (denominator)", nbins, arr); +} +void JetMonitor::bookME(DQMStore::IBooker &ibooker, JetME& me, std::string& histname, std::string& histtitle, int& nbinsX, double& xmin, double& xmax, double& ymin, double& ymax) +{ + me.numerator = ibooker.bookProfile(histname+"_numerator", histtitle+" (numerator)", nbinsX, xmin, xmax, ymin, ymax); + me.denominator = ibooker.bookProfile(histname+"_denominator", histtitle+" (denominator)", nbinsX, xmin, xmax, ymin, ymax); +} +void JetMonitor::bookME(DQMStore::IBooker &ibooker, JetME& me, std::string& histname, std::string& histtitle, int& nbinsX, double& xmin, double& xmax, int& nbinsY, double& ymin, double& ymax) +{ + me.numerator = ibooker.book2D(histname+"_numerator", histtitle+" (numerator)", nbinsX, xmin, xmax, nbinsY, ymin, ymax); + me.denominator = ibooker.book2D(histname+"_denominator", histtitle+" (denominator)", nbinsX, xmin, xmax, nbinsY, ymin, ymax); +} +void JetMonitor::bookME(DQMStore::IBooker &ibooker, JetME& me, std::string& histname, std::string& histtitle, std::vector binningX, std::vector binningY) +{ + int nbinsX = binningX.size()-1; + std::vector fbinningX(binningX.begin(),binningX.end()); + float* arrX = &fbinningX[0]; + int nbinsY = binningY.size()-1; + std::vector fbinningY(binningY.begin(),binningY.end()); + float* arrY = &fbinningY[0]; + + me.numerator = ibooker.book2D(histname+"_numerator", histtitle+" (numerator)", nbinsX, arrX, nbinsY, arrY); + me.denominator = ibooker.book2D(histname+"_denominator", histtitle+" (denominator)", nbinsX, arrX, nbinsY, arrY); +} + +void JetMonitor::bookHistograms(DQMStore::IBooker & ibooker, + edm::Run const & iRun, + edm::EventSetup const & iSetup) +{ + + std::string histname, histtitle; + std::string hist_obtag = ""; + std::string histtitle_obtag = ""; + std::string currentFolder = folderName_ ; + ibooker.setCurrentFolder(currentFolder.c_str()); + + if (isPFJetTrig) {hist_obtag = "pfjet"; histtitle_obtag = "PFJet";} + else if (isCaloJetTrig) {hist_obtag = "calojet"; histtitle_obtag = "CaloJet"; } + else {hist_obtag = "pfjet"; histtitle_obtag = "PFJet"; } //default is pfjet + + // Test bookMESub + bookMESub(ibooker,a_ME,sizeof(a_ME)/sizeof(a_ME[0]),hist_obtag,histtitle_obtag,"",""); + bookMESub(ibooker,a_ME_HB,sizeof(a_ME_HB)/sizeof(a_ME_HB[0]),hist_obtag,histtitle_obtag,"HB","(HB)"); + bookMESub(ibooker,a_ME_HE,sizeof(a_ME_HE)/sizeof(a_ME_HE[0]),hist_obtag,histtitle_obtag,"HE","(HE)"); + bookMESub(ibooker,a_ME_HF,sizeof(a_ME_HF)/sizeof(a_ME_HF[0]),hist_obtag,histtitle_obtag,"HF","(HF)"); + bookMESub(ibooker,a_ME_HE_p,sizeof(a_ME_HE_p)/sizeof(a_ME_HE_p[0]),hist_obtag,histtitle_obtag,"HE_p","(HE+)"); + bookMESub(ibooker,a_ME_HE_m,sizeof(a_ME_HE_m)/sizeof(a_ME_HE_m[0]),hist_obtag,histtitle_obtag,"HE_m","(HE-)"); + bookMESub(ibooker,a_ME_HEP17,sizeof(a_ME_HEP17)/sizeof(a_ME_HEP17[0]),hist_obtag,histtitle_obtag,"HEP17","(HEP17)"); + bookMESub(ibooker,a_ME_HEM17,sizeof(a_ME_HEM17)/sizeof(a_ME_HEM17[0]),hist_obtag,histtitle_obtag,"HEM17","(HEM17)"); + bookMESub(ibooker,a_ME_HEP18,sizeof(a_ME_HEP18)/sizeof(a_ME_HEP18[0]),hist_obtag,histtitle_obtag,"HEP18","(HEP18)"); + +/* histname = hist_obtag +"EtaVsPhi"; histtitle = histtitle_obtag + " eta Vs phi "; + bookME(ibooker,jetEtaVsPhi_,histname,histtitle, jet_eta_binning_.nbins, jet_eta_binning_.xmin, jet_eta_binning_.xmax, jet_phi_binning_.nbins, jet_phi_binning_.xmin, jet_phi_binning_.xmax); + setMETitle(jetEtaVsPhi_,histtitle_obtag + " #eta","#phi"); + v_ME.push_back(jetEtaVsPhi_);*/ + + // Initialize the GenericTriggerEventFlag + if ( num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on() ) num_genTriggerEventFlag_->initRun( iRun, iSetup ); + if ( den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on() ) den_genTriggerEventFlag_->initRun( iRun, iSetup ); + +} + +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "Geometry/Records/interface/TrackerTopologyRcd.h" +#include "DataFormats/Math/interface/deltaR.h" // For Delta R +void JetMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) { + // Filter out events if Trigger Filtering is requested + if (den_genTriggerEventFlag_->on() && ! den_genTriggerEventFlag_->accept( iEvent, iSetup) ) return; + edm::Handle pfjetHandle; + iEvent.getByToken( pfjetToken_, pfjetHandle ); + + edm::Handle calojetHandle; + iEvent.getByToken( calojetToken_, calojetHandle ); + + int ls = iEvent.id().luminosityBlock(); + v_jetpt.clear(); + v_jeteta.clear(); + v_jetphi.clear(); + std::vector pfjets; + std::vector calojets; + if ( int(pfjetHandle->size()) < njets_ ) return; + if (isPFJetTrig){ + for ( auto const & jet : *pfjetHandle ) { + if(!jetSelection_(jet)) continue; + v_jetpt.push_back(jet.pt()); + v_jeteta.push_back(jet.eta()); + v_jetphi.push_back(jet.phi()); + } + } + else if (isCaloJetTrig){ + for ( auto const & jet : *calojetHandle ) { + if(!calojetSelection_(jet)) continue; + v_jetpt.push_back(jet.pt()); + v_jeteta.push_back(jet.eta()); + v_jetphi.push_back(jet.phi()); + } + } + else {cout << "Error!! Check out the type of JetTrigger!! " << endl;} +// cout << "v_jetpt.size()? " << v_jetpt.size() << endl; + if (v_jetpt.size() < 1) {return;} + double jetpt_ = v_jetpt[0]; + double jeteta_ = v_jeteta[0]; + double jetphi_ = v_jetphi[0]; + + FillME(a_ME,jetpt_,jetphi_,jeteta_,ls,"denominator"); + if (isBarrel( jeteta_ ) ) + { + FillME(a_ME_HB,jetpt_,jetphi_,jeteta_,ls,"denominator"); + } + if (isEndCapP( jeteta_ ) ) + { + FillME(a_ME_HE,jetpt_,jetphi_,jeteta_,ls,"denominator"); + FillME(a_ME_HE_p,jetpt_,jetphi_,jeteta_,ls,"denominator"); + } + if (isEndCapM( jeteta_ ) ) + { + FillME(a_ME_HE,jetpt_,jetphi_,jeteta_,ls,"denominator"); + FillME(a_ME_HE_m,jetpt_,jetphi_,jeteta_,ls,"denominator"); + } + if (isForward( jeteta_ ) ) + { + FillME(a_ME_HF,jetpt_,jetphi_,jeteta_,ls,"denominator"); + } + if (isHEP17( jeteta_, jetphi_ ) ) + { + FillME(a_ME_HEP17,jetpt_,jetphi_,jeteta_,ls,"denominator"); + } + if (isHEM17( jeteta_, jetphi_ ) ) + { + FillME(a_ME_HEM17,jetpt_,jetphi_,jeteta_,ls,"denominator"); + } + if (isHEP18( jeteta_, jetphi_ ) ) + { + FillME(a_ME_HEP18,jetpt_,jetphi_,jeteta_,ls,"denominator"); + } + if (num_genTriggerEventFlag_->on() && ! num_genTriggerEventFlag_->accept( iEvent, iSetup) ) return; // Require Numerator // + + FillME(a_ME,jetpt_,jetphi_,jeteta_,ls,"numerator"); + + if (isBarrel( jeteta_ ) ) + { + FillME(a_ME_HB,jetpt_,jetphi_,jeteta_,ls,"numerator"); + } + if (isEndCapP( jeteta_ ) ) + { + FillME(a_ME_HE,jetpt_,jetphi_,jeteta_,ls,"numerator"); + FillME(a_ME_HE_p,jetpt_,jetphi_,jeteta_,ls,"numerator"); + } + if (isEndCapM( jeteta_ ) ) + { + FillME(a_ME_HE,jetpt_,jetphi_,jeteta_,ls,"numerator"); + FillME(a_ME_HE_m,jetpt_,jetphi_,jeteta_,ls,"numerator"); + } + if (isForward( jeteta_ ) ) + { + FillME(a_ME_HF,jetpt_,jetphi_,jeteta_,ls,"numerator"); + } + if (isHEP17( jeteta_, jetphi_ ) ) + { + FillME(a_ME_HEP17,jetpt_,jetphi_,jeteta_,ls,"numerator"); + } + if (isHEM17( jeteta_, jetphi_ ) ) + { + FillME(a_ME_HEM17,jetpt_,jetphi_,jeteta_,ls,"numerator"); + } + if (isHEP18( jeteta_, jetphi_ ) ) + { + FillME(a_ME_HEP18,jetpt_,jetphi_,jeteta_,ls,"numerator"); + } + +} + +void JetMonitor::fillHistoPSetDescription(edm::ParameterSetDescription & pset) +{ + pset.add ( "nbins"); + pset.add( "xmin" ); + pset.add( "xmax" ); +} + +void JetMonitor::fillHistoLSPSetDescription(edm::ParameterSetDescription & pset) +{ + pset.add ( "nbins", 2500); +} + +void JetMonitor::fillDescriptions(edm::ConfigurationDescriptions & descriptions) +{ + edm::ParameterSetDescription desc; + desc.add ( "FolderName", "HLT/Jet" ); + + desc.add( "met", edm::InputTag("pfMet") ); + desc.add( "pfjets", edm::InputTag("ak4PFJetsCHS") ); + desc.add( "calojets", edm::InputTag("ak4CaloJets") ); + desc.add( "electrons",edm::InputTag("gedGsfElectrons") ); + desc.add( "muons", edm::InputTag("muons") ); + desc.add("njets", 0); + desc.add("nelectrons", 0); + desc.add("nmuons", 0); + desc.add("ptcut", 0); + desc.add("metSelection", "pt > 0"); + desc.add("jetSelection", "pt > 20"); + desc.add("calojetSelection", "pt > 20"); + desc.add("eleSelection", "pt > 0"); + desc.add("muoSelection", "pt > 0"); + desc.add("ispfjettrg", true); + desc.add("iscalojettrg", false); + desc.add("isjetFrac", false); + + edm::ParameterSetDescription genericTriggerEventPSet; + genericTriggerEventPSet.add("andOr"); + genericTriggerEventPSet.add("dcsInputTag", edm::InputTag("scalersRawToDigi") ); + genericTriggerEventPSet.add >("dcsPartitions",{}); + genericTriggerEventPSet.add("andOrDcs", false); + genericTriggerEventPSet.add("errorReplyDcs", true); + genericTriggerEventPSet.add("dbLabel",""); + genericTriggerEventPSet.add("andOrHlt", true); + genericTriggerEventPSet.add("hltInputTag", edm::InputTag("TriggerResults::HLT") ); + genericTriggerEventPSet.add >("hltPaths",{}); +// genericTriggerEventPSet.add("hltDBKey",""); + genericTriggerEventPSet.add("errorReplyHlt",false); + genericTriggerEventPSet.add("verbosityLevel",1); + + desc.add("numGenericTriggerEventPSet", genericTriggerEventPSet); + desc.add("denGenericTriggerEventPSet", genericTriggerEventPSet); + + edm::ParameterSetDescription histoPSet; + edm::ParameterSetDescription metPSet; + edm::ParameterSetDescription jetPtThrPSet; + fillHistoPSetDescription(metPSet); + fillHistoPSetDescription(jetPtThrPSet); + histoPSet.add("metPSet", metPSet); + histoPSet.add("jetPtThrPSet", jetPtThrPSet); + std::vector bins = {0.,20.,40.,60.,80.,90.,100.,110.,120.,130.,140.,150.,160.,170.,180.,190.,200.,220.,240.,260.,280.,300.,350.,400.,450.,1000.}; // Jet pT Binning + histoPSet.add >("jetptBinning", bins); + + edm::ParameterSetDescription lsPSet; + fillHistoLSPSetDescription(lsPSet); + histoPSet.add("lsPSet", lsPSet); + + desc.add("histoPSet",histoPSet); + + descriptions.add("jetMonitoring", desc); +} + +bool JetMonitor::isBarrel(double eta){ + bool output = false; + if (fabs(eta)<=1.3) output=true; + return output; +} + +//------------------------------------------------------------------------// +bool JetMonitor::isEndCapM(double eta){ + bool output = false; + if (fabs(eta) <= 3.0 && fabs(eta) > 1.3 && (eta/fabs(eta) < 0) ) output=true; + return output; +} +/// For Hcal Endcap Plus Area +bool JetMonitor::isEndCapP(double eta){ + bool output = false; + //if ( eta<=3.0 && eta >1.3) output=true; + if (fabs(eta) <= 3.0 && fabs(eta) > 1.3 && (eta/fabs(eta) > 0) ) output=true; + return output; +} +/// For Hcal Forward Plus Area +bool JetMonitor::isForward(double eta){ + bool output = false; + if (fabs(eta)>3.0) output=true; + return output; +} +/// For Hcal HEP17 Area +bool JetMonitor::isHEP17(double eta, double phi){ + bool output = false; + // phi -0.87 to -0.52 + if (fabs(eta) <= 3.0 && fabs(eta) > 1.3 && (eta/fabs(eta) > 0) && + phi > -0.87 && phi <= -0.52 ) {output=true;} + return output; +} +/// For Hcal HEM17 Area +bool JetMonitor::isHEM17(double eta, double phi){ + bool output = false; + if (fabs(eta) <= 3.0 && fabs(eta) > 1.3 && (eta/fabs(eta) < 0) && + phi > -0.87 && phi <= -0.52 ) {output=true;} + return output; +} +/// For Hcal HEP18 Area +bool JetMonitor::isHEP18(double eta, double phi){ + bool output = false; + // phi -0.87 to -0.52 + if (fabs(eta) <= 3.0 && fabs(eta) > 1.3 && (eta/fabs(eta) > 0) && + phi > -0.52 && phi <= -0.17 ) {output=true;} + return output; + +} +void JetMonitor::AutoNullPtr(JetME* a_me,const int len_){ + for (int i =0; i < len_; ++i) + { + a_me[i].denominator = nullptr; + a_me[i].numerator = nullptr; + } +} +void JetMonitor::FillME(std::vector v_me,double pt_, double phi_, double eta_, int ls_,std::string denu){ + std::vector v_; + v_.clear(); + v_ = v_me; + std::string DenoOrNume = ""; + DenoOrNume = denu; +/* cout << "v_me size ? " << v_me.size() << endl; + cout << "pt : " << pt_ << " eta : " << eta_ << " phi : " << phi_ << " ls : " << ls_ << endl; + for (unsigned int i =0; i < v_me.size(); ++i){ + std::cout << "v_me[" << i<< "] : " << v_me[i].denominator->getName()<< std::endl; + }*/ + if (DenoOrNume == "denominator") + { + // index 0 = pt, 1 = ptThreshold , 2 = pt vs ls , 3 = phi, 4 = eta, 5 = eta vs phi + v_me[0].denominator->Fill(pt_);// pt + v_me[1].denominator->Fill(pt_);// jetpT Threshold binning for pt + v_me[2].denominator->Fill(ls_,pt_);// pt vs ls + v_me[3].denominator->Fill(phi_);// phi + v_me[4].denominator->Fill(eta_);// eta + v_me[5].denominator->Fill(eta_,phi_);// eta vs phi + v_me[6].denominator->Fill(eta_,pt_);// eta vs phi + } + else if (DenoOrNume == "numerator") + { + v_me[0].numerator->Fill(pt_);// pt + v_me[1].numerator->Fill(pt_);// jetpT Threshold binning for pt + v_me[2].numerator->Fill(ls_,pt_);// pt vs ls + v_me[3].numerator->Fill(phi_);// phi + v_me[4].numerator->Fill(eta_);// eat + v_me[5].numerator->Fill(eta_,phi_);// eta vs phi + v_me[6].numerator->Fill(eta_,pt_);// eta vs phi + } + else { + std::cout << "CHECK OUT denu option in FillME !!!"<< std::endl; + } +} +void JetMonitor::FillME(JetME* a_me,double pt_, double phi_, double eta_, int ls_,std::string denu){ + std::string isDeno = ""; + isDeno = denu; + std::string DenoOrNume = ""; + DenoOrNume = denu; + + if (DenoOrNume == "denominator") + { + // index 0 = pt, 1 = vari.pt , 2 = pt vs ls , 3 = phi, 4 = eta, 5 = eta vs phi , 6 = eta vs pt + a_me[0].denominator->Fill(pt_);// pt + a_me[1].denominator->Fill(pt_);// jetpT Threshold binning for pt + a_me[2].denominator->Fill(ls_,pt_);// pt vs ls + a_me[3].denominator->Fill(phi_);// phi + a_me[4].denominator->Fill(eta_);// eta + a_me[5].denominator->Fill(eta_,phi_);// eta vs phi + a_me[6].denominator->Fill(eta_,pt_);// eta vs pT + } + else if (DenoOrNume == "numerator") + { + a_me[0].numerator->Fill(pt_);// pt + a_me[1].numerator->Fill(pt_);// jetpT Threshold binning for pt + a_me[2].numerator->Fill(ls_,pt_);// pt vs ls + a_me[3].numerator->Fill(phi_);// phi + a_me[4].numerator->Fill(eta_);// eat + a_me[5].numerator->Fill(eta_,phi_);// eta vs phi + a_me[6].numerator->Fill(eta_,pt_);// eta vs pT + } + else { + std::cout << "CHECK OUT denu option in FillME !!!"<< std::endl; + } +} +void JetMonitor::bookMESub(DQMStore::IBooker & Ibooker , JetME* a_me,const int len_,std::string h_Name ,std::string h_Title, std::string h_subOptName , std::string h_suOptTitle ){ + std::string hName = h_Name; + std::string hTitle = h_Title; + std::string hSubN =""; + std::string hSubT =""; + hSubT = h_suOptTitle; + + int nbin_phi = jet_phi_binning_.nbins; + double maxbin_phi = jet_phi_binning_.xmax; + double minbin_phi = jet_phi_binning_.xmin; + + int nbin_eta = jet_eta_binning_.nbins; + double maxbin_eta = jet_eta_binning_.xmax; + double minbin_eta = jet_eta_binning_.xmin; + + if (h_subOptName != ""){ + hSubN = "_"+h_subOptName; + } + + if (h_subOptName == "HEP17") { + nbin_phi = phi_binning_hep17_.nbins; + maxbin_phi = phi_binning_hep17_.xmax; + minbin_phi = phi_binning_hep17_.xmin; + + nbin_eta = eta_binning_hep17_.nbins; + maxbin_eta = eta_binning_hep17_.xmax; + minbin_eta = eta_binning_hep17_.xmin; + } + if (h_subOptName == "HEM17") { + nbin_phi = phi_binning_hep17_.nbins; + maxbin_phi = phi_binning_hep17_.xmax; + minbin_phi = phi_binning_hep17_.xmin; + + nbin_eta = eta_binning_hem17_.nbins; + maxbin_eta = eta_binning_hem17_.xmax; + minbin_eta = eta_binning_hem17_.xmin; + } + if (h_subOptName == "HEP18") { + nbin_phi = phi_binning_hep18_.nbins; + maxbin_phi = phi_binning_hep18_.xmax; + minbin_phi = phi_binning_hep18_.xmin; + + nbin_eta = eta_binning_hep17_.nbins; + maxbin_eta = eta_binning_hep17_.xmax; + minbin_eta = eta_binning_hep17_.xmin; + } + hName = h_Name+"pT"+hSubN; + hTitle = h_Title+" pT " + hSubT; + bookME(Ibooker,a_me[0],hName,hTitle,met_binning_.nbins,met_binning_.xmin, met_binning_.xmax); + setMETitle(a_me[0], h_Title +" pT [GeV]","events / [GeV]"); + + hName = h_Name+ "pT_pTThresh" + hSubN; + hTitle = h_Title+" pT " + hSubT; + bookME(Ibooker,a_me[1],hName,hTitle,jetptThr_binning_.nbins,jetptThr_binning_.xmin, jetptThr_binning_.xmax); + setMETitle(a_me[1],h_Title + "pT [GeV]","events / [GeV]"); + + hName = h_Name + "pTVsLS" + hSubN; + hTitle = h_Title+" vs LS " + hSubT; + bookME(Ibooker,a_me[2],hName,hTitle,ls_binning_.nbins, ls_binning_.xmin, ls_binning_.xmax,met_binning_.xmin, met_binning_.xmax); + setMETitle(a_me[2],"LS",h_Title + "pT [GeV]"); + + hName = h_Name + "phi" + hSubN; + hTitle = h_Title+" phi " + hSubT; +// bookME(Ibooker,a_me[3],hName,h_Title, jet_phi_binning_.nbins, jet_phi_binning_.xmin, jet_phi_binning_.xmax); + bookME(Ibooker,a_me[3],hName,hTitle, nbin_phi, minbin_phi,maxbin_phi ); + setMETitle(a_me[3],h_Title +" #phi","events / 0.1 rad"); + + hName = h_Name + "eta"+ hSubN; + hTitle = h_Title+" eta " + hSubT; +// bookME(Ibooker,a_me[4],hName,h_Title, jet_eta_binning_.nbins, jet_eta_binning_.xmin, jet_eta_binning_.xmax); + bookME(Ibooker,a_me[4],hName,hTitle, nbin_eta, minbin_eta, maxbin_eta); + setMETitle(a_me[4],h_Title + " #eta","events / #eta"); + + hName = h_Name + "EtaVsPhi"+hSubN; + hTitle = h_Title+" eta Vs phi " + hSubT; +// bookME(Ibooker,a_me[5],hName,h_Title, jet_eta_binning_.nbins, jet_eta_binning_.xmin, jet_eta_binning_.xmax, jet_phi_binning_.nbins, jet_phi_binning_.xmin, jet_phi_binning_.xmax); + bookME(Ibooker,a_me[5],hName,hTitle, nbin_eta, minbin_eta, maxbin_eta, nbin_phi, minbin_phi, maxbin_phi); + setMETitle(a_me[5],h_Title + " #eta","#phi"); + + hName = h_Name + "EtaVspT"+hSubN; + hTitle = h_Title+" eta Vs pT " + hSubT; +// bookME(Ibooker,a_me[6],hName,h_Title, jet_eta_binning_.nbins, jet_eta_binning_.xmin, jet_eta_binning_.xmax, met_binning_.nbins,met_binning_.xmin, met_binning_.xmax); + bookME(Ibooker,a_me[6],hName,hTitle, nbin_eta, minbin_eta, maxbin_eta, met_binning_.nbins,met_binning_.xmin, met_binning_.xmax); + setMETitle(a_me[6],h_Title + " #eta","Leading Jet pT [GeV]"); + +} +// Define this as a plug-in +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(JetMonitor); diff --git a/DQMOffline/Trigger/plugins/JetMonitor.h b/DQMOffline/Trigger/plugins/JetMonitor.h new file mode 100644 index 0000000000000..3f2216e699159 --- /dev/null +++ b/DQMOffline/Trigger/plugins/JetMonitor.h @@ -0,0 +1,146 @@ +#ifndef JETMETMONITOR_H +#define JETMETMONITOR_H + +#include +#include +#include + +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DQMServices/Core/interface/MonitorElement.h" +#include + +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/Registry.h" + +#include "CommonTools/Utils/interface/StringCutObjectSelector.h" + +//DataFormats +#include "DataFormats/METReco/interface/PFMET.h" +#include "DataFormats/METReco/interface/PFMETCollection.h" + +#include "DataFormats/JetReco/interface/PFJet.h" +#include "DataFormats/JetReco/interface/PFJetCollection.h" +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/JetReco/interface/CaloJetCollection.h" +#include "DataFormats/JetReco/interface/GenJetCollection.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonFwd.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/EgammaCandidates/interface/GsfElectron.h" +#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h" +#include "DataFormats/EgammaCandidates/interface/Photon.h" +#include "DataFormats/EgammaCandidates/interface/PhotonFwd.h" + +class GenericTriggerEventFlag; + +struct MEbinning { + int nbins; + double xmin; + double xmax; +}; + +struct JetME { + MonitorElement* numerator; + MonitorElement* denominator; +}; + +// +// class declaration +// + +class JetMonitor : public DQMEDAnalyzer +{ +public: + JetMonitor( const edm::ParameterSet& ); + ~JetMonitor(); + static void fillDescriptions(edm::ConfigurationDescriptions & descriptions); + static void fillHistoPSetDescription(edm::ParameterSetDescription & pset); + static void fillHistoLSPSetDescription(edm::ParameterSetDescription & pset); + +protected: + + void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override; + void bookME(DQMStore::IBooker &, JetME& me, std::string& histname, std::string& histtitle, int& nbins, double& xmin, double& xmax); + void bookME(DQMStore::IBooker &, JetME& me, std::string& histname, std::string& histtitle, std::vector binningX); + void bookME(DQMStore::IBooker &, JetME& me, std::string& histname, std::string& histtitle, int& nbinsX, double& xmin, double& xmax, double& ymin, double& ymax); + void bookME(DQMStore::IBooker &, JetME& me, std::string& histname, std::string& histtitle, int& nbinsX, double& xmin, double& xmax, int& nbinsY, double& ymin, double& ymax); + void bookME(DQMStore::IBooker &, JetME& me, std::string& histname, std::string& histtitle, std::vector binningX, std::vector binningY); + void setMETitle(JetME& me, std::string titleX, std::string titleY); + void bookME(DQMStore::IBooker &, MonitorElement* me, std::string& histname, std::string& histtitle, int& nbins, double& xmin, double& xmax); + void bookME(DQMStore::IBooker &, MonitorElement* me, std::string& histname, std::string& histtitle, int& nbinsX, double& xmin, double& xmax,int& nbinsY, double& ymin, double& ymax ); + + void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) override; + bool isBarrel(double eta); + bool isEndCapP(double eta); + bool isEndCapM(double eta); + bool isForward(double eta); + bool isHEP17(double eta, double phi); + bool isHEM17(double eta, double phi); + bool isHEP18(double eta, double phi); // -0.87< Phi < -1.22 + //void FillME(std::vector v_me,std::vectorv_pt, std::vector v_phi); //Fill Histograms + void AutoNullPtr(JetME* a_me,const int len_); //Fill Histograms + void bookMESub(DQMStore::IBooker &,JetME* a_me,const int len_,std::string h_Name ,std::string h_Title, std::string h_subOptName, std::string h_subOptTitle ); //Fill Histograms + void FillME(std::vector v_me,double pt, double phi, double eta, int ls_, std::string denu); //Fill Histograms + void FillME(JetME* a_me,double pt_, double phi_, double eta_, int ls_, std::string denu); //Fill Histograms + +private: + static MEbinning getHistoPSet (edm::ParameterSet pset); + static MEbinning getHistoLSPSet (edm::ParameterSet pset); + + std::string folderName_; + std::string histoSuffix_; + + edm::EDGetTokenT metToken_; + edm::EDGetTokenT pfjetToken_;// pfjet + edm::EDGetTokenT calojetToken_;// calojet + edm::EDGetTokenT eleToken_; + edm::EDGetTokenT muoToken_; + + std::vector met_variable_binning_; + MEbinning met_binning_; + MEbinning jetptThr_binning_; + MEbinning ls_binning_; + + + JetME a_ME[7]; + JetME a_ME_HB[7]; + JetME a_ME_HE[7]; + JetME a_ME_HF[7]; + JetME a_ME_HE_p[7]; + JetME a_ME_HE_m[7]; + JetME a_ME_HEM17[7]; + JetME a_ME_HEP17[7]; + JetME a_ME_HEP18[7]; + +// JetME jetHEP18_EtaVsPhi_; + + GenericTriggerEventFlag* num_genTriggerEventFlag_; + GenericTriggerEventFlag* den_genTriggerEventFlag_; + + StringCutObjectSelector metSelection_; + StringCutObjectSelector jetSelection_; + StringCutObjectSelector calojetSelection_; + StringCutObjectSelector eleSelection_; + StringCutObjectSelector muoSelection_; + + int njets_; + int nelectrons_; + int nmuons_; + double ptcut_; + bool isPFJetTrig; + bool isCaloJetTrig; + bool isMetTrig; + bool isJetFrac; + std::vector v_jetpt; + std::vector v_jeteta; + std::vector v_jetphi; +}; + +#endif // JETMETMONITOR_H diff --git a/DQMOffline/Trigger/python/DQMOffline_HLT_Client_cff.py b/DQMOffline/Trigger/python/DQMOffline_HLT_Client_cff.py index f26edff34ab2f..474b840988345 100644 --- a/DQMOffline/Trigger/python/DQMOffline_HLT_Client_cff.py +++ b/DQMOffline/Trigger/python/DQMOffline_HLT_Client_cff.py @@ -28,6 +28,7 @@ from DQMOffline.Trigger.BTaggingMonitoring_Client_cff import * from DQMOffline.Trigger.BPHMonitoring_Client_cff import * +from DQMOffline.Trigger.JetMETPromptMonitoring_Client_cff import * hltOfflineDQMClient = cms.Sequence( # hltGeneralSeqClient * sipixelHarvesterHLTsequence * @@ -48,6 +49,7 @@ smpClient * topClient * btaggingClient * - bphClient + bphClient* + JetMetPromClient ) diff --git a/DQMOffline/Trigger/python/DQMOffline_Trigger_cff.py b/DQMOffline/Trigger/python/DQMOffline_Trigger_cff.py index 497c6c1198424..2363acef7ac82 100644 --- a/DQMOffline/Trigger/python/DQMOffline_Trigger_cff.py +++ b/DQMOffline/Trigger/python/DQMOffline_Trigger_cff.py @@ -81,6 +81,8 @@ from DQMOffline.Trigger.BPHMonitor_cff import * # remove quadJetAna from DQMOffline.Trigger.topHLTOfflineDQM_cff import * +from DQMOffline.Trigger.JetMETPromptMonitor_cff import * + offlineHLTSource = cms.Sequence( hltResults * lumiMonitorHLTsequence * @@ -107,7 +109,8 @@ topMonitorHLT * btagMonitorHLT * bphMonitorHLT * - hltObjectsMonitor + hltObjectsMonitor * + jetmetMonitorHLT ) # offline DQM for the HLTMonitoring stream diff --git a/DQMOffline/Trigger/python/JetMETPromptMonitor_cff.py b/DQMOffline/Trigger/python/JetMETPromptMonitor_cff.py new file mode 100644 index 0000000000000..5a8f57d9333c4 --- /dev/null +++ b/DQMOffline/Trigger/python/JetMETPromptMonitor_cff.py @@ -0,0 +1,7 @@ +import FWCore.ParameterSet.Config as cms + +from DQMOffline.Trigger.JetMonitor_cff import * + +jetmetMonitorHLT = cms.Sequence( + HLTJetmonitoring +) diff --git a/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py b/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py new file mode 100644 index 0000000000000..adfecdeef4975 --- /dev/null +++ b/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py @@ -0,0 +1,172 @@ +import FWCore.ParameterSet.Config as cms +from DQMServices.Core.DQMEDHarvester import DQMEDHarvester +pfjetEfficiency = DQMEDHarvester("DQMGenericClient", + subDirs = cms.untracked.vstring("HLT/JetMET/*"), + verbose = cms.untracked.uint32(0), # Set to 2 for all messages + resolution = cms.vstring(), + efficiency = cms.vstring( + "effic_pfjetpT 'Jet pT turnON; PFJet(pT) [GeV]; efficiency' pfjetpT_numerator pfjetpT_denominator", + "effic_pfjetpT_pTThresh 'Jet pT turnON; PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_numerator pfjetpT_pTThresh_denominator", + "effic_pfjetPhi 'Jet efficiency vs #phi; PF Jet #phi [rad]; efficiency' pfjetPhi_numerator pfjetPhi_denominator", + "effic_pfjetEta 'Jet efficiency vs #eta; PF Jet #eta [rad]; efficiency' pfjetEta_numerator pfjetEta_denominator", + ## HB + "effic_pfjetpT_HB 'Jet pT turnON (HB); PFJet(pT) [GeV]; efficiency' pfjetpT_HB_numerator pfjetpT_HB_denominator", + "effic_pfjetpT_HB_pTThresh 'Jet pT turnON (HB); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HB_numerator pfjetpT_pTThresh_HB_denominator", + "effic_pfjetPhi_HB 'Jet efficiency vs #phi (HB); PF Jet #phi [rad]; efficiency' pfjetPhi_HB_numerator pfjetPhi_HB_denominator", + "effic_pfjetEta_HB 'Jet efficiency vs #eta (HB); PF Jet #eta [rad]; efficiency' pfjetEta_HB_numerator pfjetEta_HB_denominator", + + "effic_pfjetpT_HE 'Jet pT turnON (HE); PFJet(pT) [GeV]; efficiency' pfjetpT_HE_numerator pfjetpT_HE_denominator", + "effic_pfjetpT_HE_pTThresh 'Jet pT turnON (HE); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HE_numerator pfjetpT_pTThresh_HE_denominator", + "effic_pfjetPhi_HE 'Jet efficiency vs #phi (HE); PF Jet #phi [rad]; efficiency' pfjetPhi_HE_numerator pfjetPhi_HE_denominator", + "effic_pfjetEta_HE 'Jet efficiency vs #eta (HE); PF Jet #eta [rad]; efficiency' pfjetEta_HE_numerator pfjetEta_HE_denominator", + + "effic_pfjetpT_HE_p 'Jet pT turnON (HEP); PFJet(pT) [GeV]; efficiency' pfjetpT_HE_p_numerator pfjetpT_HE_p_denominator", + "effic_pfjetpT_HE_p_pTThresh 'Jet pT turnON (HEP); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HE_p_numerator pfjetpT_pTThresh_HE_p_denominator", + "effic_pfjetPhi_HE_p 'Jet efficiency vs #phi (HEP); PF Jet #phi [rad]; efficiency' pfjetPhi_HE_p_numerator pfjetPhi_HE_p_denominator", + "effic_pfjetEta_HE_p 'Jet efficiency vs #eta (HEP); PF Jet #eta [rad]; efficiency' pfjetEta_HE_p_numerator pfjetEta_HE_p_denominator", + + "effic_pfjetpT_HE_m 'Jet pT turnON (HEM); PFJet(pT) [GeV]; efficiency' pfjetpT_HE_m_numerator pfjetpT_HE_m_denominator", + "effic_pfjetpT_HE_m_pTThresh 'Jet pT turnON (HEM); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HE_m_numerator pfjetpT_pTThresh_HE_m_denominator", + "effic_pfjetPhi_HE_m 'Jet efficiency vs #phi (HEM); PF Jet phi [rad]; efficiency' pfjetPhi_HE_m_numerator pfjetPhi_HE_m_denominator", + "effic_pfjetEta_HE_m 'Jet efficiency vs #eta (HEM); PF Jet phi [rad]; efficiency' pfjetEta_HE_m_numerator pfjetEta_HE_m_denominator", + + "effic_pfjetpT_HEP17 'Jet pT turnON (HEP17); PFJet(pT) [GeV]; efficiency' pfjetpT_HEP17_numerator pfjetpT_HEP17_denominator", + "effic_pfjetpT_HEP17_pTThresh 'Jet pT turnON (HEP17); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HEP17_numerator pfjetpT_pTThresh_HEP17_denominator", + "effic_pfjetPhi_HEP17 'Jet efficiency vs #phi (HEP17); PF Jet #phi [rad]; efficiency' pfjetPhi_HEP17_numerator pfjetPhi_HEP17_denominator", + "effic_pfjetEta_HEP17 'Jet efficiency vs #eta (HEP17); PF Jet #eta [rad]; efficiency' pfjetEta_HEP17_numerator pfjetEta_HEP17_denominator", + + "effic_pfjetpT_HEM17 'Jet pT turnON (HEM17); PFJet(pT) [GeV]; efficiency' pfjetpT_HEM17_numerator pfjetpT_HEM17_denominator", + "effic_pfjetpT_HEM17_pTThresh 'Jet pT turnON (HEM17); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HEM17_numerator pfjetpT_pTThresh_HEM17_denominator", + "effic_pfjetPhi_HEM17 'Jet efficiency vs #phi (HEM17); PF Jet phi [rad]; efficiency' pfjetPhi_HEM17_numerator pfjetPhi_HEM17_denominator", + "effic_pfjetEta_HEM17 'Jet efficiency vs #eta (HEM17); PF Jet phi [rad]; efficiency' pfjetEta_HEM17_numerator pfjetEta_HEM17_denominator", + + "effic_pfjetpT_HEP18 'Jet pT turnON (HEP18); PFJet(pT) [GeV]; efficiency' pfjetpT_HEP18_numerator pfjetpT_HEP18_denominator", + "effic_pfjetpT_HEP18_pTThresh 'Jet pT turnON (HEP18); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HEP18_numerator pfjetpT_pTThresh_HEP18_denominator", + "effic_pfjetPhi_HEP18 'Jet efficiency vs #phi (HEP18); PF Jet #phi [rad]; efficiency' pfjetPhi_HEP18_numerator pfjetPhi_HEP18_denominator", + "effic_pfjetEta_HEP18 'Jet efficiency vs #eta (HEP18); PF Jet #eta [rad]; efficiency' pfjetEta_HEP18_numerator pfjetEta_HEP18_denominator", + + "effic_pfjetpT_HF 'Jet pT turnON (HF); PFJet(pT) [GeV]; efficiency' pfjetpT_HF_numerator pfjetpT_HF_denominator", + "effic_pfjetpT_HF_pTThresh 'Jet pT turnON (HF); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HF_numerator pfjetpT_pTThresh_HF_denominator", + "effic_pfjetPhi_HF 'Jet efficiency vs #phi (HF); PF Jet phi [rad]; efficiency' pfjetPhi_HF_numerator pfjetPhi_HF_denominator", + "effic_pfjetEta_HF 'Jet efficiency vs #eta (HF); PF Jet phi [rad]; efficiency' pfjetEta_HF_numerator pfjetEta_HF_denominator", + ## 2D Eff + "effic_pfjetEtaVsPhi 'Jet efficiency vs #eta and #phi; PF Jet #eta; #phi' pfjetEtaVsPhi_numerator pfjetEtaVsPhi_denominator", + "effic_pfjetEtaVsPhi_HB 'Jet efficiency vs #eta and #phi(HB); PF Jet #eta; #phi' pfjetEtaVsPhi_HB_numerator pfjetEtaVsPhi_HB_denominator", + "effic_pfjetEtaVsPhi_HE 'Jet efficiency vs #eta and #phi(HE); PF Jet #eta; #phi' pfjetEtaVsPhi_HE_numerator pfjetEtaVsPhi_HE_denominator", + "effic_pfjetEtaVsPhi_HF 'Jet efficiency vs #eta and #phi(HF); PF Jet #eta; #phi' pfjetEtaVsPhi_HF_numerator pfjetEtaVsPhi_HF_denominator", + "effic_pfjetEtaVsPhi_HEM17 'Jet efficiency vs #eta and #phi(HEM17); PF Jet #eta; #phi' pfjetEtaVsPhi_HEM17_numerator pfjetEtaVsPhi_HEM17_denominator", + "effic_pfjetEtaVsPhi_HEP17 'Jet efficiency vs #eta and #phi(HEP17); PF Jet #eta; #phi' pfjetEtaVsPhi_HEP17_numerator pfjetEtaVsPhi_HEP17_denominator", + "effic_pfjetEtaVsPhi_HEP18 'Jet efficiency vs #eta and #phi(HEP18); PF Jet #eta; #phi' pfjetEtaVsPhi_HEP18_numerator pfjetEtaVsPhi_HEP18_denominator", + "effic_pfjetEtaVsPhi_HE_p 'Jet efficiency vs #eta and #phi(HE_p); PF Jet #eta; #phi' pfjetEtaVsPhi_HE_p_numerator pfjetEtaVsPhi_HE_p_denominator", + "effic_pfjetEtaVsPhi_HE_m 'Jet efficiency vs #eta and #phi(HE_m); PF Jet #eta; #phi' pfjetEtaVsPhi_HE_m_numerator pfjetEtaVsPhi_HE_m_denominator", + ), + efficiencyProfile = cms.untracked.vstring( + "effic_pfjetpT_vs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_numerator pfjetpTVsLS_denominator", + "effic_pfjetpT_HBvs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_HB_numerator pfjetpTVsLS_HB_denominator", + "effic_pfjetpT_HEvs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_HE_numerator pfjetpTVsLS_HE_denominator", + "effic_pfjetpT_HFvs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_HF_numerator pfjetpTVsLS_HF_denominator", + "effic_pfjetpT_HEP17vs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_HEP17_numerator pfjetpTVsLS_HEP17_denominator", + "effic_pfjetpT_HEM17vs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_HEM17_numerator pfjetpTVsLS_HEM17_denominator", + "effic_pfjetpT_HE_mvs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_HE_m_numerator pfjetpTVsLS_HE_m_denominator", + "effic_pfjetpT_HE_pvs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_HE_p_numerator pfjetpTVsLS_HE_p_denominator", + ), + +) + +calojetEfficiency = DQMEDHarvester("DQMGenericClient", + subDirs = cms.untracked.vstring("HLT/JetMET/*"), + verbose = cms.untracked.uint32(0), # Set to 2 for all messages + resolution = cms.vstring(), + efficiency = cms.vstring( + "effic_calojetpT 'Jet pT turnON; CaloJet(pT) [GeV]; efficiency' calojetpT_numerator calojetpT_denominator", + "effic_calojetpT_pTThresh 'Jet pT turnON; CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_numerator calojetpT_pTThresh_denominator", + "effic_calojetPhi 'Jet efficiency vs #phi; Calo Jet phi [rad]; efficiency' calojetPhi_numerator calojetPhi_denominator", + "effic_calojetEta 'Jet efficiency vs #eta; Calo Jet phi [rad]; efficiency' calojetEta_numerator calojetEta_denominator", + + "effic_calojetpT_HB 'Jet pT turnON (HB); CaloJet(pT) [GeV]; efficiency' calojetpT_HB_numerator calojetpT_HB_denominator", + "effic_calojetpT_HB_pTThresh 'Jet pT turnON (HB); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HB_numerator calojetpT_pTThresh_HB_denominator", + "effic_calojetPhi_HB 'Jet efficiency vs #phi (HB); Calo Jet phi [rad]; efficiency' calojetPhi_HB_numerator calojetPhi_HB_denominator", + "effic_calojetEta_HB 'Jet efficiency vs #eta (HB); Calo Jet phi [rad]; efficiency' calojetEta_HB_numerator calojetEta_HB_denominator", + + "effic_calojetpT_HE 'Jet pT turnON (HE); CaloJet(pT) [GeV]; efficiency' calojetpT_HE_numerator calojetpT_HE_denominator", + "effic_calojetpT_HE_pTThresh 'Jet pT turnON (HE); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HE_numerator calojetpT_pTThresh_HE_denominator", + "effic_calojetPhi_HE 'Jet efficiency vs #phi (HE); Calo Jet phi [rad]; efficiency' calojetPhi_HE_numerator calojetPhi_HE_denominator", + "effic_calojetEta_HE 'Jet efficiency vs #eta (HE); Calo Jet phi [rad]; efficiency' calojetEta_HE_numerator calojetEta_HE_denominator", + + "effic_calojetpT_HE_p 'Jet pT turnON (HEP); CaloJet(pT) [GeV]; efficiency' calojetpT_HE_p_numerator calojetpT_HE_p_denominator", + "effic_calojetpT_HE_p_pTThresh 'Jet pT turnON (HEP); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HE_p_numerator calojetpT_pTThresh_HE_P_denominator", + "effic_calojetPhi_HE_p 'Jet efficiency vs #phi (HEP); Calo Jet phi [rad]; efficiency' calojetPhi_HE_p_numerator calojetPhi_HE_p_denominator", + "effic_calojetEta_HE_p 'Jet efficiency vs #eta (HEP); Calo Jet phi [rad]; efficiency' calojetEta_HE_p_numerator calojetEta_HE_p_denominator", + + "effic_calojetpT_HE_m 'Jet pT turnON (HEM); CaloJet(pT) [GeV]; efficiency' calojetpT_HE_m_numerator calojetpT_HE_m_denominator", + "effic_calojetpT_HE_m_pTThresh 'Jet pT turnON (HEM); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HE_m_numerator calojetpT_pTThresh_HE_m_denominator", + "effic_calojetPhi_HE_m 'Jet efficiency vs #phi (HEM); Calo Jet phi [rad]; efficiency' calojetPhi_HE_m_numerator calojetPhi_HE_m_denominator", + "effic_calojetEta_HE_m 'Jet efficiency vs #eta (HEM); Calo Jet phi [rad]; efficiency' calojetEta_HE_m_numerator calojetEta_HE_m_denominator", + + "effic_calojetpT_HEP17 'Jet pT turnON (HEP17); CaloJet(pT) [GeV]; efficiency' calojetpT_HEP17_numerator calojetpT_HEP17_denominator", + "effic_calojetpT_HEP17_pTThresh 'Jet pT turnON (HEP17); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HEP17_numerator calojetpT_pTThresh_HEP17_denominator", + "effic_calojetPhi_HEP17 'Jet efficiency vs #phi (HEP17); Calo Jet phi [rad]; efficiency' calojetPhi_HEP17_numerator calojetPhi_HEP17_denominator", + "effic_calojetEta_HEP17 'Jet efficiency vs #eta (HEP17); Calo Jet phi [rad]; efficiency' calojetEta_HEP17_numerator calojetEta_HEP17_denominator", + + "effic_calojetpT_HEP18 'Jet pT turnON (HEP18); CaloJet(pT) [GeV]; efficiency' calojetpT_HEP18_numerator calojetpT_HEP18_denominator", + "effic_calojetpT_HEP18_pTThresh 'Jet pT turnON (HEP18); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HEP18_numerator calojetpT_pTThresh_HEP18_denominator", + "effic_calojetPhi_HEP18 'Jet efficiency vs #phi (HEP18); Calo Jet phi [rad]; efficiency' calojetPhi_HEP18_numerator calojetPhi_HEP18_denominator", + "effic_calojetEta_HEP18 'Jet efficiency vs #eta (HEP18); Calo Jet phi [rad]; efficiency' calojetEta_HEP18_numerator calojetEta_HEP18_denominator", + + "effic_calojetpT_HEM17 'Jet pT turnON (HEM17); CaloJet(pT) [GeV]; efficiency' calojetpT_HEM17_numerator calojetpT_HEM17_denominator", + "effic_calojetpT_HEM17_pTThresh 'Jet pT turnON (HEM17); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HEM17_numerator calojetpT_pTThresh_HEM17_denominator", + "effic_calojetPhi_HEM17 'Jet efficiency vs #phi (HEM17); Calo Jet phi [rad]; efficiency' calojetPhi_HEM17_numerator calojetPhi_HEM17_denominator", + "effic_calojetEta_HEM17 'Jet efficiency vs #eta (HEM17); Calo Jet phi [rad]; efficiency' calojetEta_HEM17_numerator calojetEta_HEM17_denominator", + + "effic_calojetpT_HF 'Jet pT turnON; CaloJet(pT) [GeV]; efficiency' calojetpT_HF_numerator calojetpT_HF_denominator", + "effic_calojetpT_HF_pTThresh 'Jet pT turnON; CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HF_numerator calojetpT_pTThresh_HF_denominator", + "effic_calojetPhi_HF 'Jet efficiency vs #phi; Calo Jet phi [rad]; efficiency' calojetPhi_HF_numerator calojetPhi_HF_denominator", + "effic_calojetEta_HF 'Jet efficiency vs #eta; Calo Jet phi [rad]; efficiency' calojetEta_HF_numerator calojetEta_HF_denominator", + + ## 2D Eff + "effic_calojetEtaVsPhi 'Jet efficiency vs #eta and #phi; PF Jet #eta; #phi' calojetEtaVsPhi_numerator calojetEtaVsPhi_denominator", + "effic_calojetEtaVsPhi_HB 'Jet efficiency vs #eta and #phi(HB); PF Jet #eta; #phi' calojetEtaVsPhi_HB_numerator calojetEtaVsPhi_HB_denominator", + "effic_calojetEtaVsPhi_HE 'Jet efficiency vs #eta and #phi(HE); PF Jet #eta; #phi' calojetEtaVsPhi_HE_numerator calojetEtaVsPhi_HE_denominator", + "effic_calojetEtaVsPhi_HF 'Jet efficiency vs #eta and #phi(HF); PF Jet #eta; #phi' calojetEtaVsPhi_HF_numerator calojetEtaVsPhi_HF_denominator", + "effic_calojetEtaVsPhi_HEM17 'Jet efficiency vs #eta and #phi(HEM17); PF Jet #eta; #phi' calojetEtaVsPhi_HEM17_numerator calojetEtaVsPhi_HEM17_denominator", + "effic_calojetEtaVsPhi_HEP17 'Jet efficiency vs #eta and #phi(HEP17); PF Jet #eta; #phi' calojetEtaVsPhi_HEP17_numerator calojetEtaVsPhi_HEP17_denominator", + "effic_calojetEtaVsPhi_HEP18 'Jet efficiency vs #eta and #phi(HEP18); PF Jet #eta; #phi' calojetEtaVsPhi_HEP18_numerator calojetEtaVsPhi_HEP18_denominator", + "effic_calojetEtaVsPhi_HE_p 'Jet efficiency vs #eta and #phi(HE_p); PF Jet #eta; #phi' calojetEtaVsPhi_HE_p_numerator calojetEtaVsPhi_HE_p_denominator", + "effic_calojetEtaVsPhi_HE_m 'Jet efficiency vs #eta and #phi(HE_m); PF Jet #eta; #phi' calojetEtaVsPhi_HE_m_numerator calojetEtaVsPhi_HE_m_denominator", + ), + efficiencyProfile = cms.untracked.vstring( + "effic_calojetpT_vs_LS 'JET efficiency vs LS; LS; Calo Jet efficiency' calojetpTVsLS_numerator calojetpTVsLS_denominator", + "effic_calojetpT_vs_LS 'JET efficiency vs LS; LS; Calo JET efficiency' calojetpTVsLS_numerator calojetpTVsLS_denominator", + "effic_calojetpT_HBvs_LS 'JET efficiency vs LS; LS; Calo JET efficiency' calojetpTVsLS_HB_numerator calojetpTVsLS_HB_denominator", + "effic_calojetpT_HEvs_LS 'JET efficiency vs LS; LS; Calo JET efficiency' calojetpTVsLS_HE_numerator calojetpTVsLS_HE_denominator", + "effic_calojetpT_HFvs_LS 'JET efficiency vs LS; LS; Calo JET efficiency' calojetpTVsLS_HF_numerator calojetpTVsLS_HF_denominator", + "effic_calojetpT_HEP17vs_LS 'JET efficiency vs LS; LS; Calo JET efficiency' calojetpTVsLS_HEP17_numerator calojetpTVsLS_HEP17_denominator", + "effic_calojetpT_HEM17vs_LS 'JET efficiency vs LS; LS; Calo JET efficiency' calojetpTVsLS_HEM17_numerator calojetpTVsLS_HEM17_denominator", + "effic_calojetpT_HE_mvs_LS 'JET efficiency vs LS; LS; Calo JET efficiency' calojetpTVsLS_HE_m_numerator calojetpTVsLS_HE_m_denominator", + "effic_calojetpT_HE_pvs_LS 'JET efficiency vs LS; LS; Calo JET efficiency' calojetpTVsLS_HE_p_numerator calojetpTVsLS_HE_p_denominator", + ), + +) +""" +pfmetEfficiency = DQMEDHarvester("DQMGenericClient", + subDirs = cms.untracked.vstring("HLT/JetMET/*"), + verbose = cms.untracked.uint32(0), # Set to 2 for all messages + resolution = cms.vstring(), + efficiency = cms.vstring( + "effic_pfmetpT 'MET pT turnON; PFMET(pT) [GeV]; efficiency' pfmetpT_numerator pfmetpT_denominator", + "effic_pfmetpT_pTThresh 'MET pT turnON; PFMET(pT) [GeV]; efficiency' pfmetpT_pTThresh_numerator pfmetpT_pTThresh_denominator", + "effic_pfmetPhi 'MET efficiency vs #phi; PF MET phi [rad]; efficiency' pfmetPhi_numerator pfmetPhi_denominator", + "effic_pfmetEta 'MET efficiency vs #eta; PF MET phi [rad]; efficiency' pfmetEta_numerator pfmetEta_denominator", + ), + efficiencyProfile = cms.untracked.vstring( + "effic_met_vs_LS 'MET efficiency vs LS; LS; PF MET efficiency' pfmetpTVsLS_numerator pfmetpTVsLS_denominator" + ), + +) +""" + +JetMetPromClient = cms.Sequence( + pfjetEfficiency + *calojetEfficiency + # *pfmetEfficiency +) From ad4178b5771d122347d566157d5cd57e869db35e Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Fri, 9 Jun 2017 18:35:42 +0200 Subject: [PATCH 2/9] Update Prompt DQM for HLT Jet --- DQMOffline/Trigger/python/JetMonitor_cff.py | 566 ++++++++++++++++++++ DQMOffline/Trigger/python/JetMonitor_cfi.py | 38 ++ 2 files changed, 604 insertions(+) create mode 100644 DQMOffline/Trigger/python/JetMonitor_cff.py create mode 100644 DQMOffline/Trigger/python/JetMonitor_cfi.py diff --git a/DQMOffline/Trigger/python/JetMonitor_cff.py b/DQMOffline/Trigger/python/JetMonitor_cff.py new file mode 100644 index 0000000000000..721103f345718 --- /dev/null +++ b/DQMOffline/Trigger/python/JetMonitor_cff.py @@ -0,0 +1,566 @@ +import FWCore.ParameterSet.Config as cms + +from DQMOffline.Trigger.JetMonitor_cfi import hltJetMETmonitoring + +### HLT_PFJet Triggers ### +# HLT_PFJet450 +PFJet450_Prommonitoring = hltJetMETmonitoring.clone() +PFJet450_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet450/') +PFJet450_Prommonitoring.ptcut = cms.double(450) +PFJet450_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 112 ), + xmin = cms.double( 0.), + xmax = cms.double( 1120.), +) +PFJet450_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet450_v*") + +# HLT_PFJet40 +PFJet40_Prommonitoring = hltJetMETmonitoring.clone() +PFJet40_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet40/') +PFJet40_Prommonitoring.ptcut = cms.double(40) +PFJet40_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 50 ), + xmin = cms.double( 0.), + xmax = cms.double( 100.), +) +PFJet40_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet40_v*") + +# HLT_PFJet60 +PFJet60_Prommonitoring = hltJetMETmonitoring.clone() +PFJet60_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet60/') +PFJet60_Prommonitoring.ptcut = cms.double(60) +PFJet60_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 75 ), + xmin = cms.double( 0.), + xmax = cms.double( 150.), +) +PFJet60_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet60_v*") + +# HLT_PFJet80 +PFJet80_Prommonitoring = hltJetMETmonitoring.clone() +PFJet80_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet80/') +PFJet80_Prommonitoring.ptcut = cms.double(80) +PFJet80_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 100 ), + xmin = cms.double( 0.), + xmax = cms.double( 200.), +) +PFJet80_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet80_v*") + +# HLT_PFJet140 +PFJet140_Prommonitoring = hltJetMETmonitoring.clone() +PFJet140_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet140/') +PFJet140_Prommonitoring.ptcut = cms.double(140) +PFJet140_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 70 ), + xmin = cms.double( 0.), + xmax = cms.double( 350.), +) +PFJet140_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet140_v*") + +# HLT_PFJet200 +PFJet200_Prommonitoring = hltJetMETmonitoring.clone() +PFJet200_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet200/') +PFJet200_Prommonitoring.ptcut = cms.double(200) +PFJet200_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 50 ), + xmin = cms.double( 0.), + xmax = cms.double( 500.), +) +PFJet200_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet200_v*") + +# HLT_PFJet260 +PFJet260_Prommonitoring = hltJetMETmonitoring.clone() +PFJet260_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet260/') +PFJet260_Prommonitoring.ptcut = cms.double(260) +PFJet260_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 65 ), + xmin = cms.double( 0.), + xmax = cms.double( 650.), +) +PFJet260_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet260_v*") + +# HLT_PFJet320 +PFJet320_Prommonitoring = hltJetMETmonitoring.clone() +PFJet320_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet320/') +PFJet320_Prommonitoring.ptcut = cms.double(320) +PFJet320_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 80 ), + xmin = cms.double( 0.), + xmax = cms.double( 800.), +) +PFJet320_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet320_v*") + +# HLT_PFJet400 +PFJet400_Prommonitoring = hltJetMETmonitoring.clone() +PFJet400_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet400/') +PFJet400_Prommonitoring.ptcut = cms.double(400) +PFJet400_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 100 ), + xmin = cms.double( 0.), + xmax = cms.double( 1000.), +) +PFJet400_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet400_v*") + +# HLT_PFJet500 +PFJet500_Prommonitoring = hltJetMETmonitoring.clone() +PFJet500_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet500/') +PFJet500_Prommonitoring.ptcut = cms.double(500) +PFJet500_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 125), + xmin = cms.double( 0.), + xmax = cms.double(1250), +) +PFJet500_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet500_v*") + +### HLT_PFJetFwd Triggers ### +# HLT_PFJetFwd450 +PFJetFwd450_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd450_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd450/') +PFJetFwd450_Prommonitoring.ptcut = cms.double(450) +PFJetFwd450_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 112 ), + xmin = cms.double( 0.), + xmax = cms.double( 1120.), +) +PFJetFwd450_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd450_v*") + +# HLT_PFJetFwd40 +PFJetFwd40_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd40_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd40/') +PFJetFwd40_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 50 ), + xmin = cms.double( 0.), + xmax = cms.double( 100.), +) +PFJetFwd40_Prommonitoring.ptcut = cms.double(40) +PFJetFwd40_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd40_v*") + +# HLT_PFJetFwd60 +PFJetFwd60_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd60_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd60/') +PFJetFwd60_Prommonitoring.ptcut = cms.double(60) +PFJetFwd60_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 75 ), + xmin = cms.double( 0.), + xmax = cms.double( 150.), +) +PFJetFwd60_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd60_v*") + +# HLT_PFJetFwd80 +PFJetFwd80_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd80_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd80/') +PFJetFwd80_Prommonitoring.ptcut = cms.double(80) +PFJetFwd80_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 100 ), + xmin = cms.double( 0.), + xmax = cms.double( 200.), +) +PFJetFwd80_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd80_v*") + +# HLT_PFJetFwd140 +PFJetFwd140_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd140_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd140/') +PFJetFwd140_Prommonitoring.ptcut = cms.double(140) +PFJetFwd140_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 70 ), + xmin = cms.double( 0.), + xmax = cms.double( 350.), +) +PFJetFwd140_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd140_v*") + +# HLT_PFJetFwd200 +PFJetFwd200_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd200_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd200/') +PFJetFwd200_Prommonitoring.ptcut = cms.double(200) +PFJetFwd200_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 50 ), + xmin = cms.double( 0.), + xmax = cms.double( 500.), +) +PFJetFwd200_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd200_v*") + +# HLT_PFJetFwd260 +PFJetFwd260_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd260_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd260/') +PFJetFwd260_Prommonitoring.ptcut = cms.double(260) +PFJetFwd260_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 65 ), + xmin = cms.double( 0.), + xmax = cms.double( 650.), +) +PFJetFwd260_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd260_v*") + +# HLT_PFJetFwd320 +PFJetFwd320_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd320_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd320/') +PFJetFwd320_Prommonitoring.ptcut = cms.double(320) +PFJetFwd320_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 80 ), + xmin = cms.double( 0.), + xmax = cms.double( 800.), +) +PFJetFwd320_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd320_v*") + +# HLT_PFJetFwd400 +PFJetFwd400_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd400_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd400/') +PFJetFwd400_Prommonitoring.ptcut = cms.double(400) +PFJetFwd400_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 100 ), + xmin = cms.double( 0.), + xmax = cms.double( 1000.), +) +PFJetFwd400_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd400_v*") + +# HLT_PFJetFwd500 +PFJetFwd500_Prommonitoring = hltJetMETmonitoring.clone() +PFJetFwd500_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJetFwd500/') +PFJetFwd500_Prommonitoring.ptcut = cms.double(500) +PFJetFwd500_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 125), + xmin = cms.double( 0.), + xmax = cms.double(1250), +) +PFJetFwd500_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJetFwd500_v*") + +### HLT_AK8 Triggers ### +# HLT_AK8PFJet40 +AK8PFJet40_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet40_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet40/') +AK8PFJet40_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet40_Prommonitoring.ptcut = cms.double(40) +AK8PFJet40_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 50 ), + xmin = cms.double( 0.), + xmax = cms.double( 100.), +) +AK8PFJet40_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet40_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet40_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet40_v*") + +# HLT_AK8PFJet60 +AK8PFJet60_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet60_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet60/') +AK8PFJet60_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet60_Prommonitoring.ptcut = cms.double(60) +AK8PFJet60_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 75 ), + xmin = cms.double( 0.), + xmax = cms.double( 150.), +) +AK8PFJet60_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet60_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet60_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet60_v*") + +# HLT_AK8PFJet80 +AK8PFJet80_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet80_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet80/') +AK8PFJet80_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet80_Prommonitoring.ptcut = cms.double(80) +AK8PFJet80_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 100 ), + xmin = cms.double( 0.), + xmax = cms.double( 200.), +) +AK8PFJet80_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet80_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet80_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet80_v*") + +# HLT_AK8PFJet140 +AK8PFJet140_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet140_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet140/') +AK8PFJet140_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet140_Prommonitoring.ptcut = cms.double(140) +AK8PFJet140_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 70 ), + xmin = cms.double( 0.), + xmax = cms.double( 350.), +) +AK8PFJet140_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet140_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet140_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet140_v*") + +# HLT_AK8PFJet200 +AK8PFJet200_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet200_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet200/') +AK8PFJet200_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet200_Prommonitoring.ptcut = cms.double(200) +AK8PFJet200_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 50 ), + xmin = cms.double( 0.), + xmax = cms.double( 500.), +) +AK8PFJet200_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet200_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet200_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet200_v*") + +# HLT_AK8PFJet260 +AK8PFJet260_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet260_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet260/') +AK8PFJet260_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet260_Prommonitoring.ptcut = cms.double(260) +AK8PFJet260_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 65 ), + xmin = cms.double( 0.), + xmax = cms.double( 650.), +) +AK8PFJet260_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet260_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet260_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet260_v*") + +# HLT_AK8PFJet320 +AK8PFJet320_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet320_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet320/') +AK8PFJet320_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet320_Prommonitoring.ptcut = cms.double(320) +AK8PFJet320_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 80 ), + xmin = cms.double( 0.), + xmax = cms.double( 800.), +) +AK8PFJet320_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet320_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet320_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet320_v*") + +# HLT_AK8PFJet400 +AK8PFJet400_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet400_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet400/') +AK8PFJet400_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet400_Prommonitoring.ptcut = cms.double(400) +AK8PFJet400_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 100 ), + xmin = cms.double( 0.), + xmax = cms.double( 1000.), +) +AK8PFJet400_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet400_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet400_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet400_v*") + +# HLT_AK8PFJet450 +AK8PFJet450_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet450_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet450/') +AK8PFJet450_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet450_Prommonitoring.ptcut = cms.double(450) +AK8PFJet450_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 112 ), + xmin = cms.double( 0.), + xmax = cms.double( 1120.), +) +AK8PFJet450_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet450_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet450_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet450_v*") + +# HLT_AK8PFJet500 +AK8PFJet500_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJet500_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet500/') +AK8PFJet500_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet500_Prommonitoring.ptcut = cms.double(500) +AK8PFJet500_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 125), + xmin = cms.double( 0.), + xmax = cms.double(1250), +) +AK8PFJet500_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJet500_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJet500_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJet500_v*") + +### HLT_AK8Fwd Triggers ### +# HLT_AK8PFJetFwd40 +AK8PFJetFwd40_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd40_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd40/') +AK8PFJetFwd40_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd40_Prommonitoring.ptcut = cms.double(40) +AK8PFJetFwd40_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 50 ), + xmin = cms.double( 0.), + xmax = cms.double( 100.), +) +AK8PFJetFwd40_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd40_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd40_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd40_v*") + +# HLT_AK8PFJetFwd60 +AK8PFJetFwd60_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd60_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd60/') +AK8PFJetFwd60_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd60_Prommonitoring.ptcut = cms.double(60) +AK8PFJetFwd60_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 75 ), + xmin = cms.double( 0.), + xmax = cms.double( 150.), +) +AK8PFJetFwd60_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd60_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd60_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd60_v*") + +# HLT_AK8PFJetFwd80 +AK8PFJetFwd80_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd80_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd80/') +AK8PFJetFwd80_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd80_Prommonitoring.ptcut = cms.double(80) +AK8PFJetFwd80_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 100 ), + xmin = cms.double( 0.), + xmax = cms.double( 200.), +) +AK8PFJetFwd80_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd80_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd80_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd80_v*") + +# HLT_AK8PFJetFwd140 +AK8PFJetFwd140_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd140_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd140/') +AK8PFJetFwd140_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd140_Prommonitoring.ptcut = cms.double(140) +AK8PFJetFwd140_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 70 ), + xmin = cms.double( 0.), + xmax = cms.double( 350.), +) +AK8PFJetFwd140_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd140_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd140_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd140_v*") + +# HLT_AK8PFJetFwd200 +AK8PFJetFwd200_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd200_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd200/') +AK8PFJetFwd200_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd200_Prommonitoring.ptcut = cms.double(200) +AK8PFJetFwd200_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 50 ), + xmin = cms.double( 0.), + xmax = cms.double( 500.), +) +AK8PFJetFwd200_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd200_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd200_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd200_v*") + +# HLT_AK8PFJetFwd260 +AK8PFJetFwd260_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd260_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd260/') +AK8PFJetFwd260_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd260_Prommonitoring.ptcut = cms.double(260) +AK8PFJetFwd260_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 65 ), + xmin = cms.double( 0.), + xmax = cms.double( 650.), +) +AK8PFJetFwd260_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd260_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd260_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd260_v*") + +# HLT_AK8PFJetFwd320 +AK8PFJetFwd320_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd320_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd320/') +AK8PFJetFwd320_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd320_Prommonitoring.ptcut = cms.double(320) +AK8PFJetFwd320_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 80 ), + xmin = cms.double( 0.), + xmax = cms.double( 800.), +) +AK8PFJetFwd320_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd320_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd320_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd320_v*") + +# HLT_AK8PFJetFwd400 +AK8PFJetFwd400_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd400_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd400/') +AK8PFJetFwd400_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd400_Prommonitoring.ptcut = cms.double(400) +AK8PFJetFwd400_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 100 ), + xmin = cms.double( 0.), + xmax = cms.double( 1000.), +) +AK8PFJetFwd400_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd400_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd400_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd400_v*") + +# HLT_AK8PFJetFwd450 +AK8PFJetFwd450_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd450_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd450/') +AK8PFJetFwd450_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd450_Prommonitoring.ptcut = cms.double(450) +AK8PFJetFwd450_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 112 ), + xmin = cms.double( 0.), + xmax = cms.double( 1120.), +) +AK8PFJetFwd450_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd450_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd450_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd450_v*") + +# HLT_AK8PFJetFwd500 +AK8PFJetFwd500_Prommonitoring = hltJetMETmonitoring.clone() +AK8PFJetFwd500_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd500/') +AK8PFJetFwd500_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd500_Prommonitoring.ptcut = cms.double(500) +AK8PFJetFwd500_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 125), + xmin = cms.double( 0.), + xmax = cms.double(1250), +) +AK8PFJetFwd500_Prommonitoring.ispfjettrg = cms.bool(True) +AK8PFJetFwd500_Prommonitoring.iscalojettrg = cms.bool(False) +AK8PFJetFwd500_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_AK8PFJetFwd500_v*") + +# HLT_CaloJet500_NoJetID +CaloJet500_NoJetID_Prommonitoring = hltJetMETmonitoring.clone() +CaloJet500_NoJetID_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_CaloJet500_NoJetID/') +CaloJet500_NoJetID_Prommonitoring.ptcut = cms.double(500) +CaloJet500_NoJetID_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 125), + xmin = cms.double( 0.), + xmax = cms.double(1250), +) +CaloJet500_NoJetID_Prommonitoring.ispfjettrg = cms.bool(False) +CaloJet500_NoJetID_Prommonitoring.iscalojettrg = cms.bool(True) +CaloJet500_NoJetID_Prommonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_CaloJet500_NoJetID_v*") + + + +HLTJetmonitoring = cms.Sequence( + PFJet40_Prommonitoring + *PFJet60_Prommonitoring + *PFJet80_Prommonitoring + *PFJet140_Prommonitoring + *PFJet200_Prommonitoring + *PFJet260_Prommonitoring + *PFJet320_Prommonitoring + *PFJet400_Prommonitoring + *PFJet450_Prommonitoring + *PFJet500_Prommonitoring + *PFJetFwd40_Prommonitoring + *PFJetFwd60_Prommonitoring + *PFJetFwd80_Prommonitoring + *PFJetFwd140_Prommonitoring + *PFJetFwd200_Prommonitoring + *PFJetFwd260_Prommonitoring + *PFJetFwd320_Prommonitoring + *PFJetFwd400_Prommonitoring + *PFJetFwd450_Prommonitoring + *PFJetFwd500_Prommonitoring + *AK8PFJet450_Prommonitoring + *AK8PFJet40_Prommonitoring + *AK8PFJet60_Prommonitoring + *AK8PFJet80_Prommonitoring + *AK8PFJet140_Prommonitoring + *AK8PFJet200_Prommonitoring + *AK8PFJet260_Prommonitoring + *AK8PFJet320_Prommonitoring + *AK8PFJet400_Prommonitoring + *AK8PFJet500_Prommonitoring + *AK8PFJetFwd450_Prommonitoring + *AK8PFJetFwd40_Prommonitoring + *AK8PFJetFwd60_Prommonitoring + *AK8PFJetFwd80_Prommonitoring + *AK8PFJetFwd140_Prommonitoring + *AK8PFJetFwd200_Prommonitoring + *AK8PFJetFwd260_Prommonitoring + *AK8PFJetFwd320_Prommonitoring + *AK8PFJetFwd400_Prommonitoring + *AK8PFJetFwd500_Prommonitoring + *CaloJet500_NoJetID_Prommonitoring +) diff --git a/DQMOffline/Trigger/python/JetMonitor_cfi.py b/DQMOffline/Trigger/python/JetMonitor_cfi.py new file mode 100644 index 0000000000000..121200480add7 --- /dev/null +++ b/DQMOffline/Trigger/python/JetMonitor_cfi.py @@ -0,0 +1,38 @@ +import FWCore.ParameterSet.Config as cms + +from DQMOffline.Trigger.jetMonitoring_cfi import jetMonitoring +hltJetMETmonitoring = jetMonitoring.clone() +hltJetMETmonitoring.FolderName = cms.string('HLT/JetMET/HLT_PFJet450/') +hltJetMETmonitoring.histoPSet.metPSet = cms.PSet( + nbins = cms.int32 ( 200 ), + xmin = cms.double( -0.5), + xmax = cms.double(999.5), +) +hltJetMETmonitoring.histoPSet.jetPtThrPSet = cms.PSet( + nbins = cms.int32 ( 180 ), + xmin = cms.double( 0.), + xmax = cms.double(900), +) +hltJetMETmonitoring.met = cms.InputTag("pfMetEI") # pfMet +hltJetMETmonitoring.pfjets = cms.InputTag("ak4PFJets") # ak4PFJets, ak4PFJetsCHS +hltJetMETmonitoring.electrons = cms.InputTag("gedGsfElectrons") # while pfIsolatedElectronsEI are reco::PFCandidate ! +hltJetMETmonitoring.muons = cms.InputTag("muons") # while pfIsolatedMuonsEI are reco::PFCandidate ! +hltJetMETmonitoring.ptcut = cms.double(20) # while pfIsolatedMuonsEI are reco::PFCandidate ! +hltJetMETmonitoring.ispfjettrg = cms.bool(True) # is PFJet Trigge ? +hltJetMETmonitoring.iscalojettrg = cms.bool(False) # is CaloJet Trigge ? + +hltJetMETmonitoring.numGenericTriggerEventPSet.andOr = cms.bool( False ) +hltJetMETmonitoring.numGenericTriggerEventPSet.dbLabel = cms.string("JetMETDQMTrigger") # it does not exist yet, we should consider the possibility of using the DB, but as it is now it will need a label per path ! +hltJetMETmonitoring.numGenericTriggerEventPSet.andOrHlt = cms.bool(True)# True:=OR; False:=AND +hltJetMETmonitoring.numGenericTriggerEventPSet.hltInputTag = cms.InputTag( "TriggerResults::HLT" ) +hltJetMETmonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_PFJet450_v*") # HLT_ZeroBias_v* +hltJetMETmonitoring.numGenericTriggerEventPSet.errorReplyHlt = cms.bool( False ) +hltJetMETmonitoring.numGenericTriggerEventPSet.verbosityLevel = cms.uint32(1) + +hltJetMETmonitoring.denGenericTriggerEventPSet.andOr = cms.bool( False ) +hltJetMETmonitoring.denGenericTriggerEventPSet.dcsInputTag = cms.InputTag( "scalersRawToDigi" ) +hltJetMETmonitoring.denGenericTriggerEventPSet.dcsPartitions = cms.vint32 ( 24, 25, 26, 27, 28, 29 ) # 24-27: strip, 28-29: pixel, we should add all other detectors ! +hltJetMETmonitoring.denGenericTriggerEventPSet.andOrDcs = cms.bool( False ) +hltJetMETmonitoring.denGenericTriggerEventPSet.errorReplyDcs = cms.bool( True ) +hltJetMETmonitoring.denGenericTriggerEventPSet.verbosityLevel = cms.uint32(1) + From 0710087d250b59de6f2c98c949a55166d2e5d432 Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Thu, 15 Jun 2017 18:35:30 +0200 Subject: [PATCH 3/9] Update To use edm::View --- DQMOffline/Trigger/plugins/JetMonitor.cc | 132 +++++++++++++---------- DQMOffline/Trigger/plugins/JetMonitor.h | 12 ++- 2 files changed, 86 insertions(+), 58 deletions(-) diff --git a/DQMOffline/Trigger/plugins/JetMonitor.cc b/DQMOffline/Trigger/plugins/JetMonitor.cc index 01e3d9d083b69..5e8efd8794c73 100644 --- a/DQMOffline/Trigger/plugins/JetMonitor.cc +++ b/DQMOffline/Trigger/plugins/JetMonitor.cc @@ -23,29 +23,28 @@ MEbinning jet_eta_binning_{ double Jet_MAX_PHI_HEP17 = -0.52; double Jet_MIN_PHI_HEP17 = -0.87; int N_PHI_HEP17 = 7; -const MEbinning phi_binning_hep17_{ +MEbinning phi_binning_hep17_{ N_PHI_HEP17, Jet_MIN_PHI_HEP17, Jet_MAX_PHI_HEP17 }; // Define HEP18 for PHI double Jet_MAX_PHI_HEP18 = -0.17; double Jet_MIN_PHI_HEP18 = -0.52; int N_PHI_HEP18 = 7; -const MEbinning phi_binning_hep18_{ +MEbinning phi_binning_hep18_{ N_PHI_HEP18, Jet_MIN_PHI_HEP18, Jet_MAX_PHI_HEP18 }; // Define HEP17 for ETA double Jet_MAX_ETA_HEP17 = 3.0; double Jet_MIN_ETA_HEP17 = 1.3; -int N_ETA_HEP17 = 6; -const MEbinning eta_binning_hep17_{ +int N_ETA_HEP17 = 9; +MEbinning eta_binning_hep17_{ N_ETA_HEP17, Jet_MIN_ETA_HEP17, Jet_MAX_ETA_HEP17 }; -const MEbinning eta_binning_hem17_{ - N_ETA_HEP17, -Jet_MAX_ETA_HEP17, Jet_MIN_ETA_HEP17 +MEbinning eta_binning_hem17_{ + N_ETA_HEP17, -Jet_MAX_ETA_HEP17, -Jet_MIN_ETA_HEP17 }; - // ----------------------------- // constructors and destructor // ----------------------------- @@ -59,12 +58,13 @@ JetMonitor::JetMonitor( const edm::ParameterSet& iConfig ): { folderName_ = iConfig.getParameter("FolderName"); metToken_ = consumes (iConfig.getParameter("met") ); - pfjetToken_ = mayConsume (iConfig.getParameter("pfjets") ); - calojetToken_ = mayConsume (iConfig.getParameter("calojets") ); +// pfjetToken_ = mayConsume (iConfig.getParameter("pfjets") ); +// calojetToken_ = mayConsume (iConfig.getParameter("calojets") ); + jetSrc_ = mayConsume >(iConfig.getParameter("jetSrc"));//jet eleToken_ = mayConsume(iConfig.getParameter("electrons") ); muoToken_ = mayConsume (iConfig.getParameter("muons") ); - met_variable_binning_ = iConfig.getParameter("histoPSet").getParameter >("jetptBinning"); - met_binning_ = getHistoPSet (iConfig.getParameter("histoPSet").getParameter ("metPSet") ); + jetpT_variable_binning_ = iConfig.getParameter("histoPSet").getParameter >("jetptBinning"); + jetpT_binning = getHistoPSet (iConfig.getParameter("histoPSet").getParameter ("metPSet") ); jetptThr_binning_ = getHistoPSet (iConfig.getParameter("histoPSet").getParameter ("jetPtThrPSet") ); ls_binning_ = getHistoLSPSet (iConfig.getParameter("histoPSet").getParameter ("lsPSet") ); @@ -91,6 +91,17 @@ JetMonitor::JetMonitor( const edm::ParameterSet& iConfig ): AutoNullPtr(a_ME_HEP17,sizeof(a_ME_HEP17)/sizeof(a_ME_HEP17[0])); AutoNullPtr(a_ME_HEM17,sizeof(a_ME_HEM17)/sizeof(a_ME_HEM17[0])); AutoNullPtr(a_ME_HEP18,sizeof(a_ME_HEP18)/sizeof(a_ME_HEP18[0])); + + jetHEP17_AbsEtaVsPhi_.numerator = nullptr; + jetHEP17_AbsEtaVsPhi_.denominator = nullptr; + jetHEM17_AbsEtaVsPhi_.numerator = nullptr; + jetHEM17_AbsEtaVsPhi_.denominator = nullptr; + + jetHEP17_AbsEta_.numerator = nullptr; + jetHEP17_AbsEta_.denominator = nullptr; + jetHEM17_AbsEta_.numerator = nullptr; + jetHEM17_AbsEta_.denominator = nullptr; + } JetMonitor::~JetMonitor() @@ -175,7 +186,6 @@ void JetMonitor::bookHistograms(DQMStore::IBooker & ibooker, else if (isCaloJetTrig) {hist_obtag = "calojet"; histtitle_obtag = "CaloJet"; } else {hist_obtag = "pfjet"; histtitle_obtag = "PFJet"; } //default is pfjet - // Test bookMESub bookMESub(ibooker,a_ME,sizeof(a_ME)/sizeof(a_ME[0]),hist_obtag,histtitle_obtag,"",""); bookMESub(ibooker,a_ME_HB,sizeof(a_ME_HB)/sizeof(a_ME_HB[0]),hist_obtag,histtitle_obtag,"HB","(HB)"); bookMESub(ibooker,a_ME_HE,sizeof(a_ME_HE)/sizeof(a_ME_HE[0]),hist_obtag,histtitle_obtag,"HE","(HE)"); @@ -186,11 +196,22 @@ void JetMonitor::bookHistograms(DQMStore::IBooker & ibooker, bookMESub(ibooker,a_ME_HEM17,sizeof(a_ME_HEM17)/sizeof(a_ME_HEM17[0]),hist_obtag,histtitle_obtag,"HEM17","(HEM17)"); bookMESub(ibooker,a_ME_HEP18,sizeof(a_ME_HEP18)/sizeof(a_ME_HEP18[0]),hist_obtag,histtitle_obtag,"HEP18","(HEP18)"); -/* histname = hist_obtag +"EtaVsPhi"; histtitle = histtitle_obtag + " eta Vs phi "; - bookME(ibooker,jetEtaVsPhi_,histname,histtitle, jet_eta_binning_.nbins, jet_eta_binning_.xmin, jet_eta_binning_.xmax, jet_phi_binning_.nbins, jet_phi_binning_.xmin, jet_phi_binning_.xmax); - setMETitle(jetEtaVsPhi_,histtitle_obtag + " #eta","#phi"); - v_ME.push_back(jetEtaVsPhi_);*/ - + histname = hist_obtag +"AbsEtaVsPhi_HEP17"; histtitle = histtitle_obtag + " |eta| Vs phi (HEP17) "; + bookME(ibooker,jetHEP17_AbsEtaVsPhi_,histname,histtitle, eta_binning_hep17_.nbins, eta_binning_hep17_.xmin, eta_binning_hep17_.xmax, phi_binning_hep17_.nbins,phi_binning_hep17_.xmin,phi_binning_hep17_.xmax); + setMETitle(jetHEP17_AbsEtaVsPhi_,histtitle_obtag + " |#eta|","#phi"); + + histname = hist_obtag +"AbsEtaVsPhi_HEM17"; histtitle = histtitle_obtag + " |eta| Vs phi (HEM17) "; + bookME(ibooker,jetHEM17_AbsEtaVsPhi_,histname,histtitle, eta_binning_hep17_.nbins, eta_binning_hep17_.xmin, eta_binning_hep17_.xmax, phi_binning_hep17_.nbins,phi_binning_hep17_.xmin,phi_binning_hep17_.xmax); + setMETitle(jetHEM17_AbsEtaVsPhi_,histtitle_obtag + " |#eta|","#phi"); + + histname = hist_obtag +"abseta_HEP17"; histtitle = histtitle_obtag + " |#eta| (HEP17) "; + bookME(ibooker,jetHEP17_AbsEta_,histname,histtitle, eta_binning_hep17_.nbins, eta_binning_hep17_.xmin, eta_binning_hep17_.xmax); + setMETitle(jetHEP17_AbsEta_,histtitle_obtag + " |#eta|","events / |#eta|"); + + histname = hist_obtag +"abseta_HEM17"; histtitle = histtitle_obtag + " |eta| (HEM17) "; + bookME(ibooker,jetHEM17_AbsEta_,histname,histtitle, eta_binning_hep17_.nbins, eta_binning_hep17_.xmin, eta_binning_hep17_.xmax); + setMETitle(jetHEM17_AbsEta_,histtitle_obtag + " |#eta|","events / |#eta|"); + // Initialize the GenericTriggerEventFlag if ( num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on() ) num_genTriggerEventFlag_->initRun( iRun, iSetup ); if ( den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on() ) den_genTriggerEventFlag_->initRun( iRun, iSetup ); @@ -205,37 +226,27 @@ void JetMonitor::bookHistograms(DQMStore::IBooker & ibooker, void JetMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) { // Filter out events if Trigger Filtering is requested if (den_genTriggerEventFlag_->on() && ! den_genTriggerEventFlag_->accept( iEvent, iSetup) ) return; - edm::Handle pfjetHandle; - iEvent.getByToken( pfjetToken_, pfjetHandle ); +// edm::Handle pfjetHandle; +// iEvent.getByToken( pfjetToken_, pfjetHandle ); - edm::Handle calojetHandle; - iEvent.getByToken( calojetToken_, calojetHandle ); +// edm::Handle calojetHandle; +// iEvent.getByToken( calojetToken_, calojetHandle ); int ls = iEvent.id().luminosityBlock(); v_jetpt.clear(); v_jeteta.clear(); v_jetphi.clear(); - std::vector pfjets; - std::vector calojets; - if ( int(pfjetHandle->size()) < njets_ ) return; - if (isPFJetTrig){ - for ( auto const & jet : *pfjetHandle ) { - if(!jetSelection_(jet)) continue; - v_jetpt.push_back(jet.pt()); - v_jeteta.push_back(jet.eta()); - v_jetphi.push_back(jet.phi()); - } - } - else if (isCaloJetTrig){ - for ( auto const & jet : *calojetHandle ) { - if(!calojetSelection_(jet)) continue; - v_jetpt.push_back(jet.pt()); - v_jeteta.push_back(jet.eta()); - v_jetphi.push_back(jet.phi()); - } + + edm::Handle< edm::View > offjets; + iEvent.getByToken( jetSrc_, offjets ); + for ( edm::View::const_iterator ibegin = offjets->begin(), iend = offjets->end(), ijet = ibegin; ijet != iend; ++ijet ) { + if (ijet->pt()< 20) {continue;} + v_jetpt.push_back(ijet->pt()); + v_jeteta.push_back(ijet->eta()); + v_jetphi.push_back(ijet->phi()); +// cout << "jetpt (view ) : " << ijet->pt() << endl; } - else {cout << "Error!! Check out the type of JetTrigger!! " << endl;} -// cout << "v_jetpt.size()? " << v_jetpt.size() << endl; + if (v_jetpt.size() < 1) {return;} double jetpt_ = v_jetpt[0]; double jeteta_ = v_jeteta[0]; @@ -262,11 +273,15 @@ void JetMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup } if (isHEP17( jeteta_, jetphi_ ) ) { - FillME(a_ME_HEP17,jetpt_,jetphi_,jeteta_,ls,"denominator"); + FillME(a_ME_HEP17,jetpt_,jetphi_,jeteta_,ls,"denominator"); + jetHEP17_AbsEtaVsPhi_.denominator->Fill(abs(jeteta_),jetphi_); + jetHEP17_AbsEta_.denominator->Fill(abs(jeteta_)); } if (isHEM17( jeteta_, jetphi_ ) ) { FillME(a_ME_HEM17,jetpt_,jetphi_,jeteta_,ls,"denominator"); + jetHEM17_AbsEtaVsPhi_.denominator->Fill(abs(jeteta_),jetphi_); + jetHEM17_AbsEta_.denominator->Fill(abs(jeteta_)); } if (isHEP18( jeteta_, jetphi_ ) ) { @@ -297,10 +312,14 @@ void JetMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup if (isHEP17( jeteta_, jetphi_ ) ) { FillME(a_ME_HEP17,jetpt_,jetphi_,jeteta_,ls,"numerator"); + jetHEP17_AbsEtaVsPhi_.numerator->Fill(abs(jeteta_),jetphi_); + jetHEP17_AbsEta_.numerator->Fill(abs(jeteta_)); } if (isHEM17( jeteta_, jetphi_ ) ) { FillME(a_ME_HEM17,jetpt_,jetphi_,jeteta_,ls,"numerator"); + jetHEM17_AbsEtaVsPhi_.numerator->Fill(abs(jeteta_),jetphi_); + jetHEM17_AbsEta_.numerator->Fill(abs(jeteta_)); } if (isHEP18( jeteta_, jetphi_ ) ) { @@ -327,8 +346,9 @@ void JetMonitor::fillDescriptions(edm::ConfigurationDescriptions & descriptions) desc.add ( "FolderName", "HLT/Jet" ); desc.add( "met", edm::InputTag("pfMet") ); - desc.add( "pfjets", edm::InputTag("ak4PFJetsCHS") ); - desc.add( "calojets", edm::InputTag("ak4CaloJets") ); +// desc.add( "pfjets", edm::InputTag("ak4PFJetsCHS") ); +// desc.add( "calojets", edm::InputTag("ak4CaloJets") ); + desc.add( "jetSrc", edm::InputTag("ak4PFJetsCHS") ); desc.add( "electrons",edm::InputTag("gedGsfElectrons") ); desc.add( "muons", edm::InputTag("muons") ); desc.add("njets", 0); @@ -449,7 +469,9 @@ void JetMonitor::FillME(std::vector v_me,double pt_, double phi_, double }*/ if (DenoOrNume == "denominator") { - // index 0 = pt, 1 = ptThreshold , 2 = pt vs ls , 3 = phi, 4 = eta, 5 = eta vs phi + // index 0 = pt, 1 = ptThreshold , 2 = pt vs ls , 3 = phi, 4 = eta, + // 5 = eta vs phi, 6 = eta vs pt , 7 = abs(eta) , 8 = abs(eta) vs phi + v_me[0].denominator->Fill(pt_);// pt v_me[1].denominator->Fill(pt_);// jetpT Threshold binning for pt v_me[2].denominator->Fill(ls_,pt_);// pt vs ls @@ -469,7 +491,7 @@ void JetMonitor::FillME(std::vector v_me,double pt_, double phi_, double v_me[6].numerator->Fill(eta_,pt_);// eta vs phi } else { - std::cout << "CHECK OUT denu option in FillME !!!"<< std::endl; + edm::LogWarning("JetMonitor") << "CHECK OUT denu option in FillME !!! DenoOrNume ? : " << DenoOrNume << std::endl; } } void JetMonitor::FillME(JetME* a_me,double pt_, double phi_, double eta_, int ls_,std::string denu){ @@ -480,7 +502,8 @@ void JetMonitor::FillME(JetME* a_me,double pt_, double phi_, double eta_, int ls if (DenoOrNume == "denominator") { - // index 0 = pt, 1 = vari.pt , 2 = pt vs ls , 3 = phi, 4 = eta, 5 = eta vs phi , 6 = eta vs pt + // index 0 = pt, 1 = ptThreshold , 2 = pt vs ls , 3 = phi, 4 = eta, + // 5 = eta vs phi, 6 = eta vs pt , 7 = abs(eta) , 8 = abs(eta) vs phi a_me[0].denominator->Fill(pt_);// pt a_me[1].denominator->Fill(pt_);// jetpT Threshold binning for pt a_me[2].denominator->Fill(ls_,pt_);// pt vs ls @@ -500,7 +523,7 @@ void JetMonitor::FillME(JetME* a_me,double pt_, double phi_, double eta_, int ls a_me[6].numerator->Fill(eta_,pt_);// eta vs pT } else { - std::cout << "CHECK OUT denu option in FillME !!!"<< std::endl; + edm::LogWarning("JetMonitor") << "CHECK OUT denu option in FillME !!! DenoOrNume ? : " << DenoOrNume << std::endl; } } void JetMonitor::bookMESub(DQMStore::IBooker & Ibooker , JetME* a_me,const int len_,std::string h_Name ,std::string h_Title, std::string h_subOptName , std::string h_suOptTitle ){ @@ -530,6 +553,7 @@ void JetMonitor::bookMESub(DQMStore::IBooker & Ibooker , JetME* a_me,const int l nbin_eta = eta_binning_hep17_.nbins; maxbin_eta = eta_binning_hep17_.xmax; minbin_eta = eta_binning_hep17_.xmin; + } if (h_subOptName == "HEM17") { nbin_phi = phi_binning_hep17_.nbins; @@ -539,6 +563,7 @@ void JetMonitor::bookMESub(DQMStore::IBooker & Ibooker , JetME* a_me,const int l nbin_eta = eta_binning_hem17_.nbins; maxbin_eta = eta_binning_hem17_.xmax; minbin_eta = eta_binning_hem17_.xmin; + } if (h_subOptName == "HEP18") { nbin_phi = phi_binning_hep18_.nbins; @@ -548,10 +573,11 @@ void JetMonitor::bookMESub(DQMStore::IBooker & Ibooker , JetME* a_me,const int l nbin_eta = eta_binning_hep17_.nbins; maxbin_eta = eta_binning_hep17_.xmax; minbin_eta = eta_binning_hep17_.xmin; + } hName = h_Name+"pT"+hSubN; hTitle = h_Title+" pT " + hSubT; - bookME(Ibooker,a_me[0],hName,hTitle,met_binning_.nbins,met_binning_.xmin, met_binning_.xmax); + bookME(Ibooker,a_me[0],hName,hTitle,jetpT_binning.nbins,jetpT_binning.xmin, jetpT_binning.xmax); setMETitle(a_me[0], h_Title +" pT [GeV]","events / [GeV]"); hName = h_Name+ "pT_pTThresh" + hSubN; @@ -561,31 +587,27 @@ void JetMonitor::bookMESub(DQMStore::IBooker & Ibooker , JetME* a_me,const int l hName = h_Name + "pTVsLS" + hSubN; hTitle = h_Title+" vs LS " + hSubT; - bookME(Ibooker,a_me[2],hName,hTitle,ls_binning_.nbins, ls_binning_.xmin, ls_binning_.xmax,met_binning_.xmin, met_binning_.xmax); + bookME(Ibooker,a_me[2],hName,hTitle,ls_binning_.nbins, ls_binning_.xmin, ls_binning_.xmax,jetpT_binning.xmin, jetpT_binning.xmax); setMETitle(a_me[2],"LS",h_Title + "pT [GeV]"); hName = h_Name + "phi" + hSubN; hTitle = h_Title+" phi " + hSubT; -// bookME(Ibooker,a_me[3],hName,h_Title, jet_phi_binning_.nbins, jet_phi_binning_.xmin, jet_phi_binning_.xmax); bookME(Ibooker,a_me[3],hName,hTitle, nbin_phi, minbin_phi,maxbin_phi ); setMETitle(a_me[3],h_Title +" #phi","events / 0.1 rad"); hName = h_Name + "eta"+ hSubN; hTitle = h_Title+" eta " + hSubT; -// bookME(Ibooker,a_me[4],hName,h_Title, jet_eta_binning_.nbins, jet_eta_binning_.xmin, jet_eta_binning_.xmax); bookME(Ibooker,a_me[4],hName,hTitle, nbin_eta, minbin_eta, maxbin_eta); setMETitle(a_me[4],h_Title + " #eta","events / #eta"); hName = h_Name + "EtaVsPhi"+hSubN; hTitle = h_Title+" eta Vs phi " + hSubT; -// bookME(Ibooker,a_me[5],hName,h_Title, jet_eta_binning_.nbins, jet_eta_binning_.xmin, jet_eta_binning_.xmax, jet_phi_binning_.nbins, jet_phi_binning_.xmin, jet_phi_binning_.xmax); bookME(Ibooker,a_me[5],hName,hTitle, nbin_eta, minbin_eta, maxbin_eta, nbin_phi, minbin_phi, maxbin_phi); setMETitle(a_me[5],h_Title + " #eta","#phi"); hName = h_Name + "EtaVspT"+hSubN; hTitle = h_Title+" eta Vs pT " + hSubT; -// bookME(Ibooker,a_me[6],hName,h_Title, jet_eta_binning_.nbins, jet_eta_binning_.xmin, jet_eta_binning_.xmax, met_binning_.nbins,met_binning_.xmin, met_binning_.xmax); - bookME(Ibooker,a_me[6],hName,hTitle, nbin_eta, minbin_eta, maxbin_eta, met_binning_.nbins,met_binning_.xmin, met_binning_.xmax); + bookME(Ibooker,a_me[6],hName,hTitle, nbin_eta, minbin_eta, maxbin_eta, jetpT_binning.nbins,jetpT_binning.xmin, jetpT_binning.xmax); setMETitle(a_me[6],h_Title + " #eta","Leading Jet pT [GeV]"); } diff --git a/DQMOffline/Trigger/plugins/JetMonitor.h b/DQMOffline/Trigger/plugins/JetMonitor.h index 3f2216e699159..d1e0706b42788 100644 --- a/DQMOffline/Trigger/plugins/JetMonitor.h +++ b/DQMOffline/Trigger/plugins/JetMonitor.h @@ -102,9 +102,11 @@ class JetMonitor : public DQMEDAnalyzer edm::EDGetTokenT calojetToken_;// calojet edm::EDGetTokenT eleToken_; edm::EDGetTokenT muoToken_; + //edm::InputTag jetSrc_; // test for Jet + edm::EDGetTokenT > jetSrc_; // test for Jet - std::vector met_variable_binning_; - MEbinning met_binning_; + std::vector jetpT_variable_binning_; + MEbinning jetpT_binning; MEbinning jetptThr_binning_; MEbinning ls_binning_; @@ -119,7 +121,11 @@ class JetMonitor : public DQMEDAnalyzer JetME a_ME_HEP17[7]; JetME a_ME_HEP18[7]; -// JetME jetHEP18_EtaVsPhi_; + JetME jetHEP17_AbsEtaVsPhi_; + JetME jetHEM17_AbsEtaVsPhi_; + // For Ratio plot + JetME jetHEP17_AbsEta_; + JetME jetHEM17_AbsEta_; GenericTriggerEventFlag* num_genTriggerEventFlag_; GenericTriggerEventFlag* den_genTriggerEventFlag_; From 5eeaf13f44f1ad65295b1b4e3dda2e250cf2717f Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Thu, 15 Jun 2017 18:36:01 +0200 Subject: [PATCH 4/9] Update To use edm::View --- DQMOffline/Trigger/python/JetMonitor_cff.py | 41 +++++++++++---------- DQMOffline/Trigger/python/JetMonitor_cfi.py | 3 +- 2 files changed, 23 insertions(+), 21 deletions(-) diff --git a/DQMOffline/Trigger/python/JetMonitor_cff.py b/DQMOffline/Trigger/python/JetMonitor_cff.py index 721103f345718..92e576cd5ca96 100644 --- a/DQMOffline/Trigger/python/JetMonitor_cff.py +++ b/DQMOffline/Trigger/python/JetMonitor_cff.py @@ -228,7 +228,7 @@ # HLT_AK8PFJet40 AK8PFJet40_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet40_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet40/') -AK8PFJet40_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet40_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet40_Prommonitoring.ptcut = cms.double(40) AK8PFJet40_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 50 ), @@ -242,7 +242,7 @@ # HLT_AK8PFJet60 AK8PFJet60_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet60_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet60/') -AK8PFJet60_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet60_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet60_Prommonitoring.ptcut = cms.double(60) AK8PFJet60_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 75 ), @@ -256,7 +256,7 @@ # HLT_AK8PFJet80 AK8PFJet80_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet80_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet80/') -AK8PFJet80_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet80_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet80_Prommonitoring.ptcut = cms.double(80) AK8PFJet80_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 100 ), @@ -270,7 +270,7 @@ # HLT_AK8PFJet140 AK8PFJet140_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet140_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet140/') -AK8PFJet140_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet140_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet140_Prommonitoring.ptcut = cms.double(140) AK8PFJet140_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 70 ), @@ -284,7 +284,7 @@ # HLT_AK8PFJet200 AK8PFJet200_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet200_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet200/') -AK8PFJet200_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet200_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet200_Prommonitoring.ptcut = cms.double(200) AK8PFJet200_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 50 ), @@ -298,7 +298,7 @@ # HLT_AK8PFJet260 AK8PFJet260_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet260_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet260/') -AK8PFJet260_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet260_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet260_Prommonitoring.ptcut = cms.double(260) AK8PFJet260_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 65 ), @@ -312,7 +312,7 @@ # HLT_AK8PFJet320 AK8PFJet320_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet320_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet320/') -AK8PFJet320_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet320_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet320_Prommonitoring.ptcut = cms.double(320) AK8PFJet320_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 80 ), @@ -326,7 +326,7 @@ # HLT_AK8PFJet400 AK8PFJet400_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet400_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet400/') -AK8PFJet400_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet400_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet400_Prommonitoring.ptcut = cms.double(400) AK8PFJet400_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 100 ), @@ -340,7 +340,7 @@ # HLT_AK8PFJet450 AK8PFJet450_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet450_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet450/') -AK8PFJet450_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet450_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet450_Prommonitoring.ptcut = cms.double(450) AK8PFJet450_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 112 ), @@ -354,7 +354,7 @@ # HLT_AK8PFJet500 AK8PFJet500_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJet500_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJet500/') -AK8PFJet500_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJet500_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJet500_Prommonitoring.ptcut = cms.double(500) AK8PFJet500_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 125), @@ -369,7 +369,7 @@ # HLT_AK8PFJetFwd40 AK8PFJetFwd40_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd40_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd40/') -AK8PFJetFwd40_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd40_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd40_Prommonitoring.ptcut = cms.double(40) AK8PFJetFwd40_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 50 ), @@ -383,7 +383,7 @@ # HLT_AK8PFJetFwd60 AK8PFJetFwd60_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd60_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd60/') -AK8PFJetFwd60_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd60_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd60_Prommonitoring.ptcut = cms.double(60) AK8PFJetFwd60_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 75 ), @@ -397,7 +397,7 @@ # HLT_AK8PFJetFwd80 AK8PFJetFwd80_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd80_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd80/') -AK8PFJetFwd80_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd80_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd80_Prommonitoring.ptcut = cms.double(80) AK8PFJetFwd80_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 100 ), @@ -411,7 +411,7 @@ # HLT_AK8PFJetFwd140 AK8PFJetFwd140_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd140_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd140/') -AK8PFJetFwd140_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd140_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd140_Prommonitoring.ptcut = cms.double(140) AK8PFJetFwd140_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 70 ), @@ -425,7 +425,7 @@ # HLT_AK8PFJetFwd200 AK8PFJetFwd200_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd200_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd200/') -AK8PFJetFwd200_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd200_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd200_Prommonitoring.ptcut = cms.double(200) AK8PFJetFwd200_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 50 ), @@ -439,7 +439,7 @@ # HLT_AK8PFJetFwd260 AK8PFJetFwd260_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd260_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd260/') -AK8PFJetFwd260_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd260_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd260_Prommonitoring.ptcut = cms.double(260) AK8PFJetFwd260_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 65 ), @@ -453,7 +453,7 @@ # HLT_AK8PFJetFwd320 AK8PFJetFwd320_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd320_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd320/') -AK8PFJetFwd320_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd320_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd320_Prommonitoring.ptcut = cms.double(320) AK8PFJetFwd320_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 80 ), @@ -467,7 +467,7 @@ # HLT_AK8PFJetFwd400 AK8PFJetFwd400_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd400_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd400/') -AK8PFJetFwd400_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd400_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd400_Prommonitoring.ptcut = cms.double(400) AK8PFJetFwd400_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 100 ), @@ -481,7 +481,7 @@ # HLT_AK8PFJetFwd450 AK8PFJetFwd450_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd450_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd450/') -AK8PFJetFwd450_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd450_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd450_Prommonitoring.ptcut = cms.double(450) AK8PFJetFwd450_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 112 ), @@ -495,7 +495,7 @@ # HLT_AK8PFJetFwd500 AK8PFJetFwd500_Prommonitoring = hltJetMETmonitoring.clone() AK8PFJetFwd500_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_AK8PFJetFwd500/') -AK8PFJetFwd500_Prommonitoring.pfjets = cms.InputTag("ak8PFJetsCHS") +AK8PFJetFwd500_Prommonitoring.jetSrc = cms.InputTag("ak8PFJetsCHS") AK8PFJetFwd500_Prommonitoring.ptcut = cms.double(500) AK8PFJetFwd500_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 125), @@ -509,6 +509,7 @@ # HLT_CaloJet500_NoJetID CaloJet500_NoJetID_Prommonitoring = hltJetMETmonitoring.clone() CaloJet500_NoJetID_Prommonitoring.FolderName = cms.string('HLT/JetMET/HLT_CaloJet500_NoJetID/') +CaloJet500_NoJetID_Prommonitoring.jetSrc = cms.InputTag("ak4CaloJets") CaloJet500_NoJetID_Prommonitoring.ptcut = cms.double(500) CaloJet500_NoJetID_Prommonitoring.histoPSet.jetPtThrPSet = cms.PSet( nbins = cms.int32 ( 125), diff --git a/DQMOffline/Trigger/python/JetMonitor_cfi.py b/DQMOffline/Trigger/python/JetMonitor_cfi.py index 121200480add7..4c3e5ddb59ad4 100644 --- a/DQMOffline/Trigger/python/JetMonitor_cfi.py +++ b/DQMOffline/Trigger/python/JetMonitor_cfi.py @@ -14,7 +14,8 @@ xmax = cms.double(900), ) hltJetMETmonitoring.met = cms.InputTag("pfMetEI") # pfMet -hltJetMETmonitoring.pfjets = cms.InputTag("ak4PFJets") # ak4PFJets, ak4PFJetsCHS +#hltJetMETmonitoring.pfjets = cms.InputTag("ak4PFJets") # ak4PFJets, ak4PFJetsCHS +hltJetMETmonitoring.jetSrc = cms.InputTag("ak4PFJets") # ak4PFJets, ak4PFJetsCHS hltJetMETmonitoring.electrons = cms.InputTag("gedGsfElectrons") # while pfIsolatedElectronsEI are reco::PFCandidate ! hltJetMETmonitoring.muons = cms.InputTag("muons") # while pfIsolatedMuonsEI are reco::PFCandidate ! hltJetMETmonitoring.ptcut = cms.double(20) # while pfIsolatedMuonsEI are reco::PFCandidate ! From 97f4f261786b52e3e4ba765036fbf396fde98b5a Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Thu, 15 Jun 2017 18:38:48 +0200 Subject: [PATCH 5/9] Ratio Plot(HEP17/HEM17) for eta phi pT --- .../plugins/JetPomptDQMPostProcessor.cc | 149 ++++++++++++++++++ .../plugins/JetPomptDQMPostProcessor.h | 29 ++++ .../JetMETPromptMonitoring_Client_cff.py | 100 ++++++------ 3 files changed, 226 insertions(+), 52 deletions(-) create mode 100644 DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.cc create mode 100644 DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h diff --git a/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.cc b/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.cc new file mode 100644 index 0000000000000..2f3984c64765f --- /dev/null +++ b/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.cc @@ -0,0 +1,149 @@ + +#include "DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h" + +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMServices/Core/interface/MonitorElement.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/Framework/interface/MakerMacros.h" + + +#include +#include +#include +#include +#include + + +JetPomptDQMPostProcessor::JetPomptDQMPostProcessor(const edm::ParameterSet& pset) +{ + subDir_ = pset.getUntrackedParameter("subDir"); +} + +void JetPomptDQMPostProcessor::dqmEndJob(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) +{ + ////////////////////////////////// + // setup DQM stor // + ////////////////////////////////// + + bool isPFJetDir = false; + bool isCaloJetDir = false; + //go to the directory to be processed + if(igetter.dirExists(subDir_)) ibooker.cd(subDir_); + else { + edm::LogWarning("JetPomptDQMPostProcessor") << "cannot find directory: " << subDir_ << " , skipping"; + return; + } + + std::vector subdirectories = igetter.getSubdirs(); + + for(std::vector::iterator dir = subdirectories.begin() ;dir!= subdirectories.end(); dir++ ){ + + ibooker.cd(*dir); + isPFJetDir = false; + isCaloJetDir = false; + if (TString(*dir).Contains("HLT_PFJet")) isPFJetDir = true; + if (TString(*dir).Contains("HLT_CaloJet")) isCaloJetDir = true; + if (isPFJetDir) { + dividehistos(ibooker, igetter, "effic_pfjetabseta_HEP17", "effic_pfjetabseta_HEM17", "ratio_pfjeteta_HEP17VSHEM17", "| #eta |; Ratio","HEP17/HEM17 vs |#eta|","1D");// numer deno + dividehistos(ibooker, igetter, "effic_pfjetpT_HEP17", "effic_pfjetpT_HEM17", "ratio_pfjetpT_HEP17VSHEM17", " pT [GeV]; Ratio","HEP17/HEM17 vs pT","1D");// numer deno + dividehistos(ibooker, igetter, "effic_pfjetpT_HEP17_pTThresh", "effic_pfjetpT_HEM17_pTThresh", "ratio_pfjetpT_pTTresh_HEP17VSHEM17"," pT [GeV]; Ratio","HEP17/HEM17 vs pT","1D");// numer deno + dividehistos(ibooker, igetter, "effic_pfjetphi_HEP17", "effic_pfjetphi_HEM17", "ratio_pfjetphi_HEP17VSHEM17", " #phi; Ratio","HEP17/HEM17 vs #phi","1D");// numer deno + } + if (isCaloJetDir) { + dividehistos(ibooker, igetter, "effic_calojetabseta_HEP17", "effic_calojetabseta_HEM17", "ratio_calojeteta_HEP17VSHEM17","| #eta |; Ratio","HEP17/HEM17 vs |#eta|","1D");// numer deno + dividehistos(ibooker, igetter, "effic_calojetpT_HEP17", "effic_calojetpT_HEM17", "ratio_calojetpT_HEP17VSHEM17"," pT [GeV]; Ratio","HEP17/HEM17 vs pT","1D");// numer deno + dividehistos(ibooker, igetter, "effic_calojetpT_HEP17_pTThresh", "effic_calojetpT_HEM17_pTThresh", "ratio_calojetpT_pTTresh_HEP17VSHEM17"," pT [GeV]; Ratio","HEP17/HEM17 vs pT","1D");// numer deno + dividehistos(ibooker, igetter, "effic_calojetphi_HEP17", "effic_calojetphi_HEM17", "ratio_calojetphi_HEP17VSHEM17"," #phi; Ratio","HEP17/HEM17 vs #phi","1D");// numer deno + } + + ibooker.goUp(); + } +} + +//---------------------------------------------------------------------- +//TProfile* +//TH1F* +void +JetPomptDQMPostProcessor::dividehistos(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string& numName, const std::string& denomName, + const std::string& outName, const std::string& label, const std::string& titel,const std::string histDim) +{ + //ibooker.pwd(); + if (histDim == "1D"){ + TH1F* num = getHistogram(ibooker, igetter, ibooker.pwd()+"/"+numName); + + TH1F* denom = getHistogram(ibooker, igetter, ibooker.pwd()+"/"+denomName); + + if (num == NULL) + edm::LogWarning("JetPomptDQMPostProcessor") << "numerator histogram " << ibooker.pwd()+"/"+numName << " does not exist"; + if (denom == NULL) + edm::LogWarning("JetPomptDQMPostProcessor") << "denominator histogram " << ibooker.pwd()+"/"+denomName << " does not exist"; + + // Check if histograms actually exist + //if(!num || !denom) return 0; + if(!num || !denom) return ; + + MonitorElement* meOut = ibooker.book1D(outName, titel, num->GetXaxis()->GetNbins(), num->GetXaxis()->GetXmin(), num->GetXaxis()->GetXmax()); + TH1F *ratio = new TH1F("ratio", "raito", num->GetXaxis()->GetNbins(), num->GetXaxis()->GetXmin(), num->GetXaxis()->GetXmax()); + ratio->Sumw2(); + //ratio->Divide(num,denom,1,1,"B"); + ratio->Divide(num,denom); + for (int i =0; i< ratio->GetNbinsX(); ++i){ + meOut->setBinContent(i+1,ratio->GetBinContent(i+1)); + meOut->setBinError(i+1,ratio->GetBinError(i+1)); + } + } + else if (histDim == "2D"){ + TH2F* num = getHistogram2D(ibooker, igetter, ibooker.pwd()+"/"+numName); + + TH2F* denom = getHistogram2D(ibooker, igetter, ibooker.pwd()+"/"+denomName); + + if (num == NULL) + edm::LogWarning("JetPomptDQMPostProcessor") << "numerator histogram " << ibooker.pwd()+"/"+numName << " does not exist"; + if (denom == NULL) + edm::LogWarning("JetPomptDQMPostProcessor") << "denominator histogram " << ibooker.pwd()+"/"+denomName << " does not exist"; + + // Check if histograms actually exist + //if(!num || !denom) return 0; + if(!num || !denom) return; + TH2F *ratio = new TH2F("ratio", "raito", num->GetXaxis()->GetNbins(), num->GetXaxis()->GetXmin(), num->GetXaxis()->GetXmax(),num->GetYaxis()->GetNbins(), num->GetYaxis()->GetXmin(), num->GetYaxis()->GetXmax()); + ratio->Sumw2(); + MonitorElement* meOut = ibooker.book2D(outName, titel, num->GetXaxis()->GetNbins(), num->GetXaxis()->GetXmin(), num->GetXaxis()->GetXmax(), num->GetYaxis()->GetNbins(), num->GetYaxis()->GetXmin(), num->GetYaxis()->GetXmax()); + +// num->Divide(num,denom,1,1,"B"); + ratio->Divide(num,denom); + for (int i =0; i< ratio->GetNbinsX(); ++i){ + for (int j = 0; j < ratio->GetNbinsY();++i){ + meOut->setBinContent(i+1,j+1,ratio->GetBinContent(i+1,j+1)); + meOut->setBinError(i+1,j+1,ratio->GetBinError(i+1,j+1)); + } + } + } + else { + edm::LogWarning("JetPomptDQMPostProcessor") << "CHECK OUT RATIO DIMESION OF RATIO !!"; + } +} + +//---------------------------------------------------------------------- +TH1F * +JetPomptDQMPostProcessor::getHistogram(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string &histoPath) +{ + ibooker.pwd(); + MonitorElement *monElement = igetter.get(histoPath); + if (monElement != NULL) + return monElement->getTH1F(); + else + return NULL; +} +TH2F * +JetPomptDQMPostProcessor::getHistogram2D(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string &histoPath) +{ + ibooker.pwd(); + MonitorElement *monElement = igetter.get(histoPath); + if (monElement != NULL) + return monElement->getTH2F(); + else + return NULL; +} +//---------------------------------------------------------------------- + +DEFINE_FWK_MODULE(JetPomptDQMPostProcessor); diff --git a/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h b/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h new file mode 100644 index 0000000000000..d1fe93b82a3b3 --- /dev/null +++ b/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h @@ -0,0 +1,29 @@ +// Migrated to use DQMEDHarvester by: Jyothsna Rani Komaragiri, Oct 2014 + +#ifndef DQMOffline_Trigger_JetDQMPosProcessor_H +#define DQMOffline_Trigger_JetDQMPosProcessor_H + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "DQMServices/Core/interface/DQMEDHarvester.h" + +#include "TPRegexp.h" +#include "TEfficiency.h" + +class JetPomptDQMPostProcessor : public DQMEDHarvester{ + public: + JetPomptDQMPostProcessor(const edm::ParameterSet& pset); + ~JetPomptDQMPostProcessor() {}; + + void dqmEndJob(DQMStore::IBooker &, DQMStore::IGetter &) override; //performed in the endJob + + void dividehistos(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string& numName, const std::string& denomName, const std::string& outName, const std::string& label, const std::string& titel, const std::string histDim); + + private: + std::string subDir_; + + TH1F *getHistogram(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string &histoPath); + TH2F *getHistogram2D(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string &histoPath); + +}; + +#endif diff --git a/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py b/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py index adfecdeef4975..6ddf09d07cb1a 100644 --- a/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py +++ b/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py @@ -7,48 +7,50 @@ efficiency = cms.vstring( "effic_pfjetpT 'Jet pT turnON; PFJet(pT) [GeV]; efficiency' pfjetpT_numerator pfjetpT_denominator", "effic_pfjetpT_pTThresh 'Jet pT turnON; PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_numerator pfjetpT_pTThresh_denominator", - "effic_pfjetPhi 'Jet efficiency vs #phi; PF Jet #phi [rad]; efficiency' pfjetPhi_numerator pfjetPhi_denominator", - "effic_pfjetEta 'Jet efficiency vs #eta; PF Jet #eta [rad]; efficiency' pfjetEta_numerator pfjetEta_denominator", + "effic_pfjetphi 'Jet efficiency vs #phi; PF Jet #phi [rad]; efficiency' pfjetphi_numerator pfjetphi_denominator", + "effic_pfjeteta 'Jet efficiency vs #eta; PF Jet #eta; efficiency' pfjeteta_numerator pfjeteta_denominator", ## HB "effic_pfjetpT_HB 'Jet pT turnON (HB); PFJet(pT) [GeV]; efficiency' pfjetpT_HB_numerator pfjetpT_HB_denominator", "effic_pfjetpT_HB_pTThresh 'Jet pT turnON (HB); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HB_numerator pfjetpT_pTThresh_HB_denominator", - "effic_pfjetPhi_HB 'Jet efficiency vs #phi (HB); PF Jet #phi [rad]; efficiency' pfjetPhi_HB_numerator pfjetPhi_HB_denominator", - "effic_pfjetEta_HB 'Jet efficiency vs #eta (HB); PF Jet #eta [rad]; efficiency' pfjetEta_HB_numerator pfjetEta_HB_denominator", + "effic_pfjetphi_HB 'Jet efficiency vs #phi (HB); PF Jet #phi [rad]; efficiency' pfjetphi_HB_numerator pfjetphi_HB_denominator", + "effic_pfjeteta_HB 'Jet efficiency vs #eta (HB); PF Jet #eta; efficiency' pfjeteta_HB_numerator pfjeteta_HB_denominator", "effic_pfjetpT_HE 'Jet pT turnON (HE); PFJet(pT) [GeV]; efficiency' pfjetpT_HE_numerator pfjetpT_HE_denominator", "effic_pfjetpT_HE_pTThresh 'Jet pT turnON (HE); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HE_numerator pfjetpT_pTThresh_HE_denominator", - "effic_pfjetPhi_HE 'Jet efficiency vs #phi (HE); PF Jet #phi [rad]; efficiency' pfjetPhi_HE_numerator pfjetPhi_HE_denominator", - "effic_pfjetEta_HE 'Jet efficiency vs #eta (HE); PF Jet #eta [rad]; efficiency' pfjetEta_HE_numerator pfjetEta_HE_denominator", + "effic_pfjetphi_HE 'Jet efficiency vs #phi (HE); PF Jet #phi [rad]; efficiency' pfjetphi_HE_numerator pfjetphi_HE_denominator", + "effic_pfjeteta_HE 'Jet efficiency vs #eta (HE); PF Jet #eta; efficiency' pfjeteta_HE_numerator pfjeteta_HE_denominator", "effic_pfjetpT_HE_p 'Jet pT turnON (HEP); PFJet(pT) [GeV]; efficiency' pfjetpT_HE_p_numerator pfjetpT_HE_p_denominator", "effic_pfjetpT_HE_p_pTThresh 'Jet pT turnON (HEP); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HE_p_numerator pfjetpT_pTThresh_HE_p_denominator", - "effic_pfjetPhi_HE_p 'Jet efficiency vs #phi (HEP); PF Jet #phi [rad]; efficiency' pfjetPhi_HE_p_numerator pfjetPhi_HE_p_denominator", - "effic_pfjetEta_HE_p 'Jet efficiency vs #eta (HEP); PF Jet #eta [rad]; efficiency' pfjetEta_HE_p_numerator pfjetEta_HE_p_denominator", + "effic_pfjetphi_HE_p 'Jet efficiency vs #phi (HEP); PF Jet #phi [rad]; efficiency' pfjetphi_HE_p_numerator pfjetphi_HE_p_denominator", + "effic_pfjeteta_HE_p 'Jet efficiency vs #eta (HEP); PF Jet #eta; efficiency' pfjeteta_HE_p_numerator pfjeteta_HE_p_denominator", "effic_pfjetpT_HE_m 'Jet pT turnON (HEM); PFJet(pT) [GeV]; efficiency' pfjetpT_HE_m_numerator pfjetpT_HE_m_denominator", "effic_pfjetpT_HE_m_pTThresh 'Jet pT turnON (HEM); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HE_m_numerator pfjetpT_pTThresh_HE_m_denominator", - "effic_pfjetPhi_HE_m 'Jet efficiency vs #phi (HEM); PF Jet phi [rad]; efficiency' pfjetPhi_HE_m_numerator pfjetPhi_HE_m_denominator", - "effic_pfjetEta_HE_m 'Jet efficiency vs #eta (HEM); PF Jet phi [rad]; efficiency' pfjetEta_HE_m_numerator pfjetEta_HE_m_denominator", + "effic_pfjetphi_HE_m 'Jet efficiency vs #phi (HEM); PF Jet #phi [rad]; efficiency' pfjetphi_HE_m_numerator pfjetphi_HE_m_denominator", + "effic_pfjeteta_HE_m 'Jet efficiency vs #eta (HEM); PF Jet #eta; efficiency' pfjeteta_HE_m_numerator pfjeteta_HE_m_denominator", "effic_pfjetpT_HEP17 'Jet pT turnON (HEP17); PFJet(pT) [GeV]; efficiency' pfjetpT_HEP17_numerator pfjetpT_HEP17_denominator", "effic_pfjetpT_HEP17_pTThresh 'Jet pT turnON (HEP17); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HEP17_numerator pfjetpT_pTThresh_HEP17_denominator", - "effic_pfjetPhi_HEP17 'Jet efficiency vs #phi (HEP17); PF Jet #phi [rad]; efficiency' pfjetPhi_HEP17_numerator pfjetPhi_HEP17_denominator", - "effic_pfjetEta_HEP17 'Jet efficiency vs #eta (HEP17); PF Jet #eta [rad]; efficiency' pfjetEta_HEP17_numerator pfjetEta_HEP17_denominator", + "effic_pfjetphi_HEP17 'Jet efficiency vs #phi (HEP17); PF Jet #phi [rad]; efficiency' pfjetphi_HEP17_numerator pfjetphi_HEP17_denominator", + "effic_pfjeteta_HEP17 'Jet efficiency vs #eta (HEP17); PF Jet #eta; efficiency' pfjeteta_HEP17_numerator pfjeteta_HEP17_denominator", + "effic_pfjetabseta_HEP17 'Jet efficiency vs |#eta| (HEP17); PF Jet |#eta|; efficiency' pfjetabseta_HEP17_numerator pfjetabseta_HEP17_denominator", "effic_pfjetpT_HEM17 'Jet pT turnON (HEM17); PFJet(pT) [GeV]; efficiency' pfjetpT_HEM17_numerator pfjetpT_HEM17_denominator", "effic_pfjetpT_HEM17_pTThresh 'Jet pT turnON (HEM17); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HEM17_numerator pfjetpT_pTThresh_HEM17_denominator", - "effic_pfjetPhi_HEM17 'Jet efficiency vs #phi (HEM17); PF Jet phi [rad]; efficiency' pfjetPhi_HEM17_numerator pfjetPhi_HEM17_denominator", - "effic_pfjetEta_HEM17 'Jet efficiency vs #eta (HEM17); PF Jet phi [rad]; efficiency' pfjetEta_HEM17_numerator pfjetEta_HEM17_denominator", + "effic_pfjetphi_HEM17 'Jet efficiency vs #phi (HEM17); PF Jet #phi [rad]; efficiency' pfjetphi_HEM17_numerator pfjetphi_HEM17_denominator", + "effic_pfjeteta_HEM17 'Jet efficiency vs #eta (HEM17); PF Jet #eta; efficiency' pfjeteta_HEM17_numerator pfjeteta_HEM17_denominator", + "effic_pfjetabseta_HEM17 'Jet efficiency vs |#eta| (HEM17); PF Jet |#eta|; efficiency' pfjetabseta_HEM17_numerator pfjetabseta_HEM17_denominator", "effic_pfjetpT_HEP18 'Jet pT turnON (HEP18); PFJet(pT) [GeV]; efficiency' pfjetpT_HEP18_numerator pfjetpT_HEP18_denominator", "effic_pfjetpT_HEP18_pTThresh 'Jet pT turnON (HEP18); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HEP18_numerator pfjetpT_pTThresh_HEP18_denominator", - "effic_pfjetPhi_HEP18 'Jet efficiency vs #phi (HEP18); PF Jet #phi [rad]; efficiency' pfjetPhi_HEP18_numerator pfjetPhi_HEP18_denominator", - "effic_pfjetEta_HEP18 'Jet efficiency vs #eta (HEP18); PF Jet #eta [rad]; efficiency' pfjetEta_HEP18_numerator pfjetEta_HEP18_denominator", + "effic_pfjetphi_HEP18 'Jet efficiency vs #phi (HEP18); PF Jet #phi [rad]; efficiency' pfjetphi_HEP18_numerator pfjetphi_HEP18_denominator", + "effic_pfjeteta_HEP18 'Jet efficiency vs #eta (HEP18); PF Jet #eta; efficiency' pfjeteta_HEP18_numerator pfjeteta_HEP18_denominator", "effic_pfjetpT_HF 'Jet pT turnON (HF); PFJet(pT) [GeV]; efficiency' pfjetpT_HF_numerator pfjetpT_HF_denominator", "effic_pfjetpT_HF_pTThresh 'Jet pT turnON (HF); PFJet(pT) [GeV]; efficiency' pfjetpT_pTThresh_HF_numerator pfjetpT_pTThresh_HF_denominator", - "effic_pfjetPhi_HF 'Jet efficiency vs #phi (HF); PF Jet phi [rad]; efficiency' pfjetPhi_HF_numerator pfjetPhi_HF_denominator", - "effic_pfjetEta_HF 'Jet efficiency vs #eta (HF); PF Jet phi [rad]; efficiency' pfjetEta_HF_numerator pfjetEta_HF_denominator", + "effic_pfjetphi_HF 'Jet efficiency vs #phi (HF); PF Jet #phi [rad]; efficiency' pfjetphi_HF_numerator pfjetphi_HF_denominator", + "effic_pfjeteta_HF 'Jet efficiency vs #eta (HF); PF Jet #eta; efficiency' pfjeteta_HF_numerator pfjeteta_HF_denominator", ## 2D Eff "effic_pfjetEtaVsPhi 'Jet efficiency vs #eta and #phi; PF Jet #eta; #phi' pfjetEtaVsPhi_numerator pfjetEtaVsPhi_denominator", "effic_pfjetEtaVsPhi_HB 'Jet efficiency vs #eta and #phi(HB); PF Jet #eta; #phi' pfjetEtaVsPhi_HB_numerator pfjetEtaVsPhi_HB_denominator", @@ -59,6 +61,8 @@ "effic_pfjetEtaVsPhi_HEP18 'Jet efficiency vs #eta and #phi(HEP18); PF Jet #eta; #phi' pfjetEtaVsPhi_HEP18_numerator pfjetEtaVsPhi_HEP18_denominator", "effic_pfjetEtaVsPhi_HE_p 'Jet efficiency vs #eta and #phi(HE_p); PF Jet #eta; #phi' pfjetEtaVsPhi_HE_p_numerator pfjetEtaVsPhi_HE_p_denominator", "effic_pfjetEtaVsPhi_HE_m 'Jet efficiency vs #eta and #phi(HE_m); PF Jet #eta; #phi' pfjetEtaVsPhi_HE_m_numerator pfjetEtaVsPhi_HE_m_denominator", + "effic_pfjetAbsEtaVsPhi_HEM17 'Jet efficiency vs |#eta| and #phi(HEM17); PF Jet |#eta|; #phi' pfjetAbsEtaVsPhi_HEM17_numerator pfjetAbsEtaVsPhi_HEM17_denominator", + "effic_pfjetAbsEtaVsPhi_HEP17 'Jet efficiency vs |#eta| and #phi(HEP17); PF Jet |#eta|; #phi' pfjetAbsEtaVsPhi_HEP17_numerator pfjetAbsEtaVsPhi_HEP17_denominator", ), efficiencyProfile = cms.untracked.vstring( "effic_pfjetpT_vs_LS 'JET efficiency vs LS; LS; PF JET efficiency' pfjetpTVsLS_numerator pfjetpTVsLS_denominator", @@ -80,48 +84,50 @@ efficiency = cms.vstring( "effic_calojetpT 'Jet pT turnON; CaloJet(pT) [GeV]; efficiency' calojetpT_numerator calojetpT_denominator", "effic_calojetpT_pTThresh 'Jet pT turnON; CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_numerator calojetpT_pTThresh_denominator", - "effic_calojetPhi 'Jet efficiency vs #phi; Calo Jet phi [rad]; efficiency' calojetPhi_numerator calojetPhi_denominator", - "effic_calojetEta 'Jet efficiency vs #eta; Calo Jet phi [rad]; efficiency' calojetEta_numerator calojetEta_denominator", + "effic_calojetphi 'Jet efficiency vs #phi; Calo Jet #phi [rad]; efficiency' calojetphi_numerator calojetphi_denominator", + "effic_calojeteta 'Jet efficiency vs #eta; Calo Jet #eta; efficiency' calojeteta_numerator calojeteta_denominator", "effic_calojetpT_HB 'Jet pT turnON (HB); CaloJet(pT) [GeV]; efficiency' calojetpT_HB_numerator calojetpT_HB_denominator", "effic_calojetpT_HB_pTThresh 'Jet pT turnON (HB); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HB_numerator calojetpT_pTThresh_HB_denominator", - "effic_calojetPhi_HB 'Jet efficiency vs #phi (HB); Calo Jet phi [rad]; efficiency' calojetPhi_HB_numerator calojetPhi_HB_denominator", - "effic_calojetEta_HB 'Jet efficiency vs #eta (HB); Calo Jet phi [rad]; efficiency' calojetEta_HB_numerator calojetEta_HB_denominator", + "effic_calojetphi_HB 'Jet efficiency vs #phi (HB); Calo Jet #phi [rad]; efficiency' calojetphi_HB_numerator calojetphi_HB_denominator", + "effic_calojeteta_HB 'Jet efficiency vs #eta (HB); Calo Jet #eta; efficiency' calojeteta_HB_numerator calojeteta_HB_denominator", "effic_calojetpT_HE 'Jet pT turnON (HE); CaloJet(pT) [GeV]; efficiency' calojetpT_HE_numerator calojetpT_HE_denominator", "effic_calojetpT_HE_pTThresh 'Jet pT turnON (HE); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HE_numerator calojetpT_pTThresh_HE_denominator", - "effic_calojetPhi_HE 'Jet efficiency vs #phi (HE); Calo Jet phi [rad]; efficiency' calojetPhi_HE_numerator calojetPhi_HE_denominator", - "effic_calojetEta_HE 'Jet efficiency vs #eta (HE); Calo Jet phi [rad]; efficiency' calojetEta_HE_numerator calojetEta_HE_denominator", + "effic_calojetphi_HE 'Jet efficiency vs #phi (HE); Calo Jet #phi [rad]; efficiency' calojetphi_HE_numerator calojetphi_HE_denominator", + "effic_calojeteta_HE 'Jet efficiency vs #eta (HE); Calo Jet #eta; efficiency' calojeteta_HE_numerator calojeteta_HE_denominator", "effic_calojetpT_HE_p 'Jet pT turnON (HEP); CaloJet(pT) [GeV]; efficiency' calojetpT_HE_p_numerator calojetpT_HE_p_denominator", "effic_calojetpT_HE_p_pTThresh 'Jet pT turnON (HEP); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HE_p_numerator calojetpT_pTThresh_HE_P_denominator", - "effic_calojetPhi_HE_p 'Jet efficiency vs #phi (HEP); Calo Jet phi [rad]; efficiency' calojetPhi_HE_p_numerator calojetPhi_HE_p_denominator", - "effic_calojetEta_HE_p 'Jet efficiency vs #eta (HEP); Calo Jet phi [rad]; efficiency' calojetEta_HE_p_numerator calojetEta_HE_p_denominator", + "effic_calojetphi_HE_p 'Jet efficiency vs #phi (HEP); Calo Jet #phi [rad]; efficiency' calojetphi_HE_p_numerator calojetphi_HE_p_denominator", + "effic_calojeteta_HE_p 'Jet efficiency vs #eta (HEP); Calo Jet #eta; efficiency' calojeteta_HE_p_numerator calojeteta_HE_p_denominator", "effic_calojetpT_HE_m 'Jet pT turnON (HEM); CaloJet(pT) [GeV]; efficiency' calojetpT_HE_m_numerator calojetpT_HE_m_denominator", "effic_calojetpT_HE_m_pTThresh 'Jet pT turnON (HEM); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HE_m_numerator calojetpT_pTThresh_HE_m_denominator", - "effic_calojetPhi_HE_m 'Jet efficiency vs #phi (HEM); Calo Jet phi [rad]; efficiency' calojetPhi_HE_m_numerator calojetPhi_HE_m_denominator", - "effic_calojetEta_HE_m 'Jet efficiency vs #eta (HEM); Calo Jet phi [rad]; efficiency' calojetEta_HE_m_numerator calojetEta_HE_m_denominator", + "effic_calojetphi_HE_m 'Jet efficiency vs #phi (HEM); Calo Jet #phi [rad]; efficiency' calojetphi_HE_m_numerator calojetphi_HE_m_denominator", + "effic_calojeteta_HE_m 'Jet efficiency vs #eta (HEM); Calo Jet #eta; efficiency' calojeteta_HE_m_numerator calojeteta_HE_m_denominator", "effic_calojetpT_HEP17 'Jet pT turnON (HEP17); CaloJet(pT) [GeV]; efficiency' calojetpT_HEP17_numerator calojetpT_HEP17_denominator", "effic_calojetpT_HEP17_pTThresh 'Jet pT turnON (HEP17); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HEP17_numerator calojetpT_pTThresh_HEP17_denominator", - "effic_calojetPhi_HEP17 'Jet efficiency vs #phi (HEP17); Calo Jet phi [rad]; efficiency' calojetPhi_HEP17_numerator calojetPhi_HEP17_denominator", - "effic_calojetEta_HEP17 'Jet efficiency vs #eta (HEP17); Calo Jet phi [rad]; efficiency' calojetEta_HEP17_numerator calojetEta_HEP17_denominator", + "effic_calojetphi_HEP17 'Jet efficiency vs #phi (HEP17); Calo Jet #phi [rad]; efficiency' calojetphi_HEP17_numerator calojetphi_HEP17_denominator", + "effic_calojeteta_HEP17 'Jet efficiency vs #eta (HEP17); Calo Jet #eta; efficiency' calojeteta_HEP17_numerator calojeteta_HEP17_denominator", + "effic_calojetabseta_HEP17 'Jet efficiency vs |#eta| (HEP17); Calo Jet |#eta|; efficiency' calojetabseta_HEP17_numerator calojetabseta_HEP17_denominator", "effic_calojetpT_HEP18 'Jet pT turnON (HEP18); CaloJet(pT) [GeV]; efficiency' calojetpT_HEP18_numerator calojetpT_HEP18_denominator", "effic_calojetpT_HEP18_pTThresh 'Jet pT turnON (HEP18); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HEP18_numerator calojetpT_pTThresh_HEP18_denominator", - "effic_calojetPhi_HEP18 'Jet efficiency vs #phi (HEP18); Calo Jet phi [rad]; efficiency' calojetPhi_HEP18_numerator calojetPhi_HEP18_denominator", - "effic_calojetEta_HEP18 'Jet efficiency vs #eta (HEP18); Calo Jet phi [rad]; efficiency' calojetEta_HEP18_numerator calojetEta_HEP18_denominator", + "effic_calojetphi_HEP18 'Jet efficiency vs #phi (HEP18); Calo Jet phi [rad]; efficiency' calojetphi_HEP18_numerator calojetphi_HEP18_denominator", + "effic_calojeteta_HEP18 'Jet efficiency vs #eta (HEP18); Calo Jet #eta; efficiency' calojeteta_HEP18_numerator calojeteta_HEP18_denominator", "effic_calojetpT_HEM17 'Jet pT turnON (HEM17); CaloJet(pT) [GeV]; efficiency' calojetpT_HEM17_numerator calojetpT_HEM17_denominator", "effic_calojetpT_HEM17_pTThresh 'Jet pT turnON (HEM17); CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HEM17_numerator calojetpT_pTThresh_HEM17_denominator", - "effic_calojetPhi_HEM17 'Jet efficiency vs #phi (HEM17); Calo Jet phi [rad]; efficiency' calojetPhi_HEM17_numerator calojetPhi_HEM17_denominator", - "effic_calojetEta_HEM17 'Jet efficiency vs #eta (HEM17); Calo Jet phi [rad]; efficiency' calojetEta_HEM17_numerator calojetEta_HEM17_denominator", + "effic_calojetphi_HEM17 'Jet efficiency vs #phi (HEM17); Calo Jet #phi; efficiency' calojetphi_HEM17_numerator calojetphi_HEM17_denominator", + "effic_calojeteta_HEM17 'Jet efficiency vs #eta (HEM17); Calo Jet #eta; efficiency' calojeteta_HEM17_numerator calojeteta_HEM17_denominator", + "effic_calojetabseta_HEM17 'Jet efficiency vs #eta (HEM17); Calo Jet |#eta|; efficiency' calojetabseta_HEM17_numerator calojetabseta_HEM17_denominator", "effic_calojetpT_HF 'Jet pT turnON; CaloJet(pT) [GeV]; efficiency' calojetpT_HF_numerator calojetpT_HF_denominator", "effic_calojetpT_HF_pTThresh 'Jet pT turnON; CaloJet(pT) [GeV]; efficiency' calojetpT_pTThresh_HF_numerator calojetpT_pTThresh_HF_denominator", - "effic_calojetPhi_HF 'Jet efficiency vs #phi; Calo Jet phi [rad]; efficiency' calojetPhi_HF_numerator calojetPhi_HF_denominator", - "effic_calojetEta_HF 'Jet efficiency vs #eta; Calo Jet phi [rad]; efficiency' calojetEta_HF_numerator calojetEta_HF_denominator", + "effic_calojetphi_HF 'Jet efficiency vs #phi; Calo Jet #phi [rad]; efficiency' calojetphi_HF_numerator calojetphi_HF_denominator", + "effic_calojeteta_HF 'Jet efficiency vs #eta; Calo Jet #eta; efficiency' calojeteta_HF_numerator calojeteta_HF_denominator", ## 2D Eff "effic_calojetEtaVsPhi 'Jet efficiency vs #eta and #phi; PF Jet #eta; #phi' calojetEtaVsPhi_numerator calojetEtaVsPhi_denominator", @@ -133,6 +139,8 @@ "effic_calojetEtaVsPhi_HEP18 'Jet efficiency vs #eta and #phi(HEP18); PF Jet #eta; #phi' calojetEtaVsPhi_HEP18_numerator calojetEtaVsPhi_HEP18_denominator", "effic_calojetEtaVsPhi_HE_p 'Jet efficiency vs #eta and #phi(HE_p); PF Jet #eta; #phi' calojetEtaVsPhi_HE_p_numerator calojetEtaVsPhi_HE_p_denominator", "effic_calojetEtaVsPhi_HE_m 'Jet efficiency vs #eta and #phi(HE_m); PF Jet #eta; #phi' calojetEtaVsPhi_HE_m_numerator calojetEtaVsPhi_HE_m_denominator", + "effic_calojetAbsEtaVsPhi_HEM17 'Jet efficiency vs |#eta| and #phi(HEM17); PF Jet |#eta|; #phi' calojetAbsEtaVsPhi_HEM17_numerator calojetAbsEtaVsPhi_HEM17_denominator", + "effic_calojetAbsEtaVsPhi_HEP17 'Jet efficiency vs |#eta| and #phi(HEP17); PF Jet |#eta|; #phi' calojetAbsEtaVsPhi_HEP17_numerator calojetAbsEtaVsPhi_HEP17_denominator", ), efficiencyProfile = cms.untracked.vstring( "effic_calojetpT_vs_LS 'JET efficiency vs LS; LS; Calo Jet efficiency' calojetpTVsLS_numerator calojetpTVsLS_denominator", @@ -147,26 +155,14 @@ ), ) -""" -pfmetEfficiency = DQMEDHarvester("DQMGenericClient", - subDirs = cms.untracked.vstring("HLT/JetMET/*"), - verbose = cms.untracked.uint32(0), # Set to 2 for all messages - resolution = cms.vstring(), - efficiency = cms.vstring( - "effic_pfmetpT 'MET pT turnON; PFMET(pT) [GeV]; efficiency' pfmetpT_numerator pfmetpT_denominator", - "effic_pfmetpT_pTThresh 'MET pT turnON; PFMET(pT) [GeV]; efficiency' pfmetpT_pTThresh_numerator pfmetpT_pTThresh_denominator", - "effic_pfmetPhi 'MET efficiency vs #phi; PF MET phi [rad]; efficiency' pfmetPhi_numerator pfmetPhi_denominator", - "effic_pfmetEta 'MET efficiency vs #eta; PF MET phi [rad]; efficiency' pfmetEta_numerator pfmetEta_denominator", - ), - efficiencyProfile = cms.untracked.vstring( - "effic_met_vs_LS 'MET efficiency vs LS; LS; PF MET efficiency' pfmetpTVsLS_numerator pfmetpTVsLS_denominator" - ), - +jetRatioHemHep17 = DQMEDHarvester("JetPomptDQMPostProcessor", + subDir = cms.untracked.string("HLT/JetMET"), + PatternJetTrg = cms.untracked.string("HLT_Jet([0-9])+") ) -""" JetMetPromClient = cms.Sequence( pfjetEfficiency *calojetEfficiency + *jetRatioHemHep17 # *pfmetEfficiency ) From aaa57c09bb28cdfa75864e1c6dbd7945efd3acbd Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Wed, 21 Jun 2017 18:51:23 +0200 Subject: [PATCH 6/9] To avoid the case of non ak4pfjet, bug fix --- DQMOffline/Trigger/plugins/JetMonitor.cc | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/DQMOffline/Trigger/plugins/JetMonitor.cc b/DQMOffline/Trigger/plugins/JetMonitor.cc index 5e8efd8794c73..51e670a9a9fcb 100644 --- a/DQMOffline/Trigger/plugins/JetMonitor.cc +++ b/DQMOffline/Trigger/plugins/JetMonitor.cc @@ -239,6 +239,10 @@ void JetMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup edm::Handle< edm::View > offjets; iEvent.getByToken( jetSrc_, offjets ); + if (!offjets.isValid()){ + edm::LogWarning("JetMonitor") << "Jet handle not valid \n"; + return; + } for ( edm::View::const_iterator ibegin = offjets->begin(), iend = offjets->end(), ijet = ibegin; ijet != iend; ++ijet ) { if (ijet->pt()< 20) {continue;} v_jetpt.push_back(ijet->pt()); From e6a6fe03c2df1c816992c45842efed9e5d35b2c2 Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Mon, 3 Jul 2017 03:37:51 +0200 Subject: [PATCH 7/9] fix uncertainty for simpleratio in DQMGenericClient --- DQMServices/ClientConfig/plugins/DQMGenericClient.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/DQMServices/ClientConfig/plugins/DQMGenericClient.cc b/DQMServices/ClientConfig/plugins/DQMGenericClient.cc index 43cc355938020..097e295d41c15 100644 --- a/DQMServices/ClientConfig/plugins/DQMGenericClient.cc +++ b/DQMServices/ClientConfig/plugins/DQMGenericClient.cc @@ -960,7 +960,11 @@ void DQMGenericClient::generic_eff (TH1* denom, TH1* numer, MonitorElement* effi float errVal = 0; if (type == EfficType::simpleratio) { - errVal = denomVal ? 1.f/denomVal*effVal*(1+effVal) : 0; +// errVal = denomVal ? 1.f/denomVal*effVal*(1+effVal) : 0; + float numerErr = numer->GetBinError(globalBinNum); + float denomErr = denom->GetBinError(globalBinNum); + float denomsq = denomVal*denomVal; + errVal = denomVal ? sqrt( pow( 1.f/denomVal*numerErr,2.0) + pow(numerVal/denomsq*denomErr,2) ): 0; } else { errVal = (denomVal && (effVal <=1)) ? sqrt(effVal*(1-effVal)/denomVal) : 0; } From f5ce0b79306354b614b08472ea0bbed3e811ebde Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Mon, 3 Jul 2017 04:15:35 +0200 Subject: [PATCH 8/9] There is no need to use JetPomptDQMPostProcessor, because we will use DQMGenericClient --- .../plugins/JetPomptDQMPostProcessor.cc | 149 ------------------ .../plugins/JetPomptDQMPostProcessor.h | 29 ---- 2 files changed, 178 deletions(-) delete mode 100644 DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.cc delete mode 100644 DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h diff --git a/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.cc b/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.cc deleted file mode 100644 index 2f3984c64765f..0000000000000 --- a/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.cc +++ /dev/null @@ -1,149 +0,0 @@ - -#include "DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h" - -#include "DQMServices/Core/interface/DQMStore.h" -#include "DQMServices/Core/interface/MonitorElement.h" -#include "FWCore/ServiceRegistry/interface/Service.h" -#include "FWCore/Framework/interface/MakerMacros.h" - - -#include -#include -#include -#include -#include - - -JetPomptDQMPostProcessor::JetPomptDQMPostProcessor(const edm::ParameterSet& pset) -{ - subDir_ = pset.getUntrackedParameter("subDir"); -} - -void JetPomptDQMPostProcessor::dqmEndJob(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) -{ - ////////////////////////////////// - // setup DQM stor // - ////////////////////////////////// - - bool isPFJetDir = false; - bool isCaloJetDir = false; - //go to the directory to be processed - if(igetter.dirExists(subDir_)) ibooker.cd(subDir_); - else { - edm::LogWarning("JetPomptDQMPostProcessor") << "cannot find directory: " << subDir_ << " , skipping"; - return; - } - - std::vector subdirectories = igetter.getSubdirs(); - - for(std::vector::iterator dir = subdirectories.begin() ;dir!= subdirectories.end(); dir++ ){ - - ibooker.cd(*dir); - isPFJetDir = false; - isCaloJetDir = false; - if (TString(*dir).Contains("HLT_PFJet")) isPFJetDir = true; - if (TString(*dir).Contains("HLT_CaloJet")) isCaloJetDir = true; - if (isPFJetDir) { - dividehistos(ibooker, igetter, "effic_pfjetabseta_HEP17", "effic_pfjetabseta_HEM17", "ratio_pfjeteta_HEP17VSHEM17", "| #eta |; Ratio","HEP17/HEM17 vs |#eta|","1D");// numer deno - dividehistos(ibooker, igetter, "effic_pfjetpT_HEP17", "effic_pfjetpT_HEM17", "ratio_pfjetpT_HEP17VSHEM17", " pT [GeV]; Ratio","HEP17/HEM17 vs pT","1D");// numer deno - dividehistos(ibooker, igetter, "effic_pfjetpT_HEP17_pTThresh", "effic_pfjetpT_HEM17_pTThresh", "ratio_pfjetpT_pTTresh_HEP17VSHEM17"," pT [GeV]; Ratio","HEP17/HEM17 vs pT","1D");// numer deno - dividehistos(ibooker, igetter, "effic_pfjetphi_HEP17", "effic_pfjetphi_HEM17", "ratio_pfjetphi_HEP17VSHEM17", " #phi; Ratio","HEP17/HEM17 vs #phi","1D");// numer deno - } - if (isCaloJetDir) { - dividehistos(ibooker, igetter, "effic_calojetabseta_HEP17", "effic_calojetabseta_HEM17", "ratio_calojeteta_HEP17VSHEM17","| #eta |; Ratio","HEP17/HEM17 vs |#eta|","1D");// numer deno - dividehistos(ibooker, igetter, "effic_calojetpT_HEP17", "effic_calojetpT_HEM17", "ratio_calojetpT_HEP17VSHEM17"," pT [GeV]; Ratio","HEP17/HEM17 vs pT","1D");// numer deno - dividehistos(ibooker, igetter, "effic_calojetpT_HEP17_pTThresh", "effic_calojetpT_HEM17_pTThresh", "ratio_calojetpT_pTTresh_HEP17VSHEM17"," pT [GeV]; Ratio","HEP17/HEM17 vs pT","1D");// numer deno - dividehistos(ibooker, igetter, "effic_calojetphi_HEP17", "effic_calojetphi_HEM17", "ratio_calojetphi_HEP17VSHEM17"," #phi; Ratio","HEP17/HEM17 vs #phi","1D");// numer deno - } - - ibooker.goUp(); - } -} - -//---------------------------------------------------------------------- -//TProfile* -//TH1F* -void -JetPomptDQMPostProcessor::dividehistos(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string& numName, const std::string& denomName, - const std::string& outName, const std::string& label, const std::string& titel,const std::string histDim) -{ - //ibooker.pwd(); - if (histDim == "1D"){ - TH1F* num = getHistogram(ibooker, igetter, ibooker.pwd()+"/"+numName); - - TH1F* denom = getHistogram(ibooker, igetter, ibooker.pwd()+"/"+denomName); - - if (num == NULL) - edm::LogWarning("JetPomptDQMPostProcessor") << "numerator histogram " << ibooker.pwd()+"/"+numName << " does not exist"; - if (denom == NULL) - edm::LogWarning("JetPomptDQMPostProcessor") << "denominator histogram " << ibooker.pwd()+"/"+denomName << " does not exist"; - - // Check if histograms actually exist - //if(!num || !denom) return 0; - if(!num || !denom) return ; - - MonitorElement* meOut = ibooker.book1D(outName, titel, num->GetXaxis()->GetNbins(), num->GetXaxis()->GetXmin(), num->GetXaxis()->GetXmax()); - TH1F *ratio = new TH1F("ratio", "raito", num->GetXaxis()->GetNbins(), num->GetXaxis()->GetXmin(), num->GetXaxis()->GetXmax()); - ratio->Sumw2(); - //ratio->Divide(num,denom,1,1,"B"); - ratio->Divide(num,denom); - for (int i =0; i< ratio->GetNbinsX(); ++i){ - meOut->setBinContent(i+1,ratio->GetBinContent(i+1)); - meOut->setBinError(i+1,ratio->GetBinError(i+1)); - } - } - else if (histDim == "2D"){ - TH2F* num = getHistogram2D(ibooker, igetter, ibooker.pwd()+"/"+numName); - - TH2F* denom = getHistogram2D(ibooker, igetter, ibooker.pwd()+"/"+denomName); - - if (num == NULL) - edm::LogWarning("JetPomptDQMPostProcessor") << "numerator histogram " << ibooker.pwd()+"/"+numName << " does not exist"; - if (denom == NULL) - edm::LogWarning("JetPomptDQMPostProcessor") << "denominator histogram " << ibooker.pwd()+"/"+denomName << " does not exist"; - - // Check if histograms actually exist - //if(!num || !denom) return 0; - if(!num || !denom) return; - TH2F *ratio = new TH2F("ratio", "raito", num->GetXaxis()->GetNbins(), num->GetXaxis()->GetXmin(), num->GetXaxis()->GetXmax(),num->GetYaxis()->GetNbins(), num->GetYaxis()->GetXmin(), num->GetYaxis()->GetXmax()); - ratio->Sumw2(); - MonitorElement* meOut = ibooker.book2D(outName, titel, num->GetXaxis()->GetNbins(), num->GetXaxis()->GetXmin(), num->GetXaxis()->GetXmax(), num->GetYaxis()->GetNbins(), num->GetYaxis()->GetXmin(), num->GetYaxis()->GetXmax()); - -// num->Divide(num,denom,1,1,"B"); - ratio->Divide(num,denom); - for (int i =0; i< ratio->GetNbinsX(); ++i){ - for (int j = 0; j < ratio->GetNbinsY();++i){ - meOut->setBinContent(i+1,j+1,ratio->GetBinContent(i+1,j+1)); - meOut->setBinError(i+1,j+1,ratio->GetBinError(i+1,j+1)); - } - } - } - else { - edm::LogWarning("JetPomptDQMPostProcessor") << "CHECK OUT RATIO DIMESION OF RATIO !!"; - } -} - -//---------------------------------------------------------------------- -TH1F * -JetPomptDQMPostProcessor::getHistogram(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string &histoPath) -{ - ibooker.pwd(); - MonitorElement *monElement = igetter.get(histoPath); - if (monElement != NULL) - return monElement->getTH1F(); - else - return NULL; -} -TH2F * -JetPomptDQMPostProcessor::getHistogram2D(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string &histoPath) -{ - ibooker.pwd(); - MonitorElement *monElement = igetter.get(histoPath); - if (monElement != NULL) - return monElement->getTH2F(); - else - return NULL; -} -//---------------------------------------------------------------------- - -DEFINE_FWK_MODULE(JetPomptDQMPostProcessor); diff --git a/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h b/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h deleted file mode 100644 index d1fe93b82a3b3..0000000000000 --- a/DQMOffline/Trigger/plugins/JetPomptDQMPostProcessor.h +++ /dev/null @@ -1,29 +0,0 @@ -// Migrated to use DQMEDHarvester by: Jyothsna Rani Komaragiri, Oct 2014 - -#ifndef DQMOffline_Trigger_JetDQMPosProcessor_H -#define DQMOffline_Trigger_JetDQMPosProcessor_H - -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "DQMServices/Core/interface/DQMEDHarvester.h" - -#include "TPRegexp.h" -#include "TEfficiency.h" - -class JetPomptDQMPostProcessor : public DQMEDHarvester{ - public: - JetPomptDQMPostProcessor(const edm::ParameterSet& pset); - ~JetPomptDQMPostProcessor() {}; - - void dqmEndJob(DQMStore::IBooker &, DQMStore::IGetter &) override; //performed in the endJob - - void dividehistos(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string& numName, const std::string& denomName, const std::string& outName, const std::string& label, const std::string& titel, const std::string histDim); - - private: - std::string subDir_; - - TH1F *getHistogram(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string &histoPath); - TH2F *getHistogram2D(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter, const std::string &histoPath); - -}; - -#endif From 933b1cf0361066f5307b7fcbb3b39c94c31f3699 Mon Sep 17 00:00:00 2001 From: Seungkyu Ha Date: Mon, 3 Jul 2017 04:29:33 +0200 Subject: [PATCH 9/9] Update JetMETPromptMonitoring_Client_cff, To use DQMGenericClient instead of JetPomptDQMPostProcessor --- .../JetMETPromptMonitoring_Client_cff.py | 29 +++++++++++++++---- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py b/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py index 6ddf09d07cb1a..4c87da2294c1c 100644 --- a/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py +++ b/DQMOffline/Trigger/python/JetMETPromptMonitoring_Client_cff.py @@ -155,14 +155,33 @@ ), ) -jetRatioHemHep17 = DQMEDHarvester("JetPomptDQMPostProcessor", - subDir = cms.untracked.string("HLT/JetMET"), - PatternJetTrg = cms.untracked.string("HLT_Jet([0-9])+") + +pfjetRatio = DQMEDHarvester("DQMGenericClient", + subDirs = cms.untracked.vstring("HLT/JetMET/*"), + verbose = cms.untracked.uint32(0), # Set to 2 for all messages + resolution = cms.vstring(), + efficiency = cms.vstring( + "ratio_pfjetpT_HEP17VSHEM17 'HEP17/HEM17 vs pT; PFJet(pT) [GeV]; Ratio' effic_pfjetpT_HEP17 effic_pfjetpT_HEM17 simpleratio" , + "ratio_pfjetpT_pTTresh_HEP17VSHEM17 'HEP17/HEM17 vs pT; PFJet(pT) [GeV]; Ratio' effic_pfjetpT_HEP17_pTThresh effic_pfjetpT_HEM17_pTThresh simpleratio" , + "ratio_pfjetphi_HEP17VSHEM17 'HEP17/HEM17 vs #phi; PFJet #phi [GeV]; Ratio' effic_pfjetphi_HEP17 effic_pfjetphi_HEM17 simpleratio", + "ratio_pfjeteta_HEP17VSHEM17 'HEP17/HEM17 vs |#eta|; PFJet(|#eta|) ; Ratio' effic_pfjetabseta_HEP17 effic_pfjetabseta_HEM17 simpleratio", + ) +) +calojetRatio = DQMEDHarvester("DQMGenericClient", + subDirs = cms.untracked.vstring("HLT/JetMET/*"), + verbose = cms.untracked.uint32(0), # Set to 2 for all messages + resolution = cms.vstring(), + efficiency = cms.vstring( + "ratio_calojetpT_HEP17VSHEM17 'HEP17/HEM17 vs pT; CaloJet(pT) [GeV]; Ratio' effic_calojetpT_HEP17 effic_calojetpT_HEM17 simpleratio" , + "ratio_calojetpT_pTTresh_HEP17VSHEM17 'HEP17/HEM17 vs pT; CaloJet(pT) [GeV]; Ratio' effic_calojetpT_HEP17_pTThresh effic_calojetpT_HEM17_pTThresh simpleratio" , + "ratio_calojetphi_HEP17VSHEM17 'HEP17/HEM17 vs #phi; CaloJet #phi [GeV]; Ratio' effic_calojetphi_HEP17 effic_calojetphi_HEM17 simpleratio", + "ratio_calojeteta_HEP17VSHEM17 'HEP17/HEM17 vs |#eta|; CaloJet(|#eta|) ; Ratio' effic_calojetabseta_HEP17 effic_calojetabseta_HEM17 simpleratio", + ) ) JetMetPromClient = cms.Sequence( pfjetEfficiency *calojetEfficiency - *jetRatioHemHep17 - # *pfmetEfficiency + *pfjetRatio + *calojetRatio )