Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-09-02 22:46:31

0001 #include "DQMServices/Core/interface/DQMStore.h"
0002 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0003 #include "FWCore/Utilities/interface/EDGetToken.h"
0004 #include "FWCore/Framework/interface/Frameworkfwd.h"
0005 #include "FWCore/Framework/interface/Event.h"
0006 #include "FWCore/Framework/interface/MakerMacros.h"
0007 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0008 #include "FWCore/ServiceRegistry/interface/Service.h"
0009 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0010 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0011 #include "FWCore/ParameterSet/interface/Registry.h"
0012 #include "FWCore/Utilities/interface/transform.h"
0013 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0014 #include "CommonTools/Utils/interface/StringCutObjectSelector.h"
0015 #include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
0016 #include "DataFormats/Math/interface/deltaR.h"
0017 #include "DataFormats/Common/interface/ValueMap.h"
0018 #include "DataFormats/VertexReco/interface/VertexFwd.h"
0019 #include "DataFormats/MuonReco/interface/Muon.h"
0020 #include "DataFormats/MuonReco/interface/MuonFwd.h"
0021 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
0022 #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
0023 #include "DataFormats/EgammaCandidates/interface/Photon.h"
0024 #include "DataFormats/EgammaCandidates/interface/PhotonFwd.h"
0025 #include "DataFormats/JetReco/interface/PFJet.h"
0026 #include "DataFormats/JetReco/interface/PFJetCollection.h"
0027 #include "DataFormats/BTauReco/interface/JetTag.h"
0028 #include "DataFormats/METReco/interface/PFMET.h"
0029 #include "DataFormats/METReco/interface/PFMETCollection.h"
0030 #include "DQMOffline/Trigger/plugins/TriggerDQMBase.h"
0031 
0032 #include <string>
0033 #include <vector>
0034 #include <memory>
0035 #include <map>
0036 
0037 class TopMonitor : public DQMEDAnalyzer, public TriggerDQMBase {
0038 public:
0039   typedef dqm::reco::MonitorElement MonitorElement;
0040   typedef dqm::reco::DQMStore DQMStore;
0041 
0042   TopMonitor(const edm::ParameterSet&);
0043   ~TopMonitor() throw() override;
0044   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0045 
0046 protected:
0047   void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override;
0048   void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) override;
0049 
0050   struct JetRefCompare {
0051     inline bool operator()(const edm::RefToBase<reco::Jet>& j1, const edm::RefToBase<reco::Jet>& j2) const {
0052       return (j1.id() < j2.id()) || ((j1.id() == j2.id()) && (j1.key() < j2.key()));
0053     }
0054   };
0055   typedef std::map<edm::RefToBase<reco::Jet>, float, JetRefCompare> JetTagMap;
0056 
0057 private:
0058   const std::string folderName_;
0059 
0060   const bool requireValidHLTPaths_;
0061   bool hltPathsAreValid_;
0062 
0063   edm::EDGetTokenT<reco::VertexCollection> vtxToken_;
0064   edm::EDGetTokenT<reco::MuonCollection> muoToken_;
0065   edm::EDGetTokenT<edm::View<reco::GsfElectron> > eleToken_;
0066   edm::EDGetTokenT<edm::ValueMap<bool> > elecIDToken_;
0067   edm::EDGetTokenT<reco::PhotonCollection> phoToken_;
0068   edm::EDGetTokenT<reco::PFJetCollection> jetToken_;
0069   std::vector<edm::EDGetTokenT<reco::JetTagCollection> > jetTagTokens_;
0070   edm::EDGetTokenT<reco::PFMETCollection> metToken_;
0071 
0072   struct PVcut {
0073     double dxy;
0074     double dz;
0075   };
0076 
0077   MEbinning met_binning_;
0078   MEbinning ls_binning_;
0079   MEbinning phi_binning_;
0080   MEbinning pt_binning_;
0081   MEbinning eta_binning_;
0082   MEbinning HT_binning_;
0083   MEbinning DR_binning_;
0084   MEbinning csv_binning_;
0085   MEbinning invMass_mumu_binning_;
0086   MEbinning MHT_binning_;
0087 
0088   std::vector<double> met_variable_binning_;
0089   std::vector<double> HT_variable_binning_;
0090   std::vector<double> jetPt_variable_binning_;
0091   std::vector<double> muPt_variable_binning_;
0092   std::vector<double> elePt_variable_binning_;
0093   std::vector<double> jetEta_variable_binning_;
0094   std::vector<double> muEta_variable_binning_;
0095   std::vector<double> eleEta_variable_binning_;
0096   std::vector<double> invMass_mumu_variable_binning_;
0097   std::vector<double> MHT_variable_binning_;
0098 
0099   std::vector<double> HT_variable_binning_2D_;
0100   std::vector<double> jetPt_variable_binning_2D_;
0101   std::vector<double> muPt_variable_binning_2D_;
0102   std::vector<double> elePt_variable_binning_2D_;
0103   std::vector<double> phoPt_variable_binning_2D_;
0104   std::vector<double> jetEta_variable_binning_2D_;
0105   std::vector<double> muEta_variable_binning_2D_;
0106   std::vector<double> eleEta_variable_binning_2D_;
0107   std::vector<double> phoEta_variable_binning_2D_;
0108   std::vector<double> phi_variable_binning_2D_;
0109 
0110   ObjME metME_;
0111   ObjME metME_variableBinning_;
0112   ObjME metVsLS_;
0113   ObjME metPhiME_;
0114 
0115   ObjME jetVsLS_;
0116   ObjME muVsLS_;
0117   ObjME eleVsLS_;
0118   ObjME phoVsLS_;
0119   ObjME bjetVsLS_;
0120   ObjME htVsLS_;
0121 
0122   ObjME jetEtaPhi_HEP17_;  // for HEP17 monitoring
0123 
0124   ObjME jetMulti_;
0125   ObjME eleMulti_;
0126   ObjME muMulti_;
0127   ObjME phoMulti_;
0128   ObjME bjetMulti_;
0129 
0130   ObjME elePt_jetPt_;
0131   ObjME elePt_eventHT_;
0132 
0133   ObjME ele1Pt_ele2Pt_;
0134   ObjME ele1Eta_ele2Eta_;
0135   ObjME mu1Pt_mu2Pt_;
0136   ObjME mu1Eta_mu2Eta_;
0137   ObjME elePt_muPt_;
0138   ObjME eleEta_muEta_;
0139   ObjME invMass_mumu_;
0140   ObjME eventMHT_;
0141   ObjME invMass_mumu_variableBinning_;
0142   ObjME eventMHT_variableBinning_;
0143   ObjME muPt_phoPt_;
0144   ObjME muEta_phoEta_;
0145 
0146   ObjME DeltaR_jet_Mu_;
0147 
0148   ObjME eventHT_;
0149   ObjME eventHT_variableBinning_;
0150 
0151   std::vector<ObjME> muPhi_;
0152   std::vector<ObjME> muEta_;
0153   std::vector<ObjME> muPt_;
0154 
0155   std::vector<ObjME> elePhi_;
0156   std::vector<ObjME> eleEta_;
0157   std::vector<ObjME> elePt_;
0158 
0159   std::vector<ObjME> jetPhi_;
0160   std::vector<ObjME> jetEta_;
0161   std::vector<ObjME> jetPt_;
0162 
0163   std::vector<ObjME> phoPhi_;
0164   std::vector<ObjME> phoEta_;
0165   std::vector<ObjME> phoPt_;
0166 
0167   std::vector<ObjME> bjetPhi_;
0168   std::vector<ObjME> bjetEta_;
0169   std::vector<ObjME> bjetPt_;
0170   std::vector<ObjME> bjetCSV_;
0171   std::vector<ObjME> muPt_variableBinning_;
0172   std::vector<ObjME> elePt_variableBinning_;
0173   std::vector<ObjME> jetPt_variableBinning_;
0174   std::vector<ObjME> bjetPt_variableBinning_;
0175 
0176   std::vector<ObjME> muEta_variableBinning_;
0177   std::vector<ObjME> eleEta_variableBinning_;
0178   std::vector<ObjME> jetEta_variableBinning_;
0179   std::vector<ObjME> bjetEta_variableBinning_;
0180 
0181   // 2D distributions
0182   std::vector<ObjME> jetPtEta_;
0183   std::vector<ObjME> jetEtaPhi_;
0184 
0185   std::vector<ObjME> elePtEta_;
0186   std::vector<ObjME> eleEtaPhi_;
0187 
0188   std::vector<ObjME> muPtEta_;
0189   std::vector<ObjME> muEtaPhi_;
0190 
0191   std::vector<ObjME> phoPtEta_;
0192   std::vector<ObjME> phoEtaPhi_;
0193 
0194   std::vector<ObjME> bjetPtEta_;
0195   std::vector<ObjME> bjetEtaPhi_;
0196   std::vector<ObjME> bjetCSVHT_;
0197 
0198   std::unique_ptr<GenericTriggerEventFlag> num_genTriggerEventFlag_;
0199   std::unique_ptr<GenericTriggerEventFlag> den_genTriggerEventFlag_;
0200 
0201   StringCutObjectSelector<reco::MET, true> metSelection_;
0202   StringCutObjectSelector<reco::PFJet, true> jetSelection_;
0203   StringCutObjectSelector<reco::GsfElectron, true> eleSelection_;
0204   StringCutObjectSelector<reco::Muon, true> muoSelection_;
0205   StringCutObjectSelector<reco::Photon, true> phoSelection_;
0206   StringCutObjectSelector<reco::PFJet, true> HTdefinition_;
0207 
0208   StringCutObjectSelector<reco::Vertex, true> vtxSelection_;
0209 
0210   StringCutObjectSelector<reco::Jet, true> bjetSelection_;
0211 
0212   unsigned int njets_;
0213   unsigned int nelectrons_;
0214   unsigned int nmuons_;
0215   unsigned int nphotons_;
0216   double leptJetDeltaRmin_;
0217   double bJetMuDeltaRmax_;
0218   double bJetDeltaEtaMax_;
0219   double HTcut_;
0220   unsigned int nbjets_;
0221   double workingpoint_;
0222   std::string btagalgoName_;
0223   PVcut lepPVcuts_;
0224   bool applyLeptonPVcuts_;
0225 
0226   bool applyMETcut_ = false;
0227 
0228   double invMassUppercut_;
0229   double invMassLowercut_;
0230   bool opsign_;
0231   StringCutObjectSelector<reco::PFJet, true> MHTdefinition_;
0232   double MHTcut_;
0233 
0234   bool invMassCutInAllMuPairs_;
0235 
0236   bool enablePhotonPlot_;
0237   bool enableMETPlot_;
0238   bool enable2DPlots_;
0239 };
0240 
0241 TopMonitor::TopMonitor(const edm::ParameterSet& iConfig)
0242     : folderName_(iConfig.getParameter<std::string>("FolderName")),
0243       requireValidHLTPaths_(iConfig.getParameter<bool>("requireValidHLTPaths")),
0244       hltPathsAreValid_(false),
0245       vtxToken_(mayConsume<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"))),
0246       muoToken_(mayConsume<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("muons"))),
0247       eleToken_(mayConsume<edm::View<reco::GsfElectron> >(iConfig.getParameter<edm::InputTag>("electrons"))),
0248       elecIDToken_(consumes<edm::ValueMap<bool> >(iConfig.getParameter<edm::InputTag>("elecID"))),
0249       phoToken_(mayConsume<reco::PhotonCollection>(iConfig.getParameter<edm::InputTag>("photons"))),
0250       jetToken_(mayConsume<reco::PFJetCollection>(iConfig.getParameter<edm::InputTag>("jets"))),
0251       jetTagTokens_(
0252           edm::vector_transform(iConfig.getParameter<std::vector<edm::InputTag> >("btagAlgos"),
0253                                 [this](edm::InputTag const& tag) { return mayConsume<reco::JetTagCollection>(tag); })),
0254       metToken_(consumes<reco::PFMETCollection>(iConfig.getParameter<edm::InputTag>("met"))),
0255       met_binning_(getHistoPSet(
0256           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("metPSet"))),
0257       ls_binning_(
0258           getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("lsPSet"))),
0259       phi_binning_(getHistoPSet(
0260           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("phiPSet"))),
0261       pt_binning_(
0262           getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("ptPSet"))),
0263       eta_binning_(getHistoPSet(
0264           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("etaPSet"))),
0265       HT_binning_(
0266           getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("htPSet"))),
0267       DR_binning_(
0268           getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("DRPSet"))),
0269       csv_binning_(getHistoPSet(
0270           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("csvPSet"))),
0271       invMass_mumu_binning_(getHistoPSet(
0272           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("invMassPSet"))),
0273       MHT_binning_(getHistoPSet(
0274           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("MHTPSet"))),
0275       met_variable_binning_(
0276           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("metBinning")),
0277       HT_variable_binning_(
0278           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("HTBinning")),
0279       jetPt_variable_binning_(
0280           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("jetPtBinning")),
0281       muPt_variable_binning_(
0282           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muPtBinning")),
0283       elePt_variable_binning_(
0284           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("elePtBinning")),
0285       jetEta_variable_binning_(
0286           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("jetEtaBinning")),
0287       muEta_variable_binning_(
0288           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muEtaBinning")),
0289       eleEta_variable_binning_(
0290           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("eleEtaBinning")),
0291       invMass_mumu_variable_binning_(iConfig.getParameter<edm::ParameterSet>("histoPSet")
0292                                          .getParameter<std::vector<double> >("invMassVariableBinning")),
0293       MHT_variable_binning_(
0294           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("MHTVariableBinning")),
0295       HT_variable_binning_2D_(
0296           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("HTBinning2D")),
0297       jetPt_variable_binning_2D_(
0298           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("jetPtBinning2D")),
0299       muPt_variable_binning_2D_(
0300           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muPtBinning2D")),
0301       elePt_variable_binning_2D_(
0302           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("elePtBinning2D")),
0303       phoPt_variable_binning_2D_(
0304           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("phoPtBinning2D")),
0305       jetEta_variable_binning_2D_(
0306           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("jetEtaBinning2D")),
0307       muEta_variable_binning_2D_(
0308           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muEtaBinning2D")),
0309       eleEta_variable_binning_2D_(
0310           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("eleEtaBinning2D")),
0311       phoEta_variable_binning_2D_(
0312           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("phoEtaBinning2D")),
0313       phi_variable_binning_2D_(
0314           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("phiBinning2D")),
0315       num_genTriggerEventFlag_(new GenericTriggerEventFlag(
0316           iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this)),
0317       den_genTriggerEventFlag_(new GenericTriggerEventFlag(
0318           iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this)),
0319       metSelection_(iConfig.getParameter<std::string>("metSelection")),
0320       jetSelection_(iConfig.getParameter<std::string>("jetSelection")),
0321       eleSelection_(iConfig.getParameter<std::string>("eleSelection")),
0322       muoSelection_(iConfig.getParameter<std::string>("muoSelection")),
0323       phoSelection_(iConfig.getParameter<std::string>("phoSelection")),
0324       HTdefinition_(iConfig.getParameter<std::string>("HTdefinition")),
0325       vtxSelection_(iConfig.getParameter<std::string>("vertexSelection")),
0326       bjetSelection_(iConfig.getParameter<std::string>("bjetSelection")),
0327       njets_(iConfig.getParameter<unsigned int>("njets")),
0328       nelectrons_(iConfig.getParameter<unsigned int>("nelectrons")),
0329       nmuons_(iConfig.getParameter<unsigned int>("nmuons")),
0330       nphotons_(iConfig.getParameter<unsigned int>("nphotons")),
0331       leptJetDeltaRmin_(iConfig.getParameter<double>("leptJetDeltaRmin")),
0332       bJetMuDeltaRmax_(iConfig.getParameter<double>("bJetMuDeltaRmax")),
0333       bJetDeltaEtaMax_(iConfig.getParameter<double>("bJetDeltaEtaMax")),
0334       HTcut_(iConfig.getParameter<double>("HTcut")),
0335       nbjets_(iConfig.getParameter<unsigned int>("nbjets")),
0336       workingpoint_(iConfig.getParameter<double>("workingpoint")),
0337       applyLeptonPVcuts_(iConfig.getParameter<bool>("applyLeptonPVcuts")),
0338       invMassUppercut_(iConfig.getParameter<double>("invMassUppercut")),
0339       invMassLowercut_(iConfig.getParameter<double>("invMassLowercut")),
0340       opsign_(iConfig.getParameter<bool>("oppositeSignMuons")),
0341       MHTdefinition_(iConfig.getParameter<std::string>("MHTdefinition")),
0342       MHTcut_(iConfig.getParameter<double>("MHTcut")),
0343       invMassCutInAllMuPairs_(iConfig.getParameter<bool>("invMassCutInAllMuPairs")),
0344       enablePhotonPlot_(iConfig.getParameter<bool>("enablePhotonPlot")),
0345       enableMETPlot_(iConfig.getParameter<bool>("enableMETPlot")),
0346       enable2DPlots_(iConfig.getParameter<bool>("enable2DPlots")) {
0347   ObjME empty;
0348 
0349   muPhi_ = std::vector<ObjME>(nmuons_, empty);
0350   muEta_ = std::vector<ObjME>(nmuons_, empty);
0351   muPt_ = std::vector<ObjME>(nmuons_, empty);
0352   muEta_variableBinning_ = std::vector<ObjME>(nmuons_, empty);
0353   muPt_variableBinning_ = std::vector<ObjME>(nmuons_, empty);
0354   muPtEta_ = std::vector<ObjME>(nmuons_, empty);
0355   muEtaPhi_ = std::vector<ObjME>(nmuons_, empty);
0356 
0357   elePhi_ = std::vector<ObjME>(nelectrons_, empty);
0358   eleEta_ = std::vector<ObjME>(nelectrons_, empty);
0359   elePt_ = std::vector<ObjME>(nelectrons_, empty);
0360   eleEta_variableBinning_ = std::vector<ObjME>(nelectrons_, empty);
0361   elePt_variableBinning_ = std::vector<ObjME>(nelectrons_, empty);
0362   elePtEta_ = std::vector<ObjME>(nelectrons_, empty);
0363   eleEtaPhi_ = std::vector<ObjME>(nelectrons_, empty);
0364 
0365   jetPhi_ = std::vector<ObjME>(njets_, empty);
0366   jetEta_ = std::vector<ObjME>(njets_, empty);
0367   jetPt_ = std::vector<ObjME>(njets_, empty);
0368   jetEta_variableBinning_ = std::vector<ObjME>(njets_, empty);
0369   jetPt_variableBinning_ = std::vector<ObjME>(njets_, empty);
0370   jetPtEta_ = std::vector<ObjME>(njets_, empty);
0371   jetEtaPhi_ = std::vector<ObjME>(njets_, empty);
0372 
0373   //Menglei Sun
0374   phoPhi_ = std::vector<ObjME>(nphotons_, empty);
0375   phoEta_ = std::vector<ObjME>(nphotons_, empty);
0376   phoPt_ = std::vector<ObjME>(nphotons_, empty);
0377   phoPtEta_ = std::vector<ObjME>(nphotons_, empty);
0378   phoEtaPhi_ = std::vector<ObjME>(nphotons_, empty);
0379 
0380   // Marina
0381   bjetPhi_ = std::vector<ObjME>(nbjets_, empty);
0382   bjetEta_ = std::vector<ObjME>(nbjets_, empty);
0383   bjetPt_ = std::vector<ObjME>(nbjets_, empty);
0384   bjetCSV_ = std::vector<ObjME>(nbjets_, empty);
0385   bjetEta_variableBinning_ = std::vector<ObjME>(nbjets_, empty);
0386   bjetPt_variableBinning_ = std::vector<ObjME>(nbjets_, empty);
0387   bjetPtEta_ = std::vector<ObjME>(nbjets_, empty);
0388   bjetEtaPhi_ = std::vector<ObjME>(nbjets_, empty);
0389   bjetCSVHT_ = std::vector<ObjME>(nbjets_, empty);
0390   //Suvankar
0391   lepPVcuts_.dxy = (iConfig.getParameter<edm::ParameterSet>("leptonPVcuts")).getParameter<double>("dxy");
0392   lepPVcuts_.dz = (iConfig.getParameter<edm::ParameterSet>("leptonPVcuts")).getParameter<double>("dz");
0393 }
0394 
0395 TopMonitor::~TopMonitor() throw() {
0396   if (num_genTriggerEventFlag_)
0397     num_genTriggerEventFlag_.reset();
0398   if (den_genTriggerEventFlag_)
0399     den_genTriggerEventFlag_.reset();
0400 }
0401 
0402 void TopMonitor::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const& iRun, edm::EventSetup const& iSetup) {
0403   // Initialize the GenericTriggerEventFlag
0404   if (num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on())
0405     num_genTriggerEventFlag_->initRun(iRun, iSetup);
0406   if (den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on())
0407     den_genTriggerEventFlag_->initRun(iRun, iSetup);
0408 
0409   // check if every HLT path specified in numerator and denominator has a valid match in the HLT Menu
0410   hltPathsAreValid_ = (num_genTriggerEventFlag_ && den_genTriggerEventFlag_ && num_genTriggerEventFlag_->on() &&
0411                        den_genTriggerEventFlag_->on() && num_genTriggerEventFlag_->allHLTPathsAreValid() &&
0412                        den_genTriggerEventFlag_->allHLTPathsAreValid());
0413 
0414   // if valid HLT paths are required,
0415   // create DQM outputs only if all paths are valid
0416   if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
0417     return;
0418   }
0419 
0420   std::string histname, histtitle;
0421 
0422   std::string currentFolder = folderName_;
0423   ibooker.setCurrentFolder(currentFolder);
0424 
0425   if (enableMETPlot_) {
0426     histname = "met";
0427     histtitle = "PFMET";
0428     bookME(ibooker, metME_, histname, histtitle, met_binning_.nbins, met_binning_.xmin, met_binning_.xmax);
0429     setMETitle(metME_, "PF MET [GeV]", "events / [GeV]");
0430 
0431     histname = "metPhi";
0432     histtitle = "PFMET phi";
0433     bookME(ibooker, metPhiME_, histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
0434     setMETitle(metPhiME_, "PF MET #phi", "events / 0.1 rad");
0435 
0436     histname = "met_variable";
0437     histtitle = "PFMET";
0438     bookME(ibooker, metME_variableBinning_, histname, histtitle, met_variable_binning_);
0439     setMETitle(metME_variableBinning_, "PF MET [GeV]", "events / [GeV]");
0440 
0441     histname = "metVsLS";
0442     histtitle = "PFMET vs LS";
0443     bookME(ibooker,
0444            metVsLS_,
0445            histname,
0446            histtitle,
0447            ls_binning_.nbins,
0448            ls_binning_.xmin,
0449            ls_binning_.xmax,
0450            met_binning_.xmin,
0451            met_binning_.xmax);
0452     setMETitle(metVsLS_, "LS", "PF MET [GeV]");
0453   }
0454 
0455   if (njets_ > 0) {
0456     histname = "jetVsLS";
0457     histtitle = "jet pt vs LS";
0458     bookME(ibooker,
0459            jetVsLS_,
0460            histname,
0461            histtitle,
0462            ls_binning_.nbins,
0463            ls_binning_.xmin,
0464            ls_binning_.xmax,
0465            pt_binning_.xmin,
0466            pt_binning_.xmax);
0467     setMETitle(jetVsLS_, "LS", "jet pt [GeV]");
0468 
0469     histname = "jetEtaPhi_HEP17";
0470     histtitle = "jet #eta-#phi for HEP17";
0471     bookME(ibooker, jetEtaPhi_HEP17_, histname, histtitle, 10, -2.5, 2.5, 18, -3.1415, 3.1415);  // for HEP17 monitoring
0472     setMETitle(jetEtaPhi_HEP17_, "jet #eta", "jet #phi");
0473 
0474     histname = "jetMulti";
0475     histtitle = "jet multiplicity";
0476     bookME(ibooker, jetMulti_, histname, histtitle, 11, -.5, 10.5);
0477     setMETitle(jetMulti_, "jet multiplicity", "events");
0478   }
0479 
0480   if (nmuons_ > 0) {
0481     histname = "muVsLS";
0482     histtitle = "muon pt vs LS";
0483     bookME(ibooker,
0484            muVsLS_,
0485            histname,
0486            histtitle,
0487            ls_binning_.nbins,
0488            ls_binning_.xmin,
0489            ls_binning_.xmax,
0490            pt_binning_.xmin,
0491            pt_binning_.xmax);
0492     setMETitle(muVsLS_, "LS", "muon pt [GeV]");
0493 
0494     histname = "muMulti";
0495     histtitle = "muon multiplicity";
0496     bookME(ibooker, muMulti_, histname, histtitle, 6, -.5, 5.5);
0497     setMETitle(muMulti_, "muon multiplicity", "events");
0498 
0499     if (njets_ > 0) {
0500       histname = "DeltaR_jet_Mu";
0501       histtitle = "#DeltaR(jet,mu)";
0502       bookME(ibooker, DeltaR_jet_Mu_, histname, histtitle, DR_binning_.nbins, DR_binning_.xmin, DR_binning_.xmax);
0503       setMETitle(DeltaR_jet_Mu_, "#DeltaR(jet,mu)", "events");
0504     }
0505   }
0506 
0507   if (nelectrons_ > 0) {
0508     histname = "eleVsLS";
0509     histtitle = "electron pt vs LS";
0510     bookME(ibooker,
0511            eleVsLS_,
0512            histname,
0513            histtitle,
0514            ls_binning_.nbins,
0515            ls_binning_.xmin,
0516            ls_binning_.xmax,
0517            pt_binning_.xmin,
0518            pt_binning_.xmax);
0519     setMETitle(eleVsLS_, "LS", "electron pt [GeV]");
0520 
0521     histname = "eleMulti";
0522     histtitle = "electron multiplicity";
0523     bookME(ibooker, eleMulti_, histname, histtitle, 6, -.5, 5.5);
0524     setMETitle(eleMulti_, "electron multiplicity", "events");
0525 
0526     if (njets_ > 0 && enable2DPlots_) {
0527       histname = "elePt_jetPt";
0528       histtitle = "electron pt vs jet pt";
0529       bookME(ibooker, elePt_jetPt_, histname, histtitle, elePt_variable_binning_2D_, jetPt_variable_binning_2D_);
0530       setMETitle(elePt_jetPt_, "leading electron pt", "leading jet pt");
0531     }
0532 
0533     if (nmuons_ > 0 && enable2DPlots_) {
0534       histname = "elePt_muPt";
0535       histtitle = "electron pt vs muon pt";
0536       bookME(ibooker, elePt_muPt_, histname, histtitle, elePt_variable_binning_2D_, muPt_variable_binning_2D_);
0537       setMETitle(elePt_muPt_, "electron pt [GeV]", "muon pt [GeV]");
0538 
0539       histname = "eleEta_muEta";
0540       histtitle = "electron #eta vs muon #eta";
0541       bookME(ibooker, eleEta_muEta_, histname, histtitle, eleEta_variable_binning_2D_, muEta_variable_binning_2D_);
0542       setMETitle(eleEta_muEta_, "electron #eta", "muon #eta");
0543     }
0544   }
0545 
0546   //Menglei
0547   if (enablePhotonPlot_) {
0548     if (nphotons_ > 0) {
0549       histname = "photonVsLS";
0550       histtitle = "photon pt vs LS";
0551       bookME(ibooker,
0552              phoVsLS_,
0553              histname,
0554              histtitle,
0555              ls_binning_.nbins,
0556              ls_binning_.xmin,
0557              ls_binning_.xmax,
0558              pt_binning_.xmin,
0559              pt_binning_.xmax);
0560       setMETitle(phoVsLS_, "LS", "photon pt [GeV]");
0561     }
0562   }
0563 
0564   // Marina
0565   if (nbjets_ > 0) {
0566     histname = "bjetVsLS";
0567     histtitle = "b-jet pt vs LS";
0568     bookME(ibooker,
0569            bjetVsLS_,
0570            histname,
0571            histtitle,
0572            ls_binning_.nbins,
0573            ls_binning_.xmin,
0574            ls_binning_.xmax,
0575            pt_binning_.xmin,
0576            pt_binning_.xmax);
0577     setMETitle(bjetVsLS_, "LS", "b-jet pt [GeV]");
0578 
0579     histname = "bjetMulti";
0580     histtitle = "b-jet multiplicity";
0581     bookME(ibooker, bjetMulti_, histname, histtitle, 6, -.5, 5.5);
0582     setMETitle(bjetMulti_, "b-jet multiplicity", "events");
0583   }
0584 
0585   if (nelectrons_ > 1 && enable2DPlots_) {
0586     histname = "ele1Pt_ele2Pt";
0587     histtitle = "electron-1 pt vs electron-2 pt";
0588     bookME(ibooker, ele1Pt_ele2Pt_, histname, histtitle, elePt_variable_binning_2D_, elePt_variable_binning_2D_);
0589     setMETitle(ele1Pt_ele2Pt_, "electron-1 pt [GeV]", "electron-2 pt [GeV]");
0590 
0591     histname = "ele1Eta_ele2Eta";
0592     histtitle = "electron-1 #eta vs electron-2 #eta";
0593     bookME(ibooker, ele1Eta_ele2Eta_, histname, histtitle, eleEta_variable_binning_2D_, eleEta_variable_binning_2D_);
0594     setMETitle(ele1Eta_ele2Eta_, "electron-1 #eta", "electron-2 #eta");
0595   }
0596 
0597   if (nmuons_ > 1) {
0598     if (enable2DPlots_) {
0599       histname = "mu1Pt_mu2Pt";
0600       histtitle = "muon-1 pt vs muon-2 pt";
0601       bookME(ibooker, mu1Pt_mu2Pt_, histname, histtitle, muPt_variable_binning_2D_, muPt_variable_binning_2D_);
0602       setMETitle(mu1Pt_mu2Pt_, "muon-1 pt [GeV]", "muon-2 pt [GeV]");
0603 
0604       histname = "mu1Eta_mu2Eta";
0605       histtitle = "muon-1 #eta vs muon-2 #eta";
0606       bookME(ibooker, mu1Eta_mu2Eta_, histname, histtitle, muEta_variable_binning_2D_, muEta_variable_binning_2D_);
0607       setMETitle(mu1Eta_mu2Eta_, "muon-1 #eta", "muon-2 #eta");
0608     }
0609     //george
0610     histname = "invMass";
0611     histtitle = "M mu1 mu2";
0612     bookME(ibooker,
0613            invMass_mumu_,
0614            histname,
0615            histtitle,
0616            invMass_mumu_binning_.nbins,
0617            invMass_mumu_binning_.xmin,
0618            invMass_mumu_binning_.xmax);
0619     setMETitle(invMass_mumu_, "M(mu1,mu2) [GeV]", "events");
0620     histname = "invMass_variable";
0621     histtitle = "M mu1 mu2 variable";
0622     bookME(ibooker, invMass_mumu_variableBinning_, histname, histtitle, invMass_mumu_variable_binning_);
0623     setMETitle(invMass_mumu_variableBinning_, "M(mu1,mu2) [GeV]", "events / [GeV]");
0624   }
0625 
0626   if (HTcut_ > 0) {
0627     histname = "htVsLS";
0628     histtitle = "event HT vs LS";
0629     bookME(ibooker,
0630            htVsLS_,
0631            histname,
0632            histtitle,
0633            ls_binning_.nbins,
0634            ls_binning_.xmin,
0635            ls_binning_.xmax,
0636            pt_binning_.xmin,
0637            pt_binning_.xmax);
0638     setMETitle(htVsLS_, "LS", "event HT [GeV]");
0639 
0640     histname = "eventHT";
0641     histtitle = "event HT";
0642     bookME(ibooker, eventHT_, histname, histtitle, HT_binning_.nbins, HT_binning_.xmin, HT_binning_.xmax);
0643     setMETitle(eventHT_, " event HT [GeV]", "events");
0644     histname.append("_variableBinning");
0645     bookME(ibooker, eventHT_variableBinning_, histname, histtitle, HT_variable_binning_);
0646     setMETitle(eventHT_variableBinning_, "event HT [GeV]", "events");
0647 
0648     if (nelectrons_ > 0 && enable2DPlots_) {
0649       histname = "elePt_eventHT";
0650       histtitle = "electron pt vs event HT";
0651       bookME(ibooker, elePt_eventHT_, histname, histtitle, elePt_variable_binning_2D_, HT_variable_binning_2D_);
0652       setMETitle(elePt_eventHT_, "leading electron pt", "event HT");
0653     }
0654   }
0655 
0656   if (MHTcut_ > 0) {
0657     //george
0658     histname = "eventMHT";
0659     histtitle = "event MHT";
0660     bookME(ibooker, eventMHT_, histname, histtitle, MHT_binning_.nbins, MHT_binning_.xmin, MHT_binning_.xmax);
0661     setMETitle(eventMHT_, " event MHT [GeV]", "events");
0662 
0663     histname = "eventMHT_variable";
0664     histtitle = "event MHT variable";
0665     bookME(ibooker, eventMHT_variableBinning_, histname, histtitle, MHT_variable_binning_);
0666     setMETitle(eventMHT_variableBinning_, "event MHT [GeV]", "events / [GeV]");
0667   }
0668 
0669   //Menglei
0670   if (enablePhotonPlot_) {
0671     if ((nmuons_ > 0) && (nphotons_ > 0)) {
0672       histname = "muPt_phoPt", histtitle = "muon pt vs photon pt";
0673       bookME(ibooker, muPt_phoPt_, histname, histtitle, muPt_variable_binning_2D_, phoPt_variable_binning_2D_);
0674       setMETitle(muPt_phoPt_, "muon pt [GeV]", "photon pt [GeV]");
0675 
0676       histname = "muEta_phoEta", histtitle = "muon #eta vs photon #eta";
0677       bookME(ibooker, muEta_phoEta_, histname, histtitle, muEta_variable_binning_2D_, phoEta_variable_binning_2D_);
0678       setMETitle(muEta_phoEta_, "muon #eta", "photon #eta");
0679     }
0680   }
0681 
0682   for (unsigned int iMu = 0; iMu < nmuons_; ++iMu) {
0683     std::string index = std::to_string(iMu + 1);
0684 
0685     histname = "muPt_";
0686     histtitle = "muon p_{T} - ";
0687     histname.append(index);
0688     histtitle.append(index);
0689     bookME(ibooker, muPt_.at(iMu), histname, histtitle, pt_binning_.nbins, pt_binning_.xmin, pt_binning_.xmax);
0690     setMETitle(muPt_.at(iMu), "muon p_{T} [GeV]", "events");
0691     histname.append("_variableBinning");
0692     bookME(ibooker, muPt_variableBinning_.at(iMu), histname, histtitle, muPt_variable_binning_);
0693     setMETitle(muPt_variableBinning_.at(iMu), "muon p_{T} [GeV]", "events");
0694 
0695     histname = "muEta_";
0696     histtitle = "muon #eta - ";
0697     histname.append(index);
0698     histtitle.append(index);
0699     bookME(ibooker, muEta_.at(iMu), histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
0700     setMETitle(muEta_.at(iMu), " muon #eta", "events");
0701     histname.append("_variableBinning");
0702     bookME(ibooker, muEta_variableBinning_.at(iMu), histname, histtitle, muEta_variable_binning_);
0703     setMETitle(muEta_variableBinning_.at(iMu), " muon #eta", "events");
0704 
0705     histname = "muPhi_";
0706     histtitle = "muon #phi - ";
0707     histname.append(index);
0708     histtitle.append(index);
0709     bookME(ibooker, muPhi_.at(iMu), histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
0710     setMETitle(muPhi_.at(iMu), " muon #phi", "events");
0711 
0712     if (enable2DPlots_) {
0713       histname = "muPtEta_";
0714       histtitle = "muon p_{T} - #eta - ";
0715       histname.append(index);
0716       histtitle.append(index);
0717       bookME(ibooker, muPtEta_.at(iMu), histname, histtitle, muPt_variable_binning_2D_, muEta_variable_binning_2D_);
0718       setMETitle(muPtEta_.at(iMu), "muon p_{T} [GeV]", "muon #eta");
0719 
0720       histname = "muEtaPhi_";
0721       histtitle = "muon #eta - #phi - ";
0722       histname.append(index);
0723       histtitle.append(index);
0724       bookME(ibooker, muEtaPhi_.at(iMu), histname, histtitle, muEta_variable_binning_2D_, phi_variable_binning_2D_);
0725       setMETitle(muEtaPhi_.at(iMu), "muon #eta", "muon #phi");
0726     }
0727   }
0728 
0729   for (unsigned int iEle = 0; iEle < nelectrons_; ++iEle) {
0730     std::string index = std::to_string(iEle + 1);
0731 
0732     histname = "elePt_";
0733     histtitle = "electron p_{T} - ";
0734     histname.append(index);
0735     histtitle.append(index);
0736     bookME(ibooker, elePt_.at(iEle), histname, histtitle, pt_binning_.nbins, pt_binning_.xmin, pt_binning_.xmax);
0737     setMETitle(elePt_.at(iEle), "electron p_{T} [GeV]", "events");
0738     histname.append("_variableBinning");
0739     bookME(ibooker, elePt_variableBinning_.at(iEle), histname, histtitle, elePt_variable_binning_);
0740     setMETitle(elePt_variableBinning_.at(iEle), "electron p_{T} [GeV]", "events");
0741 
0742     histname = "eleEta_";
0743     histtitle = "electron #eta - ";
0744     histname.append(index);
0745     histtitle.append(index);
0746     bookME(ibooker, eleEta_.at(iEle), histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
0747     setMETitle(eleEta_.at(iEle), " electron #eta", "events");
0748     histname.append("_variableBinning");
0749     bookME(ibooker, eleEta_variableBinning_.at(iEle), histname, histtitle, eleEta_variable_binning_);
0750     setMETitle(eleEta_variableBinning_.at(iEle), "electron #eta", "events");
0751 
0752     histname = "elePhi_";
0753     histtitle = "electron #phi - ";
0754     histname.append(index);
0755     histtitle.append(index);
0756     bookME(ibooker, elePhi_.at(iEle), histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
0757     setMETitle(elePhi_.at(iEle), " electron #phi", "events");
0758 
0759     if (enable2DPlots_) {
0760       histname = "elePtEta_";
0761       histtitle = "electron p_{T} - #eta - ";
0762       histname.append(index);
0763       histtitle.append(index);
0764       bookME(ibooker, elePtEta_.at(iEle), histname, histtitle, elePt_variable_binning_2D_, eleEta_variable_binning_2D_);
0765       setMETitle(elePtEta_.at(iEle), "electron p_{T} [GeV]", "electron #eta");
0766 
0767       histname = "eleEtaPhi_";
0768       histtitle = "electron #eta - #phi - ";
0769       histname.append(index);
0770       histtitle.append(index);
0771       bookME(ibooker, eleEtaPhi_.at(iEle), histname, histtitle, eleEta_variable_binning_2D_, phi_variable_binning_2D_);
0772       setMETitle(eleEtaPhi_.at(iEle), "electron #eta", "electron #phi");
0773     }
0774   }
0775 
0776   //Menglei
0777   if (enablePhotonPlot_) {
0778     for (unsigned int iPho(0); iPho < nphotons_; iPho++) {
0779       std::string index = std::to_string(iPho + 1);
0780 
0781       histname = "phoPt_";
0782       histtitle = "photon p_{T} - ";
0783       histname.append(index);
0784       histtitle.append(index);
0785       bookME(ibooker, phoPt_[iPho], histname, histtitle, pt_binning_.nbins, pt_binning_.xmin, pt_binning_.xmax);
0786       setMETitle(phoPt_[iPho], "photon p_{T} [GeV]", "events");
0787 
0788       histname = "phoEta_";
0789       histtitle = "photon #eta - ";
0790       histname.append(index);
0791       histtitle.append(index);
0792       bookME(ibooker, phoEta_[iPho], histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
0793       setMETitle(phoEta_[iPho], "photon #eta", "events");
0794 
0795       histname = "phoPhi_";
0796       histtitle = "photon #phi - ";
0797       histname.append(index);
0798       histtitle.append(index);
0799       bookME(ibooker, phoPhi_[iPho], histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
0800       setMETitle(phoPhi_[iPho], "photon #phi", "events");
0801 
0802       histname = "phoPtEta_";
0803       histtitle = "photon p_{T} - #eta - ";
0804       histname.append(index);
0805       histtitle.append(index);
0806       bookME(ibooker, phoPtEta_[iPho], histname, histtitle, phoPt_variable_binning_2D_, phoEta_variable_binning_2D_);
0807       setMETitle(phoPtEta_[iPho], "photon p_{T} [GeV]", "photon #eta");
0808 
0809       histname = "phoEtaPhi_";
0810       histtitle = "photon #eta - #phi - ";
0811       histname.append(index);
0812       histtitle.append(index);
0813       bookME(ibooker, phoEtaPhi_[iPho], histname, histtitle, phoEta_variable_binning_2D_, phi_variable_binning_2D_);
0814       setMETitle(phoEtaPhi_[iPho], "photon #eta", "photon #phi");
0815     }
0816   }
0817 
0818   for (unsigned int iJet = 0; iJet < njets_; ++iJet) {
0819     std::string index = std::to_string(iJet + 1);
0820 
0821     histname = "jetPt_";
0822     histtitle = "jet p_{T} - ";
0823     histname.append(index);
0824     histtitle.append(index);
0825     bookME(ibooker, jetPt_.at(iJet), histname, histtitle, pt_binning_.nbins, pt_binning_.xmin, pt_binning_.xmax);
0826     setMETitle(jetPt_.at(iJet), "jet p_{T} [GeV]", "events");
0827     histname.append("_variableBinning");
0828     bookME(ibooker, jetPt_variableBinning_.at(iJet), histname, histtitle, jetPt_variable_binning_);
0829     setMETitle(jetPt_variableBinning_.at(iJet), "jet p_{T} [GeV]", "events");
0830 
0831     histname = "jetEta_";
0832     histtitle = "jet #eta - ";
0833     histname.append(index);
0834     histtitle.append(index);
0835     bookME(ibooker, jetEta_.at(iJet), histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
0836     setMETitle(jetEta_.at(iJet), "jet #eta", "events");
0837     histname.append("_variableBinning");
0838     bookME(ibooker, jetEta_variableBinning_.at(iJet), histname, histtitle, jetEta_variable_binning_);
0839     setMETitle(jetEta_variableBinning_.at(iJet), "jet #eta", "events");
0840 
0841     histname = "jetPhi_";
0842     histtitle = "jet #phi - ";
0843     histname.append(index);
0844     histtitle.append(index);
0845     bookME(ibooker, jetPhi_.at(iJet), histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
0846     setMETitle(jetPhi_.at(iJet), "jet #phi", "events");
0847 
0848     if (enable2DPlots_) {
0849       histname = "jetPtEta_";
0850       histtitle = "jet p_{T} - #eta - ";
0851       histname.append(index);
0852       histtitle.append(index);
0853       bookME(ibooker, jetPtEta_.at(iJet), histname, histtitle, jetPt_variable_binning_2D_, jetEta_variable_binning_2D_);
0854       setMETitle(jetPtEta_.at(iJet), "jet p_{T} [GeV]", "jet #eta");
0855 
0856       histname = "jetEtaPhi_";
0857       histtitle = "jet #eta - #phi - ";
0858       histname.append(index);
0859       histtitle.append(index);
0860       bookME(ibooker, jetEtaPhi_.at(iJet), histname, histtitle, jetEta_variable_binning_2D_, phi_variable_binning_2D_);
0861       setMETitle(jetEtaPhi_.at(iJet), "jet #eta", "jet #phi");
0862     }
0863   }
0864 
0865   // Marina
0866   for (unsigned int iBJet = 0; iBJet < nbjets_; ++iBJet) {
0867     std::string index = std::to_string(iBJet + 1);
0868 
0869     histname = "bjetPt_";
0870     histtitle = "b-jet p_{T} - ";
0871     histname.append(index);
0872     histtitle.append(index);
0873     bookME(ibooker, bjetPt_.at(iBJet), histname, histtitle, pt_binning_.nbins, pt_binning_.xmin, pt_binning_.xmax);
0874     setMETitle(bjetPt_.at(iBJet), "b-jet p_{T} [GeV]", "events");
0875     histname.append("_variableBinning");
0876     bookME(ibooker, bjetPt_variableBinning_.at(iBJet), histname, histtitle, jetPt_variable_binning_);
0877     setMETitle(bjetPt_variableBinning_.at(iBJet), "b-jet p_{T} [GeV]", "events");
0878 
0879     histname = "bjetEta_";
0880     histtitle = "b-jet #eta - ";
0881     histname.append(index);
0882     histtitle.append(index);
0883     bookME(ibooker, bjetEta_.at(iBJet), histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
0884     setMETitle(bjetEta_.at(iBJet), "b-jet #eta", "events");
0885     histname.append("_variableBinning");
0886     bookME(ibooker, bjetEta_variableBinning_.at(iBJet), histname, histtitle, jetEta_variable_binning_);
0887     setMETitle(bjetEta_variableBinning_.at(iBJet), "b-jet #eta", "events");
0888 
0889     histname = "bjetPhi_";
0890     histtitle = "b-jet #phi - ";
0891     histname.append(index);
0892     histtitle.append(index);
0893     bookME(ibooker, bjetPhi_.at(iBJet), histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
0894     setMETitle(bjetPhi_.at(iBJet), "b-jet #phi", "events");
0895 
0896     histname = "bjetCSV_";
0897     histtitle = "b-jet CSV - ";
0898     histname.append(index);
0899     histtitle.append(index);
0900     bookME(ibooker, bjetCSV_.at(iBJet), histname, histtitle, csv_binning_.nbins, csv_binning_.xmin, csv_binning_.xmax);
0901     setMETitle(bjetCSV_.at(iBJet), "b-jet CSV", "events");
0902 
0903     if (enable2DPlots_) {
0904       histname = "bjetPtEta_";
0905       histtitle = "b-jet p_{T} - #eta - ";
0906       histname.append(index);
0907       histtitle.append(index);
0908       bookME(
0909           ibooker, bjetPtEta_.at(iBJet), histname, histtitle, jetPt_variable_binning_2D_, jetEta_variable_binning_2D_);
0910       setMETitle(bjetPtEta_.at(iBJet), "b-jet p_{T} [GeV]", "b-jet #eta");
0911 
0912       histname = "bjetEtaPhi_";
0913       histtitle = "b-jet #eta - #phi - ";
0914       histname.append(index);
0915       histtitle.append(index);
0916       bookME(
0917           ibooker, bjetEtaPhi_.at(iBJet), histname, histtitle, jetEta_variable_binning_2D_, phi_variable_binning_2D_);
0918       setMETitle(bjetEtaPhi_.at(iBJet), "b-jet #eta", "b-jet #phi");
0919     }
0920 
0921     histname = "bjetCSVHT_";
0922     histtitle = "HT - b-jet CSV - ";
0923     histname.append(index);
0924     histtitle.append(index);
0925     bookME(ibooker,
0926            bjetCSVHT_.at(iBJet),
0927            histname,
0928            histtitle,
0929            csv_binning_.nbins,
0930            csv_binning_.xmin,
0931            csv_binning_.xmax,
0932            HT_binning_.nbins,
0933            HT_binning_.xmin,
0934            HT_binning_.xmax);
0935     setMETitle(bjetCSVHT_.at(iBJet), "b-jet CSV", "event HT [GeV]");
0936   }
0937 }
0938 
0939 void TopMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) {
0940   // if valid HLT paths are required,
0941   // analyze event only if all paths are valid
0942   if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
0943     return;
0944   }
0945 
0946   // Filter out events if Trigger Filtering is requested
0947   if (den_genTriggerEventFlag_->on() && !den_genTriggerEventFlag_->accept(iEvent, iSetup)) {
0948     return;
0949   }
0950 
0951   edm::Handle<reco::VertexCollection> primaryVertices;
0952   iEvent.getByToken(vtxToken_, primaryVertices);
0953   //Primary Vertex selection
0954   const reco::Vertex* pv = nullptr;
0955   for (auto const& v : *primaryVertices) {
0956     if (!vtxSelection_(v)) {
0957       continue;
0958     }
0959     pv = &v;
0960     break;
0961   }
0962   if (applyLeptonPVcuts_ && (pv == nullptr)) {
0963     edm::LogWarning("TopMonitor") << "Invalid handle to reco::VertexCollection, event will be skipped";
0964     return;
0965   }
0966 
0967   edm::Handle<reco::PFMETCollection> metHandle;
0968   iEvent.getByToken(metToken_, metHandle);
0969   if ((not metHandle.isValid()) && enableMETPlot_) {
0970     edm::LogWarning("TopMonitor") << "MET handle not valid \n";
0971     return;
0972   }
0973 
0974   double met_pt(-99.);
0975   double met_phi(-99.);
0976 
0977   if (enableMETPlot_) {
0978     const reco::PFMET& pfmet = metHandle->front();
0979 
0980     if (!metSelection_(pfmet)) {
0981       return;
0982     }
0983 
0984     met_pt = pfmet.pt();
0985     met_phi = pfmet.phi();
0986   }
0987 
0988   edm::Handle<edm::View<reco::GsfElectron> > eleHandle;
0989   iEvent.getByToken(eleToken_, eleHandle);
0990   if (!eleHandle.isValid() && nelectrons_ > 0) {
0991     edm::LogWarning("TopMonitor") << "Electron handle not valid \n";
0992     return;
0993   }
0994 
0995   edm::Handle<edm::ValueMap<bool> > eleIDHandle;
0996   iEvent.getByToken(elecIDToken_, eleIDHandle);
0997   if (!eleIDHandle.isValid() && nelectrons_ > 0) {
0998     edm::LogWarning("TopMonitor") << "Electron ID handle not valid \n";
0999     return;
1000   }
1001 
1002   std::vector<reco::GsfElectron> electrons;
1003   if (nelectrons_ > 0) {
1004     if (eleHandle->size() < nelectrons_) {
1005       return;
1006     }
1007 
1008     for (size_t index = 0; index < eleHandle->size(); index++) {
1009       const auto e = eleHandle->at(index);
1010       const auto el = eleHandle->ptrAt(index);
1011 
1012       bool pass_id = (*eleIDHandle)[el];
1013 
1014       if (eleSelection_(e) && pass_id) {
1015         electrons.push_back(e);
1016       }
1017 
1018       if (applyLeptonPVcuts_ && ((std::fabs(e.gsfTrack()->dxy(pv->position())) >= lepPVcuts_.dxy) ||
1019                                  (std::fabs(e.gsfTrack()->dz(pv->position())) >= lepPVcuts_.dz))) {
1020         continue;
1021       }
1022     }
1023 
1024     if (electrons.size() < nelectrons_) {
1025       return;
1026     }
1027   }
1028 
1029   edm::Handle<reco::MuonCollection> muoHandle;
1030   iEvent.getByToken(muoToken_, muoHandle);
1031   if (!muoHandle.isValid() && nmuons_ > 0) {
1032     edm::LogWarning("TopMonitor") << "Muon handle not valid \n";
1033     return;
1034   }
1035 
1036   if (muoHandle->size() < nmuons_) {
1037     return;
1038   }
1039 
1040   std::vector<reco::Muon> muons;
1041   if (nmuons_ > 0) {
1042     for (auto const& m : *muoHandle) {
1043       if (muoSelection_(m)) {
1044         muons.push_back(m);
1045       }
1046 
1047       if (applyLeptonPVcuts_ && ((std::fabs(m.muonBestTrack()->dxy(pv->position())) >= lepPVcuts_.dxy) ||
1048                                  (std::fabs(m.muonBestTrack()->dz(pv->position())) >= lepPVcuts_.dz))) {
1049         continue;
1050       }
1051     }
1052 
1053     if (muons.size() < nmuons_) {
1054       return;
1055     }
1056   }
1057 
1058   double mll(-2);
1059   if (nmuons_ > 1) {
1060     mll = (muons[0].p4() + muons[1].p4()).M();
1061 
1062     if ((invMassUppercut_ > -1) && (invMassLowercut_ > -1) && ((mll > invMassUppercut_) || (mll < invMassLowercut_))) {
1063       return;
1064     }
1065     if (opsign_ && (muons[0].charge() == muons[1].charge())) {
1066       return;
1067     }
1068   }
1069 
1070   edm::Handle<reco::PhotonCollection> phoHandle;
1071   iEvent.getByToken(phoToken_, phoHandle);
1072   if (!phoHandle.isValid()) {
1073     edm::LogWarning("TopMonitor") << "Photon handle not valid \n";
1074     return;
1075   }
1076   if (phoHandle->size() < nphotons_) {
1077     return;
1078   }
1079 
1080   std::vector<reco::Photon> photons;
1081   for (auto const& p : *phoHandle) {
1082     if (phoSelection_(p)) {
1083       photons.push_back(p);
1084     }
1085   }
1086   if (photons.size() < nphotons_) {
1087     return;
1088   }
1089 
1090   double eventHT(0.);
1091   math::XYZTLorentzVector eventMHT(0., 0., 0., 0.);
1092 
1093   edm::Handle<reco::PFJetCollection> jetHandle;
1094   iEvent.getByToken(jetToken_, jetHandle);
1095   if (!jetHandle.isValid() && njets_ > 0) {
1096     edm::LogWarning("TopMonitor") << "Jet handle not valid \n";
1097     return;
1098   }
1099   std::vector<reco::PFJet> jets;
1100   if (njets_ > 0) {
1101     if (jetHandle->size() < njets_)
1102       return;
1103     for (auto const& j : *jetHandle) {
1104       if (HTdefinition_(j)) {
1105         eventHT += j.pt();
1106       }
1107       if (MHTdefinition_(j)) {
1108         eventMHT += j.p4();
1109       }
1110       if (jetSelection_(j)) {
1111         bool isJetOverlappedWithLepton = false;
1112         if (nmuons_ > 0) {
1113           for (auto const& m : muons) {
1114             if (deltaR(j, m) < leptJetDeltaRmin_) {
1115               isJetOverlappedWithLepton = true;
1116               break;
1117             }
1118           }
1119         }
1120         if (isJetOverlappedWithLepton)
1121           continue;
1122         if (nelectrons_ > 0) {
1123           for (auto const& e : electrons) {
1124             if (deltaR(j, e) < leptJetDeltaRmin_) {
1125               isJetOverlappedWithLepton = true;
1126               break;
1127             }
1128           }
1129         }
1130         if (isJetOverlappedWithLepton)
1131           continue;
1132         jets.push_back(j);
1133       }
1134     }
1135     if (jets.size() < njets_)
1136       return;
1137   }
1138 
1139   if (eventHT < HTcut_) {
1140     return;
1141   }
1142 
1143   if ((MHTcut_ > 0) && (eventMHT.pt() < MHTcut_)) {
1144     return;
1145   }
1146 
1147   bool allpairs = false;
1148   if (nmuons_ > 2) {
1149     double mumu_mass;
1150     for (unsigned int idx = 0; idx < muons.size(); idx++) {
1151       for (unsigned int idx2 = idx + 1; idx2 < muons.size(); idx2++) {
1152         //compute inv mass of two different leptons
1153         mumu_mass = (muons[idx2].p4() + muons[idx2].p4()).M();
1154         if (mumu_mass < invMassLowercut_ || mumu_mass > invMassUppercut_)
1155           allpairs = true;
1156       }
1157     }
1158   }
1159   //cut only if enabled and the event has a pair that failed the mll range
1160   if (allpairs && invMassCutInAllMuPairs_) {
1161     return;
1162   }
1163 
1164   JetTagMap bjets;
1165 
1166   if (nbjets_ > 0) {
1167     // map of Jet,btagValues (for all jets passing bJetSelection_)
1168     //  - btagValue of each jet is calculated as sum of values from InputTags in jetTagTokens_
1169     JetTagMap allJetBTagVals;
1170 
1171     for (const auto& jetTagToken : jetTagTokens_) {
1172       edm::Handle<reco::JetTagCollection> bjetHandle;
1173       iEvent.getByToken(jetTagToken, bjetHandle);
1174       if (not bjetHandle.isValid()) {
1175         edm::LogWarning("TopMonitor") << "B-Jet handle not valid, will skip event \n";
1176         return;
1177       }
1178 
1179       const reco::JetTagCollection& bTags = *(bjetHandle.product());
1180 
1181       for (const auto& i_jetTag : bTags) {
1182         const auto& jetRef = i_jetTag.first;
1183 
1184         if (not bjetSelection_(*dynamic_cast<const reco::Jet*>(jetRef.get()))) {
1185           continue;
1186         }
1187 
1188         const auto btagVal = i_jetTag.second;
1189 
1190         if (not std::isfinite(btagVal)) {
1191           continue;
1192         }
1193 
1194         if (allJetBTagVals.find(jetRef) != allJetBTagVals.end()) {
1195           allJetBTagVals.at(jetRef) += btagVal;
1196         } else {
1197           allJetBTagVals.insert(JetTagMap::value_type(jetRef, btagVal));
1198         }
1199       }
1200     }
1201 
1202     for (const auto& jetBTagVal : allJetBTagVals) {
1203       if (jetBTagVal.second < workingpoint_) {
1204         continue;
1205       }
1206 
1207       bjets.insert(JetTagMap::value_type(jetBTagVal.first, jetBTagVal.second));
1208     }
1209 
1210     if (bjets.size() < nbjets_) {
1211       return;
1212     }
1213   }
1214 
1215   if (nbjets_ > 1) {
1216     double deltaEta = std::abs(bjets.begin()->first->eta() - (++bjets.begin())->first->eta());
1217     if (deltaEta > bJetDeltaEtaMax_)
1218       return;
1219   }
1220 
1221   if ((nbjets_ > 0) && (nmuons_ > 0)) {
1222     bool foundMuonInsideJet = false;
1223     for (auto const& bjet : bjets) {
1224       for (auto const& mu : muons) {
1225         double dR = deltaR(*bjet.first, mu);
1226         if (dR < bJetMuDeltaRmax_) {
1227           foundMuonInsideJet = true;
1228           break;
1229         }
1230       }
1231       if (foundMuonInsideJet)
1232         break;
1233     }
1234 
1235     if (!foundMuonInsideJet)
1236       return;
1237   }
1238 
1239   const int ls = iEvent.id().luminosityBlock();
1240 
1241   // numerator condition
1242   const bool trg_passed = (num_genTriggerEventFlag_->on() && num_genTriggerEventFlag_->accept(iEvent, iSetup));
1243 
1244   if (enableMETPlot_) {
1245     metME_.fill(trg_passed, met_pt);
1246     metME_variableBinning_.fill(trg_passed, met_pt);
1247     metPhiME_.fill(trg_passed, met_phi);
1248     metVsLS_.fill(trg_passed, ls, met_pt);
1249   }
1250   if (HTcut_ > 0) {
1251     eventHT_.fill(trg_passed, eventHT);
1252     eventHT_variableBinning_.fill(trg_passed, eventHT);
1253     htVsLS_.fill(trg_passed, ls, eventHT);
1254   }
1255   //george
1256   if (MHTcut_ > 0) {
1257     eventMHT_.fill(trg_passed, eventMHT.pt());
1258     eventMHT_variableBinning_.fill(trg_passed, eventMHT.pt());
1259   }
1260 
1261   if (njets_ > 0) {
1262     jetMulti_.fill(trg_passed, jets.size());
1263     jetEtaPhi_HEP17_.fill(trg_passed, jets.at(0).eta(), jets.at(0).phi());  // for HEP17 monitorning
1264     jetVsLS_.fill(trg_passed, ls, jets.at(0).pt());
1265   }
1266 
1267   if (enablePhotonPlot_) {
1268     phoMulti_.fill(trg_passed, photons.size());
1269   }
1270 
1271   // Marina
1272   if (nbjets_ > 0) {
1273     bjetMulti_.fill(trg_passed, bjets.size());
1274     bjetVsLS_.fill(trg_passed, ls, bjets.begin()->first->pt());
1275   }
1276 
1277   if (nmuons_ > 0) {
1278     muMulti_.fill(trg_passed, muons.size());
1279     muVsLS_.fill(trg_passed, ls, muons.at(0).pt());
1280     if (nmuons_ > 1) {
1281       mu1Pt_mu2Pt_.fill(trg_passed, muons.at(0).pt(), muons.at(1).pt());
1282       mu1Eta_mu2Eta_.fill(trg_passed, muons.at(0).eta(), muons.at(1).eta());
1283       invMass_mumu_.fill(trg_passed, mll);
1284       invMass_mumu_variableBinning_.fill(trg_passed, mll);
1285     }
1286     if (njets_ > 0) {
1287       DeltaR_jet_Mu_.fill(trg_passed, deltaR(jets.at(0), muons.at(0)));
1288     }
1289   }
1290 
1291   if (nelectrons_ > 0) {
1292     eleMulti_.fill(trg_passed, electrons.size());
1293     eleVsLS_.fill(trg_passed, ls, electrons.at(0).pt());
1294     if (HTcut_ > 0)
1295       elePt_eventHT_.fill(trg_passed, electrons.at(0).pt(), eventHT);
1296     if (njets_ > 0)
1297       elePt_jetPt_.fill(trg_passed, electrons.at(0).pt(), jets.at(0).pt());
1298     if (nmuons_ > 0) {
1299       elePt_muPt_.fill(trg_passed, electrons.at(0).pt(), muons.at(0).pt());
1300       eleEta_muEta_.fill(trg_passed, electrons.at(0).eta(), muons.at(0).eta());
1301     }
1302     if (nelectrons_ > 1) {
1303       ele1Pt_ele2Pt_.fill(trg_passed, electrons.at(0).pt(), electrons.at(1).pt());
1304       ele1Eta_ele2Eta_.fill(trg_passed, electrons.at(0).eta(), electrons.at(1).eta());
1305     }
1306   }
1307 
1308   if (enablePhotonPlot_) {
1309     if (nphotons_ > 0) {
1310       phoVsLS_.fill(trg_passed, ls, photons.at(0).pt());
1311       if (nmuons_ > 0) {
1312         muPt_phoPt_.fill(trg_passed, muons.at(0).pt(), photons.at(0).pt());
1313         muEta_phoEta_.fill(trg_passed, muons.at(0).eta(), photons.at(0).eta());
1314       }
1315     }
1316   }
1317 
1318   for (unsigned int iMu = 0; iMu < muons.size(); ++iMu) {
1319     if (iMu >= nmuons_)
1320       break;
1321     muPhi_.at(iMu).fill(trg_passed, muons.at(iMu).phi());
1322     muEta_.at(iMu).fill(trg_passed, muons.at(iMu).eta());
1323     muPt_.at(iMu).fill(trg_passed, muons.at(iMu).pt());
1324     muEta_variableBinning_.at(iMu).fill(trg_passed, muons.at(iMu).eta());
1325     muPt_variableBinning_.at(iMu).fill(trg_passed, muons.at(iMu).pt());
1326     muPtEta_.at(iMu).fill(trg_passed, muons.at(iMu).pt(), muons.at(iMu).eta());
1327     muEtaPhi_.at(iMu).fill(trg_passed, muons.at(iMu).eta(), muons.at(iMu).phi());
1328   }
1329   for (unsigned int iEle = 0; iEle < electrons.size(); ++iEle) {
1330     if (iEle >= nelectrons_)
1331       break;
1332     elePhi_.at(iEle).fill(trg_passed, electrons.at(iEle).phi());
1333     eleEta_.at(iEle).fill(trg_passed, electrons.at(iEle).eta());
1334     elePt_.at(iEle).fill(trg_passed, electrons.at(iEle).pt());
1335     eleEta_variableBinning_.at(iEle).fill(trg_passed, electrons.at(iEle).eta());
1336     elePt_variableBinning_.at(iEle).fill(trg_passed, electrons.at(iEle).pt());
1337     elePtEta_.at(iEle).fill(trg_passed, electrons.at(iEle).pt(), electrons.at(iEle).eta());
1338     eleEtaPhi_.at(iEle).fill(trg_passed, electrons.at(iEle).eta(), electrons.at(iEle).phi());
1339   }
1340   //Menglei
1341   if (enablePhotonPlot_) {
1342     for (unsigned int iPho = 0; iPho < photons.size(); ++iPho) {
1343       if (iPho >= nphotons_)
1344         break;
1345       phoPhi_[iPho].fill(trg_passed, photons[iPho].phi());
1346       phoEta_[iPho].fill(trg_passed, photons[iPho].eta());
1347       phoPt_[iPho].fill(trg_passed, photons[iPho].pt());
1348       phoPtEta_[iPho].fill(trg_passed, photons[iPho].pt(), photons[iPho].eta());
1349       phoEtaPhi_[iPho].fill(trg_passed, photons[iPho].eta(), photons[iPho].phi());
1350     }
1351   }
1352 
1353   for (unsigned int iJet = 0; iJet < jets.size(); ++iJet) {
1354     if (iJet >= njets_)
1355       break;
1356     jetPhi_.at(iJet).fill(trg_passed, jets.at(iJet).phi());
1357     jetEta_.at(iJet).fill(trg_passed, jets.at(iJet).eta());
1358     jetPt_.at(iJet).fill(trg_passed, jets.at(iJet).pt());
1359     jetEta_variableBinning_.at(iJet).fill(trg_passed, jets.at(iJet).eta());
1360     jetPt_variableBinning_.at(iJet).fill(trg_passed, jets.at(iJet).pt());
1361     jetPtEta_.at(iJet).fill(trg_passed, jets.at(iJet).pt(), jets.at(iJet).eta());
1362     jetEtaPhi_.at(iJet).fill(trg_passed, jets.at(iJet).eta(), jets.at(iJet).phi());
1363   }
1364 
1365   // Marina
1366   unsigned int iBJet = 0;
1367   for (auto& bjet : bjets) {
1368     if (iBJet >= nbjets_)
1369       break;
1370 
1371     bjetPhi_.at(iBJet).fill(trg_passed, bjet.first->phi());
1372     bjetEta_.at(iBJet).fill(trg_passed, bjet.first->eta());
1373     bjetPt_.at(iBJet).fill(trg_passed, bjet.first->pt());
1374     bjetCSV_.at(iBJet).fill(trg_passed, std::fmax(0.0, bjet.second));
1375     bjetEta_variableBinning_.at(iBJet).fill(trg_passed, bjet.first->eta());
1376     bjetPt_variableBinning_.at(iBJet).fill(trg_passed, bjet.first->pt());
1377     bjetPtEta_.at(iBJet).fill(trg_passed, bjet.first->pt(), bjet.first->eta());
1378     bjetEtaPhi_.at(iBJet).fill(trg_passed, bjet.first->eta(), bjet.first->phi());
1379     bjetCSVHT_.at(iBJet).fill(trg_passed, std::fmax(0.0, bjet.second), eventHT);
1380 
1381     iBJet++;
1382   }
1383 }
1384 
1385 void TopMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1386   edm::ParameterSetDescription desc;
1387   desc.add<std::string>("FolderName", "HLT/TOP");
1388 
1389   desc.add<bool>("requireValidHLTPaths", true);
1390 
1391   desc.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
1392   desc.add<edm::InputTag>("muons", edm::InputTag("muons"));
1393   desc.add<edm::InputTag>("electrons", edm::InputTag("gedGsfElectrons"));
1394   desc.add<edm::InputTag>("elecID", edm::InputTag("egmGsfElectronIDsForDQM:cutBasedElectronID-Fall17-94X-V1-tight"));
1395   desc.add<edm::InputTag>("photons", edm::InputTag("photons"));
1396   desc.add<edm::InputTag>("jets", edm::InputTag("ak4PFJetsCHS"));
1397   desc.add<std::vector<edm::InputTag> >(
1398       "btagAlgos", {edm::InputTag("pfDeepCSVJetTags:probb"), edm::InputTag("pfDeepCSVJetTags:probbb")});
1399   desc.add<edm::InputTag>("met", edm::InputTag("pfMet"));
1400 
1401   desc.add<std::string>("metSelection", "pt > 0");
1402   desc.add<std::string>("jetSelection", "pt > 0");
1403   desc.add<std::string>("eleSelection", "pt > 0");
1404   desc.add<std::string>("muoSelection", "pt > 0");
1405   desc.add<std::string>("phoSelection", "pt > 0");
1406   desc.add<std::string>("HTdefinition", "pt > 0");
1407   desc.add<std::string>("vertexSelection", "!isFake");
1408   desc.add<std::string>("bjetSelection", "pt > 0");
1409   desc.add<unsigned int>("njets", 0);
1410   desc.add<unsigned int>("nelectrons", 0);
1411   desc.add<unsigned int>("nmuons", 0);
1412   desc.add<unsigned int>("nphotons", 0);
1413   desc.add<double>("leptJetDeltaRmin", 0);
1414   desc.add<double>("bJetMuDeltaRmax", 9999.);
1415   desc.add<double>("bJetDeltaEtaMax", 9999.);
1416   desc.add<double>("HTcut", 0);
1417 
1418   desc.add<unsigned int>("nbjets", 0);
1419   desc.add<double>("workingpoint", 0.4941);  // DeepCSV Medium wp
1420   desc.add<bool>("applyLeptonPVcuts", false);
1421   desc.add<double>("invMassUppercut", -1.0);
1422   desc.add<double>("invMassLowercut", -1.0);
1423   desc.add<bool>("oppositeSignMuons", false);
1424   desc.add<std::string>("MHTdefinition", "pt > 0");
1425   desc.add<double>("MHTcut", -1);
1426   desc.add<bool>("invMassCutInAllMuPairs", false);
1427   desc.add<bool>("enablePhotonPlot", false);
1428   desc.add<bool>("enableMETPlot", false);
1429   desc.add<bool>("enable2DPlots", true);
1430 
1431   edm::ParameterSetDescription genericTriggerEventPSet;
1432   GenericTriggerEventFlag::fillPSetDescription(genericTriggerEventPSet);
1433   desc.add<edm::ParameterSetDescription>("numGenericTriggerEventPSet", genericTriggerEventPSet);
1434   desc.add<edm::ParameterSetDescription>("denGenericTriggerEventPSet", genericTriggerEventPSet);
1435 
1436   edm::ParameterSetDescription histoPSet;
1437   edm::ParameterSetDescription metPSet;
1438   edm::ParameterSetDescription phiPSet;
1439   edm::ParameterSetDescription etaPSet;
1440   edm::ParameterSetDescription ptPSet;
1441   edm::ParameterSetDescription htPSet;
1442   edm::ParameterSetDescription DRPSet;
1443   edm::ParameterSetDescription csvPSet;
1444   edm::ParameterSetDescription invMassPSet;
1445   edm::ParameterSetDescription MHTPSet;
1446   fillHistoPSetDescription(metPSet);
1447   fillHistoPSetDescription(phiPSet);
1448   fillHistoPSetDescription(ptPSet);
1449   fillHistoPSetDescription(etaPSet);
1450   fillHistoPSetDescription(htPSet);
1451   fillHistoPSetDescription(DRPSet);
1452   fillHistoPSetDescription(csvPSet);
1453   fillHistoPSetDescription(MHTPSet);
1454   fillHistoPSetDescription(invMassPSet);
1455   histoPSet.add<edm::ParameterSetDescription>("metPSet", metPSet);
1456   histoPSet.add<edm::ParameterSetDescription>("etaPSet", etaPSet);
1457   histoPSet.add<edm::ParameterSetDescription>("phiPSet", phiPSet);
1458   histoPSet.add<edm::ParameterSetDescription>("ptPSet", ptPSet);
1459   histoPSet.add<edm::ParameterSetDescription>("htPSet", htPSet);
1460   histoPSet.add<edm::ParameterSetDescription>("DRPSet", DRPSet);
1461   histoPSet.add<edm::ParameterSetDescription>("csvPSet", csvPSet);
1462   histoPSet.add<edm::ParameterSetDescription>("invMassPSet", invMassPSet);
1463   histoPSet.add<edm::ParameterSetDescription>("MHTPSet", MHTPSet);
1464 
1465   std::vector<double> bins = {0.,   20.,  40.,  60.,  80.,  90.,  100., 110., 120., 130., 140., 150., 160.,
1466                               170., 180., 190., 200., 220., 240., 260., 280., 300., 350., 400., 450., 1000.};
1467   std::vector<double> eta_bins = {-3., -2.5, -2., -1.5, -1., -.5, 0., .5, 1., 1.5, 2., 2.5, 3.};
1468   histoPSet.add<std::vector<double> >("metBinning", bins);
1469   histoPSet.add<std::vector<double> >("HTBinning", bins);
1470   histoPSet.add<std::vector<double> >("jetPtBinning", bins);
1471   histoPSet.add<std::vector<double> >("elePtBinning", bins);
1472   histoPSet.add<std::vector<double> >("muPtBinning", bins);
1473   histoPSet.add<std::vector<double> >("jetEtaBinning", eta_bins);
1474   histoPSet.add<std::vector<double> >("eleEtaBinning", eta_bins);
1475   histoPSet.add<std::vector<double> >("muEtaBinning", eta_bins);
1476   histoPSet.add<std::vector<double> >("invMassVariableBinning", bins);
1477   histoPSet.add<std::vector<double> >("MHTVariableBinning", bins);
1478 
1479   std::vector<double> bins_2D = {0., 40., 80., 100., 120., 140., 160., 180., 200., 240., 280., 350., 450., 1000.};
1480   std::vector<double> eta_bins_2D = {-3., -2., -1., 0., 1., 2., 3.};
1481   std::vector<double> phi_bins_2D = {
1482       -3.1415, -2.5132, -1.8849, -1.2566, -0.6283, 0, 0.6283, 1.2566, 1.8849, 2.5132, 3.1415};
1483   histoPSet.add<std::vector<double> >("HTBinning2D", bins_2D);
1484   histoPSet.add<std::vector<double> >("jetPtBinning2D", bins_2D);
1485   histoPSet.add<std::vector<double> >("elePtBinning2D", bins_2D);
1486   histoPSet.add<std::vector<double> >("muPtBinning2D", bins_2D);
1487   histoPSet.add<std::vector<double> >("phoPtBinning2D", bins_2D);
1488   histoPSet.add<std::vector<double> >("jetEtaBinning2D", eta_bins_2D);
1489   histoPSet.add<std::vector<double> >("eleEtaBinning2D", eta_bins_2D);
1490   histoPSet.add<std::vector<double> >("muEtaBinning2D", eta_bins_2D);
1491   histoPSet.add<std::vector<double> >("phoEtaBinning2D", eta_bins_2D);
1492   histoPSet.add<std::vector<double> >("phiBinning2D", phi_bins_2D);
1493 
1494   edm::ParameterSetDescription lsPSet;
1495   fillHistoLSPSetDescription(lsPSet);
1496   histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
1497 
1498   desc.add<edm::ParameterSetDescription>("histoPSet", histoPSet);
1499 
1500   edm::ParameterSetDescription lPVcutPSet;
1501   lPVcutPSet.add<double>("dxy", 9999.);
1502   lPVcutPSet.add<double>("dz", 9999.);
1503   desc.add<edm::ParameterSetDescription>("leptonPVcuts", lPVcutPSet);
1504 
1505   descriptions.add("topMonitoring", desc);
1506 }
1507 
1508 // Define this as a plug-in
1509 DEFINE_FWK_MODULE(TopMonitor);