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_;
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
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
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
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
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
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
0410 hltPathsAreValid_ = (num_genTriggerEventFlag_ && den_genTriggerEventFlag_ && num_genTriggerEventFlag_->on() &&
0411 den_genTriggerEventFlag_->on() && num_genTriggerEventFlag_->allHLTPathsAreValid() &&
0412 den_genTriggerEventFlag_->allHLTPathsAreValid());
0413
0414
0415
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);
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
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
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
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
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
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
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
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
0941
0942 if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
0943 return;
0944 }
0945
0946
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
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
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
1160 if (allpairs && invMassCutInAllMuPairs_) {
1161 return;
1162 }
1163
1164 JetTagMap bjets;
1165
1166 if (nbjets_ > 0) {
1167
1168
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
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
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());
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
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
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
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);
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
1509 DEFINE_FWK_MODULE(TopMonitor);
