CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
TopDiLeptonDQM.cc
Go to the documentation of this file.
1 /*
2  * $Date: 2012/01/11 13:53:29 $
3  * $Revision: 1.14 $
4  * \author M. Marienfeld - DESY Hamburg
5  */
6 
7 #include "TLorentzVector.h"
8 #include "DataFormats/Math/interface/deltaR.h"
9 #include "DQM/Physics/src/TopDiLeptonDQM.h"
10 #include "FWCore/Common/interface/TriggerNames.h"
11 
12 using namespace std;
13 using namespace edm;
14 
15 TopDiLeptonDQM::TopDiLeptonDQM(const edm::ParameterSet& ps) {
16 
17  initialize();
18 
19  moduleName_ = ps.getUntrackedParameter<string>("moduleName");
20  fileOutput_ = ps.getParameter<bool>("fileOutput");
21  outputFile_ = ps.getUntrackedParameter<string>("outputFile");
22  triggerResults_ = consumes<TriggerResults>(
23  ps.getParameter<edm::InputTag>("TriggerResults"));
24  hltPaths_ = ps.getParameter<vector<string> >("hltPaths");
25  hltPaths_sig_ = ps.getParameter<vector<string> >("hltPaths_sig");
26  hltPaths_trig_ = ps.getParameter<vector<string> >("hltPaths_trig");
27 
28  vertex_ = consumes<reco::VertexCollection>(
29  ps.getParameter<edm::InputTag>("vertexCollection"));
30  vertex_X_cut_ = ps.getParameter<double>("vertex_X_cut");
31  vertex_Y_cut_ = ps.getParameter<double>("vertex_Y_cut");
32  vertex_Z_cut_ = ps.getParameter<double>("vertex_Z_cut");
33 
34  muons_ = consumes<reco::MuonCollection>(
35  ps.getParameter<edm::InputTag>("muonCollection"));
36  muon_pT_cut_ = ps.getParameter<double>("muon_pT_cut");
37  muon_eta_cut_ = ps.getParameter<double>("muon_eta_cut");
38  muon_iso_cut_ = ps.getParameter<double>("muon_iso_cut");
39 
40  elecs_ = consumes<reco::GsfElectronCollection>(
41  ps.getParameter<edm::InputTag>("elecCollection"));
42  elec_pT_cut_ = ps.getParameter<double>("elec_pT_cut");
43  elec_eta_cut_ = ps.getParameter<double>("elec_eta_cut");
44  elec_iso_cut_ = ps.getParameter<double>("elec_iso_cut");
45  elec_emf_cut_ = ps.getParameter<double>("elec_emf_cut");
46 
47  MassWindow_up_ = ps.getParameter<double>("MassWindow_up");
48  MassWindow_down_ = ps.getParameter<double>("MassWindow_down");
49 
50  for (int i = 0; i < 100; ++i) {
51  N_sig[i] = 0;
52  N_trig[i] = 0;
53  Eff[i] = 0.;
54  }
55 
56  N_mumu = 0;
57  N_muel = 0;
58  N_elel = 0;
59 
60  if (fileOutput_) {
61  const char* fileName = outputFile_.c_str();
62  outfile.open(fileName);
63  }
64 
65  dbe_ = Service<DQMStore>().operator->();
66 
67  Events_ = 0;
68  Trigs_ = 0;
69  TriggerEff_ = 0;
70  Ntracks_ = 0;
71  Nmuons_ = 0;
72  Nmuons_iso_ = 0;
73  Nmuons_charge_ = 0;
74  VxVy_muons_ = 0;
75  Vz_muons_ = 0;
76  pT_muons_ = 0;
77  eta_muons_ = 0;
78  phi_muons_ = 0;
79  Nelecs_ = 0;
80  Nelecs_iso_ = 0;
81  Nelecs_charge_ = 0;
82  HoverE_elecs_ = 0;
83  pT_elecs_ = 0;
84  eta_elecs_ = 0;
85  phi_elecs_ = 0;
86  MuIso_emEt03_ = 0;
87  MuIso_hadEt03_ = 0;
88  MuIso_hoEt03_ = 0;
89  MuIso_nJets03_ = 0;
90  MuIso_nTracks03_ = 0;
91  MuIso_sumPt03_ = 0;
92  MuIso_CombRelIso03_ = 0;
93  ElecIso_cal_ = 0;
94  ElecIso_trk_ = 0;
95  ElecIso_CombRelIso_ = 0;
96  dimassRC_ = 0;
97  dimassWC_ = 0;
98  dimassRC_LOGX_ = 0;
99  dimassWC_LOGX_ = 0;
100  dimassRC_LOG10_ = 0;
101  dimassWC_LOG10_ = 0;
102  D_eta_muons_ = 0;
103  D_phi_muons_ = 0;
104  D_eta_elecs_ = 0;
105  D_phi_elecs_ = 0;
106  D_eta_lepts_ = 0;
107  D_phi_lepts_ = 0;
108 }
109 
110 TopDiLeptonDQM::~TopDiLeptonDQM() {}
111 
112 void TopDiLeptonDQM::initialize() {}
113 
114 void TopDiLeptonDQM::beginJob() {
115 
116  dbe_->setCurrentFolder(moduleName_);
117 
118  Events_ = dbe_->book1D("00_Events", "Isolated dilepton events", 5, 0., 5.);
119  Events_->setBinLabel(2, "#mu #mu", 1);
120  Events_->setBinLabel(3, "#mu e", 1);
121  Events_->setBinLabel(4, "e e", 1);
122 
123  Trigs_ =
124  dbe_->book1D("01_Trigs", "Fired muon/electron triggers", 15, 0., 15.);
125  TriggerEff_ =
126  dbe_->book1D("02_TriggerEff", "HL Trigger Efficiencies", 10, 0., 10.);
127  TriggerEff_->setTitle(
128  "HL Trigger Efficiencies #epsilon_{signal} = #frac{[signal] && "
129  "[control]}{[control]}");
130  Ntracks_ = dbe_->book1D("Ntracks", "Number of tracks", 50, 0., 50.);
131 
132  Nmuons_ = dbe_->book1D("03_Nmuons", "Number of muons", 20, 0., 10.);
133  Nmuons_iso_ =
134  dbe_->book1D("04_Nmuons_iso", "Number of isolated muons", 20, 0., 10.);
135  Nmuons_charge_ = dbe_->book1D("Nmuons_charge",
136  "Number of muons * moun charge", 19, -10., 10.);
137  VxVy_muons_ = dbe_->book2D("VxVy_muons", "Vertex x-y-positon (global)", 40,
138  -1., 1., 40, -1., 1.);
139  Vz_muons_ =
140  dbe_->book1D("Vz_muons", "Vertex z-positon (global)", 40, -20., 20.);
141  pT_muons_ = dbe_->book1D("pT_muons", "P_T of muons", 40, 0., 200.);
142  eta_muons_ = dbe_->book1D("eta_muons", "Eta of muons", 50, -5., 5.);
143  phi_muons_ = dbe_->book1D("phi_muons", "Phi of muons", 40, -4., 4.);
144 
145  Nelecs_ = dbe_->book1D("05_Nelecs", "Number of electrons", 20, 0., 10.);
146  Nelecs_iso_ = dbe_->book1D("06_Nelecs_iso", "Number of isolated electrons",
147  20, 0., 10.);
148  Nelecs_charge_ = dbe_->book1D("Nelecs_charge",
149  "Number of elecs * elec charge", 19, -10., 10.);
150  HoverE_elecs_ =
151  dbe_->book1D("HoverE_elecs", "Hadronic over Ecal energy", 50, 0., 1.);
152  pT_elecs_ = dbe_->book1D("pT_elecs", "P_T of electrons", 40, 0., 200.);
153  eta_elecs_ = dbe_->book1D("eta_elecs", "Eta of electrons", 50, -5., 5.);
154  phi_elecs_ = dbe_->book1D("phi_elecs", "Phi of electrons", 40, -4., 4.);
155 
156  MuIso_emEt03_ = dbe_->book1D("MuIso_emEt03", "Muon emEt03", 20, 0., 20.);
157  MuIso_hadEt03_ = dbe_->book1D("MuIso_hadEt03", "Muon hadEt03", 20, 0., 20.);
158  MuIso_hoEt03_ = dbe_->book1D("MuIso_hoEt03", "Muon hoEt03", 20, 0., 20.);
159  MuIso_nJets03_ = dbe_->book1D("MuIso_nJets03", "Muon nJets03", 10, 0., 10.);
160  MuIso_nTracks03_ =
161  dbe_->book1D("MuIso_nTracks03", "Muon nTracks03", 20, 0., 20.);
162  MuIso_sumPt03_ = dbe_->book1D("MuIso_sumPt03", "Muon sumPt03", 20, 0., 40.);
163  MuIso_CombRelIso03_ =
164  dbe_->book1D("07_MuIso_CombRelIso03", "Muon CombRelIso03", 20, 0., 1.);
165 
166  ElecIso_cal_ = dbe_->book1D("ElecIso_cal", "Electron Iso_cal", 21, -1., 20.);
167  ElecIso_trk_ = dbe_->book1D("ElecIso_trk", "Electron Iso_trk", 21, -2., 40.);
168  ElecIso_CombRelIso_ =
169  dbe_->book1D("08_ElecIso_CombRelIso", "Electron CombRelIso", 20, 0., 1.);
170 
171  const int nbins = 200;
172 
173  double logmin = 0.;
174  double logmax = 3.; // 10^(3.)=1000
175 
176  float bins[nbins + 1];
177 
178  for (int i = 0; i <= nbins; i++) {
179 
180  double log = logmin + (logmax - logmin) * i / nbins;
181  bins[i] = std::pow(10.0, log);
182  }
183 
184  dimassRC_ = dbe_->book1D("09_dimassRC", "Dilepton mass RC", 50, 0., 200.);
185  dimassWC_ = dbe_->book1D("11_dimassWC", "Dilepton mass WC", 50, 0., 200.);
186  dimassRC_LOGX_ =
187  dbe_->book1D("10_dimassRC_LOGX", "Dilepton mass RC LOG", nbins, &bins[0]);
188  dimassWC_LOGX_ =
189  dbe_->book1D("12_dimassWC_LOGX", "Dilepton mass WC LOG", nbins, &bins[0]);
190  dimassRC_LOG10_ =
191  dbe_->book1D("dimassRC_LOG10", "Dilepton mass RC LOG", 50, 0., 2.5);
192  dimassWC_LOG10_ =
193  dbe_->book1D("dimassWC_LOG10", "Dilepton mass WC LOG", 50, 0., 2.5);
194 
195  D_eta_muons_ =
196  dbe_->book1D("13_D_eta_muons", "#Delta eta_muons", 20, -5., 5.);
197  D_phi_muons_ =
198  dbe_->book1D("14_D_phi_muons", "#Delta phi_muons", 20, -5., 5.);
199  D_eta_elecs_ = dbe_->book1D("D_eta_elecs", "#Delta eta_elecs", 20, -5., 5.);
200  D_phi_elecs_ = dbe_->book1D("D_phi_elecs", "#Delta phi_elecs", 20, -5., 5.);
201  D_eta_lepts_ = dbe_->book1D("D_eta_lepts", "#Delta eta_lepts", 20, -5., 5.);
202  D_phi_lepts_ = dbe_->book1D("D_phi_lepts", "#Delta phi_lepts", 20, -5., 5.);
203 }
204 
205 void TopDiLeptonDQM::beginRun(const edm::Run& r,
206  const edm::EventSetup& context) {}
207 
208 void TopDiLeptonDQM::analyze(const edm::Event& evt,
209  const edm::EventSetup& context) {
210 
211  // ------------------------
212  // Global Event Variables
213  // ------------------------
214 
215  const int N_TriggerPaths = hltPaths_.size();
216  const int N_SignalPaths = hltPaths_sig_.size();
217  const int N_ControlPaths = hltPaths_trig_.size();
218 
219  bool Fired_Signal_Trigger[100] = {false};
220  bool Fired_Control_Trigger[100] = {false};
221 
222  int N_run = (evt.id()).run();
223  int N_event = (evt.id()).event();
224  int N_lumi = evt.luminosityBlock();
225 
226  int N_leptons = 0;
227  int N_iso_mu = 0;
228  int N_iso_el = 0;
229  // int N_iso_lep = 0; // UNUSED
230 
231  double DilepMass = 0.;
232 
233  double vertex_X = 100.;
234  double vertex_Y = 100.;
235  double vertex_Z = 100.;
236 
237  // ------------------------
238  // Analyze Primary Vertex
239  // ------------------------
240 
241  edm::Handle<reco::VertexCollection> vertexs;
242  evt.getByToken(vertex_, vertexs);
243 
244  if (!vertexs.failedToGet()) {
245 
246  reco::Vertex primaryVertex = vertexs->front();
247 
248  int numberTracks = primaryVertex.tracksSize();
249  // double ndof = primaryVertex.ndof();
250  bool fake = primaryVertex.isFake();
251 
252  Ntracks_->Fill(numberTracks);
253 
254  if (!fake && numberTracks > 3) {
255 
256  vertex_X = primaryVertex.x();
257  vertex_Y = primaryVertex.y();
258  vertex_Z = primaryVertex.z();
259  }
260  }
261 
262  // -------------------------
263  // Analyze Trigger Results
264  // -------------------------
265 
266  edm::Handle<TriggerResults> trigResults;
267  evt.getByToken(triggerResults_, trigResults);
268 
269  if (!trigResults.failedToGet()) {
270 
271  int N_Triggers = trigResults->size();
272 
273  const edm::TriggerNames& trigName = evt.triggerNames(*trigResults);
274 
275  for (int i_Trig = 0; i_Trig < N_Triggers; ++i_Trig) {
276 
277  if (trigResults.product()->accept(i_Trig)) {
278 
279  // Check for all trigger paths
280 
281  for (int i = 0; i < N_TriggerPaths; i++) {
282 
283  if (trigName.triggerName(i_Trig) == hltPaths_[i]) {
284 
285  Trigs_->Fill(i);
286  Trigs_->setBinLabel(i + 1, hltPaths_[i], 1);
287  }
288  }
289 
290  // Check for signal & control trigger paths
291 
292  for (int j = 0; j < N_SignalPaths; ++j) {
293 
294  if (trigName.triggerName(i_Trig) == hltPaths_sig_[j])
295  Fired_Signal_Trigger[j] = true;
296  }
297 
298  for (int k = 0; k < N_ControlPaths; ++k) {
299 
300  if (trigName.triggerName(i_Trig) == hltPaths_trig_[k])
301  Fired_Control_Trigger[k] = true;
302  }
303  }
304  }
305  }
306 
307  // ------------------------
308  // Analyze Muon Isolation
309  // ------------------------
310 
311  edm::Handle<reco::MuonCollection> muons;
312  evt.getByToken(muons_, muons);
313 
314  reco::MuonCollection::const_iterator muon;
315 
316  if (!muons.failedToGet()) {
317 
318  Nmuons_->Fill(muons->size());
319 
320  N_leptons = N_leptons + muons->size();
321 
322  for (muon = muons->begin(); muon != muons->end(); ++muon) {
323 
324  float N_muons = muons->size();
325  float Q_muon = muon->charge();
326 
327  Nmuons_charge_->Fill(N_muons * Q_muon);
328 
329  double track_X = 100.;
330  double track_Y = 100.;
331  double track_Z = 100.;
332 
333  if (muon->isGlobalMuon()) {
334 
335  reco::TrackRef track = muon->globalTrack();
336 
337  track_X = track->vx();
338  track_Y = track->vy();
339  track_Z = track->vz();
340 
341  VxVy_muons_->Fill(track_X, track_Y);
342  Vz_muons_->Fill(track_Z);
343  }
344 
345  // Vertex and kinematic cuts
346 
347  if (track_X > vertex_X_cut_) continue;
348  if (track_Y > vertex_Y_cut_) continue;
349  if (track_Z > vertex_Z_cut_) continue;
350  if (muon->pt() < muon_pT_cut_) continue;
351  if (abs(muon->eta()) > muon_eta_cut_) continue;
352 
353  reco::MuonIsolation muIso03 = muon->isolationR03();
354 
355  double muonCombRelIso = 1.;
356 
357  if (muon->pt() != 0.)
358  muonCombRelIso =
359  (muIso03.emEt + muIso03.hadEt + muIso03.hoEt + muIso03.sumPt) /
360  muon->pt();
361 
362  MuIso_CombRelIso03_->Fill(muonCombRelIso);
363 
364  MuIso_emEt03_->Fill(muIso03.emEt);
365  MuIso_hadEt03_->Fill(muIso03.hadEt);
366  MuIso_hoEt03_->Fill(muIso03.hoEt);
367  MuIso_nJets03_->Fill(muIso03.nJets);
368  MuIso_nTracks03_->Fill(muIso03.nTracks);
369  MuIso_sumPt03_->Fill(muIso03.sumPt);
370 
371  if (muonCombRelIso < muon_iso_cut_) ++N_iso_mu;
372  }
373 
374  Nmuons_iso_->Fill(N_iso_mu);
375  }
376 
377  // ----------------------------
378  // Analyze Electron Isolation
379  // ----------------------------
380 
381  edm::Handle<reco::GsfElectronCollection> elecs;
382  evt.getByToken(elecs_, elecs);
383 
384  reco::GsfElectronCollection::const_iterator elec;
385 
386  if (!elecs.failedToGet()) {
387 
388  Nelecs_->Fill(elecs->size());
389 
390  N_leptons = N_leptons + elecs->size();
391 
392  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
393 
394  float N_elecs = elecs->size();
395  float Q_elec = elec->charge();
396  float HoverE = elec->hcalOverEcal();
397 
398  HoverE_elecs_->Fill(HoverE);
399 
400  Nelecs_charge_->Fill(N_elecs * Q_elec);
401 
402  double track_X = 100.;
403  double track_Y = 100.;
404  double track_Z = 100.;
405 
406  reco::GsfTrackRef track = elec->gsfTrack();
407 
408  track_X = track->vx();
409  track_Y = track->vy();
410  track_Z = track->vz();
411 
412  // Vertex and kinematic cuts
413 
414  if (track_X > vertex_X_cut_) continue;
415  if (track_Y > vertex_Y_cut_) continue;
416  if (track_Z > vertex_Z_cut_) continue;
417  if (elec->pt() < elec_pT_cut_) continue;
418  if (abs(elec->eta()) > elec_eta_cut_) continue;
419  if (HoverE > elec_emf_cut_) continue;
420 
421  reco::GsfElectron::IsolationVariables elecIso =
422  elec->dr03IsolationVariables();
423 
424  double elecCombRelIso = 1.;
425 
426  if (elec->et() != 0.)
427  elecCombRelIso = (elecIso.ecalRecHitSumEt +
428  elecIso.hcalDepth1TowerSumEt + elecIso.tkSumPt) /
429  elec->et();
430 
431  ElecIso_CombRelIso_->Fill(elecCombRelIso);
432 
433  ElecIso_cal_->Fill(elecIso.ecalRecHitSumEt);
434  ElecIso_trk_->Fill(elecIso.tkSumPt);
435 
436  if (elecCombRelIso < elec_iso_cut_) ++N_iso_el;
437  }
438 
439  Nelecs_iso_->Fill(N_iso_el);
440  }
441 
442  // --------------------
443  // TWO Isolated MUONS
444  // --------------------
445 
446  if (N_iso_mu > 1) {
447 
448  // Vertex cut
449 
450  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ &&
451  vertex_Z < vertex_Z_cut_) {
452 
453  ++N_mumu;
454 
455  Events_->Fill(1.);
456 
457  reco::MuonCollection::const_reference mu1 = muons->at(0);
458  reco::MuonCollection::const_reference mu2 = muons->at(1);
459 
460  DilepMass =
461  sqrt((mu1.energy() + mu2.energy()) * (mu1.energy() + mu2.energy()) -
462  (mu1.px() + mu2.px()) * (mu1.px() + mu2.px()) -
463  (mu1.py() + mu2.py()) * (mu1.py() + mu2.py()) -
464  (mu1.pz() + mu2.pz()) * (mu1.pz() + mu2.pz()));
465 
466  // Opposite muon charges -> Right Charge (RC)
467 
468  if (mu1.charge() * mu2.charge() < 0.) {
469 
470  dimassRC_LOG10_->Fill(log10(DilepMass));
471  dimassRC_->Fill(DilepMass);
472  dimassRC_LOGX_->Fill(DilepMass);
473 
474  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
475 
476  for (muon = muons->begin(); muon != muons->end(); ++muon) {
477 
478  pT_muons_->Fill(muon->pt());
479  eta_muons_->Fill(muon->eta());
480  phi_muons_->Fill(muon->phi());
481  }
482 
483  D_eta_muons_->Fill(mu1.eta() - mu2.eta());
484  D_phi_muons_->Fill(mu1.phi() - mu2.phi());
485 
486  if (fileOutput_) {
487 
488  if (mu1.isGlobalMuon() && mu2.isGlobalMuon()) {
489 
490  outfile << "--------------------"
491  << "\n";
492  outfile << " Run : " << N_run << "\n";
493  outfile << " Event : " << N_event << "\n";
494  outfile << "LumiBlock : " << N_lumi << "\n";
495  outfile << " Type : mu mu"
496  << "\n";
497  outfile << "--------------------"
498  << "\n";
499  outfile << "DilepMass : " << DilepMass << "\n";
500  outfile << "Mu1 Pt : " << mu1.pt() << "\n";
501  outfile << "Mu1 Eta : " << mu1.eta() << "\n";
502  outfile << "Mu1 Phi : " << mu1.phi() << "\n";
503  outfile << "Mu2 Pt : " << mu2.pt() << "\n";
504  outfile << "Mu2 Eta : " << mu2.eta() << "\n";
505  outfile << "Mu2 Phi : " << mu2.phi() << "\n";
506  outfile << "--------------------"
507  << "\n";
508  }
509  }
510 
511  // Determinating trigger efficiencies
512 
513  for (int k = 0; k < N_SignalPaths; ++k) {
514 
515  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k]) ++N_sig[k];
516 
517  if (Fired_Control_Trigger[k]) ++N_trig[k];
518 
519  if (N_trig[k] != 0)
520  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
521 
522  TriggerEff_->setBinContent(k + 1, Eff[k]);
523  TriggerEff_->setBinLabel(k + 1,
524  "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" +
525  hltPaths_trig_[k] + "]}",
526  1);
527  }
528  }
529  }
530 
531  // Same muon charges -> Wrong Charge (WC)
532 
533  if (mu1.charge() * mu2.charge() > 0.) {
534 
535  dimassWC_LOG10_->Fill(log10(DilepMass));
536  dimassWC_->Fill(DilepMass);
537  dimassWC_LOGX_->Fill(DilepMass);
538 
539  if (fileOutput_) {
540 
541  if (mu1.isGlobalMuon() && mu2.isGlobalMuon()) {
542 
543  outfile << "---------------------"
544  << "\n";
545  outfile << " Run : " << N_run << "\n";
546  outfile << " Event : " << N_event << "\n";
547  outfile << "LumiBlock : " << N_lumi << "\n";
548  outfile << " Type : WC mu mu"
549  << "\n";
550  outfile << "---------------------"
551  << "\n";
552  outfile << "DilepMass : " << DilepMass << "\n";
553  outfile << "Mu1 Pt : " << mu1.pt() << "\n";
554  outfile << "Mu1 Eta : " << mu1.eta() << "\n";
555  outfile << "Mu1 Phi : " << mu1.phi() << "\n";
556  outfile << "Mu2 Pt : " << mu2.pt() << "\n";
557  outfile << "Mu2 Eta : " << mu2.eta() << "\n";
558  outfile << "Mu2 Phi : " << mu2.phi() << "\n";
559  outfile << "---------------------"
560  << "\n";
561  }
562  }
563  }
564  }
565  }
566 
567  // -----------------------------
568  // TWO Isolated LEPTONS (mu/e)
569  // -----------------------------
570 
571  if (N_iso_el > 0 && N_iso_mu > 0) {
572 
573  // Vertex cut
574 
575  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ &&
576  vertex_Z < vertex_Z_cut_) {
577 
578  ++N_muel;
579 
580  Events_->Fill(2.);
581 
582  reco::MuonCollection::const_reference mu1 = muons->at(0);
583  reco::GsfElectronCollection::const_reference el1 = elecs->at(0);
584 
585  DilepMass =
586  sqrt((mu1.energy() + el1.energy()) * (mu1.energy() + el1.energy()) -
587  (mu1.px() + el1.px()) * (mu1.px() + el1.px()) -
588  (mu1.py() + el1.py()) * (mu1.py() + el1.py()) -
589  (mu1.pz() + el1.pz()) * (mu1.pz() + el1.pz()));
590 
591  // Opposite lepton charges -> Right Charge (RC)
592 
593  if (mu1.charge() * el1.charge() < 0.) {
594 
595  dimassRC_LOG10_->Fill(log10(DilepMass));
596  dimassRC_->Fill(DilepMass);
597  dimassRC_LOGX_->Fill(DilepMass);
598 
599  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
600 
601  for (muon = muons->begin(); muon != muons->end(); ++muon) {
602 
603  pT_muons_->Fill(muon->pt());
604  eta_muons_->Fill(muon->eta());
605  phi_muons_->Fill(muon->phi());
606  }
607 
608  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
609 
610  pT_elecs_->Fill(elec->pt());
611  eta_elecs_->Fill(elec->eta());
612  phi_elecs_->Fill(elec->phi());
613  }
614 
615  D_eta_lepts_->Fill(mu1.eta() - el1.eta());
616  D_phi_lepts_->Fill(mu1.phi() - el1.phi());
617 
618  if (fileOutput_) {
619 
620  if (mu1.isGlobalMuon() && el1.isElectron()) {
621 
622  outfile << "--------------------"
623  << "\n";
624  outfile << " Run : " << N_run << "\n";
625  outfile << " Event : " << N_event << "\n";
626  outfile << "LumiBlock : " << N_lumi << "\n";
627  outfile << " Type : mu el"
628  << "\n";
629  outfile << "--------------------"
630  << "\n";
631  outfile << "DilepMass : " << DilepMass << "\n";
632  outfile << "Mu1 Pt : " << mu1.pt() << "\n";
633  outfile << "Mu1 Eta : " << mu1.eta() << "\n";
634  outfile << "Mu1 Phi : " << mu1.phi() << "\n";
635  outfile << "El1 Pt : " << el1.pt() << "\n";
636  outfile << "El1 Eta : " << el1.eta() << "\n";
637  outfile << "El1 Phi : " << el1.phi() << "\n";
638  outfile << "--------------------"
639  << "\n";
640  }
641  }
642 
643  // Determinating trigger efficiencies
644 
645  for (int k = 0; k < N_SignalPaths; ++k) {
646 
647  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k]) ++N_sig[k];
648 
649  if (Fired_Control_Trigger[k]) ++N_trig[k];
650 
651  if (N_trig[k] != 0)
652  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
653 
654  TriggerEff_->setBinContent(k + 1, Eff[k]);
655  TriggerEff_->setBinLabel(k + 1,
656  "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" +
657  hltPaths_trig_[k] + "]}",
658  1);
659  }
660  }
661  }
662 
663  // Same muon charges -> Wrong Charge (WC)
664 
665  if (mu1.charge() * el1.charge() > 0.) {
666 
667  dimassWC_LOG10_->Fill(log10(DilepMass));
668  dimassWC_->Fill(DilepMass);
669  dimassWC_LOGX_->Fill(DilepMass);
670  }
671  }
672  }
673 
674  // ------------------------
675  // TWO Isolated ELECTRONS
676  // ------------------------
677 
678  if (N_iso_el > 1) {
679 
680  // Vertex cut
681 
682  if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ &&
683  vertex_Z < vertex_Z_cut_) {
684 
685  ++N_elel;
686 
687  Events_->Fill(3.);
688 
689  reco::GsfElectronCollection::const_reference el1 = elecs->at(0);
690  reco::GsfElectronCollection::const_reference el2 = elecs->at(1);
691 
692  DilepMass =
693  sqrt((el1.energy() + el2.energy()) * (el1.energy() + el2.energy()) -
694  (el1.px() + el2.px()) * (el1.px() + el2.px()) -
695  (el1.py() + el2.py()) * (el1.py() + el2.py()) -
696  (el1.pz() + el2.pz()) * (el1.pz() + el2.pz()));
697 
698  // Opposite lepton charges -> Right Charge (RC)
699 
700  if (el1.charge() * el2.charge() < 0.) {
701 
702  dimassRC_LOG10_->Fill(log10(DilepMass));
703  dimassRC_->Fill(DilepMass);
704  dimassRC_LOGX_->Fill(DilepMass);
705 
706  if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
707 
708  for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
709 
710  pT_elecs_->Fill(elec->pt());
711  eta_elecs_->Fill(elec->eta());
712  phi_elecs_->Fill(elec->phi());
713  }
714 
715  D_eta_elecs_->Fill(el1.eta() - el2.eta());
716  D_phi_elecs_->Fill(el1.phi() - el2.phi());
717 
718  if (fileOutput_) {
719 
720  if (el1.isElectron() && el2.isElectron()) {
721 
722  outfile << "--------------------"
723  << "\n";
724  outfile << " Run : " << N_run << "\n";
725  outfile << " Event : " << N_event << "\n";
726  outfile << "LumiBlock : " << N_lumi << "\n";
727  outfile << " Type : el el"
728  << "\n";
729  outfile << "--------------------"
730  << "\n";
731  outfile << "DilepMass : " << DilepMass << "\n";
732  outfile << "El1 Pt : " << el1.pt() << "\n";
733  outfile << "El1 Eta : " << el1.eta() << "\n";
734  outfile << "El1 Phi : " << el1.phi() << "\n";
735  outfile << "El2 Pt : " << el2.pt() << "\n";
736  outfile << "El2 Eta : " << el2.eta() << "\n";
737  outfile << "El2 Phi : " << el2.phi() << "\n";
738  outfile << "--------------------"
739  << "\n";
740  }
741  }
742 
743  // Determinating trigger efficiencies
744 
745  for (int k = 0; k < N_SignalPaths; ++k) {
746 
747  if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k]) ++N_sig[k];
748 
749  if (Fired_Control_Trigger[k]) ++N_trig[k];
750 
751  if (N_trig[k] != 0)
752  Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
753 
754  TriggerEff_->setBinContent(k + 1, Eff[k]);
755  TriggerEff_->setBinLabel(k + 1,
756  "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" +
757  hltPaths_trig_[k] + "]}",
758  1);
759  }
760  }
761  }
762 
763  // Same muon charges -> Wrong Charge (WC)
764 
765  if (el1.charge() * el2.charge() > 0.) {
766 
767  dimassWC_LOG10_->Fill(log10(DilepMass));
768  dimassWC_->Fill(DilepMass);
769  dimassWC_LOGX_->Fill(DilepMass);
770  }
771  }
772  }
773 }
774 
775 void TopDiLeptonDQM::endRun(const edm::Run& r, const edm::EventSetup& context) {
776 }
777 
778 void TopDiLeptonDQM::endJob() {
779 
780  if (fileOutput_) outfile.close();
781 }
782 
783 // Local Variables:
784 // show-trailing-whitespace: t
785 // truncate-lines: t
786 // End:
TopDiLeptonDQM::endJob
virtual void endJob()
Definition: TopDiLeptonDQM.cc:778
reco::MuonIsolation::hadEt
float hadEt
hcal sum-Et
Definition: MuonIsolation.h:9
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
initialize
static AlgebraicMatrix initialize()
Definition: BeamSpotTransientTrackingRecHit.cc:27
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
TopDiLeptonDQM::endRun
void endRun(const edm::Run &, const edm::EventSetup &)
Definition: TopDiLeptonDQM.cc:775
edm::Event::triggerNames
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:199
reco::MuonIsolation::sumPt
float sumPt
sum-pt of tracks
Definition: MuonIsolation.h:7
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:446
reco::Vertex::y
double y() const
y coordinate
Definition: Vertex.h:110
fff_deleter.log
tuple log
Definition: fff_deleter.py:13
edm::EventBase::luminosityBlock
edm::LuminosityBlockNumber_t luminosityBlock() const
Definition: EventBase.h:59
convertXMLtoSQLite_cfg.fileName
tuple fileName
Definition: convertXMLtoSQLite_cfg.py:12
trackingTruthProducerFastSim_cfi.muon
tuple muon
Definition: trackingTruthProducerFastSim_cfi.py:10
TopDiLeptonDQM::TopDiLeptonDQM
TopDiLeptonDQM(const edm::ParameterSet &)
Definition: TopDiLeptonDQM.cc:15
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
reco::MuonIsolation::emEt
float emEt
ecal sum-Et
Definition: MuonIsolation.h:8
reco::MuonIsolation::nJets
int nJets
number of jets in the cone
Definition: MuonIsolation.h:12
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
j
int j
Definition: DBlmapReader.cc:9
reco::Vertex::z
double z() const
y coordinate
Definition: Vertex.h:112
reco::MuonIsolation::hoEt
float hoEt
ho sum-Et
Definition: MuonIsolation.h:10
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
dbe_
DQMStore * dbe_
Definition: PFJetBenchmarkAnalyzer.cc:79
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:79
TopDiLeptonDQM::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: TopDiLeptonDQM.cc:208
reco::MuonIsolation::nTracks
int nTracks
number of tracks in the cone (excluding veto region)
Definition: MuonIsolation.h:11
edm::HandleBase::failedToGet
bool failedToGet() const
Definition: HandleBase.h:80
reco::Vertex::x
double x() const
x coordinate
Definition: Vertex.h:108
reco::Vertex::isFake
bool isFake() const
Definition: Vertex.h:64
edm::Handle::product
T const * product() const
Definition: Handle.h:81
edm::TriggerNames::triggerName
std::string const & triggerName(unsigned int index) const
Definition: TriggerNames.cc:27
TopDiLeptonDQM::beginJob
virtual void beginJob()
Definition: TopDiLeptonDQM.cc:114
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:56
patZpeak.muons
tuple muons
Definition: patZpeak.py:38
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
reco::Vertex::tracksSize
size_t tracksSize() const
number of tracks
Definition: Vertex.cc:34
edm::Run
Definition: Run.h:41
TopDiLeptonDQM::beginRun
void beginRun(const edm::Run &, const edm::EventSetup &)
Definition: TopDiLeptonDQM.cc:205
Generated for CMSSW Reference Manual by doxygen 1.8.5