Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:09:58 

0001 #include "FWCore/Framework/interface/MakerMacros.h"
0002 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0003 #include "DQMServices/Core/interface/DQMStore.h"
0004 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0005 #include "DQMOffline/Trigger/plugins/TriggerDQMBase.h"
0006 #include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
0007 #include "CommonTools/Utils/interface/StringCutObjectSelector.h"
0008 #include "DataFormats/JetReco/interface/CaloJet.h"
0009 #include "DataFormats/JetReco/interface/CaloJetCollection.h"
0010 #include "DataFormats/TrackReco/interface/Track.h"
0011 #include "DataFormats/TrackReco/interface/TrackFwd.h"
0012 
0013 #include <string>
0014 #include <vector>
0015 
0016 class NoBPTXMonitor : public DQMEDAnalyzer, public TriggerDQMBase {
0017 public:
0018   typedef dqm::reco::MonitorElement MonitorElement;
0019   typedef dqm::reco::DQMStore DQMStore;
0020 
0021   NoBPTXMonitor(const edm::ParameterSet&);
0022   ~NoBPTXMonitor() throw() override;
0023   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0024 
0025 protected:
0026   void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override;
0027   void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) override;
0028 
0029 private:
0030   const std::string folderName_;
0031 
0032   const bool requireValidHLTPaths_;
0033   bool hltPathsAreValid_;
0034 
0035   edm::EDGetTokenT<reco::CaloJetCollection> jetToken_;
0036   edm::EDGetTokenT<reco::TrackCollection> muonToken_;
0037 
0038   std::vector<double> jetE_variable_binning_;
0039   MEbinning jetE_binning_;
0040   MEbinning jetEta_binning_;
0041   MEbinning jetPhi_binning_;
0042   std::vector<double> muonPt_variable_binning_;
0043   MEbinning muonPt_binning_;
0044   MEbinning muonEta_binning_;
0045   MEbinning muonPhi_binning_;
0046   MEbinning ls_binning_;
0047   MEbinning bx_binning_;
0048 
0049   ObjME jetENoBPTX_;
0050   ObjME jetENoBPTX_variableBinning_;
0051   ObjME jetEVsLS_;
0052   ObjME jetEVsBX_;
0053   ObjME jetEtaNoBPTX_;
0054   ObjME jetEtaVsLS_;
0055   ObjME jetEtaVsBX_;
0056   ObjME jetPhiNoBPTX_;
0057   ObjME jetPhiVsLS_;
0058   ObjME jetPhiVsBX_;
0059   ObjME muonPtNoBPTX_;
0060   ObjME muonPtNoBPTX_variableBinning_;
0061   ObjME muonPtVsLS_;
0062   ObjME muonPtVsBX_;
0063   ObjME muonEtaNoBPTX_;
0064   ObjME muonEtaVsLS_;
0065   ObjME muonEtaVsBX_;
0066   ObjME muonPhiNoBPTX_;
0067   ObjME muonPhiVsLS_;
0068   ObjME muonPhiVsBX_;
0069 
0070   std::unique_ptr<GenericTriggerEventFlag> num_genTriggerEventFlag_;
0071   std::unique_ptr<GenericTriggerEventFlag> den_genTriggerEventFlag_;
0072 
0073   StringCutObjectSelector<reco::CaloJet, true> jetSelection_;
0074   StringCutObjectSelector<reco::Track, true> muonSelection_;
0075 
0076   unsigned int njets_;
0077   unsigned int nmuons_;
0078 };
0079 
0080 NoBPTXMonitor::NoBPTXMonitor(const edm::ParameterSet& iConfig)
0081     : folderName_(iConfig.getParameter<std::string>("FolderName")),
0082       requireValidHLTPaths_(iConfig.getParameter<bool>("requireValidHLTPaths")),
0083       hltPathsAreValid_(false),
0084       jetToken_(consumes<reco::CaloJetCollection>(iConfig.getParameter<edm::InputTag>("jets"))),
0085       muonToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("muons"))),
0086       jetE_variable_binning_(
0087           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("jetEBinning")),
0088       jetE_binning_(getHistoPSet(
0089           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("jetEPSet"))),
0090       jetEta_binning_(getHistoPSet(
0091           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("jetEtaPSet"))),
0092       jetPhi_binning_(getHistoPSet(
0093           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("jetPhiPSet"))),
0094       muonPt_variable_binning_(
0095           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muonPtBinning")),
0096       muonPt_binning_(getHistoPSet(
0097           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonPtPSet"))),
0098       muonEta_binning_(getHistoPSet(
0099           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonEtaPSet"))),
0100       muonPhi_binning_(getHistoPSet(
0101           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonPhiPSet"))),
0102       ls_binning_(
0103           getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("lsPSet"))),
0104       bx_binning_(getHistoLSPSet(
0105           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("bxPSet"))),
0106       num_genTriggerEventFlag_(new GenericTriggerEventFlag(
0107           iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this)),
0108       den_genTriggerEventFlag_(new GenericTriggerEventFlag(
0109           iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this)),
0110       jetSelection_(iConfig.getParameter<std::string>("jetSelection")),
0111       muonSelection_(iConfig.getParameter<std::string>("muonSelection")),
0112       njets_(iConfig.getParameter<unsigned int>("njets")),
0113       nmuons_(iConfig.getParameter<unsigned int>("nmuons")) {}
0114 
0115 NoBPTXMonitor::~NoBPTXMonitor() throw() {
0116   if (num_genTriggerEventFlag_) {
0117     num_genTriggerEventFlag_.reset();
0118   }
0119   if (den_genTriggerEventFlag_) {
0120     den_genTriggerEventFlag_.reset();
0121   }
0122 }
0123 
0124 void NoBPTXMonitor::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const& iRun, edm::EventSetup const& iSetup) {
0125   // Initialize the GenericTriggerEventFlag
0126   if (num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on()) {
0127     num_genTriggerEventFlag_->initRun(iRun, iSetup);
0128   }
0129   if (den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on()) {
0130     den_genTriggerEventFlag_->initRun(iRun, iSetup);
0131   }
0132 
0133   // check if every HLT path specified in numerator and denominator has a valid match in the HLT Menu
0134   hltPathsAreValid_ = (num_genTriggerEventFlag_ && den_genTriggerEventFlag_ && num_genTriggerEventFlag_->on() &&
0135                        den_genTriggerEventFlag_->on() && num_genTriggerEventFlag_->allHLTPathsAreValid() &&
0136                        den_genTriggerEventFlag_->allHLTPathsAreValid());
0137 
0138   // if valid HLT paths are required,
0139   // create DQM outputs only if all paths are valid
0140   if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
0141     return;
0142   }
0143 
0144   std::string histname, histtitle;
0145 
0146   std::string currentFolder = folderName_;
0147   ibooker.setCurrentFolder(currentFolder);
0148 
0149   histname = "jetE";
0150   histtitle = "jetE";
0151   bookME(ibooker, jetENoBPTX_, histname, histtitle, jetE_binning_.nbins, jetE_binning_.xmin, jetE_binning_.xmax);
0152   setMETitle(jetENoBPTX_, "Jet E [GeV]", "Events / [GeV]");
0153 
0154   histname = "jetE_variable";
0155   histtitle = "jetE";
0156   bookME(ibooker, jetENoBPTX_variableBinning_, histname, histtitle, jetE_variable_binning_);
0157   setMETitle(jetENoBPTX_variableBinning_, "Jet E [GeV]", "Events / [GeV]");
0158 
0159   histname = "jetEVsLS";
0160   histtitle = "jetE vs LS";
0161   bookME(ibooker,
0162          jetEVsLS_,
0163          histname,
0164          histtitle,
0165          ls_binning_.nbins,
0166          ls_binning_.xmin,
0167          ls_binning_.xmax,
0168          jetE_binning_.xmin,
0169          jetE_binning_.xmax);
0170   setMETitle(jetEVsLS_, "LS", "Jet E [GeV]");
0171 
0172   histname = "jetEVsBX";
0173   histtitle = "jetE vs BX";
0174   bookME(ibooker,
0175          jetEVsBX_,
0176          histname,
0177          histtitle,
0178          bx_binning_.nbins,
0179          bx_binning_.xmin,
0180          bx_binning_.xmax,
0181          jetE_binning_.xmin,
0182          jetE_binning_.xmax,
0183          false);
0184   setMETitle(jetEVsBX_, "BX", "Jet E [GeV]");
0185 
0186   histname = "jetEta";
0187   histtitle = "jetEta";
0188   bookME(
0189       ibooker, jetEtaNoBPTX_, histname, histtitle, jetEta_binning_.nbins, jetEta_binning_.xmin, jetEta_binning_.xmax);
0190   setMETitle(jetEtaNoBPTX_, "Jet #eta", "Events");
0191 
0192   histname = "jetEtaVsLS";
0193   histtitle = "jetEta vs LS";
0194   bookME(ibooker,
0195          jetEtaVsLS_,
0196          histname,
0197          histtitle,
0198          ls_binning_.nbins,
0199          ls_binning_.xmin,
0200          ls_binning_.xmax,
0201          jetEta_binning_.xmin,
0202          jetEta_binning_.xmax,
0203          false);
0204   setMETitle(jetEtaVsLS_, "LS", "Jet #eta");
0205 
0206   histname = "jetEtaVsBX";
0207   histtitle = "jetEta vs BX";
0208   bookME(ibooker,
0209          jetEtaVsBX_,
0210          histname,
0211          histtitle,
0212          bx_binning_.nbins,
0213          bx_binning_.xmin,
0214          bx_binning_.xmax,
0215          jetEta_binning_.xmin,
0216          jetEta_binning_.xmax,
0217          false);
0218   setMETitle(jetEtaVsBX_, "BX", "Jet #eta");
0219 
0220   histname = "jetPhi";
0221   histtitle = "jetPhi";
0222   bookME(
0223       ibooker, jetPhiNoBPTX_, histname, histtitle, jetPhi_binning_.nbins, jetPhi_binning_.xmin, jetPhi_binning_.xmax);
0224   setMETitle(jetPhiNoBPTX_, "Jet #phi", "Events");
0225 
0226   histname = "jetPhiVsLS";
0227   histtitle = "jetPhi vs LS";
0228   bookME(ibooker,
0229          jetPhiVsLS_,
0230          histname,
0231          histtitle,
0232          ls_binning_.nbins,
0233          ls_binning_.xmin,
0234          ls_binning_.xmax,
0235          jetPhi_binning_.xmin,
0236          jetPhi_binning_.xmax,
0237          false);
0238   setMETitle(jetPhiVsLS_, "LS", "Jet #phi");
0239 
0240   histname = "jetPhiVsBX";
0241   histtitle = "jetPhi vs BX";
0242   bookME(ibooker,
0243          jetPhiVsBX_,
0244          histname,
0245          histtitle,
0246          bx_binning_.nbins,
0247          bx_binning_.xmin,
0248          bx_binning_.xmax,
0249          jetPhi_binning_.xmin,
0250          jetPhi_binning_.xmax,
0251          false);
0252   setMETitle(jetPhiVsBX_, "BX", "Jet #phi");
0253 
0254   histname = "muonPt";
0255   histtitle = "muonPt";
0256   bookME(
0257       ibooker, muonPtNoBPTX_, histname, histtitle, muonPt_binning_.nbins, muonPt_binning_.xmin, muonPt_binning_.xmax);
0258   setMETitle(muonPtNoBPTX_, "DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]");
0259 
0260   histname = "muonPt_variable";
0261   histtitle = "muonPt";
0262   bookME(ibooker, muonPtNoBPTX_variableBinning_, histname, histtitle, muonPt_variable_binning_);
0263   setMETitle(muonPtNoBPTX_variableBinning_, "DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]");
0264 
0265   histname = "muonPtVsLS";
0266   histtitle = "muonPt vs LS";
0267   bookME(ibooker,
0268          muonPtVsLS_,
0269          histname,
0270          histtitle,
0271          ls_binning_.nbins,
0272          ls_binning_.xmin,
0273          ls_binning_.xmax,
0274          muonPt_binning_.xmin,
0275          muonPt_binning_.xmax,
0276          false);
0277   setMETitle(muonPtVsLS_, "LS", "DisplacedStandAlone Muon p_{T} [GeV]");
0278 
0279   histname = "muonPtVsBX";
0280   histtitle = "muonPt vs BX";
0281   bookME(ibooker,
0282          muonPtVsBX_,
0283          histname,
0284          histtitle,
0285          bx_binning_.nbins,
0286          bx_binning_.xmin,
0287          bx_binning_.xmax,
0288          muonPt_binning_.xmin,
0289          muonPt_binning_.xmax,
0290          false);
0291   setMETitle(muonPtVsBX_, "BX", "DisplacedStandAlone Muon p_{T} [GeV]");
0292 
0293   histname = "muonEta";
0294   histtitle = "muonEta";
0295   bookME(ibooker,
0296          muonEtaNoBPTX_,
0297          histname,
0298          histtitle,
0299          muonEta_binning_.nbins,
0300          muonEta_binning_.xmin,
0301          muonEta_binning_.xmax);
0302   setMETitle(muonEtaNoBPTX_, "DisplacedStandAlone Muon #eta", "Events");
0303 
0304   histname = "muonEtaVsLS";
0305   histtitle = "muonEta vs LS";
0306   bookME(ibooker,
0307          muonEtaVsLS_,
0308          histname,
0309          histtitle,
0310          ls_binning_.nbins,
0311          ls_binning_.xmin,
0312          ls_binning_.xmax,
0313          muonEta_binning_.xmin,
0314          muonEta_binning_.xmax,
0315          false);
0316   setMETitle(muonEtaVsLS_, "LS", "DisplacedStandAlone Muon #eta");
0317 
0318   histname = "muonEtaVsBX";
0319   histtitle = "muonEta vs BX";
0320   bookME(ibooker,
0321          muonEtaVsBX_,
0322          histname,
0323          histtitle,
0324          bx_binning_.nbins,
0325          bx_binning_.xmin,
0326          bx_binning_.xmax,
0327          muonEta_binning_.xmin,
0328          muonEta_binning_.xmax,
0329          false);
0330   setMETitle(muonEtaVsBX_, "BX", "DisplacedStandAlone Muon #eta");
0331 
0332   histname = "muonPhi";
0333   histtitle = "muonPhi";
0334   bookME(ibooker,
0335          muonPhiNoBPTX_,
0336          histname,
0337          histtitle,
0338          muonPhi_binning_.nbins,
0339          muonPhi_binning_.xmin,
0340          muonPhi_binning_.xmax);
0341   setMETitle(muonPhiNoBPTX_, "DisplacedStandAlone Muon #phi", "Events");
0342 
0343   histname = "muonPhiVsLS";
0344   histtitle = "muonPhi vs LS";
0345   bookME(ibooker,
0346          muonPhiVsLS_,
0347          histname,
0348          histtitle,
0349          ls_binning_.nbins,
0350          ls_binning_.xmin,
0351          ls_binning_.xmax,
0352          muonPhi_binning_.xmin,
0353          muonPhi_binning_.xmax,
0354          false);
0355   setMETitle(muonPhiVsLS_, "LS", "DisplacedStandAlone Muon #phi");
0356 
0357   histname = "muonPhiVsBX";
0358   histtitle = "muonPhi vs BX";
0359   bookME(ibooker,
0360          muonPhiVsBX_,
0361          histname,
0362          histtitle,
0363          bx_binning_.nbins,
0364          bx_binning_.xmin,
0365          bx_binning_.xmax,
0366          muonPhi_binning_.xmin,
0367          muonPhi_binning_.xmax,
0368          false);
0369   setMETitle(muonPhiVsBX_, "BX", "DisplacedStandAlone Muon #phi");
0370 }
0371 
0372 void NoBPTXMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) {
0373   // if valid HLT paths are required,
0374   // analyze event only if all paths are valid
0375   if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
0376     return;
0377   }
0378 
0379   // Filter out events if Trigger Filtering is requested
0380   if (den_genTriggerEventFlag_->on() && !den_genTriggerEventFlag_->accept(iEvent, iSetup)) {
0381     return;
0382   }
0383 
0384   const int ls = iEvent.id().luminosityBlock();
0385   const int bx = iEvent.bunchCrossing();
0386 
0387   edm::Handle<reco::CaloJetCollection> jetHandle;
0388   iEvent.getByToken(jetToken_, jetHandle);
0389 
0390   if ((unsigned int)(jetHandle->size()) < njets_)
0391     return;
0392 
0393   std::vector<reco::CaloJet> jets;
0394   for (auto const& j : *jetHandle) {
0395     if (jetSelection_(j))
0396       jets.push_back(j);
0397   }
0398 
0399   if ((unsigned int)(jets.size()) < njets_)
0400     return;
0401 
0402   double jetE = -999;
0403   double jetEta = -999;
0404   double jetPhi = -999;
0405   if (!jets.empty()) {
0406     jetE = jets[0].energy();
0407     jetEta = jets[0].eta();
0408     jetPhi = jets[0].phi();
0409   }
0410 
0411   edm::Handle<reco::TrackCollection> DSAHandle;
0412   iEvent.getByToken(muonToken_, DSAHandle);
0413 
0414   if ((unsigned int)(DSAHandle->size()) < nmuons_)
0415     return;
0416 
0417   std::vector<reco::Track> muons;
0418   for (auto const& m : *DSAHandle) {
0419     if (muonSelection_(m))
0420       muons.push_back(m);
0421   }
0422 
0423   if ((unsigned int)(muons.size()) < nmuons_)
0424     return;
0425 
0426   double muonPt = -999;
0427   double muonEta = -999;
0428   double muonPhi = -999;
0429   if (!muons.empty()) {
0430     muonPt = muons[0].pt();
0431     muonEta = muons[0].eta();
0432     muonPhi = muons[0].phi();
0433   }
0434 
0435   // passes numerator-trigger (fill-numerator flag)
0436   const bool trg_passed = (num_genTriggerEventFlag_->on() && num_genTriggerEventFlag_->accept(iEvent, iSetup));
0437 
0438   // filling histograms
0439   jetENoBPTX_.fill(trg_passed, jetE);
0440   jetENoBPTX_variableBinning_.fill(trg_passed, jetE);
0441   jetEtaNoBPTX_.fill(trg_passed, jetEta);
0442   jetPhiNoBPTX_.fill(trg_passed, jetPhi);
0443   muonPtNoBPTX_.fill(trg_passed, muonPt);
0444   muonPtNoBPTX_variableBinning_.fill(trg_passed, muonPt);
0445   muonEtaNoBPTX_.fill(trg_passed, muonEta);
0446   muonPhiNoBPTX_.fill(trg_passed, muonPhi);
0447 
0448   jetEVsLS_.fill(trg_passed, ls, jetE);
0449 
0450   if (trg_passed) {
0451     jetEVsBX_.numerator->Fill(bx, jetE);
0452     jetEtaVsLS_.numerator->Fill(ls, jetEta);
0453     jetEtaVsBX_.numerator->Fill(bx, jetEta);
0454     jetPhiVsLS_.numerator->Fill(ls, jetPhi);
0455     jetPhiVsBX_.numerator->Fill(bx, jetPhi);
0456     muonPtVsLS_.numerator->Fill(ls, muonPt);
0457     muonPtVsBX_.numerator->Fill(bx, muonPt);
0458     muonEtaVsLS_.numerator->Fill(ls, muonEta);
0459     muonEtaVsBX_.numerator->Fill(bx, muonEta);
0460     muonPhiVsLS_.numerator->Fill(ls, muonPhi);
0461     muonPhiVsBX_.numerator->Fill(bx, muonPhi);
0462   }
0463 }
0464 
0465 void NoBPTXMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0466   edm::ParameterSetDescription desc;
0467   desc.add<std::string>("FolderName", "HLT/NoBPTX");
0468   desc.add<bool>("requireValidHLTPaths", true);
0469 
0470   desc.add<edm::InputTag>("jets", edm::InputTag("ak4CaloJets"));
0471   desc.add<edm::InputTag>("muons", edm::InputTag("displacedStandAloneMuons"));
0472   desc.add<std::string>("jetSelection", "pt > 0");
0473   desc.add<std::string>("muonSelection", "pt > 0");
0474   desc.add<unsigned int>("njets", 0);
0475   desc.add<unsigned int>("nmuons", 0);
0476 
0477   edm::ParameterSetDescription genericTriggerEventPSet;
0478   GenericTriggerEventFlag::fillPSetDescription(genericTriggerEventPSet);
0479   desc.add<edm::ParameterSetDescription>("numGenericTriggerEventPSet", genericTriggerEventPSet);
0480   desc.add<edm::ParameterSetDescription>("denGenericTriggerEventPSet", genericTriggerEventPSet);
0481 
0482   edm::ParameterSetDescription histoPSet;
0483   edm::ParameterSetDescription jetEPSet;
0484   edm::ParameterSetDescription jetEtaPSet;
0485   edm::ParameterSetDescription jetPhiPSet;
0486   edm::ParameterSetDescription muonPtPSet;
0487   edm::ParameterSetDescription muonEtaPSet;
0488   edm::ParameterSetDescription muonPhiPSet;
0489   edm::ParameterSetDescription lsPSet;
0490   edm::ParameterSetDescription bxPSet;
0491   fillHistoPSetDescription(jetEPSet);
0492   fillHistoPSetDescription(jetEtaPSet);
0493   fillHistoPSetDescription(jetPhiPSet);
0494   fillHistoPSetDescription(muonPtPSet);
0495   fillHistoPSetDescription(muonEtaPSet);
0496   fillHistoPSetDescription(muonPhiPSet);
0497   fillHistoPSetDescription(lsPSet);
0498   fillHistoLSPSetDescription(bxPSet);
0499   histoPSet.add<edm::ParameterSetDescription>("jetEPSet", jetEPSet);
0500   histoPSet.add<edm::ParameterSetDescription>("jetEtaPSet", jetEtaPSet);
0501   histoPSet.add<edm::ParameterSetDescription>("jetPhiPSet", jetPhiPSet);
0502   histoPSet.add<edm::ParameterSetDescription>("muonPtPSet", muonPtPSet);
0503   histoPSet.add<edm::ParameterSetDescription>("muonEtaPSet", muonEtaPSet);
0504   histoPSet.add<edm::ParameterSetDescription>("muonPhiPSet", muonPhiPSet);
0505   histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
0506   histoPSet.add<edm::ParameterSetDescription>("bxPSet", bxPSet);
0507   std::vector<double> bins = {0.,   20.,  40.,  60.,  80.,  90.,  100., 110., 120., 130., 140., 150., 160.,
0508                               170., 180., 190., 200., 220., 240., 260., 280., 300., 350., 400., 450., 1000.};
0509   histoPSet.add<std::vector<double> >("jetEBinning", bins);
0510   histoPSet.add<std::vector<double> >("muonPtBinning", bins);
0511 
0512   desc.add<edm::ParameterSetDescription>("histoPSet", histoPSet);
0513 
0514   descriptions.add("NoBPTXMonitoring", desc);
0515 }
0516 
0517 // Define this as a plug-in
0518 DEFINE_FWK_MODULE(NoBPTXMonitor);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!