CMS 3D CMS Logo
L1TEGammaOffline.cc
Go to the documentation of this file.
1 #include "DQMOffline/L1Trigger/interface/L1TEGammaOffline.h"
2 #include "DQMOffline/L1Trigger/interface/L1TFillWithinLimits.h"
3 #include "DQMOffline/L1Trigger/interface/L1TCommon.h"
4 
5 #include "FWCore/MessageLogger/interface/MessageLogger.h"
6 #include "FWCore/Framework/interface/MakerMacros.h"
7 // Geometry
8 #include "DataFormats/Math/interface/deltaR.h"
9 #include "DataFormats/Math/interface/deltaPhi.h"
10 #include "DataFormats/Math/interface/LorentzVector.h"
11 #include "DataFormats/EgammaCandidates/interface/PhotonFwd.h"
12 #include "TLorentzVector.h"
13 
14 #include <iostream>
15 #include <iomanip>
16 #include <cstdio>
17 #include <string>
18 #include <sstream>
19 #include <cmath>
20 #include <algorithm>
21 
22 const std::map<std::string, unsigned int> L1TEGammaOffline::PlotConfigNames = {
23  {"nVertex", PlotConfig::nVertex}, {"ETvsET", PlotConfig::ETvsET}, {"PHIvsPHI", PlotConfig::PHIvsPHI}};
24 
25 //
26 // -------------------------------------- Constructor --------------------------------------------
27 //
28 L1TEGammaOffline::L1TEGammaOffline(const edm::ParameterSet& ps)
29  : theGsfElectronCollection_(
30  consumes<reco::GsfElectronCollection>(ps.getParameter<edm::InputTag>("electronCollection"))),
31  thePhotonCollection_(consumes<std::vector<reco::Photon> >(ps.getParameter<edm::InputTag>("photonCollection"))),
32  thePVCollection_(consumes<reco::VertexCollection>(ps.getParameter<edm::InputTag>("PVCollection"))),
33  theBSCollection_(consumes<reco::BeamSpot>(ps.getParameter<edm::InputTag>("beamSpotCollection"))),
34  triggerInputTag_(consumes<trigger::TriggerEvent>(ps.getParameter<edm::InputTag>("triggerInputTag"))),
35  triggerResultsInputTag_(consumes<edm::TriggerResults>(ps.getParameter<edm::InputTag>("triggerResults"))),
36  triggerProcess_(ps.getParameter<std::string>("triggerProcess")),
37  triggerNames_(ps.getParameter<std::vector<std::string> >("triggerNames")),
38  histFolder_(ps.getParameter<std::string>("histFolder")),
39  efficiencyFolder_(histFolder_ + "/efficiency_raw"),
40  stage2CaloLayer2EGammaToken_(
41  consumes<l1t::EGammaBxCollection>(ps.getParameter<edm::InputTag>("stage2CaloLayer2EGammaSource"))),
42  electronEfficiencyThresholds_(ps.getParameter<std::vector<double> >("electronEfficiencyThresholds")),
43  electronEfficiencyBins_(ps.getParameter<std::vector<double> >("electronEfficiencyBins")),
44  probeToL1Offset_(ps.getParameter<double>("probeToL1Offset")),
45  deepInspectionElectronThresholds_(ps.getParameter<std::vector<double> >("deepInspectionElectronThresholds")),
46  photonEfficiencyThresholds_(ps.getParameter<std::vector<double> >("photonEfficiencyThresholds")),
47  photonEfficiencyBins_(ps.getParameter<std::vector<double> >("photonEfficiencyBins")),
48  maxDeltaRForL1Matching_(ps.getParameter<double>("maxDeltaRForL1Matching")),
49  maxDeltaRForHLTMatching_(ps.getParameter<double>("maxDeltaRForHLTMatching")),
50  recoToL1TThresholdFactor_(ps.getParameter<double>("recoToL1TThresholdFactor")),
51  tagElectron_(),
52  probeElectron_(),
53  tagAndProbleInvariantMass_(-1.),
54  hltConfig_(),
55  triggerIndices_(),
56  triggerResults_(),
57  triggerEvent_(),
58  histDefinitions_(dqmoffline::l1t::readHistDefinitions(ps.getParameterSet("histDefinitions"), PlotConfigNames)),
59  h_nVertex_(),
60  h_tagAndProbeMass_(),
61  h_L1EGammaETvsElectronET_EB_(),
62  h_L1EGammaETvsElectronET_EE_(),
63  h_L1EGammaETvsElectronET_EB_EE_(),
64  h_L1EGammaPhivsElectronPhi_EB_(),
65  h_L1EGammaPhivsElectronPhi_EE_(),
66  h_L1EGammaPhivsElectronPhi_EB_EE_(),
67  h_L1EGammaEtavsElectronEta_(),
68  h_resolutionElectronET_EB_(),
69  h_resolutionElectronET_EE_(),
70  h_resolutionElectronET_EB_EE_(),
71  h_resolutionElectronPhi_EB_(),
72  h_resolutionElectronPhi_EE_(),
73  h_resolutionElectronPhi_EB_EE_(),
74  h_resolutionElectronEta_(),
75  h_efficiencyElectronET_EB_pass_(),
76  h_efficiencyElectronET_EE_pass_(),
77  h_efficiencyElectronET_EB_EE_pass_(),
78  h_efficiencyElectronPhi_vs_Eta_pass_(),
79  h_efficiencyElectronEta_pass_(),
80  h_efficiencyElectronPhi_pass_(),
81  h_efficiencyElectronNVertex_pass_(),
82  h_efficiencyElectronET_EB_total_(),
83  h_efficiencyElectronET_EE_total_(),
84  h_efficiencyElectronET_EB_EE_total_(),
85  h_efficiencyElectronPhi_vs_Eta_total_(),
86  h_efficiencyElectronEta_total_(),
87  h_efficiencyElectronPhi_total_(),
88  h_efficiencyElectronNVertex_total_(),
89  h_L1EGammaETvsPhotonET_EB_(),
90  h_L1EGammaETvsPhotonET_EE_(),
91  h_L1EGammaETvsPhotonET_EB_EE_(),
92  h_L1EGammaPhivsPhotonPhi_EB_(),
93  h_L1EGammaPhivsPhotonPhi_EE_(),
94  h_L1EGammaPhivsPhotonPhi_EB_EE_(),
95  h_L1EGammaEtavsPhotonEta_(),
96  h_resolutionPhotonEta_(),
97  h_efficiencyPhotonET_EB_pass_(),
98  h_efficiencyPhotonET_EE_pass_(),
99  h_efficiencyPhotonET_EB_EE_pass_(),
100  h_efficiencyPhotonET_EB_total_(),
101  h_efficiencyPhotonET_EE_total_(),
102  h_efficiencyPhotonET_EB_EE_total_() {
103  edm::LogInfo("L1TEGammaOffline") << "Constructor "
104  << "L1TEGammaOffline::L1TEGammaOffline " << std::endl;
105 }
106 
107 //
108 // -- Destructor
109 //
110 L1TEGammaOffline::~L1TEGammaOffline() {
111  edm::LogInfo("L1TEGammaOffline") << "Destructor L1TEGammaOffline::~L1TEGammaOffline " << std::endl;
112 }
113 
114 //
115 // -------------------------------------- beginRun --------------------------------------------
116 //
117 void L1TEGammaOffline::dqmBeginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
118  edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::beginRun" << std::endl;
119  bool changed(true);
120  if (!hltConfig_.init(iRun, iSetup, triggerProcess_, changed)) {
121  edm::LogError("L1TEGammaOffline") << " HLT config extraction failure with process name " << triggerProcess_
122  << std::endl;
123  triggerNames_.clear();
124  } else {
125  triggerIndices_ = dqmoffline::l1t::getTriggerIndices(triggerNames_, hltConfig_.triggerNames());
126  }
127 }
128 
129 //
130 // -------------------------------------- bookHistos --------------------------------------------
131 //
132 void L1TEGammaOffline::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const&, edm::EventSetup const&) {
133  edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::bookHistograms" << std::endl;
134 
135  //book at beginRun
136  bookElectronHistos(ibooker);
137  // bookPhotonHistos(ibooker);
138 }
139 
140 //
141 // -------------------------------------- Analyze --------------------------------------------
142 //
143 void L1TEGammaOffline::analyze(edm::Event const& e, edm::EventSetup const& eSetup) {
144  edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::analyze" << std::endl;
145 
146  edm::Handle<edm::TriggerResults> triggerResultHandle;
147  e.getByToken(triggerResultsInputTag_, triggerResultHandle);
148  if (!triggerResultHandle.isValid()) {
149  edm::LogWarning("L1TEGammaOffline") << "invalid edm::TriggerResults handle" << std::endl;
150  return;
151  }
152  triggerResults_ = *triggerResultHandle;
153 
154  edm::Handle<trigger::TriggerEvent> triggerEventHandle;
155  e.getByToken(triggerInputTag_, triggerEventHandle);
156  if (!triggerEventHandle.isValid()) {
157  edm::LogWarning("L1TEGammaOffline") << "invalid trigger::TriggerEvent handle" << std::endl;
158  return;
159  }
160  triggerEvent_ = *triggerEventHandle;
161 
162  edm::Handle<reco::VertexCollection> vertexHandle;
163  e.getByToken(thePVCollection_, vertexHandle);
164  if (!vertexHandle.isValid()) {
165  edm::LogWarning("L1TEGammaOffline") << "invalid collection: vertex " << std::endl;
166  return;
167  }
168 
169  unsigned int nVertex = vertexHandle->size();
170  dqmoffline::l1t::fillWithinLimits(h_nVertex_, nVertex);
171 
172  if (!dqmoffline::l1t::passesAnyTriggerFromList(triggerIndices_, triggerResults_)) {
173  return;
174  }
175  // L1T
176  fillElectrons(e, nVertex);
177  // fillPhotons(e, nVertex);
178 }
179 
180 void L1TEGammaOffline::fillElectrons(edm::Event const& e, const unsigned int nVertex) {
181  edm::Handle<l1t::EGammaBxCollection> l1EGamma;
182  e.getByToken(stage2CaloLayer2EGammaToken_, l1EGamma);
183 
184  edm::Handle<reco::GsfElectronCollection> gsfElectrons;
185  e.getByToken(theGsfElectronCollection_, gsfElectrons);
186 
187  if (!gsfElectrons.isValid()) {
188  edm::LogWarning("L1TEGammaOffline") << "invalid collection: GSF electrons " << std::endl;
189  return;
190  }
191  if (gsfElectrons->empty()) {
192  LogDebug("L1TEGammaOffline") << "empty collection: GSF electrons " << std::endl;
193  return;
194  }
195  if (!l1EGamma.isValid()) {
196  edm::LogWarning("L1TEGammaOffline") << "invalid collection: L1 EGamma " << std::endl;
197  return;
198  }
199  if (!findTagAndProbePair(gsfElectrons)) {
200  LogDebug("L1TEGammaOffline") << "Could not find a tag & probe pair" << std::endl;
201  return; //continue to next event
202  }
203 
204  auto probeElectron = probeElectron_;
205 
206  // find corresponding L1 EG
207  double minDeltaR = maxDeltaRForL1Matching_;
208  l1t::EGamma closestL1EGamma;
209  bool foundMatch = false;
210 
211  int bunchCrossing = 0;
212  for (auto egamma = l1EGamma->begin(bunchCrossing); egamma != l1EGamma->end(bunchCrossing); ++egamma) {
213  double currentDeltaR = deltaR(egamma->eta(), egamma->phi(), probeElectron.eta(), probeElectron.phi());
214  if (currentDeltaR > minDeltaR) {
215  continue;
216  } else {
217  minDeltaR = currentDeltaR;
218  closestL1EGamma = *egamma;
219  foundMatch = true;
220  }
221  }
222 
223  if (!foundMatch) {
224  LogDebug("L1TEGammaOffline") << "Could not find a matching L1 EGamma " << std::endl;
225  return;
226  }
227 
228  double recoEt = probeElectron.et();
229  double recoEta = probeElectron.eta();
230  double recoPhi = probeElectron.phi();
231 
232  double l1Et = closestL1EGamma.et();
233  double l1Eta = closestL1EGamma.eta();
234  double l1Phi = closestL1EGamma.phi();
235 
236  // if no reco value, relative resolution does not make sense -> sort to overflow
237  double outOfBounds = 9999;
238  double resolutionEt = recoEt > 0 ? (l1Et - recoEt) / recoEt : outOfBounds;
239  double resolutionEta = l1Eta - recoEta;
240  double resolutionPhi = reco::deltaPhi(l1Phi, recoPhi);
241 
242  using namespace dqmoffline::l1t;
243  // eta
244  fill2DWithinLimits(h_L1EGammaEtavsElectronEta_, recoEta, l1Eta);
245  fillWithinLimits(h_resolutionElectronEta_, resolutionEta);
246 
247  // plots for deeper inspection
248  for (auto threshold : deepInspectionElectronThresholds_) {
249  if (recoEt > threshold * recoToL1TThresholdFactor_) {
250  fillWithinLimits(h_efficiencyElectronEta_total_[threshold], recoEta);
251  fillWithinLimits(h_efficiencyElectronPhi_total_[threshold], recoPhi);
252  fillWithinLimits(h_efficiencyElectronNVertex_total_[threshold], nVertex);
253  if (l1Et > threshold + probeToL1Offset_) {
254  fillWithinLimits(h_efficiencyElectronEta_pass_[threshold], recoEta);
255  fillWithinLimits(h_efficiencyElectronPhi_pass_[threshold], recoPhi);
256  fillWithinLimits(h_efficiencyElectronNVertex_pass_[threshold], nVertex);
257  }
258  }
259  }
260 
261  for (auto threshold : electronEfficiencyThresholds_) {
262  if (recoEt > threshold * recoToL1TThresholdFactor_) {
263  fill2DWithinLimits(h_efficiencyElectronPhi_vs_Eta_total_[threshold], recoEta, recoPhi);
264  if (l1Et > threshold + probeToL1Offset_) {
265  fill2DWithinLimits(h_efficiencyElectronPhi_vs_Eta_pass_[threshold], recoEta, recoPhi);
266  }
267  }
268  }
269 
270  if (std::abs(recoEta) <= 1.479) { // barrel
271  // et
272  fill2DWithinLimits(h_L1EGammaETvsElectronET_EB_, recoEt, l1Et);
273  fill2DWithinLimits(h_L1EGammaETvsElectronET_EB_EE_, recoEt, l1Et);
274  //resolution
275  fillWithinLimits(h_resolutionElectronET_EB_, resolutionEt);
276  fillWithinLimits(h_resolutionElectronET_EB_EE_, resolutionEt);
277  // phi
278  fill2DWithinLimits(h_L1EGammaPhivsElectronPhi_EB_, recoPhi, l1Phi);
279  fill2DWithinLimits(h_L1EGammaPhivsElectronPhi_EB_EE_, recoPhi, l1Phi);
280  // resolution
281  fillWithinLimits(h_resolutionElectronPhi_EB_, resolutionPhi);
282  fillWithinLimits(h_resolutionElectronPhi_EB_EE_, resolutionPhi);
283 
284  // turn-ons
285  for (auto threshold : electronEfficiencyThresholds_) {
286  fillWithinLimits(h_efficiencyElectronET_EB_total_[threshold], recoEt);
287  fillWithinLimits(h_efficiencyElectronET_EB_EE_total_[threshold], recoEt);
288  if (l1Et > threshold) {
289  fillWithinLimits(h_efficiencyElectronET_EB_pass_[threshold], recoEt);
290  fillWithinLimits(h_efficiencyElectronET_EB_EE_pass_[threshold], recoEt);
291  }
292  }
293  } else { // end-cap
294  // et
295  fill2DWithinLimits(h_L1EGammaETvsElectronET_EE_, recoEt, l1Et);
296  fill2DWithinLimits(h_L1EGammaETvsElectronET_EB_EE_, recoEt, l1Et);
297  //resolution
298  fillWithinLimits(h_resolutionElectronET_EE_, resolutionEt);
299  fillWithinLimits(h_resolutionElectronET_EB_EE_, resolutionEt);
300  // phi
301  fill2DWithinLimits(h_L1EGammaPhivsElectronPhi_EE_, recoPhi, l1Phi);
302  fill2DWithinLimits(h_L1EGammaPhivsElectronPhi_EB_EE_, recoPhi, l1Phi);
303  // resolution
304  fillWithinLimits(h_resolutionElectronPhi_EE_, resolutionPhi);
305  fillWithinLimits(h_resolutionElectronPhi_EB_EE_, resolutionPhi);
306 
307  // turn-ons
308  for (auto threshold : electronEfficiencyThresholds_) {
309  fillWithinLimits(h_efficiencyElectronET_EE_total_[threshold], recoEt);
310  fillWithinLimits(h_efficiencyElectronET_EB_EE_total_[threshold], recoEt);
311  if (l1Et > threshold) {
312  fillWithinLimits(h_efficiencyElectronET_EE_pass_[threshold], recoEt);
313  fillWithinLimits(h_efficiencyElectronET_EB_EE_pass_[threshold], recoEt);
314  }
315  }
316  }
317 }
318 
337 bool L1TEGammaOffline::findTagAndProbePair(edm::Handle<reco::GsfElectronCollection> const& electrons) {
338  bool foundBoth(false);
339  auto nElectrons = electrons->size();
340  if (nElectrons < 2)
341  return false;
342 
343  for (const auto& tagElectron : *electrons) {
344  for (const auto& probeElectron : *electrons) {
345  if (tagElectron.p4() == probeElectron.p4())
346  continue;
347 
348  auto combined(tagElectron.p4() + probeElectron.p4());
349  auto tagAbsEta = std::abs(tagElectron.eta());
350  auto probeAbsEta = std::abs(probeElectron.eta());
351 
352  // EB-EE transition region
353  bool isEBEEGap = tagElectron.isEBEEGap() || probeElectron.isEBEEGap();
354  bool passesEta = !isEBEEGap && tagAbsEta < 2.5 && probeAbsEta < 2.5;
355  bool passesCharge = tagElectron.charge() == -probeElectron.charge();
356 
357  // https://github.com/ikrav/cmssw/blob/egm_id_80X_v1/RecoEgamma/ElectronIdentification/plugins/cuts/GsfEleFull5x5SigmaIEtaIEtaCut.cc#L45
358  bool tagPassesMediumID = passesMediumEleId(tagElectron) && tagElectron.et() > 30.;
359  bool probePassesLooseID = passesLooseEleId(probeElectron);
360  bool passesInvariantMass = combined.M() > 60 && combined.M() < 120;
361  bool tagMatchesHLTObject = matchesAnHLTObject(tagElectron.eta(), tagElectron.phi());
362 
363  if (passesEta && passesInvariantMass && passesCharge && tagPassesMediumID && probePassesLooseID &&
364  tagMatchesHLTObject) {
365  foundBoth = true;
366  tagElectron_ = tagElectron;
367  probeElectron_ = probeElectron;
368  // plot tag & probe invariant mass
369  dqmoffline::l1t::fillWithinLimits(h_tagAndProbeMass_, combined.M());
370  return foundBoth;
371  }
372  }
373  }
374  return foundBoth;
375 }
376 
383 bool L1TEGammaOffline::passesLooseEleId(reco::GsfElectron const& electron) const {
384  const float ecal_energy_inverse = 1.0 / electron.ecalEnergy();
385  const float eSCoverP = electron.eSuperClusterOverP();
386  const float eOverP = std::abs(1.0 - eSCoverP) * ecal_energy_inverse;
387 
388  if (electron.isEB() && eOverP > 0.241)
389  return false;
390  if (electron.isEE() && eOverP > 0.14)
391  return false;
392  if (electron.isEB() && std::abs(electron.deltaEtaSuperClusterTrackAtVtx()) > 0.00477)
393  return false;
394  if (electron.isEE() && std::abs(electron.deltaEtaSuperClusterTrackAtVtx()) > 0.00868)
395  return false;
396  if (electron.isEB() && std::abs(electron.deltaPhiSuperClusterTrackAtVtx()) > 0.222)
397  return false;
398  if (electron.isEE() && std::abs(electron.deltaPhiSuperClusterTrackAtVtx()) > 0.213)
399  return false;
400  if (electron.isEB() && electron.scSigmaIEtaIEta() > 0.011)
401  return false;
402  if (electron.isEE() && electron.scSigmaIEtaIEta() > 0.0314)
403  return false;
404  if (electron.isEB() && electron.hadronicOverEm() > 0.298)
405  return false;
406  if (electron.isEE() && electron.hadronicOverEm() > 0.101)
407  return false;
408  return true;
409 }
410 
411 /*
412  * Structure from
413  * https://github.com/cms-sw/cmssw/blob/CMSSW_9_0_X/DQMOffline/EGamma/plugins/ElectronAnalyzer.cc
414  * Values from
415  * https://twiki.cern.ch/twiki/bin/view/CMS/CutBasedElectronIdentificationRun2
416  */
417 bool L1TEGammaOffline::passesMediumEleId(reco::GsfElectron const& electron) const {
418  const float ecal_energy_inverse = 1.0 / electron.ecalEnergy();
419  const float eSCoverP = electron.eSuperClusterOverP();
420  const float eOverP = std::abs(1.0 - eSCoverP) * ecal_energy_inverse;
421 
422  if (electron.isEB() && eOverP < 0.134)
423  return false;
424  if (electron.isEE() && eOverP > 0.13)
425  return false;
426  if (electron.isEB() && std::abs(electron.deltaEtaSuperClusterTrackAtVtx()) > 0.00311)
427  return false;
428  if (electron.isEE() && std::abs(electron.deltaEtaSuperClusterTrackAtVtx()) > 0.00609)
429  return false;
430  if (electron.isEB() && std::abs(electron.deltaPhiSuperClusterTrackAtVtx()) > 0.103)
431  return false;
432  if (electron.isEE() && std::abs(electron.deltaPhiSuperClusterTrackAtVtx()) > 0.045)
433  return false;
434  if (electron.isEB() && electron.scSigmaIEtaIEta() > 0.00998)
435  return false;
436  if (electron.isEE() && electron.scSigmaIEtaIEta() > 0.0298)
437  return false;
438  if (electron.isEB() && electron.hadronicOverEm() > 0.253)
439  return false;
440  if (electron.isEE() && electron.hadronicOverEm() > 0.0878)
441  return false;
442  return true;
443 }
444 
445 bool L1TEGammaOffline::matchesAnHLTObject(double eta, double phi) const {
446  // get HLT objects of fired triggers
447  using namespace dqmoffline::l1t;
448  std::vector<bool> results = getTriggerResults(triggerIndices_, triggerResults_);
449  std::vector<unsigned int> firedTriggers = getFiredTriggerIndices(triggerIndices_, results);
450  std::vector<edm::InputTag> hltFilters = getHLTFilters(firedTriggers, hltConfig_, triggerProcess_);
451  const trigger::TriggerObjectCollection hltObjects = getTriggerObjects(hltFilters, triggerEvent_);
452  const trigger::TriggerObjectCollection matchedObjects =
453  getMatchedTriggerObjects(eta, phi, maxDeltaRForHLTMatching_, hltObjects);
454 
455  return !matchedObjects.empty();
456 }
457 
458 void L1TEGammaOffline::fillPhotons(edm::Event const& e, const unsigned int nVertex) {
459  // TODO - just an example here
460  edm::Handle<l1t::EGammaBxCollection> l1EGamma;
461  e.getByToken(stage2CaloLayer2EGammaToken_, l1EGamma);
462 
463  edm::Handle<reco::PhotonCollection> photons;
464  e.getByToken(thePhotonCollection_, photons);
465 
466  if (!photons.isValid()) {
467  edm::LogWarning("L1TEGammaOffline") << "invalid collection: reco::Photons " << std::endl;
468  return;
469  }
470  if (!l1EGamma.isValid()) {
471  edm::LogWarning("L1TEGammaOffline") << "invalid collection: L1 EGamma " << std::endl;
472  return;
473  }
474 
475  if (photons->empty()) {
476  LogDebug("L1TEGammaOffline") << "No photons found in event." << std::endl;
477  return;
478  }
479 
480  auto probePhoton = photons->at(0);
481 
482  double minDeltaR = 0.3;
483  l1t::EGamma closestL1EGamma;
484  bool foundMatch = false;
485 
486  int bunchCrossing = 0;
487  for (auto egamma = l1EGamma->begin(bunchCrossing); egamma != l1EGamma->end(bunchCrossing); ++egamma) {
488  double currentDeltaR = deltaR(egamma->eta(), egamma->phi(), probePhoton.eta(), probePhoton.phi());
489  if (currentDeltaR > minDeltaR) {
490  continue;
491  } else {
492  minDeltaR = currentDeltaR;
493  closestL1EGamma = *egamma;
494  foundMatch = true;
495  }
496  }
497 
498  if (!foundMatch) {
499  LogDebug("L1TEGammaOffline") << "Could not find a matching L1 EGamma " << std::endl;
500  return;
501  }
502 
503  double recoEt = probePhoton.et();
504  double recoEta = probePhoton.eta();
505  double recoPhi = probePhoton.phi();
506 
507  double l1Et = closestL1EGamma.et();
508  double l1Eta = closestL1EGamma.eta();
509  double l1Phi = closestL1EGamma.phi();
510 
511  // if no reco value, relative resolution does not make sense -> sort to overflow
512  double outOfBounds = 9999;
513  double resolutionEt = recoEt > 0 ? (l1Et - recoEt) / recoEt : outOfBounds;
514  double resolutionEta = l1Eta - recoEta;
515  double resolutionPhi = reco::deltaPhi(l1Phi, recoPhi);
516 
517  using namespace dqmoffline::l1t;
518  // eta
519  fill2DWithinLimits(h_L1EGammaEtavsPhotonEta_, recoEta, l1Eta);
520  fillWithinLimits(h_resolutionPhotonEta_, resolutionEta);
521 
522  if (std::abs(recoEta) <= 1.479) { // barrel
523  // et
524  fill2DWithinLimits(h_L1EGammaETvsPhotonET_EB_, recoEt, l1Et);
525  fill2DWithinLimits(h_L1EGammaETvsPhotonET_EB_EE_, recoEt, l1Et);
526  //resolution
527  fillWithinLimits(h_resolutionPhotonET_EB_, resolutionEt);
528  fillWithinLimits(h_resolutionPhotonET_EB_EE_, resolutionEt);
529  // phi
530  fill2DWithinLimits(h_L1EGammaPhivsPhotonPhi_EB_, recoPhi, l1Phi);
531  fill2DWithinLimits(h_L1EGammaPhivsPhotonPhi_EB_EE_, recoPhi, l1Phi);
532  // resolution
533  fillWithinLimits(h_resolutionPhotonPhi_EB_, resolutionPhi);
534  fillWithinLimits(h_resolutionPhotonPhi_EB_EE_, resolutionPhi);
535 
536  // turn-ons
537  for (auto threshold : photonEfficiencyThresholds_) {
538  fillWithinLimits(h_efficiencyPhotonET_EB_total_[threshold], recoEt);
539  fillWithinLimits(h_efficiencyPhotonET_EB_EE_total_[threshold], recoEt);
540  if (l1Et > threshold) {
541  fillWithinLimits(h_efficiencyPhotonET_EB_pass_[threshold], recoEt);
542  fillWithinLimits(h_efficiencyPhotonET_EB_EE_pass_[threshold], recoEt);
543  }
544  }
545  } else { // end-cap
546  // et
547  fill2DWithinLimits(h_L1EGammaETvsPhotonET_EE_, recoEt, l1Et);
548  fill2DWithinLimits(h_L1EGammaETvsPhotonET_EB_EE_, recoEt, l1Et);
549  //resolution
550  fillWithinLimits(h_resolutionPhotonET_EE_, resolutionEt);
551  fillWithinLimits(h_resolutionPhotonET_EB_EE_, resolutionEt);
552  // phi
553  fill2DWithinLimits(h_L1EGammaPhivsPhotonPhi_EE_, recoPhi, l1Phi);
554  fill2DWithinLimits(h_L1EGammaPhivsPhotonPhi_EB_EE_, recoPhi, l1Phi);
555  // resolution
556  fillWithinLimits(h_resolutionPhotonPhi_EE_, resolutionPhi);
557  fillWithinLimits(h_resolutionPhotonPhi_EB_EE_, resolutionPhi);
558 
559  // turn-ons
560  for (auto threshold : photonEfficiencyThresholds_) {
561  fillWithinLimits(h_efficiencyPhotonET_EE_total_[threshold], recoEt);
562  fillWithinLimits(h_efficiencyPhotonET_EB_EE_total_[threshold], recoEt);
563  if (l1Et > threshold) {
564  fillWithinLimits(h_efficiencyPhotonET_EE_pass_[threshold], recoEt);
565  fillWithinLimits(h_efficiencyPhotonET_EB_EE_pass_[threshold], recoEt);
566  }
567  }
568  }
569 }
570 
571 //
572 // -------------------------------------- endRun --------------------------------------------
573 //
574 void L1TEGammaOffline::dqmEndRun(edm::Run const& run, edm::EventSetup const& eSetup) {
575  normalise2DHistogramsToBinArea();
576 }
577 
578 //
579 // -------------------------------------- book histograms --------------------------------------------
580 //
581 void L1TEGammaOffline::bookElectronHistos(DQMStore::IBooker& ibooker) {
582  ibooker.cd();
583  ibooker.setCurrentFolder(histFolder_);
584  // since there are endRun manipulations.
585  ibooker.setScope(MonitorElementData::Scope::RUN);
586 
587  dqmoffline::l1t::HistDefinition nVertexDef = histDefinitions_[PlotConfig::nVertex];
588  h_nVertex_ = ibooker.book1D(nVertexDef.name, nVertexDef.title, nVertexDef.nbinsX, nVertexDef.xmin, nVertexDef.xmax);
589  h_tagAndProbeMass_ = ibooker.book1D("tagAndProbeMass", "Invariant mass of tag & probe pair", 100, 40, 140);
590  // electron reco vs L1
591  dqmoffline::l1t::HistDefinition templateETvsET = histDefinitions_[PlotConfig::ETvsET];
592  h_L1EGammaETvsElectronET_EB_ =
593  ibooker.book2D("L1EGammaETvsElectronET_EB",
594  "L1 EGamma E_{T} vs GSF Electron E_{T} (EB); GSF Electron E_{T} (GeV); L1 EGamma E_{T} (GeV)",
595  templateETvsET.nbinsX,
596  &templateETvsET.binsX[0],
597  templateETvsET.nbinsY,
598  &templateETvsET.binsY[0]);
599  h_L1EGammaETvsElectronET_EE_ =
600  ibooker.book2D("L1EGammaETvsElectronET_EE",
601  "L1 EGamma E_{T} vs GSF Electron E_{T} (EE); GSF Electron E_{T} (GeV); L1 EGamma E_{T} (GeV)",
602  templateETvsET.nbinsX,
603  &templateETvsET.binsX[0],
604  templateETvsET.nbinsY,
605  &templateETvsET.binsY[0]);
606  h_L1EGammaETvsElectronET_EB_EE_ =
607  ibooker.book2D("L1EGammaETvsElectronET_EB_EE",
608  "L1 EGamma E_{T} vs GSF Electron E_{T} (EB+EE); GSF Electron E_{T} (GeV); L1 EGamma E_{T} (GeV)",
609  templateETvsET.nbinsX,
610  &templateETvsET.binsX[0],
611  templateETvsET.nbinsY,
612  &templateETvsET.binsY[0]);
613 
614  dqmoffline::l1t::HistDefinition templatePHIvsPHI = histDefinitions_[PlotConfig::PHIvsPHI];
615  h_L1EGammaPhivsElectronPhi_EB_ = ibooker.book2D(
616  "L1EGammaPhivsElectronPhi_EB",
617  "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EB); #phi_{electron}^{offline}; #phi_{electron}^{L1}",
618  templatePHIvsPHI.nbinsX,
619  templatePHIvsPHI.xmin,
620  templatePHIvsPHI.xmax,
621  templatePHIvsPHI.nbinsY,
622  templatePHIvsPHI.ymin,
623  templatePHIvsPHI.ymax);
624  h_L1EGammaPhivsElectronPhi_EE_ = ibooker.book2D(
625  "L1EGammaPhivsElectronPhi_EE",
626  "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EE); #phi_{electron}^{offline}; #phi_{electron}^{L1}",
627  templatePHIvsPHI.nbinsX,
628  templatePHIvsPHI.xmin,
629  templatePHIvsPHI.xmax,
630  templatePHIvsPHI.nbinsY,
631  templatePHIvsPHI.ymin,
632  templatePHIvsPHI.ymax);
633  h_L1EGammaPhivsElectronPhi_EB_EE_ = ibooker.book2D(
634  "L1EGammaPhivsElectronPhi_EB_EE",
635  "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EB+EE); #phi_{electron}^{offline}; #phi_{electron}^{L1}",
636  templatePHIvsPHI.nbinsX,
637  templatePHIvsPHI.xmin,
638  templatePHIvsPHI.xmax,
639  templatePHIvsPHI.nbinsY,
640  templatePHIvsPHI.ymin,
641  templatePHIvsPHI.ymax);
642 
643  h_L1EGammaEtavsElectronEta_ = ibooker.book2D("L1EGammaEtavsElectronEta",
644  "L1 EGamma #eta vs GSF Electron #eta; GSF Electron #eta; L1 EGamma #eta",
645  100,
646  -3,
647  3,
648  100,
649  -3,
650  3);
651 
652  // electron resolutions
653  h_resolutionElectronET_EB_ =
654  ibooker.book1D("resolutionElectronET_EB",
655  "electron ET resolution (EB); (L1 EGamma E_{T} - GSF Electron E_{T})/GSF Electron E_{T}; events",
656  50,
657  -1,
658  1.5);
659  h_resolutionElectronET_EE_ =
660  ibooker.book1D("resolutionElectronET_EE",
661  "electron ET resolution (EE); (L1 EGamma E_{T} - GSF Electron E_{T})/GSF Electron E_{T}; events",
662  50,
663  -1,
664  1.5);
665  h_resolutionElectronET_EB_EE_ = ibooker.book1D(
666  "resolutionElectronET_EB_EE",
667  "electron ET resolution (EB+EE); (L1 EGamma E_{T} - GSF Electron E_{T})/GSF Electron E_{T}; events",
668  50,
669  -1,
670  1.5);
671 
672  h_resolutionElectronPhi_EB_ =
673  ibooker.book1D("resolutionElectronPhi_EB",
674  "#phi_{electron} resolution (EB); #phi_{electron}^{L1} - #phi_{electron}^{offline}; events",
675  120,
676  -0.3,
677  0.3);
678  h_resolutionElectronPhi_EE_ =
679  ibooker.book1D("resolutionElectronPhi_EE",
680  "electron #phi resolution (EE); #phi_{electron}^{L1} - #phi_{electron}^{offline}; events",
681  120,
682  -0.3,
683  0.3);
684  h_resolutionElectronPhi_EB_EE_ =
685  ibooker.book1D("resolutionElectronPhi_EB_EE",
686  "electron #phi resolution (EB+EE); #phi_{electron}^{L1} - #phi_{electron}^{offline}; events",
687  120,
688  -0.3,
689  0.3);
690 
691  h_resolutionElectronEta_ =
692  ibooker.book1D("resolutionElectronEta",
693  "electron #eta resolution (EB); L1 EGamma #eta - GSF Electron #eta; events",
694  120,
695  -0.3,
696  0.3);
697 
698  // electron turn-ons
699  ibooker.setCurrentFolder(efficiencyFolder_);
700  std::vector<float> electronBins(electronEfficiencyBins_.begin(), electronEfficiencyBins_.end());
701  int nBins = electronBins.size() - 1;
702  float* electronBinArray = &(electronBins[0]);
703 
704  for (auto threshold : electronEfficiencyThresholds_) {
705  std::string str_threshold = std::to_string(int(threshold));
706  h_efficiencyElectronET_EB_pass_[threshold] =
707  ibooker.book1D("efficiencyElectronET_EB_threshold_" + str_threshold + "_Num",
708  "electron efficiency (EB) (numerator); GSF Electron E_{T} (GeV); events",
709  nBins,
710  electronBinArray);
711  h_efficiencyElectronET_EE_pass_[threshold] =
712  ibooker.book1D("efficiencyElectronET_EE_threshold_" + str_threshold + "_Num",
713  "electron efficiency (EE) (numerator); GSF Electron E_{T} (GeV); events",
714  nBins,
715  electronBinArray);
716  h_efficiencyElectronET_EB_EE_pass_[threshold] =
717  ibooker.book1D("efficiencyElectronET_EB_EE_threshold_" + str_threshold + "_Num",
718  "electron efficiency (EB+EE) (numerator); GSF Electron E_{T} (GeV); events",
719  nBins,
720  electronBinArray);
721  h_efficiencyElectronPhi_vs_Eta_pass_[threshold] =
722  ibooker.book2D("efficiencyElectronPhi_vs_Eta_threshold_" + str_threshold + "_Num",
723  "electron efficiency (numerator); GSF Electron #eta; GSF Electron #phi",
724  50,
725  -2.5,
726  2.5,
727  32,
728  -3.2,
729  3.2);
730 
731  h_efficiencyElectronET_EB_total_[threshold] =
732  ibooker.book1D("efficiencyElectronET_EB_threshold_" + str_threshold + "_Den",
733  "electron efficiency (EB) (denominator); GSF Electron E_{T} (GeV); events",
734  nBins,
735  electronBinArray);
736  h_efficiencyElectronET_EE_total_[threshold] =
737  ibooker.book1D("efficiencyElectronET_EE_threshold_" + str_threshold + "_Den",
738  "electron efficiency (EE) (denominator); GSF Electron E_{T} (GeV); events",
739  nBins,
740  electronBinArray);
741  h_efficiencyElectronET_EB_EE_total_[threshold] =
742  ibooker.book1D("efficiencyElectronET_EB_EE_threshold_" + str_threshold + "_Den",
743  "electron efficiency (EB+EE) (denominator); GSF Electron E_{T} (GeV); events",
744  nBins,
745  electronBinArray);
746  h_efficiencyElectronPhi_vs_Eta_total_[threshold] =
747  ibooker.book2D("efficiencyElectronPhi_vs_Eta_threshold_" + str_threshold + "_Den",
748  "electron efficiency (denominator); GSF Electron #eta; GSF Electron #phi",
749  50,
750  -2.5,
751  2.5,
752  32,
753  -3.2,
754  3.2);
755  }
756 
757  for (auto threshold : deepInspectionElectronThresholds_) {
758  std::string str_threshold = std::to_string(int(threshold));
759  h_efficiencyElectronEta_pass_[threshold] =
760  ibooker.book1D("efficiencyElectronEta_threshold_" + str_threshold + "_Num",
761  "electron efficiency (numerator); GSF Electron #eta; events",
762  50,
763  -2.5,
764  2.5);
765  h_efficiencyElectronPhi_pass_[threshold] =
766  ibooker.book1D("efficiencyElectronPhi_threshold_" + str_threshold + "_Num",
767  "electron efficiency (numerator); GSF Electron #phi; events",
768  32,
769  -3.2,
770  3.2);
771  h_efficiencyElectronNVertex_pass_[threshold] =
772  ibooker.book1D("efficiencyElectronNVertex_threshold_" + str_threshold + "_Num",
773  "electron efficiency (numerator); Nvtx; events",
774  30,
775  0,
776  60);
777 
778  h_efficiencyElectronEta_total_[threshold] =
779  ibooker.book1D("efficiencyElectronEta_threshold_" + str_threshold + "_Den",
780  "electron efficiency (denominator); GSF Electron #eta; events",
781  50,
782  -2.5,
783  2.5);
784  h_efficiencyElectronPhi_total_[threshold] =
785  ibooker.book1D("efficiencyElectronPhi_threshold_" + str_threshold + "_Den",
786  "electron efficiency (denominator); GSF Electron #phi; events",
787  32,
788  -3.2,
789  3.2);
790  h_efficiencyElectronNVertex_total_[threshold] =
791  ibooker.book1D("efficiencyElectronNVertex_threshold_" + str_threshold + "_Den",
792  "electron efficiency (denominator); Nvtx; events",
793  30,
794  0,
795  60);
796  }
797 
798  ibooker.cd();
799 }
800 
801 void L1TEGammaOffline::bookPhotonHistos(DQMStore::IBooker& ibooker) {
802  ibooker.cd();
803  ibooker.setCurrentFolder(histFolder_);
804 
805  dqmoffline::l1t::HistDefinition templateETvsET = histDefinitions_[PlotConfig::ETvsET];
806  h_L1EGammaETvsPhotonET_EB_ =
807  ibooker.book2D("L1EGammaETvsPhotonET_EB",
808  "L1 EGamma E_{T} vs Photon E_{T} (EB); Photon E_{T} (GeV); L1 EGamma E_{T} (GeV)",
809  templateETvsET.nbinsX,
810  &templateETvsET.binsX[0],
811  templateETvsET.nbinsY,
812  &templateETvsET.binsY[0]);
813  h_L1EGammaETvsPhotonET_EE_ =
814  ibooker.book2D("L1EGammaETvsPhotonET_EE",
815  "L1 EGamma E_{T} vs Photon E_{T} (EE); Photon E_{T} (GeV); L1 EGamma E_{T} (GeV)",
816  templateETvsET.nbinsX,
817  &templateETvsET.binsX[0],
818  templateETvsET.nbinsY,
819  &templateETvsET.binsY[0]);
820  h_L1EGammaETvsPhotonET_EB_EE_ =
821  ibooker.book2D("L1EGammaETvsPhotonET_EB_EE",
822  "L1 EGamma E_{T} vs Photon E_{T} (EB+EE); Photon E_{T} (GeV); L1 EGamma E_{T} (GeV)",
823  templateETvsET.nbinsX,
824  &templateETvsET.binsX[0],
825  templateETvsET.nbinsY,
826  &templateETvsET.binsY[0]);
827 
828  dqmoffline::l1t::HistDefinition templatePHIvsPHI = histDefinitions_[PlotConfig::PHIvsPHI];
829  h_L1EGammaPhivsPhotonPhi_EB_ =
830  ibooker.book2D("L1EGammaPhivsPhotonPhi_EB",
831  "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EB); #phi_{photon}^{offline}; #phi_{photon}^{L1}",
832  templatePHIvsPHI.nbinsX,
833  templatePHIvsPHI.xmin,
834  templatePHIvsPHI.xmax,
835  templatePHIvsPHI.nbinsY,
836  templatePHIvsPHI.ymin,
837  templatePHIvsPHI.ymax);
838  h_L1EGammaPhivsPhotonPhi_EE_ =
839  ibooker.book2D("L1EGammaPhivsPhotonPhi_EE",
840  "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EE); #phi_{photon}^{offline}; #phi_{photon}^{L1}",
841  templatePHIvsPHI.nbinsX,
842  templatePHIvsPHI.xmin,
843  templatePHIvsPHI.xmax,
844  templatePHIvsPHI.nbinsY,
845  templatePHIvsPHI.ymin,
846  templatePHIvsPHI.ymax);
847  h_L1EGammaPhivsPhotonPhi_EB_EE_ = ibooker.book2D(
848  "L1EGammaPhivsPhotonPhi_EB_EE",
849  "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EB+EE); #phi_{photon}^{offline}; #phi_{photon}^{L1}",
850  templatePHIvsPHI.nbinsX,
851  templatePHIvsPHI.xmin,
852  templatePHIvsPHI.xmax,
853  templatePHIvsPHI.nbinsY,
854  templatePHIvsPHI.ymin,
855  templatePHIvsPHI.ymax);
856 
857  h_L1EGammaEtavsPhotonEta_ = ibooker.book2D(
858  "L1EGammaEtavsPhotonEta", "L1 EGamma #eta vs Photon #eta; Photon #eta; L1 EGamma #eta", 100, -3, 3, 100, -3, 3);
859 
860  // photon resolutions
861  h_resolutionPhotonET_EB_ =
862  ibooker.book1D("resolutionPhotonET_EB",
863  "photon ET resolution (EB); (L1 EGamma E_{T} - Photon E_{T})/ Photon E_{T}; events",
864  50,
865  -1,
866  1.5);
867  h_resolutionPhotonET_EE_ =
868  ibooker.book1D("resolutionPhotonET_EE",
869  "photon ET resolution (EE); (L1 EGamma E_{T} - Photon E_{T})/ Photon E_{T}; events",
870  50,
871  -1,
872  1.5);
873  h_resolutionPhotonET_EB_EE_ =
874  ibooker.book1D("resolutionPhotonET_EB_EE",
875  "photon ET resolution (EB+EE); (L1 EGamma E_{T} - Photon E_{T})/ Photon E_{T}; events",
876  50,
877  -1,
878  1.5);
879 
880  h_resolutionPhotonPhi_EB_ =
881  ibooker.book1D("resolutionPhotonPhi_EB",
882  "#phi_{photon} resolution (EB); #phi_{photon}^{L1} - #phi_{photon}^{offline}; events",
883  120,
884  -0.3,
885  0.3);
886  h_resolutionPhotonPhi_EE_ =
887  ibooker.book1D("resolutionPhotonPhi_EE",
888  "photon #phi resolution (EE); #phi_{photon}^{L1} - #phi_{photon}^{offline}; events",
889  120,
890  -0.3,
891  0.3);
892  h_resolutionPhotonPhi_EB_EE_ =
893  ibooker.book1D("resolutionPhotonPhi_EB_EE",
894  "photon #phi resolution (EB+EE); #phi_{photon}^{L1} - #phi_{photon}^{offline}; events",
895  120,
896  -0.3,
897  0.3);
898 
899  h_resolutionPhotonEta_ = ibooker.book1D(
900  "resolutionPhotonEta", "photon #eta resolution (EB); L1 EGamma #eta - Photon #eta; events", 120, -0.3, 0.3);
901 
902  // photon turn-ons
903  ibooker.setCurrentFolder(efficiencyFolder_);
904  std::vector<float> photonBins(photonEfficiencyBins_.begin(), photonEfficiencyBins_.end());
905  int nBins = photonBins.size() - 1;
906  float* photonBinArray = &(photonBins[0]);
907 
908  for (auto threshold : photonEfficiencyThresholds_) {
909  std::string str_threshold = std::to_string(int(threshold));
910  h_efficiencyPhotonET_EB_pass_[threshold] =
911  ibooker.book1D("efficiencyPhotonET_EB_threshold_" + str_threshold + "_Num",
912  "photon efficiency (EB) (numerator); Photon E_{T} (GeV); events",
913  nBins,
914  photonBinArray);
915  h_efficiencyPhotonET_EE_pass_[threshold] =
916  ibooker.book1D("efficiencyPhotonET_EE_threshold_" + str_threshold + "_Num",
917  "photon efficiency (EE) (numerator); Photon E_{T} (GeV); events",
918  nBins,
919  photonBinArray);
920  h_efficiencyPhotonET_EB_EE_pass_[threshold] =
921  ibooker.book1D("efficiencyPhotonET_EB_EE_threshold_" + str_threshold + "_Num",
922  "photon efficiency (EB+EE) (numerator); Photon E_{T} (GeV); events",
923  nBins,
924  photonBinArray);
925 
926  h_efficiencyPhotonET_EB_total_[threshold] =
927  ibooker.book1D("efficiencyPhotonET_EB_threshold_" + str_threshold + "_Den",
928  "photon efficiency (EB) (denominator); Photon E_{T} (GeV); events",
929  nBins,
930  photonBinArray);
931  h_efficiencyPhotonET_EE_total_[threshold] =
932  ibooker.book1D("efficiencyPhotonET_EE_threshold_" + str_threshold + "_Den",
933  "photon efficiency (EE) (denominator); Photon E_{T} (GeV); events",
934  nBins,
935  photonBinArray);
936  h_efficiencyPhotonET_EB_EE_total_[threshold] =
937  ibooker.book1D("efficiencyPhotonET_EB_EE_threshold_" + str_threshold + "_Den",
938  "photon efficiency (EB+EE) (denominator); Photon E_{T} (GeV); events",
939  nBins,
940  photonBinArray);
941  }
942 
943  ibooker.cd();
944 }
945 
946 void L1TEGammaOffline::normalise2DHistogramsToBinArea() {
947  std::vector<MonitorElement*> monElementstoNormalize = {h_L1EGammaETvsElectronET_EB_,
948  h_L1EGammaETvsElectronET_EE_,
949  h_L1EGammaETvsElectronET_EB_EE_,
950  h_L1EGammaPhivsElectronPhi_EB_,
951  h_L1EGammaPhivsElectronPhi_EE_,
952  h_L1EGammaPhivsElectronPhi_EB_EE_,
953  h_L1EGammaEtavsElectronEta_,
954  h_L1EGammaETvsPhotonET_EB_,
955  h_L1EGammaETvsPhotonET_EE_,
956  h_L1EGammaETvsPhotonET_EB_EE_,
957  h_L1EGammaPhivsPhotonPhi_EB_,
958  h_L1EGammaPhivsPhotonPhi_EE_,
959  h_L1EGammaPhivsPhotonPhi_EB_EE_,
960  h_L1EGammaEtavsPhotonEta_};
961 
962  for (auto mon : monElementstoNormalize) {
963  if (mon != nullptr) {
964  auto h = mon->getTH2F();
965  if (h != nullptr) {
966  h->Scale(1, "width");
967  }
968  }
969  }
970 }
971 
972 //define this as a plug-in
973 DEFINE_FWK_MODULE(L1TEGammaOffline);
dqmoffline::l1t::HistDefinition::ymax
double ymax
Definition: HistDefinition.h:69
L1TEGammaOffline::fillPhotons
void fillPhotons(edm::Event const &e, const unsigned int nVertex)
Definition: L1TEGammaOffline.cc:458
EgHLTOffHistBins_cfi.eOverP
eOverP
Definition: EgHLTOffHistBins_cfi.py:37
dqmoffline::l1t::readHistDefinitions
HistDefinitions readHistDefinitions(const edm::ParameterSet &ps, const std::map< std::string, unsigned int > &mapping)
Definition: HistDefinition.cc:29
L1TEGammaOffline::theGsfElectronCollection_
edm::EDGetTokenT< reco::GsfElectronCollection > theGsfElectronCollection_
Definition: L1TEGammaOffline.h:74
L1TEGammaOffline::efficiencyFolder_
std::string efficiencyFolder_
Definition: L1TEGammaOffline.h:83
L1TEGammaOffline::L1TEGammaOffline
L1TEGammaOffline(const edm::ParameterSet &ps)
Definition: L1TEGammaOffline.cc:28
L1TEGammaOffline::dqmEndRun
void dqmEndRun(edm::Run const &run, edm::EventSetup const &eSetup) override
Definition: L1TEGammaOffline.cc:574
L1TEGammaOffline::passesMediumEleId
bool passesMediumEleId(reco::GsfElectron const &electron) const
Definition: L1TEGammaOffline.cc:417
L1TEGammaOffline::h_resolutionElectronET_EE_
MonitorElement * h_resolutionElectronET_EE_
Definition: L1TEGammaOffline.h:127
L1TEGammaOffline::h_L1EGammaETvsPhotonET_EE_
MonitorElement * h_L1EGammaETvsPhotonET_EE_
Definition: L1TEGammaOffline.h:159
MessageLogger.h
L1TEGammaOffline::electronEfficiencyBins_
std::vector< double > electronEfficiencyBins_
Definition: L1TEGammaOffline.h:88
dqmoffline::l1t::HistDefinition::ymin
double ymin
Definition: HistDefinition.h:68
L1TEGammaOffline::h_L1EGammaETvsElectronET_EB_EE_
MonitorElement * h_L1EGammaETvsElectronET_EB_EE_
Definition: L1TEGammaOffline.h:117
L1TEGammaOffline::triggerEvent_
trigger::TriggerEvent triggerEvent_
Definition: L1TEGammaOffline.h:106
L1TEGammaOffline::h_efficiencyPhotonET_EB_pass_
std::map< double, MonitorElement * > h_efficiencyPhotonET_EB_pass_
Definition: L1TEGammaOffline.h:180
dqm::implementation::IBooker::setScope
virtual MonitorElementData::Scope setScope(MonitorElementData::Scope newscope)
Definition: DQMStore.cc:46
L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EB_
MonitorElement * h_L1EGammaPhivsPhotonPhi_EB_
Definition: L1TEGammaOffline.h:162
L1TEGammaOffline::nVertex
Definition: L1TEGammaOffline.h:43
align::BeamSpot
Definition: StructureType.h:95
dqmoffline::l1t::HistDefinition::xmin
double xmin
Definition: HistDefinition.h:66
L1TEGammaOffline::h_L1EGammaETvsPhotonET_EB_
MonitorElement * h_L1EGammaETvsPhotonET_EB_
Definition: L1TEGammaOffline.h:158
edm::Run
Definition: Run.h:45
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
custom_jme_cff.nElectrons
nElectrons
Definition: custom_jme_cff.py:149
deltaPhi.h
L1TEGammaOffline.h
L1TEGammaOffline::h_L1EGammaEtavsElectronEta_
MonitorElement * h_L1EGammaEtavsElectronEta_
Definition: L1TEGammaOffline.h:123
L1TEGammaOffline::triggerResults_
edm::TriggerResults triggerResults_
Definition: L1TEGammaOffline.h:105
edm
HLT enums.
Definition: AlignableModifier.h:19
L1TEGammaOffline::photonEfficiencyBins_
std::vector< double > photonEfficiencyBins_
Definition: L1TEGammaOffline.h:93
dqmoffline::l1t::HistDefinition::name
std::string name
Definition: HistDefinition.h:62
L1TEGammaOffline::h_L1EGammaETvsPhotonET_EB_EE_
MonitorElement * h_L1EGammaETvsPhotonET_EB_EE_
Definition: L1TEGammaOffline.h:160
L1TEGammaOffline::dqmBeginRun
void dqmBeginRun(edm::Run const &, edm::EventSetup const &) override
Definition: L1TEGammaOffline.cc:117
L1TEGammaOffline::bookPhotonHistos
void bookPhotonHistos(DQMStore::IBooker &)
Definition: L1TEGammaOffline.cc:801
L1TEGammaOffline::h_resolutionElectronPhi_EB_EE_
MonitorElement * h_resolutionElectronPhi_EB_EE_
Definition: L1TEGammaOffline.h:132
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89301
L1TEGammaOffline::h_tagAndProbeMass_
MonitorElement * h_tagAndProbeMass_
Definition: L1TEGammaOffline.h:112
dqmoffline::l1t::getTriggerIndices
std::vector< unsigned int > getTriggerIndices(const std::vector< std::string > &requestedTriggers, const std::vector< std::string > &triggersInEvent)
Definition: L1TCommon.cc:10
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
L1TEGammaOffline::h_resolutionPhotonET_EB_EE_
MonitorElement * h_resolutionPhotonET_EB_EE_
Definition: L1TEGammaOffline.h:171
L1TEGammaOffline::h_L1EGammaEtavsPhotonEta_
MonitorElement * h_L1EGammaEtavsPhotonEta_
Definition: L1TEGammaOffline.h:166
dqmoffline::l1t::HistDefinition::binsY
std::vector< float > binsY
Definition: HistDefinition.h:73
L1TEGammaOffline::h_efficiencyPhotonET_EB_EE_total_
std::map< double, MonitorElement * > h_efficiencyPhotonET_EB_EE_total_
Definition: L1TEGammaOffline.h:188
L1TEGammaOffline::h_resolutionPhotonET_EE_
MonitorElement * h_resolutionPhotonET_EE_
Definition: L1TEGammaOffline.h:170
L1TCommon.h
L1TEGammaOffline::h_efficiencyPhotonET_EB_EE_pass_
std::map< double, MonitorElement * > h_efficiencyPhotonET_EB_EE_pass_
Definition: L1TEGammaOffline.h:182
L1TEGammaOffline::analyze
void analyze(edm::Event const &e, edm::EventSetup const &eSetup) override
Definition: L1TEGammaOffline.cc:143
L1TEGammaOffline::h_resolutionPhotonPhi_EE_
MonitorElement * h_resolutionPhotonPhi_EE_
Definition: L1TEGammaOffline.h:174
bookConverter.results
results
Definition: bookConverter.py:144
L1TEGammaOffline::h_resolutionElectronET_EB_
MonitorElement * h_resolutionElectronET_EB_
Definition: L1TEGammaOffline.h:126
PhotonFwd.h
L1TEGammaOffline::h_efficiencyElectronEta_pass_
std::map< double, MonitorElement * > h_efficiencyElectronEta_pass_
Definition: L1TEGammaOffline.h:142
L1TEGammaOffline::fillElectrons
void fillElectrons(edm::Event const &e, const unsigned int nVertex)
Definition: L1TEGammaOffline.cc:180
L1TEGammaOffline::h_efficiencyPhotonET_EE_total_
std::map< double, MonitorElement * > h_efficiencyPhotonET_EE_total_
Definition: L1TEGammaOffline.h:187
reco::GsfElectronCollection
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
Definition: GsfElectronFwd.h:14
L1TEGammaOffline::h_efficiencyElectronPhi_pass_
std::map< double, MonitorElement * > h_efficiencyElectronPhi_pass_
Definition: L1TEGammaOffline.h:143
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:46
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
L1TEGammaOffline_cfi.PHIvsPHI
PHIvsPHI
Definition: L1TEGammaOffline_cfi.py:62
dqmoffline::l1t::HistDefinition::binsX
std::vector< float > binsX
Definition: HistDefinition.h:72
electronIsolatorFromEffectiveArea_cfi.gsfElectrons
gsfElectrons
Definition: electronIsolatorFromEffectiveArea_cfi.py:4
edm::Handle< edm::TriggerResults >
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
L1TEGammaOffline::thePhotonCollection_
edm::EDGetTokenT< std::vector< reco::Photon > > thePhotonCollection_
Definition: L1TEGammaOffline.h:75
L1TEGammaOffline::bookElectronHistos
void bookElectronHistos(DQMStore::IBooker &)
Definition: L1TEGammaOffline.cc:581
L1TEGammaOffline::h_efficiencyElectronET_EB_EE_pass_
std::map< double, MonitorElement * > h_efficiencyElectronET_EB_EE_pass_
Definition: L1TEGammaOffline.h:139
L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EE_
MonitorElement * h_L1EGammaPhivsElectronPhi_EE_
Definition: L1TEGammaOffline.h:120
dqmoffline::l1t
Definition: HistDefinition.h:49
L1TEGammaOffline::h_L1EGammaETvsElectronET_EB_
MonitorElement * h_L1EGammaETvsElectronET_EB_
Definition: L1TEGammaOffline.h:115
MakerMacros.h
h
L1TEGammaOffline::h_efficiencyElectronNVertex_total_
std::map< double, MonitorElement * > h_efficiencyElectronNVertex_total_
Definition: L1TEGammaOffline.h:155
dqmoffline::l1t::getTriggerObjects
trigger::TriggerObjectCollection getTriggerObjects(const std::vector< edm::InputTag > &hltFilters, const trigger::TriggerEvent &triggerEvent)
Definition: L1TCommon.cc:75
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
dqmoffline::l1t::HistDefinition::nbinsX
unsigned int nbinsX
Definition: HistDefinition.h:64
L1TEGammaOffline::h_efficiencyElectronET_EB_total_
std::map< double, MonitorElement * > h_efficiencyElectronET_EB_total_
Definition: L1TEGammaOffline.h:148
L1TEGammaOffline::stage2CaloLayer2EGammaToken_
edm::EDGetTokenT< l1t::EGammaBxCollection > stage2CaloLayer2EGammaToken_
Definition: L1TEGammaOffline.h:85
L1TEGammaOffline::maxDeltaRForHLTMatching_
double maxDeltaRForHLTMatching_
Definition: L1TEGammaOffline.h:96
L1TEGammaOffline::maxDeltaRForL1Matching_
double maxDeltaRForL1Matching_
Definition: L1TEGammaOffline.h:95
PVValHelper::eta
Definition: PVValidationHelpers.h:70
L1TEGammaOffline::h_efficiencyElectronPhi_vs_Eta_total_
std::map< double, MonitorElement * > h_efficiencyElectronPhi_vs_Eta_total_
Definition: L1TEGammaOffline.h:151
L1TEGammaOffline::triggerNames_
std::vector< std::string > triggerNames_
Definition: L1TEGammaOffline.h:81
dqmoffline::l1t::HistDefinition::xmax
double xmax
Definition: HistDefinition.h:67
dqmoffline::l1t::passesAnyTriggerFromList
bool passesAnyTriggerFromList(const std::vector< unsigned int > &triggers, const edm::TriggerResults &triggerResults)
Definition: L1TCommon.cc:66
L1TEGammaOffline::h_efficiencyElectronPhi_vs_Eta_pass_
std::map< double, MonitorElement * > h_efficiencyElectronPhi_vs_Eta_pass_
Definition: L1TEGammaOffline.h:140
dqmoffline::l1t::getTriggerResults
std::vector< bool > getTriggerResults(const std::vector< unsigned int > &triggers, const edm::TriggerResults &triggerResults)
Definition: L1TCommon.cc:34
dqm::implementation::NavigatorBase::cd
virtual void cd()
Definition: DQMStore.cc:29
L1TEGammaOffline::normalise2DHistogramsToBinArea
void normalise2DHistogramsToBinArea()
Definition: L1TEGammaOffline.cc:946
L1TEGammaOffline::histFolder_
std::string histFolder_
Definition: L1TEGammaOffline.h:82
seedmultiplicitymonitor_newtracking_cfi.nBins
nBins
Definition: seedmultiplicitymonitor_newtracking_cfi.py:8
reco::GsfElectron
Definition: GsfElectron.h:35
dqmoffline::l1t::getHLTFilters
std::vector< edm::InputTag > getHLTFilters(const std::vector< unsigned int > &triggers, const HLTConfigProvider &hltConfig, const std::string triggerProcess)
Definition: L1TCommon.cc:99
L1TEGammaOffline::matchesAnHLTObject
bool matchesAnHLTObject(double eta, double phi) const
Definition: L1TEGammaOffline.cc:445
BXVector::begin
const_iterator begin(int bx) const
L1TEGammaOffline::PlotConfigNames
static const std::map< std::string, unsigned int > PlotConfigNames
Definition: L1TEGammaOffline.h:45
L1TEGammaOffline::h_resolutionElectronEta_
MonitorElement * h_resolutionElectronEta_
Definition: L1TEGammaOffline.h:134
LaserDQM_cfi.mon
mon
Definition: LaserDQM_cfi.py:3
commonCuts_cff.triggerResults_
triggerResults_
Definition: commonCuts_cff.py:17
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
L1TEGammaOffline::tagElectron_
reco::GsfElectron tagElectron_
Definition: L1TEGammaOffline.h:99
L1TEGammaOffline::passesLooseEleId
bool passesLooseEleId(reco::GsfElectron const &electron) const
Definition: L1TEGammaOffline.cc:383
l1t::EGammaBxCollection
BXVector< EGamma > EGammaBxCollection
Definition: EGamma.h:10
L1TFillWithinLimits.h
L1TEGammaOffline::triggerProcess_
std::string triggerProcess_
Definition: L1TEGammaOffline.h:80
BXVector::end
const_iterator end(int bx) const
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
edm::ParameterSet
Definition: ParameterSet.h:47
L1TEGammaOffline::h_efficiencyElectronET_EB_pass_
std::map< double, MonitorElement * > h_efficiencyElectronET_EB_pass_
Definition: L1TEGammaOffline.h:137
L1TEGammaOffline::h_resolutionPhotonEta_
MonitorElement * h_resolutionPhotonEta_
Definition: L1TEGammaOffline.h:177
L1TEGammaOffline::deepInspectionElectronThresholds_
std::vector< double > deepInspectionElectronThresholds_
Definition: L1TEGammaOffline.h:90
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:152
deltaR.h
dqmoffline::l1t::fillWithinLimits
void fillWithinLimits(MonitorElement *mon, double value, double weight=1.)
Definition: L1TFillWithinLimits.cc:12
l1t
delete x;
Definition: CaloConfig.h:22
dqmoffline
Definition: HistDefinition.h:48
trigger::TriggerObjectCollection
std::vector< TriggerObject > TriggerObjectCollection
collection of trigger physics objects (e.g., all isolated muons)
Definition: TriggerObject.h:75
dqmoffline::l1t::getFiredTriggerIndices
std::vector< unsigned int > getFiredTriggerIndices(const std::vector< unsigned int > &triggers, const std::vector< bool > &triggerResults)
Definition: L1TCommon.cc:54
HLT_FULL_cff.minDeltaR
minDeltaR
Definition: HLT_FULL_cff.py:26296
L1TEGammaOffline::triggerInputTag_
edm::EDGetTokenT< trigger::TriggerEvent > triggerInputTag_
Definition: L1TEGammaOffline.h:78
LorentzVector.h
Photon
Definition: Photon.py:1
L1TEGammaOffline::hltConfig_
HLTConfigProvider hltConfig_
Definition: L1TEGammaOffline.h:103
dqmoffline::l1t::fill2DWithinLimits
void fill2DWithinLimits(MonitorElement *mon, double valueX, double valueY, double weight=1.)
Definition: L1TFillWithinLimits.cc:19
L1TEGammaOffline::h_resolutionPhotonET_EB_
MonitorElement * h_resolutionPhotonET_EB_
Definition: L1TEGammaOffline.h:169
L1TEGammaOffline::photonEfficiencyThresholds_
std::vector< double > photonEfficiencyThresholds_
Definition: L1TEGammaOffline.h:92
trackerHitRTTI::vector
Definition: trackerHitRTTI.h:21
L1TEGammaOffline::h_efficiencyPhotonET_EB_total_
std::map< double, MonitorElement * > h_efficiencyPhotonET_EB_total_
Definition: L1TEGammaOffline.h:186
BPHMonitor_cfi.photons
photons
Definition: BPHMonitor_cfi.py:91
L1TEGammaOffline::h_efficiencyElectronET_EE_pass_
std::map< double, MonitorElement * > h_efficiencyElectronET_EE_pass_
Definition: L1TEGammaOffline.h:138
l1t::EGamma
Definition: EGamma.h:20
dqmoffline::l1t::HistDefinition
Definition: HistDefinition.h:54
L1TEGammaOffline::probeElectron_
reco::GsfElectron probeElectron_
Definition: L1TEGammaOffline.h:100
edm::EventSetup
Definition: EventSetup.h:58
L1TEGammaOffline::h_nVertex_
MonitorElement * h_nVertex_
Definition: L1TEGammaOffline.h:111
dqmoffline::l1t::getMatchedTriggerObjects
trigger::TriggerObjectCollection getMatchedTriggerObjects(double eta, double phi, double maxDeltaR, const trigger::TriggerObjectCollection triggerObjects)
Definition: L1TCommon.cc:114
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
HPSPFTauProducerPuppi_cfi.electron
electron
Definition: HPSPFTauProducerPuppi_cfi.py:13
L1TEGammaOffline::findTagAndProbePair
bool findTagAndProbePair(edm::Handle< reco::GsfElectronCollection > const &electrons)
Definition: L1TEGammaOffline.cc:337
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLTMuonOfflineAnalyzer_cfi.resolutionEta
resolutionEta
Definition: HLTMuonOfflineAnalyzer_cfi.py:108
L1TEGammaOffline::triggerResultsInputTag_
edm::EDGetTokenT< edm::TriggerResults > triggerResultsInputTag_
Definition: L1TEGammaOffline.h:79
dqmoffline::l1t::HistDefinition::nbinsY
unsigned int nbinsY
Definition: HistDefinition.h:65
egamma
Definition: ConversionFinder.h:29
L1TEGammaOffline::h_resolutionPhotonPhi_EB_EE_
MonitorElement * h_resolutionPhotonPhi_EB_EE_
Definition: L1TEGammaOffline.h:175
DDAxes::phi
L1TEGammaOffline::h_efficiencyElectronET_EB_EE_total_
std::map< double, MonitorElement * > h_efficiencyElectronET_EB_EE_total_
Definition: L1TEGammaOffline.h:150
reco::LeafCandidate::et
double et() const final
transverse energy
Definition: LeafCandidate.h:127
L1TEGammaOffline::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: L1TEGammaOffline.cc:132
L1TEGammaOffline::h_efficiencyElectronET_EE_total_
std::map< double, MonitorElement * > h_efficiencyElectronET_EE_total_
Definition: L1TEGammaOffline.h:149
edm::getParameterSet
ParameterSet const & getParameterSet(ParameterSetID const &id)
Definition: ParameterSet.cc:862
L1TEGammaOffline
Definition: L1TEGammaOffline.h:38
std
Definition: JetResolutionObject.h:76
writedatasetfile.run
run
Definition: writedatasetfile.py:27
L1TEGammaOffline::triggerIndices_
std::vector< unsigned int > triggerIndices_
Definition: L1TEGammaOffline.h:104
HLTConfigProvider::init
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
d'tor
Definition: HLTConfigProvider.cc:36
reco::LeafCandidate::phi
double phi() const final
momentum azimuthal angle
Definition: LeafCandidate.h:148
L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EB_EE_
MonitorElement * h_L1EGammaPhivsPhotonPhi_EB_EE_
Definition: L1TEGammaOffline.h:164
dqmoffline::l1t::HistDefinition::title
std::string title
Definition: HistDefinition.h:63
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
L1TEGammaOffline::electronEfficiencyThresholds_
std::vector< double > electronEfficiencyThresholds_
Definition: L1TEGammaOffline.h:87
L1TEGammaOffline::probeToL1Offset_
double probeToL1Offset_
Definition: L1TEGammaOffline.h:89
L1TEGammaOffline::h_efficiencyElectronPhi_total_
std::map< double, MonitorElement * > h_efficiencyElectronPhi_total_
Definition: L1TEGammaOffline.h:154
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
L1TEGammaOffline::h_efficiencyPhotonET_EE_pass_
std::map< double, MonitorElement * > h_efficiencyPhotonET_EE_pass_
Definition: L1TEGammaOffline.h:181
l1t::VertexCollection
std::vector< Vertex > VertexCollection
Definition: Vertex.h:12
L1TEGammaOffline::h_resolutionElectronPhi_EE_
MonitorElement * h_resolutionElectronPhi_EE_
Definition: L1TEGammaOffline.h:131
L1TEGammaOffline::h_resolutionPhotonPhi_EB_
MonitorElement * h_resolutionPhotonPhi_EB_
Definition: L1TEGammaOffline.h:173
L1TEGammaOffline::h_L1EGammaETvsElectronET_EE_
MonitorElement * h_L1EGammaETvsElectronET_EE_
Definition: L1TEGammaOffline.h:116
dqm::implementation::IBooker
Definition: DQMStore.h:43
L1TEGammaOffline::thePVCollection_
edm::EDGetTokenT< reco::VertexCollection > thePVCollection_
Definition: L1TEGammaOffline.h:76
trigger
Definition: HLTPrescaleTableCond.h:8
L1TEGammaOffline_cfi.nVertex
nVertex
Definition: L1TEGammaOffline_cfi.py:60
L1TEGammaOffline::h_resolutionElectronET_EB_EE_
MonitorElement * h_resolutionElectronET_EB_EE_
Definition: L1TEGammaOffline.h:128
L1TEGammaOffline::h_efficiencyElectronEta_total_
std::map< double, MonitorElement * > h_efficiencyElectronEta_total_
Definition: L1TEGammaOffline.h:153
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
L1TEGammaOffline::h_resolutionElectronPhi_EB_
MonitorElement * h_resolutionElectronPhi_EB_
Definition: L1TEGammaOffline.h:130
L1TEGammaOffline::h_efficiencyElectronNVertex_pass_
std::map< double, MonitorElement * > h_efficiencyElectronNVertex_pass_
Definition: L1TEGammaOffline.h:144
L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EB_
MonitorElement * h_L1EGammaPhivsElectronPhi_EB_
Definition: L1TEGammaOffline.h:119
HLTConfigProvider::triggerNames
const std::vector< std::string > & triggerNames() const
names of trigger paths
Definition: HLTConfigProvider.h:69
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
remoteMonitoring_LED_IterMethod_cfg.threshold
threshold
Definition: remoteMonitoring_LED_IterMethod_cfg.py:430
HLTObjectsMonitor_cfi.TriggerResults
TriggerResults
Definition: HLTObjectsMonitor_cfi.py:9
L1TEGammaOffline_cfi.ETvsET
ETvsET
Definition: L1TEGammaOffline_cfi.py:61
edm::Event
Definition: Event.h:73
L1TEGammaOffline::~L1TEGammaOffline
~L1TEGammaOffline() override
Definition: L1TEGammaOffline.cc:110
L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EE_
MonitorElement * h_L1EGammaPhivsPhotonPhi_EE_
Definition: L1TEGammaOffline.h:163
L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EB_EE_
MonitorElement * h_L1EGammaPhivsElectronPhi_EB_EE_
Definition: L1TEGammaOffline.h:121
L1TEGammaOffline::recoToL1TThresholdFactor_
double recoToL1TThresholdFactor_
Definition: L1TEGammaOffline.h:97
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
ZCounting_cff.TriggerEvent
TriggerEvent
Definition: ZCounting_cff.py:5
HLTMuonOfflineAnalyzer_cfi.resolutionPhi
resolutionPhi
Definition: HLTMuonOfflineAnalyzer_cfi.py:109
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
L1TEGammaOffline::histDefinitions_
dqmoffline::l1t::HistDefinitions histDefinitions_
Definition: L1TEGammaOffline.h:107
Generated for CMSSW Reference Manual by doxygen 1.8.16