CMS 3D CMS Logo
List of all members | Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes
TopDiLeptonDQM Class Reference

#include <TopDiLeptonDQM.h>

Inheritance diagram for TopDiLeptonDQM:
DQMEDAnalyzer edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >

Public Member Functions

 TopDiLeptonDQM (const edm::ParameterSet &)
 
 ~TopDiLeptonDQM () override
 
- Public Member Functions inherited from DQMEDAnalyzer
void accumulate (edm::Event const &event, edm::EventSetup const &setup) final
 
void beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void beginRun (edm::Run const &run, edm::EventSetup const &setup) final
 
void beginStream (edm::StreamID id) final
 
virtual void dqmBeginRun (edm::Run const &, edm::EventSetup const &)
 
 DQMEDAnalyzer ()
 
void endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void endRun (edm::Run const &run, edm::EventSetup const &setup) final
 
virtual bool getCanSaveByLumi ()
 
- Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
 EDProducer ()=default
 
 EDProducer (const EDProducer &)=delete
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 
const EDProducer & operator= (const EDProducer &)=delete
 

Protected Member Functions

void bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
 
- Protected Member Functions inherited from DQMEDAnalyzer
uint64_t meId () const
 

Private Member Functions

void analyze (const edm::Event &, const edm::EventSetup &) override
 

Private Attributes

MonitorElement * D_eta_elecs_
 
MonitorElement * D_eta_lepts_
 
MonitorElement * D_eta_muons_
 
MonitorElement * D_phi_elecs_
 
MonitorElement * D_phi_lepts_
 
MonitorElement * D_phi_muons_
 
MonitorElement * dimassRC_
 
MonitorElement * dimassRC_LOG10_
 
MonitorElement * dimassRC_LOGX_
 
MonitorElement * dimassWC_
 
MonitorElement * dimassWC_LOG10_
 
MonitorElement * dimassWC_LOGX_
 
float Eff [100]
 
double elec_emf_cut_
 
double elec_eta_cut_
 
double elec_iso_cut_
 
double elec_pT_cut_
 
MonitorElement * ElecIso_cal_
 
MonitorElement * ElecIso_CombRelIso_
 
MonitorElement * ElecIso_trk_
 
edm::EDGetTokenT< reco::GsfElectronCollection > elecs_
 
MonitorElement * eta_elecs_
 
MonitorElement * eta_muons_
 
MonitorElement * Events_
 
std::vector< std::string > hltPaths_
 
std::vector< std::string > hltPaths_sig_
 
std::vector< std::string > hltPaths_trig_
 
MonitorElement * HoverE_elecs_
 
double MassWindow_down_
 
double MassWindow_up_
 
std::string moduleName_
 
MonitorElement * MuIso_CombRelIso03_
 
MonitorElement * MuIso_emEt03_
 
MonitorElement * MuIso_hadEt03_
 
MonitorElement * MuIso_hoEt03_
 
MonitorElement * MuIso_nJets03_
 
MonitorElement * MuIso_nTracks03_
 
MonitorElement * MuIso_sumPt03_
 
double muon_eta_cut_
 
double muon_iso_cut_
 
double muon_pT_cut_
 
edm::EDGetTokenT< reco::MuonCollection > muons_
 
int N_elel
 
int N_muel
 
int N_mumu
 
int N_sig [100]
 
int N_trig [100]
 
MonitorElement * Nelecs_
 
MonitorElement * Nelecs_charge_
 
MonitorElement * Nelecs_iso_
 
MonitorElement * Nmuons_
 
MonitorElement * Nmuons_charge_
 
MonitorElement * Nmuons_iso_
 
MonitorElement * Ntracks_
 
std::ofstream outfile
 
std::string outputFile_
 
MonitorElement * phi_elecs_
 
MonitorElement * phi_muons_
 
MonitorElement * pT_elecs_
 
MonitorElement * pT_muons_
 
MonitorElement * TriggerEff_
 
edm::EDGetTokenT< edm::TriggerResults > triggerResults_
 
MonitorElement * Trigs_
 
edm::EDGetTokenT< reco::VertexCollection > vertex_
 
double vertex_X_cut_
 
double vertex_Y_cut_
 
double vertex_Z_cut_
 
MonitorElement * VxVy_muons_
 
MonitorElement * Vz_muons_
 

Additional Inherited Members

- Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore DQMStore
 
typedef dqm::reco::MonitorElement MonitorElement
 
- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using CacheTypes = CacheContexts< T... >
 
using GlobalCache = typename CacheTypes::GlobalCache
 
using HasAbility = AbilityChecker< T... >
 
using InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
 
using LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
 
using LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
 
using LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
 
using RunCache = typename CacheTypes::RunCache
 
using RunContext = RunContextT< RunCache, GlobalCache >
 
using RunSummaryCache = typename CacheTypes::RunSummaryCache
 
- Static Public Member Functions inherited from DQMEDAnalyzer
static void globalEndJob (DQMEDAnalyzerGlobalCache const *)
 
static void globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
 
static void globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
 
static std::unique_ptr< DQMEDAnalyzerGlobalCache > initializeGlobalCache (edm::ParameterSet const &)
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken > lumiToken_
 
edm::EDPutTokenT< DQMToken > runToken_
 
unsigned int streamId_
 

Detailed Description

Definition at line 38 of file TopDiLeptonDQM.h.

Constructor & Destructor Documentation

◆ TopDiLeptonDQM()

TopDiLeptonDQM::TopDiLeptonDQM ( const edm::ParameterSet &  ps)
explicit

Definition at line 16 of file TopDiLeptonDQM.cc.

16  {
17  moduleName_ = ps.getUntrackedParameter<string>("moduleName");
18  outputFile_ = ps.getUntrackedParameter<string>("outputFile");
19  triggerResults_ = consumes<TriggerResults>(ps.getParameter<edm::InputTag>("TriggerResults"));
20  hltPaths_ = ps.getParameter<vector<string> >("hltPaths");
21  hltPaths_sig_ = ps.getParameter<vector<string> >("hltPaths_sig");
22  hltPaths_trig_ = ps.getParameter<vector<string> >("hltPaths_trig");
23 
24  vertex_ = consumes<reco::VertexCollection>(ps.getParameter<edm::InputTag>("vertexCollection"));
25  vertex_X_cut_ = ps.getParameter<double>("vertex_X_cut");
26  vertex_Y_cut_ = ps.getParameter<double>("vertex_Y_cut");
27  vertex_Z_cut_ = ps.getParameter<double>("vertex_Z_cut");
28 
29  muons_ = consumes<reco::MuonCollection>(ps.getParameter<edm::InputTag>("muonCollection"));
30  muon_pT_cut_ = ps.getParameter<double>("muon_pT_cut");
31  muon_eta_cut_ = ps.getParameter<double>("muon_eta_cut");
32  muon_iso_cut_ = ps.getParameter<double>("muon_iso_cut");
33 
34  elecs_ = consumes<reco::GsfElectronCollection>(ps.getParameter<edm::InputTag>("elecCollection"));
35  elec_pT_cut_ = ps.getParameter<double>("elec_pT_cut");
36  elec_eta_cut_ = ps.getParameter<double>("elec_eta_cut");
37  elec_iso_cut_ = ps.getParameter<double>("elec_iso_cut");
38  elec_emf_cut_ = ps.getParameter<double>("elec_emf_cut");
39 
40  MassWindow_up_ = ps.getParameter<double>("MassWindow_up");
41  MassWindow_down_ = ps.getParameter<double>("MassWindow_down");
42 
43  for (int i = 0; i < 100; ++i) {
44  N_sig[i] = 0;
45  N_trig[i] = 0;
46  Eff[i] = 0.;
47  }
48 
49  N_mumu = 0;
50  N_muel = 0;
51  N_elel = 0;
52  Events_ = nullptr;
53  Trigs_ = nullptr;
54  TriggerEff_ = nullptr;
55  Ntracks_ = nullptr;
56  Nmuons_ = nullptr;
57  Nmuons_iso_ = nullptr;
58  Nmuons_charge_ = nullptr;
59  VxVy_muons_ = nullptr;
60  Vz_muons_ = nullptr;
61  pT_muons_ = nullptr;
62  eta_muons_ = nullptr;
63  phi_muons_ = nullptr;
64  Nelecs_ = nullptr;
65  Nelecs_iso_ = nullptr;
66  Nelecs_charge_ = nullptr;
67  HoverE_elecs_ = nullptr;
68  pT_elecs_ = nullptr;
69  eta_elecs_ = nullptr;
70  phi_elecs_ = nullptr;
71  MuIso_emEt03_ = nullptr;
72  MuIso_hadEt03_ = nullptr;
73  MuIso_hoEt03_ = nullptr;
74  MuIso_nJets03_ = nullptr;
75  MuIso_nTracks03_ = nullptr;
76  MuIso_sumPt03_ = nullptr;
77  MuIso_CombRelIso03_ = nullptr;
78  ElecIso_cal_ = nullptr;
79  ElecIso_trk_ = nullptr;
80  ElecIso_CombRelIso_ = nullptr;
81  dimassRC_ = nullptr;
82  dimassWC_ = nullptr;
83  dimassRC_LOGX_ = nullptr;
84  dimassWC_LOGX_ = nullptr;
85  dimassRC_LOG10_ = nullptr;
86  dimassWC_LOG10_ = nullptr;
87  D_eta_muons_ = nullptr;
88  D_phi_muons_ = nullptr;
89  D_eta_elecs_ = nullptr;
90  D_phi_elecs_ = nullptr;
91  D_eta_lepts_ = nullptr;
92  D_phi_lepts_ = nullptr;
93 }

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, and commonCuts_cff::triggerResults_.

◆ ~TopDiLeptonDQM()

TopDiLeptonDQM::~TopDiLeptonDQM ( )
override

Definition at line 95 of file TopDiLeptonDQM.cc.

95 {}

Member Function Documentation

◆ analyze()

void TopDiLeptonDQM::analyze ( const edm::Event &  evt,
const edm::EventSetup &  context 
)
overrideprivatevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 168 of file TopDiLeptonDQM.cc.

168  {
169  // ------------------------
170  // Global Event Variables
171  // ------------------------
172 
173  const int N_TriggerPaths = hltPaths_.size();
174  const int N_SignalPaths = hltPaths_sig_.size();
175  const int N_ControlPaths = hltPaths_trig_.size();
176 
177  bool Fired_Signal_Trigger[100] = {false};
178  bool Fired_Control_Trigger[100] = {false};
179 
180  int N_leptons = 0;
181  int N_iso_mu = 0;
182  int N_iso_el = 0;
183 
184  double DilepMass = 0.;
185 
186  double vertex_X = 100.;
187  double vertex_Y = 100.;
188  double vertex_Z = 100.;
189 
190  // ------------------------
191  // Analyze Primary Vertex
192  // ------------------------
193 
194  edm::Handle<reco::VertexCollection> vertexs;
195  evt.getByToken(vertex_, vertexs);
196 
197  if (!vertexs.failedToGet()) {
198  reco::Vertex primaryVertex = vertexs->front();
199 
200  int numberTracks = primaryVertex.tracksSize();
201  // double ndof = primaryVertex.ndof();
202  bool fake = primaryVertex.isFake();
203 
204  Ntracks_->Fill(numberTracks);
205 
206  if (!fake && numberTracks > 3) {
207  vertex_X = primaryVertex.x();
208  vertex_Y = primaryVertex.y();
209  vertex_Z = primaryVertex.z();
210  }
211  }
212 
213  // -------------------------
214  // Analyze Trigger Results
215  // -------------------------
216 
217  edm::Handle<TriggerResults> trigResults;
218  evt.getByToken(triggerResults_, trigResults);
219 
220  if (!trigResults.failedToGet()) {
221  int N_Triggers = trigResults->size();
222 
223  const edm::TriggerNames& trigName = evt.triggerNames(*trigResults);
224 
225  for (int i_Trig = 0; i_Trig < N_Triggers; ++i_Trig) {
226  if (trigResults.product()->accept(i_Trig)) {
227  // Check for all trigger paths
228 
229  for (int i = 0; i < N_TriggerPaths; i++) {
230  if (trigName.triggerName(i_Trig) == hltPaths_[i]) {
231  Trigs_->Fill(i);
232  Trigs_->setBinLabel(i + 1, hltPaths_[i], 1);
233  }
234  }
235 
236  // Check for signal & control trigger paths
237 
238  for (int j = 0; j < N_SignalPaths; ++j) {
239  if (trigName.triggerName(i_Trig) == hltPaths_sig_[j])
240  Fired_Signal_Trigger[j] = true;
241  }
242 
243  for (int k = 0; k < N_ControlPaths; ++k) {
244  if (trigName.triggerName(i_Trig) == hltPaths_trig_[k])
245  Fired_Control_Trigger[k] = true;
246  }
247  }
248  }
249  }
250 
251  // ------------------------
252  // Analyze Muon Isolation
253  // ------------------------
254 
255  edm::Handle<reco::MuonCollection> muons;
256  evt.getByToken(muons_, muons);
257 
258  reco::MuonCollection::const_iterator muon;
259 
260  if (!muons.failedToGet()) {
261  Nmuons_->Fill(muons->size());
262 
263  N_leptons = N_leptons + muons->size();
264 
265  for (muon = muons->begin(); muon != muons->end(); ++muon) {
266  float N_muons = muons->size();
267  float Q_muon = muon->charge();
268 
269  Nmuons_charge_->Fill(N_muons * Q_muon);
270 
271  double track_X = 100.;
272  double track_Y = 100.;
273  double track_Z = 100.;
274 
275  if (muon->isGlobalMuon()) {
276  reco::TrackRef track = muon->globalTrack();
277 
278  track_X = track->vx();
279  track_Y = track->vy();
280  track_Z = track->vz();
281 
282  VxVy_muons_->Fill(track_X, track_Y);
283  Vz_muons_->Fill(track_Z);
284  }
285 
286  // Vertex and kinematic cuts
287 
288  if (track_X > vertex_X_cut_)
289  continue;
290  if (track_Y > vertex_Y_cut_)
291  continue;
292  if (track_Z > vertex_Z_cut_)
293  continue;
294  if (muon->pt() < muon_pT_cut_)
295  continue;
296  if (abs(muon->eta()) > muon_eta_cut_)
297  continue;
298 
299  reco::MuonIsolation muIso03 = muon->isolationR03();
300 
301  double muonCombRelIso = 1.;
302 
303  if (muon->pt() != 0.)
304  muonCombRelIso = (muIso03.emEt + muIso03.hadEt + muIso03.hoEt + muIso03.sumPt) / muon->pt();
305 
306  MuIso_CombRelIso03_->Fill(muonCombRelIso);
307 
308  MuIso_emEt03_->Fill(muIso03.emEt);
309  MuIso_hadEt03_->Fill(muIso03.hadEt);
310  MuIso_hoEt03_->Fill(muIso03.hoEt);
311  MuIso_nJets03_->Fill(muIso03.nJets);
312  MuIso_nTracks03_->Fill(muIso03.nTracks);
313  MuIso_sumPt03_->Fill(muIso03.sumPt);
314 
315  if (muonCombRelIso < muon_iso_cut_)
316  ++N_iso_mu;
317  }
318 
319  Nmuons_iso_->Fill(N_iso_mu);
320  }
321 
322  // ----------------------------
323  // Analyze Electron Isolation
324  // ----------------------------
325 
326  edm::Handle<reco::GsfElectronCollection> elecs;
327  evt.getByToken(elecs_, elecs);
328 
329  reco::GsfElectronCollection::const_iterator elec;
330 
331  if (!elecs.failedToGet()) {
332  Nelecs_->Fill(elecs->size());
333 
334  N_leptons = N_leptons + elecs->size();
335 
336  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
337  float N_elecs = elecs->size();
338  float Q_elec = elec->charge();
339  float HoverE = elec->hcalOverEcal();
340 
341  HoverE_elecs_->Fill(HoverE);
342 
343  Nelecs_charge_->Fill(N_elecs * Q_elec);
344 
345  double track_X = 100.;
346  double track_Y = 100.;
347  double track_Z = 100.;
348 
349  reco::GsfTrackRef track = elec->gsfTrack();
350 
351  track_X = track->vx();
352  track_Y = track->vy();
353  track_Z = track->vz();
354 
355  // Vertex and kinematic cuts
356 
357  if (track_X > vertex_X_cut_)
358  continue;
359  if (track_Y > vertex_Y_cut_)
360  continue;
361  if (track_Z > vertex_Z_cut_)
362  continue;
363  if (elec->pt() < elec_pT_cut_)
364  continue;
365  if (abs(elec->eta()) > elec_eta_cut_)
366  continue;
367  if (HoverE > elec_emf_cut_)
368  continue;
369 
370  reco::GsfElectron::IsolationVariables elecIso = elec->dr03IsolationVariables();
371 
372  double elecCombRelIso = 1.;
373 
374  if (elec->et() != 0.)
375  elecCombRelIso = (elecIso.ecalRecHitSumEt + elecIso.hcalRecHitSumEt[0] + elecIso.tkSumPt) / elec->et();
376 
377  ElecIso_CombRelIso_->Fill(elecCombRelIso);
378 
379  ElecIso_cal_->Fill(elecIso.ecalRecHitSumEt);
380  ElecIso_trk_->Fill(elecIso.tkSumPt);
381 
382  if (elecCombRelIso < elec_iso_cut_)
383  ++N_iso_el;
384  }
385 
386  Nelecs_iso_->Fill(N_iso_el);
387  }
388 
389  // --------------------
390  // TWO Isolated MUONS
391  // --------------------
392 
393  if (N_iso_mu > 1) {
394  // Vertex cut
395 
396  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
397  ++N_mumu;
398 
399  Events_->Fill(1.);
400 
401  reco::MuonCollection::const_reference mu1 = muons->at(0);
402  reco::MuonCollection::const_reference mu2 = muons->at(1);
403 
404  DilepMass = sqrt((mu1.energy() + mu2.energy()) * (mu1.energy() + mu2.energy()) -
405  (mu1.px() + mu2.px()) * (mu1.px() + mu2.px()) - (mu1.py() + mu2.py()) * (mu1.py() + mu2.py()) -
406  (mu1.pz() + mu2.pz()) * (mu1.pz() + mu2.pz()));
407 
408  // Opposite muon charges -> Right Charge (RC)
409 
410  if (mu1.charge() * mu2.charge() < 0.) {
411  dimassRC_LOG10_->Fill(log10(DilepMass));
412  dimassRC_->Fill(DilepMass);
413  dimassRC_LOGX_->Fill(DilepMass);
414 
415  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
416  for (muon = muons->begin(); muon != muons->end(); ++muon) {
417  pT_muons_->Fill(muon->pt());
418  eta_muons_->Fill(muon->eta());
419  phi_muons_->Fill(muon->phi());
420  }
421 
422  D_eta_muons_->Fill(mu1.eta() - mu2.eta());
423  D_phi_muons_->Fill(mu1.phi() - mu2.phi());
424 
425  // Determinating trigger efficiencies
426 
427  for (int k = 0; k < N_SignalPaths; ++k) {
428  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
429  ++N_sig[k];
430 
431  if (Fired_Control_Trigger[k])
432  ++N_trig[k];
433 
434  if (N_trig[k] != 0)
435  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
436 
437  TriggerEff_->setBinContent(k + 1, Eff[k]);
438  TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
439  }
440  }
441  }
442 
443  // Same muon charges -> Wrong Charge (WC)
444 
445  if (mu1.charge() * mu2.charge() > 0.) {
446  dimassWC_LOG10_->Fill(log10(DilepMass));
447  dimassWC_->Fill(DilepMass);
448  dimassWC_LOGX_->Fill(DilepMass);
449  }
450  }
451  }
452 
453  // -----------------------------
454  // TWO Isolated LEPTONS (mu/e)
455  // -----------------------------
456 
457  if (N_iso_el > 0 && N_iso_mu > 0) {
458  // Vertex cut
459 
460  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
461  ++N_muel;
462 
463  Events_->Fill(2.);
464 
465  reco::MuonCollection::const_reference mu1 = muons->at(0);
466  reco::GsfElectronCollection::const_reference el1 = elecs->at(0);
467 
468  DilepMass = sqrt((mu1.energy() + el1.energy()) * (mu1.energy() + el1.energy()) -
469  (mu1.px() + el1.px()) * (mu1.px() + el1.px()) - (mu1.py() + el1.py()) * (mu1.py() + el1.py()) -
470  (mu1.pz() + el1.pz()) * (mu1.pz() + el1.pz()));
471 
472  // Opposite lepton charges -> Right Charge (RC)
473 
474  if (mu1.charge() * el1.charge() < 0.) {
475  dimassRC_LOG10_->Fill(log10(DilepMass));
476  dimassRC_->Fill(DilepMass);
477  dimassRC_LOGX_->Fill(DilepMass);
478 
479  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
480  for (muon = muons->begin(); muon != muons->end(); ++muon) {
481  pT_muons_->Fill(muon->pt());
482  eta_muons_->Fill(muon->eta());
483  phi_muons_->Fill(muon->phi());
484  }
485 
486  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
487  pT_elecs_->Fill(elec->pt());
488  eta_elecs_->Fill(elec->eta());
489  phi_elecs_->Fill(elec->phi());
490  }
491 
492  D_eta_lepts_->Fill(mu1.eta() - el1.eta());
493  D_phi_lepts_->Fill(mu1.phi() - el1.phi());
494 
495  // Determinating trigger efficiencies
496 
497  for (int k = 0; k < N_SignalPaths; ++k) {
498  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
499  ++N_sig[k];
500 
501  if (Fired_Control_Trigger[k])
502  ++N_trig[k];
503 
504  if (N_trig[k] != 0)
505  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
506 
507  TriggerEff_->setBinContent(k + 1, Eff[k]);
508  TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
509  }
510  }
511  }
512 
513  // Same muon charges -> Wrong Charge (WC)
514 
515  if (mu1.charge() * el1.charge() > 0.) {
516  dimassWC_LOG10_->Fill(log10(DilepMass));
517  dimassWC_->Fill(DilepMass);
518  dimassWC_LOGX_->Fill(DilepMass);
519  }
520  }
521  }
522 
523  // ------------------------
524  // TWO Isolated ELECTRONS
525  // ------------------------
526 
527  if (N_iso_el > 1) {
528  // Vertex cut
529 
530  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
531  ++N_elel;
532 
533  Events_->Fill(3.);
534 
535  reco::GsfElectronCollection::const_reference el1 = elecs->at(0);
536  reco::GsfElectronCollection::const_reference el2 = elecs->at(1);
537 
538  DilepMass = sqrt((el1.energy() + el2.energy()) * (el1.energy() + el2.energy()) -
539  (el1.px() + el2.px()) * (el1.px() + el2.px()) - (el1.py() + el2.py()) * (el1.py() + el2.py()) -
540  (el1.pz() + el2.pz()) * (el1.pz() + el2.pz()));
541 
542  // Opposite lepton charges -> Right Charge (RC)
543 
544  if (el1.charge() * el2.charge() < 0.) {
545  dimassRC_LOG10_->Fill(log10(DilepMass));
546  dimassRC_->Fill(DilepMass);
547  dimassRC_LOGX_->Fill(DilepMass);
548 
549  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
550  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
551  pT_elecs_->Fill(elec->pt());
552  eta_elecs_->Fill(elec->eta());
553  phi_elecs_->Fill(elec->phi());
554  }
555 
556  D_eta_elecs_->Fill(el1.eta() - el2.eta());
557  D_phi_elecs_->Fill(el1.phi() - el2.phi());
558 
559  // Determinating trigger efficiencies
560 
561  for (int k = 0; k < N_SignalPaths; ++k) {
562  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
563  ++N_sig[k];
564 
565  if (Fired_Control_Trigger[k])
566  ++N_trig[k];
567 
568  if (N_trig[k] != 0)
569  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
570 
571  TriggerEff_->setBinContent(k + 1, Eff[k]);
572  TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
573  }
574  }
575  }
576 
577  // Same muon charges -> Wrong Charge (WC)
578 
579  if (el1.charge() * el2.charge() > 0.) {
580  dimassWC_LOG10_->Fill(log10(DilepMass));
581  dimassWC_->Fill(DilepMass);
582  dimassWC_LOGX_->Fill(DilepMass);
583  }
584  }
585  }
586 }

References funct::abs(), edm::HLTGlobalStatus::accept(), reco::GsfElectron::IsolationVariables::ecalRecHitSumEt, singleTopDQM_cfi::elecs, reco::MuonIsolation::emEt, edm::HandleBase::failedToGet(), RunInfoPI::fake, edm::Event::getByToken(), reco::MuonIsolation::hadEt, reco::GsfElectron::IsolationVariables::hcalRecHitSumEt, reco::MuonIsolation::hoEt, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, HLT_FULL_cff::muon, PDWG_BPHSkim_cff::muons, reco::MuonIsolation::nJets, reco::MuonIsolation::nTracks, BeamMonitor_cff::primaryVertex, edm::Handle< T >::product(), edm::HLTGlobalStatus::size(), mathSSE::sqrt(), reco::MuonIsolation::sumPt, reco::GsfElectron::IsolationVariables::tkSumPt, HLT_FULL_cff::track, edm::Event::triggerNames(), commonCuts_cff::triggerResults_, and EgHLTOffTrigSelection_cfi::trigName.

◆ bookHistograms()

void TopDiLeptonDQM::bookHistograms ( DQMStore::IBooker &  iBooker,
edm::Run const &  ,
edm::EventSetup const &   
)
overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 97 of file TopDiLeptonDQM.cc.

97  {
98  iBooker.setCurrentFolder(moduleName_);
99 
100  Events_ = iBooker.book1D("00_Events", "Isolated dilepton events", 5, 0., 5.);
101  Events_->setBinLabel(2, "#mu #mu", 1);
102  Events_->setBinLabel(3, "#mu e", 1);
103  Events_->setBinLabel(4, "e e", 1);
104 
105  Trigs_ = iBooker.book1D("01_Trigs", "Fired muon/electron triggers", 15, 0., 15.);
106  TriggerEff_ = iBooker.book1D("02_TriggerEff", "HL Trigger Efficiencies", 10, 0., 10.);
107  TriggerEff_->setTitle(
108  "HL Trigger Efficiencies #epsilon_{signal} = #frac{[signal] && "
109  "[control]}{[control]}");
110  Ntracks_ = iBooker.book1D("Ntracks", "Number of tracks", 50, 0., 50.);
111 
112  Nmuons_ = iBooker.book1D("03_Nmuons", "Number of muons", 20, 0., 10.);
113  Nmuons_iso_ = iBooker.book1D("04_Nmuons_iso", "Number of isolated muons", 20, 0., 10.);
114  Nmuons_charge_ = iBooker.book1D("Nmuons_charge", "Number of muons * moun charge", 19, -10., 10.);
115  VxVy_muons_ = iBooker.book2D("VxVy_muons", "Vertex x-y-positon (global)", 40, -1., 1., 40, -1., 1.);
116  Vz_muons_ = iBooker.book1D("Vz_muons", "Vertex z-positon (global)", 40, -20., 20.);
117  pT_muons_ = iBooker.book1D("pT_muons", "P_T of muons", 40, 0., 200.);
118  eta_muons_ = iBooker.book1D("eta_muons", "Eta of muons", 50, -5., 5.);
119  phi_muons_ = iBooker.book1D("phi_muons", "Phi of muons", 40, -4., 4.);
120 
121  Nelecs_ = iBooker.book1D("05_Nelecs", "Number of electrons", 20, 0., 10.);
122  Nelecs_iso_ = iBooker.book1D("06_Nelecs_iso", "Number of isolated electrons", 20, 0., 10.);
123  Nelecs_charge_ = iBooker.book1D("Nelecs_charge", "Number of elecs * elec charge", 19, -10., 10.);
124  HoverE_elecs_ = iBooker.book1D("HoverE_elecs", "Hadronic over Ecal energy", 50, 0., 1.);
125  pT_elecs_ = iBooker.book1D("pT_elecs", "P_T of electrons", 40, 0., 200.);
126  eta_elecs_ = iBooker.book1D("eta_elecs", "Eta of electrons", 50, -5., 5.);
127  phi_elecs_ = iBooker.book1D("phi_elecs", "Phi of electrons", 40, -4., 4.);
128 
129  MuIso_emEt03_ = iBooker.book1D("MuIso_emEt03", "Muon emEt03", 20, 0., 20.);
130  MuIso_hadEt03_ = iBooker.book1D("MuIso_hadEt03", "Muon hadEt03", 20, 0., 20.);
131  MuIso_hoEt03_ = iBooker.book1D("MuIso_hoEt03", "Muon hoEt03", 20, 0., 20.);
132  MuIso_nJets03_ = iBooker.book1D("MuIso_nJets03", "Muon nJets03", 10, 0., 10.);
133  MuIso_nTracks03_ = iBooker.book1D("MuIso_nTracks03", "Muon nTracks03", 20, 0., 20.);
134  MuIso_sumPt03_ = iBooker.book1D("MuIso_sumPt03", "Muon sumPt03", 20, 0., 40.);
135  MuIso_CombRelIso03_ = iBooker.book1D("07_MuIso_CombRelIso03", "Muon CombRelIso03", 20, 0., 1.);
136 
137  ElecIso_cal_ = iBooker.book1D("ElecIso_cal", "Electron Iso_cal", 21, -1., 20.);
138  ElecIso_trk_ = iBooker.book1D("ElecIso_trk", "Electron Iso_trk", 21, -2., 40.);
139  ElecIso_CombRelIso_ = iBooker.book1D("08_ElecIso_CombRelIso", "Electron CombRelIso", 20, 0., 1.);
140 
141  const int nbins = 200;
142 
143  double logmin = 0.;
144  double logmax = 3.; // 10^(3.)=1000
145 
146  float bins[nbins + 1];
147 
148  for (int i = 0; i <= nbins; i++) {
149  double log = logmin + (logmax - logmin) * i / nbins;
150  bins[i] = std::pow(10.0, log);
151  }
152 
153  dimassRC_ = iBooker.book1D("09_dimassRC", "Dilepton mass RC", 50, 0., 200.);
154  dimassWC_ = iBooker.book1D("11_dimassWC", "Dilepton mass WC", 50, 0., 200.);
155  dimassRC_LOGX_ = iBooker.book1D("10_dimassRC_LOGX", "Dilepton mass RC LOG", nbins, &bins[0]);
156  dimassWC_LOGX_ = iBooker.book1D("12_dimassWC_LOGX", "Dilepton mass WC LOG", nbins, &bins[0]);
157  dimassRC_LOG10_ = iBooker.book1D("dimassRC_LOG10", "Dilepton mass RC LOG", 50, 0., 2.5);
158  dimassWC_LOG10_ = iBooker.book1D("dimassWC_LOG10", "Dilepton mass WC LOG", 50, 0., 2.5);
159 
160  D_eta_muons_ = iBooker.book1D("13_D_eta_muons", "#Delta eta_muons", 20, -5., 5.);
161  D_phi_muons_ = iBooker.book1D("14_D_phi_muons", "#Delta phi_muons", 20, -5., 5.);
162  D_eta_elecs_ = iBooker.book1D("D_eta_elecs", "#Delta eta_elecs", 20, -5., 5.);
163  D_phi_elecs_ = iBooker.book1D("D_phi_elecs", "#Delta phi_elecs", 20, -5., 5.);
164  D_eta_lepts_ = iBooker.book1D("D_eta_lepts", "#Delta eta_lepts", 20, -5., 5.);
165  D_phi_lepts_ = iBooker.book1D("D_phi_lepts", "#Delta phi_lepts", 20, -5., 5.);
166 }

References trigObjTnPSource_cfi::bins, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), mps_fire::i, dqm-mbProfile::log, LaserClient_cfi::nbins, funct::pow(), dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), and dqm::impl::MonitorElement::setTitle().

Member Data Documentation

◆ D_eta_elecs_

MonitorElement* TopDiLeptonDQM::D_eta_elecs_
private

Definition at line 128 of file TopDiLeptonDQM.h.

◆ D_eta_lepts_

MonitorElement* TopDiLeptonDQM::D_eta_lepts_
private

Definition at line 130 of file TopDiLeptonDQM.h.

◆ D_eta_muons_

MonitorElement* TopDiLeptonDQM::D_eta_muons_
private

Definition at line 126 of file TopDiLeptonDQM.h.

◆ D_phi_elecs_

MonitorElement* TopDiLeptonDQM::D_phi_elecs_
private

Definition at line 129 of file TopDiLeptonDQM.h.

◆ D_phi_lepts_

MonitorElement* TopDiLeptonDQM::D_phi_lepts_
private

Definition at line 131 of file TopDiLeptonDQM.h.

◆ D_phi_muons_

MonitorElement* TopDiLeptonDQM::D_phi_muons_
private

Definition at line 127 of file TopDiLeptonDQM.h.

◆ dimassRC_

MonitorElement* TopDiLeptonDQM::dimassRC_
private

Definition at line 119 of file TopDiLeptonDQM.h.

◆ dimassRC_LOG10_

MonitorElement* TopDiLeptonDQM::dimassRC_LOG10_
private

Definition at line 123 of file TopDiLeptonDQM.h.

◆ dimassRC_LOGX_

MonitorElement* TopDiLeptonDQM::dimassRC_LOGX_
private

Definition at line 121 of file TopDiLeptonDQM.h.

◆ dimassWC_

MonitorElement* TopDiLeptonDQM::dimassWC_
private

Definition at line 120 of file TopDiLeptonDQM.h.

◆ dimassWC_LOG10_

MonitorElement* TopDiLeptonDQM::dimassWC_LOG10_
private

Definition at line 124 of file TopDiLeptonDQM.h.

◆ dimassWC_LOGX_

MonitorElement* TopDiLeptonDQM::dimassWC_LOGX_
private

Definition at line 122 of file TopDiLeptonDQM.h.

◆ Eff

float TopDiLeptonDQM::Eff[100]
private

Definition at line 60 of file TopDiLeptonDQM.h.

◆ elec_emf_cut_

double TopDiLeptonDQM::elec_emf_cut_
private

Definition at line 80 of file TopDiLeptonDQM.h.

◆ elec_eta_cut_

double TopDiLeptonDQM::elec_eta_cut_
private

Definition at line 78 of file TopDiLeptonDQM.h.

◆ elec_iso_cut_

double TopDiLeptonDQM::elec_iso_cut_
private

Definition at line 79 of file TopDiLeptonDQM.h.

◆ elec_pT_cut_

double TopDiLeptonDQM::elec_pT_cut_
private

Definition at line 77 of file TopDiLeptonDQM.h.

◆ ElecIso_cal_

MonitorElement* TopDiLeptonDQM::ElecIso_cal_
private

Definition at line 115 of file TopDiLeptonDQM.h.

◆ ElecIso_CombRelIso_

MonitorElement* TopDiLeptonDQM::ElecIso_CombRelIso_
private

Definition at line 117 of file TopDiLeptonDQM.h.

◆ ElecIso_trk_

MonitorElement* TopDiLeptonDQM::ElecIso_trk_
private

Definition at line 116 of file TopDiLeptonDQM.h.

◆ elecs_

edm::EDGetTokenT<reco::GsfElectronCollection> TopDiLeptonDQM::elecs_
private

Definition at line 76 of file TopDiLeptonDQM.h.

◆ eta_elecs_

MonitorElement* TopDiLeptonDQM::eta_elecs_
private

Definition at line 104 of file TopDiLeptonDQM.h.

◆ eta_muons_

MonitorElement* TopDiLeptonDQM::eta_muons_
private

Definition at line 96 of file TopDiLeptonDQM.h.

◆ Events_

MonitorElement* TopDiLeptonDQM::Events_
private

Definition at line 85 of file TopDiLeptonDQM.h.

◆ hltPaths_

std::vector<std::string> TopDiLeptonDQM::hltPaths_
private

Definition at line 52 of file TopDiLeptonDQM.h.

◆ hltPaths_sig_

std::vector<std::string> TopDiLeptonDQM::hltPaths_sig_
private

Definition at line 53 of file TopDiLeptonDQM.h.

◆ hltPaths_trig_

std::vector<std::string> TopDiLeptonDQM::hltPaths_trig_
private

Definition at line 54 of file TopDiLeptonDQM.h.

◆ HoverE_elecs_

MonitorElement* TopDiLeptonDQM::HoverE_elecs_
private

Definition at line 102 of file TopDiLeptonDQM.h.

◆ MassWindow_down_

double TopDiLeptonDQM::MassWindow_down_
private

Definition at line 83 of file TopDiLeptonDQM.h.

◆ MassWindow_up_

double TopDiLeptonDQM::MassWindow_up_
private

Definition at line 82 of file TopDiLeptonDQM.h.

◆ moduleName_

std::string TopDiLeptonDQM::moduleName_
private

Definition at line 49 of file TopDiLeptonDQM.h.

◆ MuIso_CombRelIso03_

MonitorElement* TopDiLeptonDQM::MuIso_CombRelIso03_
private

Definition at line 113 of file TopDiLeptonDQM.h.

◆ MuIso_emEt03_

MonitorElement* TopDiLeptonDQM::MuIso_emEt03_
private

Definition at line 107 of file TopDiLeptonDQM.h.

◆ MuIso_hadEt03_

MonitorElement* TopDiLeptonDQM::MuIso_hadEt03_
private

Definition at line 108 of file TopDiLeptonDQM.h.

◆ MuIso_hoEt03_

MonitorElement* TopDiLeptonDQM::MuIso_hoEt03_
private

Definition at line 109 of file TopDiLeptonDQM.h.

◆ MuIso_nJets03_

MonitorElement* TopDiLeptonDQM::MuIso_nJets03_
private

Definition at line 110 of file TopDiLeptonDQM.h.

◆ MuIso_nTracks03_

MonitorElement* TopDiLeptonDQM::MuIso_nTracks03_
private

Definition at line 111 of file TopDiLeptonDQM.h.

◆ MuIso_sumPt03_

MonitorElement* TopDiLeptonDQM::MuIso_sumPt03_
private

Definition at line 112 of file TopDiLeptonDQM.h.

◆ muon_eta_cut_

double TopDiLeptonDQM::muon_eta_cut_
private

Definition at line 73 of file TopDiLeptonDQM.h.

◆ muon_iso_cut_

double TopDiLeptonDQM::muon_iso_cut_
private

Definition at line 74 of file TopDiLeptonDQM.h.

◆ muon_pT_cut_

double TopDiLeptonDQM::muon_pT_cut_
private

Definition at line 72 of file TopDiLeptonDQM.h.

◆ muons_

edm::EDGetTokenT<reco::MuonCollection> TopDiLeptonDQM::muons_
private

Definition at line 71 of file TopDiLeptonDQM.h.

◆ N_elel

int TopDiLeptonDQM::N_elel
private

Definition at line 64 of file TopDiLeptonDQM.h.

◆ N_muel

int TopDiLeptonDQM::N_muel
private

Definition at line 63 of file TopDiLeptonDQM.h.

◆ N_mumu

int TopDiLeptonDQM::N_mumu
private

Definition at line 62 of file TopDiLeptonDQM.h.

◆ N_sig

int TopDiLeptonDQM::N_sig[100]
private

Definition at line 58 of file TopDiLeptonDQM.h.

◆ N_trig

int TopDiLeptonDQM::N_trig[100]
private

Definition at line 59 of file TopDiLeptonDQM.h.

◆ Nelecs_

MonitorElement* TopDiLeptonDQM::Nelecs_
private

Definition at line 99 of file TopDiLeptonDQM.h.

◆ Nelecs_charge_

MonitorElement* TopDiLeptonDQM::Nelecs_charge_
private

Definition at line 101 of file TopDiLeptonDQM.h.

◆ Nelecs_iso_

MonitorElement* TopDiLeptonDQM::Nelecs_iso_
private

Definition at line 100 of file TopDiLeptonDQM.h.

◆ Nmuons_

MonitorElement* TopDiLeptonDQM::Nmuons_
private

Definition at line 90 of file TopDiLeptonDQM.h.

◆ Nmuons_charge_

MonitorElement* TopDiLeptonDQM::Nmuons_charge_
private

Definition at line 92 of file TopDiLeptonDQM.h.

◆ Nmuons_iso_

MonitorElement* TopDiLeptonDQM::Nmuons_iso_
private

Definition at line 91 of file TopDiLeptonDQM.h.

◆ Ntracks_

MonitorElement* TopDiLeptonDQM::Ntracks_
private

Definition at line 88 of file TopDiLeptonDQM.h.

◆ outfile

std::ofstream TopDiLeptonDQM::outfile
private

Definition at line 56 of file TopDiLeptonDQM.h.

◆ outputFile_

std::string TopDiLeptonDQM::outputFile_
private

Definition at line 50 of file TopDiLeptonDQM.h.

◆ phi_elecs_

MonitorElement* TopDiLeptonDQM::phi_elecs_
private

Definition at line 105 of file TopDiLeptonDQM.h.

◆ phi_muons_

MonitorElement* TopDiLeptonDQM::phi_muons_
private

Definition at line 97 of file TopDiLeptonDQM.h.

◆ pT_elecs_

MonitorElement* TopDiLeptonDQM::pT_elecs_
private

Definition at line 103 of file TopDiLeptonDQM.h.

◆ pT_muons_

MonitorElement* TopDiLeptonDQM::pT_muons_
private

Definition at line 95 of file TopDiLeptonDQM.h.

◆ TriggerEff_

MonitorElement* TopDiLeptonDQM::TriggerEff_
private

Definition at line 87 of file TopDiLeptonDQM.h.

◆ triggerResults_

edm::EDGetTokenT<edm::TriggerResults> TopDiLeptonDQM::triggerResults_
private

Definition at line 51 of file TopDiLeptonDQM.h.

◆ Trigs_

MonitorElement* TopDiLeptonDQM::Trigs_
private

Definition at line 86 of file TopDiLeptonDQM.h.

◆ vertex_

edm::EDGetTokenT<reco::VertexCollection> TopDiLeptonDQM::vertex_
private

Definition at line 66 of file TopDiLeptonDQM.h.

◆ vertex_X_cut_

double TopDiLeptonDQM::vertex_X_cut_
private

Definition at line 67 of file TopDiLeptonDQM.h.

◆ vertex_Y_cut_

double TopDiLeptonDQM::vertex_Y_cut_
private

Definition at line 68 of file TopDiLeptonDQM.h.

◆ vertex_Z_cut_

double TopDiLeptonDQM::vertex_Z_cut_
private

Definition at line 69 of file TopDiLeptonDQM.h.

◆ VxVy_muons_

MonitorElement* TopDiLeptonDQM::VxVy_muons_
private

Definition at line 93 of file TopDiLeptonDQM.h.

◆ Vz_muons_

MonitorElement* TopDiLeptonDQM::Vz_muons_
private

Definition at line 94 of file TopDiLeptonDQM.h.

TopDiLeptonDQM::MuIso_nTracks03_
MonitorElement * MuIso_nTracks03_
Definition: TopDiLeptonDQM.h:111
TopDiLeptonDQM::Nelecs_charge_
MonitorElement * Nelecs_charge_
Definition: TopDiLeptonDQM.h:101
TopDiLeptonDQM::elec_eta_cut_
double elec_eta_cut_
Definition: TopDiLeptonDQM.h:78
TopDiLeptonDQM::muon_eta_cut_
double muon_eta_cut_
Definition: TopDiLeptonDQM.h:73
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
TopDiLeptonDQM::moduleName_
std::string moduleName_
Definition: TopDiLeptonDQM.h:49
TopDiLeptonDQM::pT_muons_
MonitorElement * pT_muons_
Definition: TopDiLeptonDQM.h:95
mps_fire.i
i
Definition: mps_fire.py:428
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11724
edm::Handle::product
T const * product() const
Definition: Handle.h:70
dqm::impl::MonitorElement::setTitle
virtual void setTitle(const std::string &title)
set (ie. change) histogram/profile title
Definition: MonitorElement.cc:809
TopDiLeptonDQM::elec_emf_cut_
double elec_emf_cut_
Definition: TopDiLeptonDQM.h:80
TopDiLeptonDQM::pT_elecs_
MonitorElement * pT_elecs_
Definition: TopDiLeptonDQM.h:103
muon
Definition: MuonCocktails.h:17
TopDiLeptonDQM::MuIso_CombRelIso03_
MonitorElement * MuIso_CombRelIso03_
Definition: TopDiLeptonDQM.h:113
reco::MuonIsolation::emEt
float emEt
ecal sum-Et
Definition: MuonIsolation.h:7
reco::MuonIsolation::nJets
int nJets
number of jets in the cone
Definition: MuonIsolation.h:11
TopDiLeptonDQM::dimassWC_LOG10_
MonitorElement * dimassWC_LOG10_
Definition: TopDiLeptonDQM.h:124
TopDiLeptonDQM::Events_
MonitorElement * Events_
Definition: TopDiLeptonDQM.h:85
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
TopDiLeptonDQM::TriggerEff_
MonitorElement * TriggerEff_
Definition: TopDiLeptonDQM.h:87
TopDiLeptonDQM::N_sig
int N_sig[100]
Definition: TopDiLeptonDQM.h:58
TopDiLeptonDQM::muons_
edm::EDGetTokenT< reco::MuonCollection > muons_
Definition: TopDiLeptonDQM.h:71
TopDiLeptonDQM::phi_elecs_
MonitorElement * phi_elecs_
Definition: TopDiLeptonDQM.h:105
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
edm::Event::triggerNames
edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const override
Definition: Event.cc:275
TopDiLeptonDQM::phi_muons_
MonitorElement * phi_muons_
Definition: TopDiLeptonDQM.h:97
edm::Handle< reco::VertexCollection >
reco::MuonIsolation
Definition: MuonIsolation.h:5
TopDiLeptonDQM::Eff
float Eff[100]
Definition: TopDiLeptonDQM.h:60
edm::Ref< TrackCollection >
TopDiLeptonDQM::elec_pT_cut_
double elec_pT_cut_
Definition: TopDiLeptonDQM.h:77
TopDiLeptonDQM::Trigs_
MonitorElement * Trigs_
Definition: TopDiLeptonDQM.h:86
BeamMonitor_cff.primaryVertex
primaryVertex
hltOfflineBeamSpot for HLTMON
Definition: BeamMonitor_cff.py:7
reco::MuonIsolation::sumPt
float sumPt
sum-pt of tracks
Definition: MuonIsolation.h:6
reco::GsfElectron::IsolationVariables::tkSumPt
float tkSumPt
Definition: GsfElectron.h:541
TopDiLeptonDQM::vertex_Y_cut_
double vertex_Y_cut_
Definition: TopDiLeptonDQM.h:68
TopDiLeptonDQM::N_mumu
int N_mumu
Definition: TopDiLeptonDQM.h:62
TopDiLeptonDQM::dimassRC_
MonitorElement * dimassRC_
Definition: TopDiLeptonDQM.h:119
TopDiLeptonDQM::dimassWC_
MonitorElement * dimassWC_
Definition: TopDiLeptonDQM.h:120
TopDiLeptonDQM::D_eta_lepts_
MonitorElement * D_eta_lepts_
Definition: TopDiLeptonDQM.h:130
edm::HLTGlobalStatus::size
unsigned int size() const
Get number of paths stored.
Definition: HLTGlobalStatus.h:35
HLT_FULL_cff.muon
muon
Definition: HLT_FULL_cff.py:11725
TopDiLeptonDQM::elec_iso_cut_
double elec_iso_cut_
Definition: TopDiLeptonDQM.h:79
TopDiLeptonDQM::Ntracks_
MonitorElement * Ntracks_
Definition: TopDiLeptonDQM.h:88
TopDiLeptonDQM::Nelecs_iso_
MonitorElement * Nelecs_iso_
Definition: TopDiLeptonDQM.h:100
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
TopDiLeptonDQM::Nmuons_charge_
MonitorElement * Nmuons_charge_
Definition: TopDiLeptonDQM.h:92
LaserClient_cfi.nbins
nbins
Definition: LaserClient_cfi.py:51
TopDiLeptonDQM::D_phi_muons_
MonitorElement * D_phi_muons_
Definition: TopDiLeptonDQM.h:127
singleTopDQM_cfi.elecs
elecs
Definition: singleTopDQM_cfi.py:41
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:539
dqmdumpme.k
k
Definition: dqmdumpme.py:60
reco::GsfElectron::IsolationVariables
Definition: GsfElectron.h:540
TopDiLeptonDQM::eta_muons_
MonitorElement * eta_muons_
Definition: TopDiLeptonDQM.h:96
TopDiLeptonDQM::elecs_
edm::EDGetTokenT< reco::GsfElectronCollection > elecs_
Definition: TopDiLeptonDQM.h:76
EgHLTOffTrigSelection_cfi.trigName
trigName
Definition: EgHLTOffTrigSelection_cfi.py:8
TopDiLeptonDQM::N_elel
int N_elel
Definition: TopDiLeptonDQM.h:64
TopDiLeptonDQM::ElecIso_trk_
MonitorElement * ElecIso_trk_
Definition: TopDiLeptonDQM.h:116
TopDiLeptonDQM::Vz_muons_
MonitorElement * Vz_muons_
Definition: TopDiLeptonDQM.h:94
edm::HandleBase::failedToGet
bool failedToGet() const
Definition: HandleBase.h:72
TopDiLeptonDQM::Nelecs_
MonitorElement * Nelecs_
Definition: TopDiLeptonDQM.h:99
reco::GsfElectron::IsolationVariables::hcalRecHitSumEt
std::array< float, 7 > hcalRecHitSumEt
Definition: GsfElectron.h:548
TopDiLeptonDQM::D_phi_lepts_
MonitorElement * D_phi_lepts_
Definition: TopDiLeptonDQM.h:131
TopDiLeptonDQM::N_muel
int N_muel
Definition: TopDiLeptonDQM.h:63
TopDiLeptonDQM::HoverE_elecs_
MonitorElement * HoverE_elecs_
Definition: TopDiLeptonDQM.h:102
dqm::impl::MonitorElement::setBinLabel
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:762
RunInfoPI::fake
Definition: RunInfoPayloadInspectoHelper.h:16
TopDiLeptonDQM::outputFile_
std::string outputFile_
Definition: TopDiLeptonDQM.h:50
reco::MuonIsolation::nTracks
int nTracks
number of tracks in the cone (excluding veto region)
Definition: MuonIsolation.h:10
reco::MuonIsolation::hoEt
float hoEt
ho sum-Et
Definition: MuonIsolation.h:9
TopDiLeptonDQM::Nmuons_
MonitorElement * Nmuons_
Definition: TopDiLeptonDQM.h:90
TopDiLeptonDQM::MassWindow_down_
double MassWindow_down_
Definition: TopDiLeptonDQM.h:83
TopDiLeptonDQM::D_phi_elecs_
MonitorElement * D_phi_elecs_
Definition: TopDiLeptonDQM.h:129
TopDiLeptonDQM::dimassRC_LOGX_
MonitorElement * dimassRC_LOGX_
Definition: TopDiLeptonDQM.h:121
TopDiLeptonDQM::MuIso_hoEt03_
MonitorElement * MuIso_hoEt03_
Definition: TopDiLeptonDQM.h:109
TopDiLeptonDQM::eta_elecs_
MonitorElement * eta_elecs_
Definition: TopDiLeptonDQM.h:104
TopDiLeptonDQM::dimassWC_LOGX_
MonitorElement * dimassWC_LOGX_
Definition: TopDiLeptonDQM.h:122
dqm::impl::MonitorElement::setBinContent
virtual void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:682
TopDiLeptonDQM::MuIso_hadEt03_
MonitorElement * MuIso_hadEt03_
Definition: TopDiLeptonDQM.h:108
reco::MuonIsolation::hadEt
float hadEt
hcal sum-Et
Definition: MuonIsolation.h:8
TopDiLeptonDQM::MuIso_emEt03_
MonitorElement * MuIso_emEt03_
Definition: TopDiLeptonDQM.h:107
TopDiLeptonDQM::ElecIso_cal_
MonitorElement * ElecIso_cal_
Definition: TopDiLeptonDQM.h:115
TopDiLeptonDQM::hltPaths_
std::vector< std::string > hltPaths_
Definition: TopDiLeptonDQM.h:52
TopDiLeptonDQM::VxVy_muons_
MonitorElement * VxVy_muons_
Definition: TopDiLeptonDQM.h:93
TopDiLeptonDQM::D_eta_muons_
MonitorElement * D_eta_muons_
Definition: TopDiLeptonDQM.h:126
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
edm::TriggerNames
Definition: TriggerNames.h:55
TopDiLeptonDQM::MuIso_nJets03_
MonitorElement * MuIso_nJets03_
Definition: TopDiLeptonDQM.h:110
TopDiLeptonDQM::dimassRC_LOG10_
MonitorElement * dimassRC_LOG10_
Definition: TopDiLeptonDQM.h:123
TopDiLeptonDQM::vertex_X_cut_
double vertex_X_cut_
Definition: TopDiLeptonDQM.h:67
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
TopDiLeptonDQM::vertex_
edm::EDGetTokenT< reco::VertexCollection > vertex_
Definition: TopDiLeptonDQM.h:66
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
edm::HLTGlobalStatus::accept
bool accept() const
Has at least one path accepted the event?
Definition: HLTGlobalStatus.h:49
TopDiLeptonDQM::muon_pT_cut_
double muon_pT_cut_
Definition: TopDiLeptonDQM.h:72
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
TopDiLeptonDQM::Nmuons_iso_
MonitorElement * Nmuons_iso_
Definition: TopDiLeptonDQM.h:91
reco::GsfElectron::IsolationVariables::ecalRecHitSumEt
float ecalRecHitSumEt
Definition: GsfElectron.h:543
TopDiLeptonDQM::triggerResults_
edm::EDGetTokenT< edm::TriggerResults > triggerResults_
Definition: TopDiLeptonDQM.h:51
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
trigObjTnPSource_cfi.bins
bins
Definition: trigObjTnPSource_cfi.py:20
TopDiLeptonDQM::MassWindow_up_
double MassWindow_up_
Definition: TopDiLeptonDQM.h:82
TopDiLeptonDQM::D_eta_elecs_
MonitorElement * D_eta_elecs_
Definition: TopDiLeptonDQM.h:128
TopDiLeptonDQM::ElecIso_CombRelIso_
MonitorElement * ElecIso_CombRelIso_
Definition: TopDiLeptonDQM.h:117
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
TopDiLeptonDQM::hltPaths_trig_
std::vector< std::string > hltPaths_trig_
Definition: TopDiLeptonDQM.h:54
TopDiLeptonDQM::MuIso_sumPt03_
MonitorElement * MuIso_sumPt03_
Definition: TopDiLeptonDQM.h:112
edm::InputTag
Definition: InputTag.h:15
TopDiLeptonDQM::muon_iso_cut_
double muon_iso_cut_
Definition: TopDiLeptonDQM.h:74
reco::Vertex
Definition: Vertex.h:35
TopDiLeptonDQM::hltPaths_sig_
std::vector< std::string > hltPaths_sig_
Definition: TopDiLeptonDQM.h:53
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
TopDiLeptonDQM::N_trig
int N_trig[100]
Definition: TopDiLeptonDQM.h:59
TopDiLeptonDQM::vertex_Z_cut_
double vertex_Z_cut_
Definition: TopDiLeptonDQM.h:69
Generated for CMSSW Reference Manual by doxygen 1.8.16