CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
DiDispStaMuonMonitor.cc
Go to the documentation of this file.
1 #include <string>
2 #include <vector>
3 
4 #include "FWCore/Framework/interface/Frameworkfwd.h"
5 #include "FWCore/Framework/interface/MakerMacros.h"
6 #include "FWCore/MessageLogger/interface/MessageLogger.h"
7 #include "DQMServices/Core/interface/DQMStore.h"
8 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
9 #include "DQMOffline/Trigger/plugins/TriggerDQMBase.h"
10 #include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
11 #include "CommonTools/Utils/interface/StringCutObjectSelector.h"
12 
13 #include "DataFormats/TrackReco/interface/Track.h"
14 #include "DataFormats/TrackReco/interface/TrackFwd.h"
15 
16 class DiDispStaMuonMonitor : public DQMEDAnalyzer, public TriggerDQMBase {
17 public:
18  typedef dqm::reco::MonitorElement MonitorElement;
19  typedef dqm::reco::DQMStore DQMStore;
20 
21  DiDispStaMuonMonitor(const edm::ParameterSet&);
22  ~DiDispStaMuonMonitor() throw() override;
23  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
24 
25 protected:
26  void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override;
27  void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) override;
28 
29 private:
30  const std::string folderName_;
31 
32  const bool requireValidHLTPaths_;
33  bool hltPathsAreValid_;
34 
35  edm::EDGetTokenT<reco::TrackCollection> muonToken_;
36 
37  std::vector<double> muonPt_variable_binning_;
38  MEbinning muonPt_binning_;
39  MEbinning muonEta_binning_;
40  MEbinning muonPhi_binning_;
41  MEbinning muonDxy_binning_;
42  MEbinning ls_binning_;
43 
44  ObjME muonPtME_;
45  ObjME muonPtNoDxyCutME_;
46  ObjME muonPtME_variableBinning_;
47  ObjME muonPtVsLS_;
48  ObjME muonEtaME_;
49  ObjME muonPhiME_;
50  ObjME muonDxyME_;
51  ObjME subMuonPtME_;
52  ObjME subMuonPtME_variableBinning_;
53  ObjME subMuonEtaME_;
54  ObjME subMuonPhiME_;
55  ObjME subMuonDxyME_;
56 
57  std::unique_ptr<GenericTriggerEventFlag> num_genTriggerEventFlag_;
58  std::unique_ptr<GenericTriggerEventFlag> den_genTriggerEventFlag_;
59 
60  StringCutObjectSelector<reco::Track, true> muonSelectionGeneral_;
61  StringCutObjectSelector<reco::Track, true> muonSelectionPt_;
62  StringCutObjectSelector<reco::Track, true> muonSelectionDxy_;
63 
64  unsigned int nmuons_;
65 };
66 
67 DiDispStaMuonMonitor::DiDispStaMuonMonitor(const edm::ParameterSet& iConfig)
68  : folderName_(iConfig.getParameter<std::string>("FolderName")),
69  requireValidHLTPaths_(iConfig.getParameter<bool>("requireValidHLTPaths")),
70  hltPathsAreValid_(false),
71  muonToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("muons"))),
72  muonPt_variable_binning_(
73  iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double>>("muonPtBinning")),
74  muonPt_binning_(getHistoPSet(
75  iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonPtPSet"))),
76  muonEta_binning_(getHistoPSet(
77  iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonEtaPSet"))),
78  muonPhi_binning_(getHistoPSet(
79  iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonPhiPSet"))),
80  muonDxy_binning_(getHistoPSet(
81  iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonDxyPSet"))),
82  ls_binning_(
83  getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("lsPSet"))),
84  num_genTriggerEventFlag_(new GenericTriggerEventFlag(
85  iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this)),
86  den_genTriggerEventFlag_(new GenericTriggerEventFlag(
87  iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this)),
88  muonSelectionGeneral_(
89  iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("general")),
90  muonSelectionPt_(iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("pt")),
91  muonSelectionDxy_(iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("dxy")),
92  nmuons_(iConfig.getParameter<unsigned int>("nmuons")) {}
93 
94 DiDispStaMuonMonitor::~DiDispStaMuonMonitor() throw() {
95  if (num_genTriggerEventFlag_) {
96  num_genTriggerEventFlag_.reset();
97  }
98  if (den_genTriggerEventFlag_) {
99  den_genTriggerEventFlag_.reset();
100  }
101 }
102 
103 void DiDispStaMuonMonitor::bookHistograms(DQMStore::IBooker& ibooker,
104  edm::Run const& iRun,
105  edm::EventSetup const& iSetup) {
106  // Initialize the GenericTriggerEventFlag
107  if (num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on()) {
108  num_genTriggerEventFlag_->initRun(iRun, iSetup);
109  }
110  if (den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on()) {
111  den_genTriggerEventFlag_->initRun(iRun, iSetup);
112  }
113 
114  // check if every HLT path specified in numerator and denominator has a valid match in the HLT Menu
115  hltPathsAreValid_ = (num_genTriggerEventFlag_ && den_genTriggerEventFlag_ && num_genTriggerEventFlag_->on() &&
116  den_genTriggerEventFlag_->on() && num_genTriggerEventFlag_->allHLTPathsAreValid() &&
117  den_genTriggerEventFlag_->allHLTPathsAreValid());
118 
119  // if valid HLT paths are required,
120  // create DQM outputs only if all paths are valid
121  if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
122  return;
123  }
124 
125  std::string histname, histtitle;
126 
127  std::string currentFolder = folderName_;
128  ibooker.setCurrentFolder(currentFolder);
129 
130  histname = "muonPt";
131  histtitle = "muonPt";
132 
133  bookME(ibooker, muonPtME_, histname, histtitle, muonPt_binning_.nbins, muonPt_binning_.xmin, muonPt_binning_.xmax);
134  setMETitle(muonPtME_, "DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]");
135 
136  histname = "muonPtNoDxyCut";
137  histtitle = "muonPtNoDxyCut";
138  bookME(ibooker,
139  muonPtNoDxyCutME_,
140  histname,
141  histtitle,
142  muonPt_binning_.nbins,
143  muonPt_binning_.xmin,
144  muonPt_binning_.xmax);
145  setMETitle(muonPtNoDxyCutME_, "DisplacedStandAlone Muon p_{T} [GeV] without Dxy cut", "Events / [GeV]");
146 
147  histname = "muonPt_variable";
148  histtitle = "muonPt";
149  bookME(ibooker, muonPtME_variableBinning_, histname, histtitle, muonPt_variable_binning_);
150  setMETitle(muonPtME_variableBinning_, "DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]");
151 
152  histname = "muonPtVsLS";
153  histtitle = "muonPt vs LS";
154  bookME(ibooker,
155  muonPtVsLS_,
156  histname,
157  histtitle,
158  ls_binning_.nbins,
159  ls_binning_.xmin,
160  ls_binning_.xmax,
161  muonPt_binning_.xmin,
162  muonPt_binning_.xmax);
163  setMETitle(muonPtVsLS_, "LS", "DisplacedStandAlone Muon p_{T} [GeV]");
164 
165  histname = "muonEta";
166  histtitle = "muonEta";
167  bookME(
168  ibooker, muonEtaME_, histname, histtitle, muonEta_binning_.nbins, muonEta_binning_.xmin, muonEta_binning_.xmax);
169  setMETitle(muonEtaME_, "DisplacedStandAlone Muon #eta", "Events");
170 
171  histname = "muonPhi";
172  histtitle = "muonPhi";
173  bookME(
174  ibooker, muonPhiME_, histname, histtitle, muonPhi_binning_.nbins, muonPhi_binning_.xmin, muonPhi_binning_.xmax);
175  setMETitle(muonPhiME_, "DisplacedStandAlone Muon #phi", "Events");
176 
177  histname = "muonDxy";
178  histtitle = "muonDxy";
179  bookME(
180  ibooker, muonDxyME_, histname, histtitle, muonDxy_binning_.nbins, muonDxy_binning_.xmin, muonDxy_binning_.xmax);
181  setMETitle(muonDxyME_, "DisplacedStandAlone Muon #dxy", "Events");
182 
183  if (nmuons_ > 1) {
184  histname = "subMuonPt";
185  histtitle = "subMuonPt";
186  bookME(
187  ibooker, subMuonPtME_, histname, histtitle, muonPt_binning_.nbins, muonPt_binning_.xmin, muonPt_binning_.xmax);
188  setMETitle(subMuonPtME_, "Subleading DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]");
189 
190  histname = "subMuonPt_variable";
191  histtitle = "subMuonPt";
192  bookME(ibooker, subMuonPtME_variableBinning_, histname, histtitle, muonPt_variable_binning_);
193  setMETitle(subMuonPtME_variableBinning_, "Subleading DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]");
194 
195  histname = "subMuonEta";
196  histtitle = "subMuonEta";
197  bookME(ibooker,
198  subMuonEtaME_,
199  histname,
200  histtitle,
201  muonEta_binning_.nbins,
202  muonEta_binning_.xmin,
203  muonEta_binning_.xmax);
204  setMETitle(subMuonEtaME_, "Subleading DisplacedStandAlone Muon #eta", "Events");
205 
206  histname = "subMuonPhi";
207  histtitle = "subMuonPhi";
208  bookME(ibooker,
209  subMuonPhiME_,
210  histname,
211  histtitle,
212  muonPhi_binning_.nbins,
213  muonPhi_binning_.xmin,
214  muonPhi_binning_.xmax);
215  setMETitle(subMuonPhiME_, "Subleading DisplacedStandAlone Muon #phi", "Events");
216 
217  histname = "subMuonDxy";
218  histtitle = "subMuonDxy";
219  bookME(ibooker,
220  subMuonDxyME_,
221  histname,
222  histtitle,
223  muonDxy_binning_.nbins,
224  muonDxy_binning_.xmin,
225  muonDxy_binning_.xmax);
226  setMETitle(subMuonDxyME_, "Subleading DisplacedStandAlone Muon #dxy", "Events");
227  }
228 }
229 
230 void DiDispStaMuonMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) {
231  // if valid HLT paths are required,
232  // analyze event only if all paths are valid
233  if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
234  return;
235  }
236 
237  // Filter out events if Trigger Filtering is requested
238  if (den_genTriggerEventFlag_->on() && !den_genTriggerEventFlag_->accept(iEvent, iSetup))
239  return;
240 
241  const int ls = iEvent.id().luminosityBlock();
242 
243  edm::Handle<reco::TrackCollection> DSAHandle;
244  iEvent.getByToken(muonToken_, DSAHandle);
245  if ((unsigned int)(DSAHandle->size()) < nmuons_)
246  return;
247  std::vector<edm::Ptr<reco::Track>> dsaMuonPtrs_{}; // = DSAHandle->ptrs();
248  for (size_t i(0); i != DSAHandle->size(); ++i) {
249  dsaMuonPtrs_.emplace_back(DSAHandle, i);
250  }
251  std::vector<edm::Ptr<reco::Track>> muons{}, muonsCutOnPt{}, muonsCutOnDxy{}, muonsCutOnPtAndDxy{};
252 
253  // general selection
254  auto selectGeneral_([this](edm::Ptr<reco::Track> const& m) -> bool { return muonSelectionGeneral_(*m); });
255  std::copy_if(dsaMuonPtrs_.begin(), dsaMuonPtrs_.end(), back_inserter(muons), selectGeneral_);
256  if ((unsigned int)(muons.size()) < nmuons_)
257  return;
258 
259  // sort by pt
260  auto ptSorter_ = [](edm::Ptr<reco::Track> const& lhs, edm::Ptr<reco::Track> const& rhs) -> bool {
261  return lhs->pt() > rhs->pt();
262  };
263  std::sort(muons.begin(), muons.end(), ptSorter_);
264 
265  // cut on pt
266  auto selectOnPt_([this](edm::Ptr<reco::Track> const& m) -> bool { return muonSelectionPt_(*m); });
267  std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnPt), selectOnPt_);
268  // cut on dxy
269  auto selectOnDxy_([this](edm::Ptr<reco::Track> const& m) -> bool { return muonSelectionDxy_(*m); });
270  std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnDxy), selectOnDxy_);
271  // cut on pt and dxy
272  auto selectOnPtAndDxy_(
273  [this](edm::Ptr<reco::Track> const& m) -> bool { return muonSelectionPt_(*m) && muonSelectionDxy_(*m); });
274  std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnPtAndDxy), selectOnPtAndDxy_);
275 
276  std::sort(muonsCutOnPt.begin(), muonsCutOnPt.end(), ptSorter_);
277  std::sort(muonsCutOnDxy.begin(), muonsCutOnDxy.end(), ptSorter_);
278  std::sort(muonsCutOnPtAndDxy.begin(), muonsCutOnPtAndDxy.end(), ptSorter_);
279 
280  // --------------------------------
281  // filling histograms (denominator)
282  // --------------------------------
283  if (muonsCutOnDxy.size() >= nmuons_) {
284  // pt has cut on dxy
285  muonPtME_.denominator->Fill(muonsCutOnDxy[0]->pt());
286  muonPtNoDxyCutME_.denominator->Fill(muons[0]->pt());
287  muonPtME_variableBinning_.denominator->Fill(muonsCutOnDxy[0]->pt());
288  muonPtVsLS_.denominator->Fill(ls, muonsCutOnDxy[0]->pt());
289  if (nmuons_ > 1) {
290  subMuonPtME_.denominator->Fill(muonsCutOnDxy[1]->pt());
291  subMuonPtME_variableBinning_.denominator->Fill(muonsCutOnDxy[1]->pt());
292  }
293  }
294  if (muonsCutOnPtAndDxy.size() >= nmuons_) {
295  // eta, phi have cut on pt and dxy
296  muonEtaME_.denominator->Fill(muonsCutOnPtAndDxy[0]->eta());
297  muonPhiME_.denominator->Fill(muonsCutOnPtAndDxy[0]->phi());
298  if (nmuons_ > 1) {
299  subMuonEtaME_.denominator->Fill(muonsCutOnPtAndDxy[1]->eta());
300  subMuonPhiME_.denominator->Fill(muonsCutOnPtAndDxy[1]->phi());
301  }
302  }
303  if (muonsCutOnPt.size() >= nmuons_) {
304  // dxy has cut on pt
305  muonDxyME_.denominator->Fill(muonsCutOnPt[0]->dxy());
306  if (nmuons_ > 1) {
307  subMuonDxyME_.denominator->Fill(muonsCutOnPt[1]->dxy());
308  }
309  }
310 
311  // --------------------------------
312  // filling histograms (numerator)
313  // --------------------------------
314  if (num_genTriggerEventFlag_->on() && !num_genTriggerEventFlag_->accept(iEvent, iSetup))
315  return;
316 
317  if (muonsCutOnDxy.size() >= nmuons_) {
318  // pt has cut on dxy
319  muonPtME_.numerator->Fill(muonsCutOnDxy[0]->pt());
320  muonPtNoDxyCutME_.numerator->Fill(muons[0]->pt());
321  muonPtME_variableBinning_.numerator->Fill(muonsCutOnDxy[0]->pt());
322  muonPtVsLS_.numerator->Fill(ls, muonsCutOnDxy[0]->pt());
323  if (nmuons_ > 1) {
324  subMuonPtME_.numerator->Fill(muonsCutOnDxy[1]->pt());
325  subMuonPtME_variableBinning_.numerator->Fill(muonsCutOnDxy[1]->pt());
326  }
327  }
328  if (muonsCutOnPtAndDxy.size() >= nmuons_) {
329  // eta, phi have cut on pt and dxy
330  muonEtaME_.numerator->Fill(muonsCutOnPtAndDxy[0]->eta());
331  muonPhiME_.numerator->Fill(muonsCutOnPtAndDxy[0]->phi());
332  if (nmuons_ > 1) {
333  subMuonEtaME_.numerator->Fill(muonsCutOnPtAndDxy[1]->eta());
334  subMuonPhiME_.numerator->Fill(muonsCutOnPtAndDxy[1]->phi());
335  }
336  }
337  if (muonsCutOnPt.size() >= nmuons_) {
338  // dxy has cut on pt
339  muonDxyME_.numerator->Fill(muonsCutOnPt[0]->dxy());
340  if (nmuons_ > 1) {
341  subMuonDxyME_.numerator->Fill(muonsCutOnPt[1]->dxy());
342  }
343  }
344 }
345 
346 void DiDispStaMuonMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
347  edm::ParameterSetDescription desc;
348  desc.add<std::string>("FolderName", "HLT/EXO/DiDispStaMuon");
349  desc.add<bool>("requireValidHLTPaths", true);
350 
351  desc.add<edm::InputTag>("muons", edm::InputTag("displacedStandAloneMuons"));
352  desc.add<unsigned int>("nmuons", 2);
353 
354  edm::ParameterSetDescription muonSelection;
355  muonSelection.add<std::string>("general", "pt > 0");
356  muonSelection.add<std::string>("pt", "");
357  muonSelection.add<std::string>("dxy", "pt > 0");
358  desc.add<edm::ParameterSetDescription>("muonSelection", muonSelection);
359 
360  edm::ParameterSetDescription genericTriggerEventPSet;
361  genericTriggerEventPSet.add<bool>("andOr");
362  genericTriggerEventPSet.add<edm::InputTag>("dcsInputTag", edm::InputTag("scalersRawToDigi"));
363  genericTriggerEventPSet.add<std::vector<int>>("dcsPartitions", {});
364  genericTriggerEventPSet.add<bool>("andOrDcs", false);
365  genericTriggerEventPSet.add<bool>("errorReplyDcs", true);
366  genericTriggerEventPSet.add<std::string>("dbLabel", "");
367  genericTriggerEventPSet.add<bool>("andOrHlt", true);
368  genericTriggerEventPSet.add<edm::InputTag>("hltInputTag", edm::InputTag("TriggerResults::HLT"));
369  genericTriggerEventPSet.add<std::vector<std::string>>("hltPaths", {});
370  genericTriggerEventPSet.add<std::string>("hltDBKey", "");
371  genericTriggerEventPSet.add<bool>("errorReplyHlt", false);
372  genericTriggerEventPSet.add<unsigned int>("verbosityLevel", 1);
373 
374  desc.add<edm::ParameterSetDescription>("numGenericTriggerEventPSet", genericTriggerEventPSet);
375  desc.add<edm::ParameterSetDescription>("denGenericTriggerEventPSet", genericTriggerEventPSet);
376 
377  edm::ParameterSetDescription histoPSet;
378  edm::ParameterSetDescription muonPtPSet;
379  edm::ParameterSetDescription muonEtaPSet;
380  edm::ParameterSetDescription muonPhiPSet;
381  edm::ParameterSetDescription muonDxyPSet;
382  edm::ParameterSetDescription lsPSet;
383  fillHistoPSetDescription(muonPtPSet);
384  fillHistoPSetDescription(muonEtaPSet);
385  fillHistoPSetDescription(muonPhiPSet);
386  fillHistoPSetDescription(muonDxyPSet);
387  fillHistoPSetDescription(lsPSet);
388  histoPSet.add<edm::ParameterSetDescription>("muonPtPSet", muonPtPSet);
389  histoPSet.add<edm::ParameterSetDescription>("muonEtaPSet", muonEtaPSet);
390  histoPSet.add<edm::ParameterSetDescription>("muonPhiPSet", muonPhiPSet);
391  histoPSet.add<edm::ParameterSetDescription>("muonDxyPSet", muonDxyPSet);
392  histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
393  std::vector<double> bins = {0., 20., 40., 60., 80., 90., 100., 110., 120., 130., 140., 150., 160.,
394  170., 180., 190., 200., 220., 240., 260., 280., 300., 350., 400., 450., 1000.};
395  histoPSet.add<std::vector<double>>("muonPtBinning", bins);
396 
397  desc.add<edm::ParameterSetDescription>("histoPSet", histoPSet);
398 
399  descriptions.add("DiDispStaMuonMonitoring", desc);
400 }
401 
402 DEFINE_FWK_MODULE(DiDispStaMuonMonitor);
mps_fire.i
i
Definition: mps_fire.py:428
DiDispStaMuonMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: DiDispStaMuonMonitor.cc:103
DiDispStaMuonMonitor_cfi.pt
tuple pt
Definition: DiDispStaMuonMonitor_cfi.py:39
DiDispStaMuonMonitor::muonPt_variable_binning_
std::vector< double > muonPt_variable_binning_
Definition: DiDispStaMuonMonitor.cc:37
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:539
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
eostools.ls
def ls
Definition: eostools.py:349
reco::TrackCollection
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:14
GenericTriggerEventFlag
Provides a code based selection for trigger and DCS information in order to have no failing filters i...
Definition: GenericTriggerEventFlag.h:42
TriggerDQMBase::fillHistoPSetDescription
static void fillHistoPSetDescription(edm::ParameterSetDescription &pset)
Definition: TriggerDQMBase.cc:108
DiDispStaMuonMonitor::folderName_
const std::string folderName_
Definition: DiDispStaMuonMonitor.cc:30
dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:111
cms::cuda::device::unique_ptr
std::unique_ptr< T, impl::DeviceDeleter > unique_ptr
Definition: device_unique_ptr.h:33
edm::EventID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventID.h:39
TriggerDQMBase::setMETitle
void setMETitle(ObjME &me, const std::string &titleX, const std::string &titleY)
Definition: TriggerDQMBase.cc:3
HLT_FULL_cff.muonSelection
tuple muonSelection
Definition: HLT_FULL_cff.py:53316
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
DiDispStaMuonMonitor::MonitorElement
dqm::reco::MonitorElement MonitorElement
Definition: DiDispStaMuonMonitor.cc:18
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
visualization-live-secondInstance_cfg.m
tuple m
Definition: visualization-live-secondInstance_cfg.py:79
TriggerDQMBase::getHistoPSet
static MEbinning getHistoPSet(const edm::ParameterSet &pset)
Definition: TriggerDQMBase.cc:120
iEvent
int iEvent
Definition: GenABIO.cc:224
DiDispStaMuonMonitor::num_genTriggerEventFlag_
std::unique_ptr< GenericTriggerEventFlag > num_genTriggerEventFlag_
Definition: DiDispStaMuonMonitor.cc:57
DiDispStaMuonMonitor::analyze
void analyze(edm::Event const &iEvent, edm::EventSetup const &iSetup) override
Definition: DiDispStaMuonMonitor.cc:230
DiDispStaMuonMonitor::muonSelectionDxy_
StringCutObjectSelector< reco::Track, true > muonSelectionDxy_
Definition: DiDispStaMuonMonitor.cc:62
DiDispStaMuonMonitor::muonSelectionGeneral_
StringCutObjectSelector< reco::Track, true > muonSelectionGeneral_
Definition: DiDispStaMuonMonitor.cc:60
TriggerDQMBase::ObjME::denominator
MonitorElement * denominator
Definition: TriggerDQMBase.h:28
DiDispStaMuonMonitor::DiDispStaMuonMonitor
DiDispStaMuonMonitor(const edm::ParameterSet &)
Definition: DiDispStaMuonMonitor.cc:67
TriggerDQMBase::ObjME::numerator
MonitorElement * numerator
Definition: TriggerDQMBase.h:27
DQMOffline_LumiMontiroring_cff.lsPSet
tuple lsPSet
Definition: DQMOffline_LumiMontiroring_cff.py:14
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
DiDispStaMuonMonitor::den_genTriggerEventFlag_
std::unique_ptr< GenericTriggerEventFlag > den_genTriggerEventFlag_
Definition: DiDispStaMuonMonitor.cc:58
DiDispStaMuonMonitor::DQMStore
dqm::reco::DQMStore DQMStore
Definition: DiDispStaMuonMonitor.cc:19
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
DiDispStaMuonMonitor::muonSelectionPt_
StringCutObjectSelector< reco::Track, true > muonSelectionPt_
Definition: DiDispStaMuonMonitor.cc:61
TriggerDQMBase::bookME
void bookME(DQMStore::IBooker &, ObjME &me, const std::string &histname, const std::string &histtitle, const uint nbins, const double xmin, const double xmax, const bool bookDen=true)
Definition: TriggerDQMBase.cc:15
DiDispStaMuonMonitor::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: DiDispStaMuonMonitor.cc:346
HLT_FULL_cff.InputTag
tuple InputTag
Definition: HLT_FULL_cff.py:86956
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:59
patZpeak.muons
tuple muons
Definition: patZpeak.py:39
DiDispStaMuonMonitor_cfi.general
tuple general
Definition: DiDispStaMuonMonitor_cfi.py:37
DiDispStaMuonMonitor::muonToken_
edm::EDGetTokenT< reco::TrackCollection > muonToken_
Definition: DiDispStaMuonMonitor.cc:35
beam_dqm_sourceclient-live_cfg.FolderName
string FolderName
Definition: beam_dqm_sourceclient-live_cfg.py:174
edm::Run
Definition: Run.h:45
CommPDSkim_cfg.throw
tuple throw
Definition: CommPDSkim_cfg.py:101
Generated for CMSSW Reference Manual by doxygen 1.8.5