CMS 3D CMS Logo
ZCounting.cc
Go to the documentation of this file.
1 #include "FWCore/Framework/interface/Event.h"
2 #include "FWCore/Common/interface/TriggerNames.h"
3 #include "FWCore/Utilities/interface/RegexMatch.h"
4 #include "DataFormats/Common/interface/Handle.h"
5 #include "DataFormats/Common/interface/TriggerResults.h"
6 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
7 #include "DataFormats/VertexReco/interface/Vertex.h"
8 #include "DataFormats/MuonReco/interface/Muon.h"
9 #include "DataFormats/MuonReco/interface/MuonSelectors.h"
10 
11 #include "DQMOffline/Lumi/interface/TriggerDefs.h"
12 #include "DQMOffline/Lumi/interface/TTrigger.h"
13 #include "DQMOffline/Lumi/interface/TriggerTools.h"
14 
15 #include <TLorentzVector.h>
16 
17 #include <memory>
18 
19 #include "DQMOffline/Lumi/plugins/ZCounting.h"
20 
21 using namespace ZCountingTrigger;
22 
23 //
24 // -------------------------------------- Constructor --------------------------------------------
25 //
26 ZCounting::ZCounting(const edm::ParameterSet& iConfig)
27  : fHLTObjTag(iConfig.getParameter<edm::InputTag>("TriggerEvent")),
28  fHLTTag(iConfig.getParameter<edm::InputTag>("TriggerResults")),
29  fPVName(iConfig.getUntrackedParameter<std::string>("edmPVName", "offlinePrimaryVertices")),
30  fMuonName(iConfig.getUntrackedParameter<std::string>("edmName", "muons")),
31  fTrackName(iConfig.getUntrackedParameter<std::string>("edmTrackName", "generalTracks")),
32 
33  // Electron-specific Parameters
34  fElectronName(iConfig.getUntrackedParameter<std::string>("edmGsfEleName", "gedGsfElectrons")),
35  fSCName(iConfig.getUntrackedParameter<std::string>("edmSCName", "particleFlowEGamma")),
36 
37  // Electron-specific Tags
38  fRhoTag(iConfig.getParameter<edm::InputTag>("rhoname")),
39  fBeamspotTag(iConfig.getParameter<edm::InputTag>("beamspotName")),
40  fConversionTag(iConfig.getParameter<edm::InputTag>("conversionsName")),
41 
42  // Electron-specific Cuts
43  ELE_PT_CUT_TAG(iConfig.getUntrackedParameter<double>("PtCutEleTag")),
44  ELE_PT_CUT_PROBE(iConfig.getUntrackedParameter<double>("PtCutEleProbe")),
45  ELE_ETA_CUT_TAG(iConfig.getUntrackedParameter<double>("EtaCutEleTag")),
46  ELE_ETA_CUT_PROBE(iConfig.getUntrackedParameter<double>("EtaCutEleProbe")),
47 
48  ELE_MASS_CUT_LOW(iConfig.getUntrackedParameter<double>("MassCutEleLow")),
49  ELE_MASS_CUT_HIGH(iConfig.getUntrackedParameter<double>("MassCutEleHigh")),
50 
51  ELE_ID_WP(iConfig.getUntrackedParameter<std::string>("ElectronIDType", "TIGHT")),
52  EleID_(ElectronIdentifier(iConfig)) {
53  edm::LogInfo("ZCounting") << "Constructor ZCounting::ZCounting " << std::endl;
54 
55  //Get parameters from configuration file
56  fHLTTag_token = consumes<edm::TriggerResults>(fHLTTag);
57  fHLTObjTag_token = consumes<trigger::TriggerEvent>(fHLTObjTag);
58  fPVName_token = consumes<reco::VertexCollection>(fPVName);
59  fMuonName_token = consumes<reco::MuonCollection>(fMuonName);
60  fTrackName_token = consumes<reco::TrackCollection>(fTrackName);
61 
62  // Trigger-specific Parameters
63  fMuonHLTNames = iConfig.getParameter<std::vector<std::string>>("MuonTriggerNames");
64  fMuonHLTObjectNames = iConfig.getParameter<std::vector<std::string>>("MuonTriggerObjectNames");
65  if (fMuonHLTNames.size() != fMuonHLTObjectNames.size()) {
66  edm::LogError("ZCounting") << "List of MuonTriggerNames and MuonTriggerObjectNames has to be the same length"
67  << std::endl;
68  }
69 
70  // Electron-specific parameters
71  fGsfElectronName_token = consumes<edm::View<reco::GsfElectron>>(fElectronName);
72  fSCName_token = consumes<edm::View<reco::SuperCluster>>(fSCName);
73  fRhoToken = consumes<double>(fRhoTag);
74  fBeamspotToken = consumes<reco::BeamSpot>(fBeamspotTag);
75  fConversionToken = consumes<reco::ConversionCollection>(fConversionTag);
76 
77  // Muon-specific Cuts
78  IDTypestr_ = iConfig.getUntrackedParameter<std::string>("IDType");
79  IsoTypestr_ = iConfig.getUntrackedParameter<std::string>("IsoType");
80  IsoCut_ = iConfig.getUntrackedParameter<double>("IsoCut");
81 
82  if (IDTypestr_ == "Loose")
83  IDType_ = LooseID;
84  else if (IDTypestr_ == "Medium")
85  IDType_ = MediumID;
86  else if (IDTypestr_ == "Tight")
87  IDType_ = TightID;
88  else
89  IDType_ = NoneID;
90 
91  if (IsoTypestr_ == "Tracker-based")
92  IsoType_ = TrackerIso;
93  else if (IsoTypestr_ == "PF-based")
94  IsoType_ = PFIso;
95  else
96  IsoType_ = NoneIso;
97 
98  PtCutL1_ = iConfig.getUntrackedParameter<double>("PtCutL1");
99  PtCutL2_ = iConfig.getUntrackedParameter<double>("PtCutL2");
100  EtaCutL1_ = iConfig.getUntrackedParameter<double>("EtaCutL1");
101  EtaCutL2_ = iConfig.getUntrackedParameter<double>("EtaCutL2");
102 
103  MassBin_ = iConfig.getUntrackedParameter<int>("MassBin");
104  MassMin_ = iConfig.getUntrackedParameter<double>("MassMin");
105  MassMax_ = iConfig.getUntrackedParameter<double>("MassMax");
106 
107  LumiBin_ = iConfig.getUntrackedParameter<int>("LumiBin");
108  LumiMin_ = iConfig.getUntrackedParameter<double>("LumiMin");
109  LumiMax_ = iConfig.getUntrackedParameter<double>("LumiMax");
110 
111  PVBin_ = iConfig.getUntrackedParameter<int>("PVBin");
112  PVMin_ = iConfig.getUntrackedParameter<double>("PVMin");
113  PVMax_ = iConfig.getUntrackedParameter<double>("PVMax");
114 
115  VtxNTracksFitCut_ = iConfig.getUntrackedParameter<double>("VtxNTracksFitMin");
116  VtxNdofCut_ = iConfig.getUntrackedParameter<double>("VtxNdofMin");
117  VtxAbsZCut_ = iConfig.getUntrackedParameter<double>("VtxAbsZMax");
118  VtxRhoCut_ = iConfig.getUntrackedParameter<double>("VtxRhoMax");
119 
120  EleID_.setID(ELE_ID_WP);
121 }
122 
123 //
124 // -------------------------------------- Destructor --------------------------------------------
125 //
126 ZCounting::~ZCounting() { edm::LogInfo("ZCounting") << "Destructor ZCounting::~ZCounting " << std::endl; }
127 
128 //
129 // -------------------------------------- beginRun --------------------------------------------
130 //
131 void ZCounting::dqmBeginRun(edm::Run const&, edm::EventSetup const&) {
132  edm::LogInfo("ZCounting") << "ZCounting::beginRun" << std::endl;
133 
134  // Triggers
135  fTrigger = std::make_unique<ZCountingTrigger::TTrigger>(fMuonHLTNames, fMuonHLTObjectNames);
136 }
137 //
138 // -------------------------------------- bookHistos --------------------------------------------
139 //
140 void ZCounting::bookHistograms(DQMStore::IBooker& ibooker_, edm::Run const&, edm::EventSetup const&) {
141  edm::LogInfo("ZCounting") << "ZCounting::bookHistograms" << std::endl;
142  ibooker_.cd();
143  ibooker_.setCurrentFolder("ZCounting/Histograms");
144 
145  // Muon histograms
146  h_mass_HLT_pass_central = ibooker_.book2D("h_mass_HLT_pass_central",
147  "Muon HLT passing probes central",
148  LumiBin_,
149  LumiMin_,
150  LumiMax_,
151  MassBin_,
152  MassMin_,
153  MassMax_);
154  h_mass_HLT_pass_forward = ibooker_.book2D("h_mass_HLT_pass_forward",
155  "Muon HLT passing probes forward",
156  LumiBin_,
157  LumiMin_,
158  LumiMax_,
159  MassBin_,
160  MassMin_,
161  MassMax_);
162  h_mass_HLT_fail_central = ibooker_.book2D("h_mass_HLT_fail_central",
163  "Muon HLT failing probes central",
164  LumiBin_,
165  LumiMin_,
166  LumiMax_,
167  MassBin_,
168  MassMin_,
169  MassMax_);
170  h_mass_HLT_fail_forward = ibooker_.book2D("h_mass_HLT_fail_forward",
171  "Muon HLT failing probes forward",
172  LumiBin_,
173  LumiMin_,
174  LumiMax_,
175  MassBin_,
176  MassMin_,
177  MassMax_);
178 
179  h_mass_SIT_pass_central = ibooker_.book2D("h_mass_SIT_pass_central",
180  "Muon SIT passing probes central",
181  LumiBin_,
182  LumiMin_,
183  LumiMax_,
184  MassBin_,
185  MassMin_,
186  MassMax_);
187  h_mass_SIT_pass_forward = ibooker_.book2D("h_mass_SIT_pass_forward",
188  "Muon SIT passing probes forward",
189  LumiBin_,
190  LumiMin_,
191  LumiMax_,
192  MassBin_,
193  MassMin_,
194  MassMax_);
195  h_mass_SIT_fail_central = ibooker_.book2D("h_mass_SIT_fail_central",
196  "Muon SIT_failing probes central",
197  LumiBin_,
198  LumiMin_,
199  LumiMax_,
200  MassBin_,
201  MassMin_,
202  MassMax_);
203  h_mass_SIT_fail_forward = ibooker_.book2D("h_mass_SIT_fail_forward",
204  "Muon SIT failing probes forward",
205  LumiBin_,
206  LumiMin_,
207  LumiMax_,
208  MassBin_,
209  MassMin_,
210  MassMax_);
211 
212  h_mass_Glo_pass_central = ibooker_.book2D("h_mass_Glo_pass_central",
213  "Muon Glo passing probes central",
214  LumiBin_,
215  LumiMin_,
216  LumiMax_,
217  MassBin_,
218  MassMin_,
219  MassMax_);
220  h_mass_Glo_pass_forward = ibooker_.book2D("h_mass_Glo_pass_forward",
221  "Muon Glo passing probes forward",
222  LumiBin_,
223  LumiMin_,
224  LumiMax_,
225  MassBin_,
226  MassMin_,
227  MassMax_);
228  h_mass_Glo_fail_central = ibooker_.book2D("h_mass_Glo_fail_central",
229  "Muon Glo failing probes central",
230  LumiBin_,
231  LumiMin_,
232  LumiMax_,
233  MassBin_,
234  MassMin_,
235  MassMax_);
236  h_mass_Glo_fail_forward = ibooker_.book2D("h_mass_Glo_fail_forward",
237  "Muon Glo failing probes forward",
238  LumiBin_,
239  LumiMin_,
240  LumiMax_,
241  MassBin_,
242  MassMin_,
243  MassMax_);
244 
245  h_npv = ibooker_.book2D(
246  "h_npv", "Events with valid primary vertex", LumiBin_, LumiMin_, LumiMax_, PVBin_, PVMin_, PVMax_);
247  h_mass_yield_Z = ibooker_.book2D(
248  "h_mass_yield_Z", "reconstructed Z bosons", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
249  h_npv_yield_Z =
250  ibooker_.book2D("h_npv_yield_Z", "reconstructed Z bosons", LumiBin_, LumiMin_, LumiMax_, PVBin_, PVMin_, PVMax_);
251  h_yieldBB_Z = ibooker_.book1D("h_yieldBB_Z", "reconstructed Z bosons in barrel", LumiBin_, LumiMin_, LumiMax_);
252  h_yieldEE_Z = ibooker_.book1D("h_yieldEE_Z", "reconstructed Z bosons in endcap", LumiBin_, LumiMin_, LumiMax_);
253 
254  // Axis titles
255  h_mass_HLT_pass_central->setAxisTitle("luminosiry section", 1);
256  h_mass_HLT_pass_forward->setAxisTitle("luminosiry section", 1);
257  h_mass_HLT_fail_central->setAxisTitle("luminosiry section", 1);
258  h_mass_HLT_fail_forward->setAxisTitle("luminosiry section", 1);
259  h_mass_SIT_pass_central->setAxisTitle("luminosiry section", 1);
260  h_mass_SIT_pass_forward->setAxisTitle("luminosiry section", 1);
261  h_mass_SIT_fail_central->setAxisTitle("luminosiry section", 1);
262  h_mass_SIT_fail_forward->setAxisTitle("luminosiry section", 1);
263  h_mass_Glo_pass_central->setAxisTitle("luminosiry section", 1);
264  h_mass_Glo_pass_forward->setAxisTitle("luminosiry section", 1);
265  h_mass_Glo_fail_central->setAxisTitle("luminosiry section", 1);
266  h_mass_Glo_fail_forward->setAxisTitle("luminosiry section", 1);
267  h_mass_HLT_pass_central->setAxisTitle("tag and probe mass", 2);
268  h_mass_HLT_pass_forward->setAxisTitle("tag and probe mass", 2);
269  h_mass_HLT_fail_central->setAxisTitle("tag and probe mass", 2);
270  h_mass_HLT_fail_forward->setAxisTitle("tag and probe mass", 2);
271  h_mass_SIT_pass_central->setAxisTitle("tag and probe mass", 2);
272  h_mass_SIT_pass_forward->setAxisTitle("tag and probe mass", 2);
273  h_mass_SIT_fail_central->setAxisTitle("tag and probe mass", 2);
274  h_mass_SIT_fail_forward->setAxisTitle("tag and probe mass", 2);
275  h_mass_Glo_pass_central->setAxisTitle("tag and probe mass", 2);
276  h_mass_Glo_pass_forward->setAxisTitle("tag and probe mass", 2);
277  h_mass_Glo_fail_central->setAxisTitle("tag and probe mass", 2);
278  h_mass_Glo_fail_forward->setAxisTitle("tag and probe mass", 2);
279  h_npv->setAxisTitle("luminosity section", 1);
280  h_npv->setAxisTitle("number of primary vertices", 2);
281  h_npv_yield_Z->setAxisTitle("luminosiry section", 1);
282  h_npv_yield_Z->setAxisTitle("number of primary vertices", 2);
283  h_mass_yield_Z->setAxisTitle("luminosiry section", 1);
284  h_mass_yield_Z->setAxisTitle("tag and probe mass", 2);
285 
286  h_yieldBB_Z->setAxisTitle("luminosiry section", 1);
287  h_yieldEE_Z->setAxisTitle("luminosiry section", 1);
288 
289  /*
290  // Electron histograms
291  h_ee_mass_id_pass_central = ibooker_.book2D("h_ee_mass_id_pass_central", "h_ee_mass_id_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
292  h_ee_mass_id_fail_central = ibooker_.book2D("h_ee_mass_id_fail_central", "h_ee_mass_id_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
293  h_ee_mass_id_pass_forward = ibooker_.book2D("h_ee_mass_id_pass_forward", "h_ee_mass_id_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
294  h_ee_mass_id_fail_forward = ibooker_.book2D("h_ee_mass_id_fail_forward", "h_ee_mass_id_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
295 
296  h_ee_mass_HLT_pass_central = ibooker_.book2D("h_ee_mass_HLT_pass_central", "h_ee_mass_HLT_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
297  h_ee_mass_HLT_fail_central = ibooker_.book2D("h_ee_mass_HLT_fail_central", "h_ee_mass_HLT_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
298  h_ee_mass_HLT_pass_forward = ibooker_.book2D("h_ee_mass_HLT_pass_forward", "h_ee_mass_HLT_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
299  h_ee_mass_HLT_fail_forward = ibooker_.book2D("h_ee_mass_HLT_fail_forward", "h_ee_mass_HLT_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
300 
301  h_ee_yield_Z_ebeb = ibooker_.book1D("h_ee_yield_Z_ebeb", "h_ee_yield_Z_ebeb", LumiBin_, LumiMin_, LumiMax_);
302  h_ee_yield_Z_ebee = ibooker_.book1D("h_ee_yield_Z_ebee", "h_ee_yield_Z_ebee", LumiBin_, LumiMin_, LumiMax_);
303  h_ee_yield_Z_eeee = ibooker_.book1D("h_ee_yield_Z_eeee", "h_ee_yield_Z_eeee", LumiBin_, LumiMin_, LumiMax_);*/
304 }
305 
306 //
307 // -------------------------------------- Analyze --------------------------------------------
308 //
309 //--------------------------------------------------------------------------------------------------
310 void ZCounting::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { // Fill event tree on the fly
311  edm::LogInfo("ZCounting") << "ZCounting::analyze" << std::endl;
312  analyzeMuons(iEvent, iSetup);
313  //analyzeElectrons(iEvent, iSetup);
314 }
315 
316 void ZCounting::analyzeMuons(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
317  edm::LogInfo("ZCounting") << "ZCounting::analyzeMuons" << std::endl;
318  //-------------------------------
319  //--- Vertex
320  //-------------------------------
321  edm::Handle<reco::VertexCollection> hVertexProduct;
322  iEvent.getByToken(fPVName_token, hVertexProduct);
323  if (!hVertexProduct.isValid()) {
324  edm::LogWarning("ZCounting") << "ZCounting::analyzeMuons - no valid primary vertex product found" << std::endl;
325  return;
326  }
327  const reco::VertexCollection* pvCol = hVertexProduct.product();
328  const reco::Vertex* pv = &(*pvCol->begin());
329  int nvtx = 0;
330 
331  for (auto const& itVtx : *hVertexProduct) {
332  if (itVtx.isFake())
333  continue;
334  if (itVtx.tracksSize() < VtxNTracksFitCut_)
335  continue;
336  if (itVtx.ndof() < VtxNdofCut_)
337  continue;
338  if (fabs(itVtx.z()) > VtxAbsZCut_)
339  continue;
340  if (itVtx.position().Rho() > VtxRhoCut_)
341  continue;
342 
343  if (nvtx == 0) {
344  pv = &itVtx;
345  }
346  nvtx++;
347  }
348 
349  h_npv->Fill(iEvent.luminosityBlock(), nvtx);
350 
351  // Good vertex requirement
352  if (nvtx == 0)
353  return;
354 
355  //-------------------------------
356  //--- Trigger
357  //-------------------------------
358  edm::Handle<edm::TriggerResults> hTrgRes;
359  iEvent.getByToken(fHLTTag_token, hTrgRes);
360  if (!hTrgRes.isValid())
361  return;
362 
363  edm::Handle<trigger::TriggerEvent> hTrgEvt;
364  iEvent.getByToken(fHLTObjTag_token, hTrgEvt);
365 
366  const edm::TriggerNames& triggerNames = iEvent.triggerNames(*hTrgRes);
367  bool config_changed = false;
368  if (fTriggerNamesID != triggerNames.parameterSetID()) {
369  fTriggerNamesID = triggerNames.parameterSetID();
370  config_changed = true;
371  }
372  if (config_changed) {
373  initHLT(*hTrgRes, triggerNames);
374  }
375 
376  TriggerBits triggerBits;
377  for (unsigned int irec = 0; irec < fTrigger->fRecords.size(); irec++) {
378  if (fTrigger->fRecords[irec].hltPathIndex == (unsigned int)-1)
379  continue;
380  if (hTrgRes->accept(fTrigger->fRecords[irec].hltPathIndex)) {
381  triggerBits[fTrigger->fRecords[irec].baconTrigBit] = true;
382  }
383  }
384  //if(fSkipOnHLTFail && triggerBits == 0) return;
385 
386  // Trigger requirement
387  if (!isMuonTrigger(*fTrigger, triggerBits))
388  return;
389 
390  //-------------------------------
391  //--- Muons and Tracks
392  //-------------------------------
393  edm::Handle<reco::MuonCollection> hMuonProduct;
394  iEvent.getByToken(fMuonName_token, hMuonProduct);
395  if (!hMuonProduct.isValid())
396  return;
397 
398  edm::Handle<reco::TrackCollection> hTrackProduct;
399  iEvent.getByToken(fTrackName_token, hTrackProduct);
400  if (!hTrackProduct.isValid())
401  return;
402 
403  TLorentzVector vTag(0., 0., 0., 0.);
404  TLorentzVector vProbe(0., 0., 0., 0.);
405  TLorentzVector vTrack(0., 0., 0., 0.);
406 
407  // Tag loop
408  for (auto const& itMu1 : *hMuonProduct) {
409  float pt1 = itMu1.muonBestTrack()->pt();
410  float eta1 = itMu1.muonBestTrack()->eta();
411  float phi1 = itMu1.muonBestTrack()->phi();
412  float q1 = itMu1.muonBestTrack()->charge();
413 
414  // Tag selection: kinematic cuts, lepton selection and trigger matching
415  if (pt1 < PtCutL1_)
416  continue;
417  if (fabs(eta1) > EtaCutL1_)
418  continue;
419  if (!(passMuonID(itMu1, *pv, IDType_) && passMuonIso(itMu1, IsoType_, IsoCut_)))
420  continue;
421  if (!isMuonTriggerObj(*fTrigger, TriggerTools::matchHLT(eta1, phi1, fTrigger->fRecords, *hTrgEvt)))
422  continue;
423 
424  vTag.SetPtEtaPhiM(pt1, eta1, phi1, MUON_MASS);
425 
426  // Probe loop over muons
427  for (auto const& itMu2 : *hMuonProduct) {
428  if (&itMu2 == &itMu1)
429  continue;
430 
431  float pt2 = itMu2.muonBestTrack()->pt();
432  float eta2 = itMu2.muonBestTrack()->eta();
433  float phi2 = itMu2.muonBestTrack()->phi();
434  float q2 = itMu2.muonBestTrack()->charge();
435 
436  // Probe selection: kinematic cuts and opposite charge requirement
437  if (pt2 < PtCutL2_)
438  continue;
439  if (fabs(eta2) > EtaCutL2_)
440  continue;
441  if (q1 == q2)
442  continue;
443 
444  vProbe.SetPtEtaPhiM(pt2, eta2, phi2, MUON_MASS);
445 
446  // Mass window
447  TLorentzVector vDilep = vTag + vProbe;
448  float dilepMass = vDilep.M();
449  if ((dilepMass < MassMin_) || (dilepMass > MassMax_))
450  continue;
451 
452  bool isTagCentral = false;
453  bool isProbeCentral = false;
454  if (fabs(eta1) < MUON_BOUND)
455  isTagCentral = true;
456  if (fabs(eta2) < MUON_BOUND)
457  isProbeCentral = true;
458 
459  // Determine event category for efficiency calculation
460  if (passMuonID(itMu2, *pv, IDType_) && passMuonIso(itMu2, IsoType_, IsoCut_)) {
461  if (isMuonTriggerObj(*fTrigger, TriggerTools::matchHLT(eta2, phi2, fTrigger->fRecords, *hTrgEvt))) {
462  // category 2HLT: both muons passing trigger requirements
463  if (&itMu1 > &itMu2)
464  continue; // make sure we don't double count MuMu2HLT category
465 
466  // Fill twice for each event, since both muons pass trigger
467  if (isTagCentral) {
468  h_mass_HLT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
469  h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
470  h_mass_Glo_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
471  } else {
472  h_mass_HLT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
473  h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
474  h_mass_Glo_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
475  }
476 
477  if (isProbeCentral) {
478  h_mass_HLT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
479  h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
480  h_mass_Glo_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
481  } else {
482  h_mass_HLT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
483  h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
484  h_mass_Glo_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
485  }
486 
487  } else {
488  // category 1HLT: probe passing selection but not trigger
489  if (isProbeCentral) {
490  h_mass_HLT_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
491  h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
492  h_mass_Glo_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
493  } else {
494  h_mass_HLT_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
495  h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
496  h_mass_Glo_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
497  }
498  }
499  // category 2HLT + 1HLT: Fill once for Z yield
500  h_npv_yield_Z->Fill(iEvent.luminosityBlock(), nvtx);
501  h_mass_yield_Z->Fill(iEvent.luminosityBlock(), dilepMass);
502  if (isTagCentral && isProbeCentral)
503  h_yieldBB_Z->Fill(iEvent.luminosityBlock());
504  else if (!isTagCentral && !isProbeCentral)
505  h_yieldEE_Z->Fill(iEvent.luminosityBlock());
506  } else if (itMu2.isGlobalMuon()) {
507  // category Glo: probe is a Global muon but failing selection
508  if (isProbeCentral) {
509  h_mass_SIT_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
510  h_mass_Glo_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
511  } else {
512  h_mass_SIT_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
513  h_mass_Glo_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
514  }
515  } else if (itMu2.isStandAloneMuon()) {
516  // category Sta: probe is a Standalone muon
517  if (isProbeCentral) {
518  h_mass_Glo_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
519  } else {
520  h_mass_Glo_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
521  }
522  } else if (itMu2.innerTrack()->hitPattern().trackerLayersWithMeasurement() >= 6 &&
523  itMu2.innerTrack()->hitPattern().numberOfValidPixelHits() >= 1) {
524  // cateogry Trk: probe is a tracker track
525  if (isProbeCentral) {
526  h_mass_Glo_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
527  } else {
528  h_mass_Glo_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
529  }
530  }
531 
532  } // End of probe loop over muons
533 
534  // Probe loop over tracks, only for standalone efficiency calculation
535  for (auto const& itTrk : *hTrackProduct) {
536  // Check track is not a muon
537  bool isMuon = false;
538  for (auto const& itMu : *hMuonProduct) {
539  if (itMu.innerTrack().isNonnull() && itMu.innerTrack().get() == &itTrk) {
540  isMuon = true;
541  break;
542  }
543  }
544  if (isMuon)
545  continue;
546 
547  float pt2 = itTrk.pt();
548  float eta2 = itTrk.eta();
549  float phi2 = itTrk.phi();
550  float q2 = itTrk.charge();
551 
552  // Probe selection: kinematic cuts and opposite charge requirement
553  if (pt2 < PtCutL2_)
554  continue;
555  if (fabs(eta2) > EtaCutL2_)
556  continue;
557  if (q1 == q2)
558  continue;
559 
560  vTrack.SetPtEtaPhiM(pt2, eta2, phi2, MUON_MASS);
561 
562  TLorentzVector vDilep = vTag + vTrack;
563  float dilepMass = vDilep.M();
564  if ((dilepMass < MassMin_) || (dilepMass > MassMax_))
565  continue;
566 
567  bool isTrackCentral = false;
568  if (fabs(eta2) > MUON_BOUND)
569  isTrackCentral = true;
570 
571  if (itTrk.hitPattern().trackerLayersWithMeasurement() >= 6 && itTrk.hitPattern().numberOfValidPixelHits() >= 1) {
572  if (isTrackCentral)
573  h_mass_Glo_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
574  else
575  h_mass_Glo_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
576  }
577 
578  } //End of probe loop over tracks
579 
580  } //End of tag loop
581 }
582 void ZCounting::analyzeElectrons(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
583  edm::LogInfo("ZCounting") << "ZCounting::analyzeElectrons" << std::endl;
584 
585  //-------------------------------
586  //--- Vertex
587  //-------------------------------
588  edm::Handle<reco::VertexCollection> hVertexProduct;
589  iEvent.getByToken(fPVName_token, hVertexProduct);
590  if (!hVertexProduct.isValid())
591  return;
592 
593  const reco::VertexCollection* pvCol = hVertexProduct.product();
594  int nvtx = 0;
595 
596  for (auto const& vtx : *pvCol) {
597  if (vtx.isFake())
598  continue;
599  if (vtx.tracksSize() < VtxNTracksFitCut_)
600  continue;
601  if (vtx.ndof() < VtxNdofCut_)
602  continue;
603  if (fabs(vtx.z()) > VtxAbsZCut_)
604  continue;
605  if (vtx.position().Rho() > VtxRhoCut_)
606  continue;
607 
608  nvtx++;
609  }
610 
611  // Good vertex requirement
612  if (nvtx == 0)
613  return;
614 
615  //-------------------------------
616  //--- Trigger
617  //-------------------------------
618  edm::Handle<edm::TriggerResults> hTrgRes;
619  iEvent.getByToken(fHLTTag_token, hTrgRes);
620  if (!hTrgRes.isValid())
621  return;
622 
623  edm::Handle<trigger::TriggerEvent> hTrgEvt;
624  iEvent.getByToken(fHLTObjTag_token, hTrgEvt);
625 
626  const edm::TriggerNames& triggerNames = iEvent.triggerNames(*hTrgRes);
627  Bool_t config_changed = false;
628  if (fTriggerNamesID != triggerNames.parameterSetID()) {
629  fTriggerNamesID = triggerNames.parameterSetID();
630  config_changed = true;
631  }
632  if (config_changed) {
633  initHLT(*hTrgRes, triggerNames);
634  }
635 
636  TriggerBits triggerBits;
637  for (unsigned int irec = 0; irec < fTrigger->fRecords.size(); irec++) {
638  if (fTrigger->fRecords[irec].hltPathIndex == (unsigned int)-1)
639  continue;
640  if (hTrgRes->accept(fTrigger->fRecords[irec].hltPathIndex)) {
641  triggerBits[fTrigger->fRecords[irec].baconTrigBit] = true;
642  }
643  }
644 
645  // Trigger requirement
646  if (!isElectronTrigger(*fTrigger, triggerBits))
647  return;
648 
649  // Get Electrons
650  edm::Handle<edm::View<reco::GsfElectron>> electrons;
651  iEvent.getByToken(fGsfElectronName_token, electrons);
652 
653  // Get SuperClusters
654  edm::Handle<edm::View<reco::SuperCluster>> superclusters;
655  iEvent.getByToken(fSCName_token, superclusters);
656 
657  // Get Rho
658  edm::Handle<double> rhoHandle;
659  iEvent.getByToken(fRhoToken, rhoHandle);
660  EleID_.setRho(*rhoHandle);
661 
662  // Get beamspot
663  edm::Handle<reco::BeamSpot> beamspotHandle;
664  iEvent.getByToken(fBeamspotToken, beamspotHandle);
665 
666  // Conversions
667  edm::Handle<reco::ConversionCollection> conversionsHandle;
668  iEvent.getByToken(fConversionToken, conversionsHandle);
669 
670  edm::Ptr<reco::GsfElectron> eleProbe;
671  enum { eEleEle2HLT = 1, eEleEle1HLT1L1, eEleEle1HLT, eEleEleNoSel, eEleSC }; // event category enum
672 
673  // Loop over Tags
674  for (size_t itag = 0; itag < electrons->size(); ++itag) {
675  const auto el1 = electrons->ptrAt(itag);
676  if (not EleID_.passID(el1, beamspotHandle, conversionsHandle))
677  continue;
678 
679  float pt1 = el1->pt();
680  float eta1 = el1->eta();
681  float phi1 = el1->phi();
682 
683  if (!isElectronTriggerObj(*fTrigger, TriggerTools::matchHLT(eta1, phi1, fTrigger->fRecords, *hTrgEvt)))
684  continue;
685  TLorentzVector vTag(0., 0., 0., 0.);
686  vTag.SetPtEtaPhiM(pt1, eta1, phi1, ELECTRON_MASS);
687 
688  // Tag selection: kinematic cuts, lepton selection and trigger matching
689  double tag_pt = vTag.Pt();
690  double tag_abseta = fabs(vTag.Eta());
691 
692  bool tag_is_valid_tag = ele_tag_selection(tag_pt, tag_abseta);
693  bool tag_is_valid_probe = ele_probe_selection(tag_pt, tag_abseta);
694 
695  if (not(tag_is_valid_tag or tag_is_valid_probe))
696  continue;
697 
698  // Loop over probes
699  for (size_t iprobe = 0; iprobe < superclusters->size(); ++iprobe) {
700  // Initialize probe
701  const auto sc = superclusters->ptrAt(iprobe);
702  if (*sc == *(el1->superCluster())) {
703  continue;
704  }
705 
706  // Find matching electron
707  for (size_t iele = 0; iele < electrons->size(); ++iele) {
708  if (iele == itag)
709  continue;
710  const auto ele = electrons->ptrAt(iele);
711  if (*sc == *(ele->superCluster())) {
712  eleProbe = ele;
713  break;
714  }
715  }
716 
717  // Assign final probe 4-vector
718  TLorentzVector vProbe(0., 0., 0., 0.);
719  if (eleProbe.isNonnull()) {
720  vProbe.SetPtEtaPhiM(eleProbe->pt(), eleProbe->eta(), eleProbe->phi(), ELECTRON_MASS);
721  } else {
722  double pt = sc->energy() * sqrt(1 - pow(tanh(sc->eta()), 2));
723  vProbe.SetPtEtaPhiM(pt, sc->eta(), sc->phi(), ELECTRON_MASS);
724  }
725 
726  // Probe Selection
727  double probe_pt = vProbe.Pt();
728  double probe_abseta = fabs(sc->eta());
729  bool probe_is_valid_probe = ele_probe_selection(probe_pt, probe_abseta);
730  if (!probe_is_valid_probe)
731  continue;
732 
733  // Good Probe found!
734 
735  // Require good Z
736  TLorentzVector vDilep = vTag + vProbe;
737 
738  if ((vDilep.M() < ELE_MASS_CUT_LOW) || (vDilep.M() > ELE_MASS_CUT_HIGH))
739  continue;
740  if (eleProbe.isNonnull() and (eleProbe->charge() != -el1->charge()))
741  continue;
742 
743  // Good Z found!
744 
745  long ls = iEvent.luminosityBlock();
746  bool probe_pass_trigger = isElectronTriggerObj(
747  *fTrigger, TriggerTools::matchHLT(vProbe.Eta(), vProbe.Phi(), fTrigger->fRecords, *hTrgEvt));
748  bool probe_pass_id = eleProbe.isNonnull() and EleID_.passID(eleProbe, beamspotHandle, conversionsHandle);
749 
751  bool probe_is_forward = probe_abseta > ELE_ETA_CRACK_LOW;
752  bool tag_is_forward = tag_abseta > ELE_ETA_CRACK_LOW;
753 
754  if (probe_pass_id) {
755  if (probe_is_forward and tag_is_forward) {
756  h_ee_yield_Z_eeee->Fill(ls);
757  } else if (!probe_is_forward and !tag_is_forward) {
758  h_ee_yield_Z_ebeb->Fill(ls);
759  } else {
760  h_ee_yield_Z_ebee->Fill(ls);
761  }
762  }
763 
764  if (!tag_is_valid_tag)
765  continue;
766 
768  if (probe_pass_id) {
769  if (probe_is_forward) {
770  h_ee_mass_id_pass_forward->Fill(ls, vDilep.M());
771  } else {
772  h_ee_mass_id_pass_central->Fill(ls, vDilep.M());
773  }
774  } else {
775  if (probe_is_forward) {
776  h_ee_mass_id_fail_forward->Fill(ls, vDilep.M());
777  } else {
778  h_ee_mass_id_fail_central->Fill(ls, vDilep.M());
779  }
780  }
781 
783  if (probe_pass_id and probe_pass_trigger) {
784  if (probe_is_forward) {
785  h_ee_mass_HLT_pass_forward->Fill(ls, vDilep.M());
786  } else {
787  h_ee_mass_HLT_pass_central->Fill(ls, vDilep.M());
788  }
789  } else if (probe_pass_id) {
790  if (probe_is_forward) {
791  h_ee_mass_HLT_fail_forward->Fill(ls, vDilep.M());
792  } else {
793  h_ee_mass_HLT_fail_central->Fill(ls, vDilep.M());
794  }
795  }
796  } // End of probe loop
797  } //End of tag loop
798 }
799 
800 bool ZCounting::ele_probe_selection(double pt, double abseta) {
801  if (pt < ELE_PT_CUT_PROBE)
802  return false;
803  if (abseta > ELE_ETA_CUT_PROBE)
804  return false;
805  if ((abseta > ELE_ETA_CRACK_LOW) and (abseta < ELE_ETA_CRACK_HIGH))
806  return false;
807  return true;
808 }
809 bool ZCounting::ele_tag_selection(double pt, double abseta) {
810  if (pt < ELE_PT_CUT_TAG)
811  return false;
812  if (abseta > ELE_ETA_CUT_TAG)
813  return false;
814  if ((abseta > ELE_ETA_CRACK_LOW) and (abseta < ELE_ETA_CRACK_HIGH))
815  return false;
816  return true;
817 }
818 //
819 // -------------------------------------- functions --------------------------------------------
820 //
821 
822 void ZCounting::initHLT(const edm::TriggerResults& result, const edm::TriggerNames& triggerNames) {
823  for (unsigned int irec = 0; irec < fTrigger->fRecords.size(); irec++) {
824  fTrigger->fRecords[irec].hltPathName = "";
825  fTrigger->fRecords[irec].hltPathIndex = (unsigned int)-1;
826  const std::string pattern = fTrigger->fRecords[irec].hltPattern;
827  if (edm::is_glob(pattern)) { // handle pattern with wildcards (*,?)
828  std::vector<std::vector<std::string>::const_iterator> matches =
829  edm::regexMatch(triggerNames.triggerNames(), pattern);
830  if (matches.empty()) {
831  edm::LogWarning("ZCounting") << "requested pattern [" << pattern << "] does not match any HLT paths"
832  << std::endl;
833  } else {
834  for (auto const& match : matches) {
835  fTrigger->fRecords[irec].hltPathName = *match;
836  }
837  }
838  } else { // take full HLT path name given
839  fTrigger->fRecords[irec].hltPathName = pattern;
840  }
841  // Retrieve index in trigger menu corresponding to HLT path
842  unsigned int index = triggerNames.triggerIndex(fTrigger->fRecords[irec].hltPathName);
843  if (index < result.size()) { // check for valid index
844  fTrigger->fRecords[irec].hltPathIndex = index;
845  }
846  }
847 }
848 
849 //--------------------------------------------------------------------------------------------------
850 bool ZCounting::isMuonTrigger(const ZCountingTrigger::TTrigger& triggerMenu, const TriggerBits& hltBits) {
851  for (unsigned int i = 0; i < fMuonHLTNames.size(); ++i) {
852  if (triggerMenu.pass(fMuonHLTNames.at(i), hltBits))
853  return true;
854  }
855  return false;
856 }
857 
858 //--------------------------------------------------------------------------------------------------
859 bool ZCounting::isMuonTriggerObj(const ZCountingTrigger::TTrigger& triggerMenu, const TriggerObjects& hltMatchBits) {
860  for (unsigned int i = 0; i < fMuonHLTNames.size(); ++i) {
861  if (triggerMenu.passObj(fMuonHLTNames.at(i), fMuonHLTObjectNames.at(i), hltMatchBits))
862  return true;
863  }
864  return false;
865 }
866 
867 //--------------------------------------------------------------------------------------------------
868 bool ZCounting::passMuonID(
869  const reco::Muon& muon,
870  const reco::Vertex& vtx,
871  const MuonIDTypes& idType) { //Muon ID selection, using internal function "DataFormats/MuonReco/src/MuonSelectors.cc
872 
873  if (idType == LooseID && muon::isLooseMuon(muon))
874  return true;
875  else if (idType == MediumID && muon::isMediumMuon(muon))
876  return true;
877  else if (idType == TightID && muon::isTightMuon(muon, vtx))
878  return true;
879  else if (idType == NoneID)
880  return true;
881  else
882  return false;
883 }
884 //--------------------------------------------------------------------------------------------------
885 bool ZCounting::passMuonIso(const reco::Muon& muon,
886  const MuonIsoTypes& isoType,
887  const float isoCut) { //Muon isolation selection, up-to-date with MUO POG recommendation
888 
889  if (isoType == TrackerIso && muon.isolationR03().sumPt < isoCut)
890  return true;
891  else if (isoType == PFIso &&
892  muon.pfIsolationR04().sumChargedHadronPt +
893  std::max(0.,
894  muon.pfIsolationR04().sumNeutralHadronEt + muon.pfIsolationR04().sumPhotonEt -
895  0.5 * muon.pfIsolationR04().sumPUPt) <
896  isoCut)
897  return true;
898  else if (isoType == NoneIso)
899  return true;
900  else
901  return false;
902 }
903 
904 //--------------------------------------------------------------------------------------------------
905 bool ZCounting::isElectronTrigger(ZCountingTrigger::TTrigger triggerMenu, TriggerBits hltBits) {
906  return triggerMenu.pass("HLT_Ele35_WPTight_Gsf_v*", hltBits);
907 }
908 //--------------------------------------------------------------------------------------------------
909 bool ZCounting::isElectronTriggerObj(ZCountingTrigger::TTrigger triggerMenu, TriggerObjects hltMatchBits) {
910  return triggerMenu.passObj("HLT_Ele35_WPTight_Gsf_v*", "hltEle35noerWPTightGsfTrackIsoFilter", hltMatchBits);
911 }
912 DEFINE_FWK_MODULE(ZCounting);
ZCounting::h_npv
MonitorElement * h_npv
Definition: ZCounting.h:171
ZCounting::EtaCutL1_
double EtaCutL1_
Definition: ZCounting.h:117
ZCounting::dqmBeginRun
void dqmBeginRun(edm::Run const &, edm::EventSetup const &) override
Definition: ZCounting.cc:131
ZCounting.h
eostools.ls
def ls(path, rec=False)
Definition: eostools.py:349
ZCounting::ELE_MASS_CUT_HIGH
const float ELE_MASS_CUT_HIGH
Definition: ZCounting.h:147
ZCounting::h_ee_mass_id_fail_forward
MonitorElement * h_ee_mass_id_fail_forward
Definition: ZCounting.h:181
ZCounting::fPVName_token
edm::EDGetTokenT< reco::VertexCollection > fPVName_token
Definition: ZCounting.h:79
ZCounting::ELE_ETA_CRACK_LOW
const float ELE_ETA_CRACK_LOW
Definition: ZCounting.h:150
Handle.h
TTrigger.h
mps_fire.i
i
Definition: mps_fire.py:428
Muon.h
ZCounting::fHLTTag_token
edm::EDGetTokenT< edm::TriggerResults > fHLTTag_token
Definition: ZCounting.h:77
edm::Handle::product
T const * product() const
Definition: Handle.h:70
ZCounting::ele_probe_selection
bool ele_probe_selection(double pt, double abseta)
Definition: ZCounting.cc:800
ZCounting::fBeamspotTag
edm::InputTag fBeamspotTag
Definition: ZCounting.h:100
TriggerResults.h
muon
Definition: MuonCocktails.h:17
ZCounting::h_mass_HLT_pass_forward
MonitorElement * h_mass_HLT_pass_forward
Definition: ZCounting.h:157
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
ZCounting::h_ee_yield_Z_eeee
MonitorElement * h_ee_yield_Z_eeee
Definition: ZCounting.h:190
edm::regexMatch
std::vector< std::vector< std::string >::const_iterator > regexMatch(std::vector< std::string > const &strings, std::regex const &regexp)
Definition: RegexMatch.cc:26
edm::Run
Definition: Run.h:45
TriggerEvent.h
edm
HLT enums.
Definition: AlignableModifier.h:19
ZCounting::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: ZCounting.cc:140
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
ZCounting::LumiMin_
double LumiMin_
Definition: ZCounting.h:125
oniaPATMuonsWithTrigger_cff.matches
matches
Definition: oniaPATMuonsWithTrigger_cff.py:77
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89285
ZCounting::fHLTObjTag
edm::InputTag fHLTObjTag
Definition: ZCounting.h:74
ZCounting::analyzeMuons
void analyzeMuons(edm::Event const &e, edm::EventSetup const &eSetup)
Definition: ZCounting.cc:316
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
ZCounting::analyze
void analyze(edm::Event const &e, edm::EventSetup const &eSetup) override
Definition: ZCounting.cc:310
ZCounting::VtxAbsZCut_
double VtxAbsZCut_
Definition: ZCounting.h:134
ZCounting::passMuonID
bool passMuonID(const reco::Muon &muon, const reco::Vertex &vtx, const MuonIDTypes &idType)
Definition: ZCounting.cc:868
ZCounting::fHLTObjTag_token
edm::EDGetTokenT< trigger::TriggerEvent > fHLTObjTag_token
Definition: ZCounting.h:76
ZCounting::fRhoTag
edm::InputTag fRhoTag
Definition: ZCounting.h:97
ZCounting::h_ee_mass_id_pass_forward
MonitorElement * h_ee_mass_id_pass_forward
Definition: ZCounting.h:180
ZCounting::ELE_MASS_CUT_LOW
const float ELE_MASS_CUT_LOW
Definition: ZCounting.h:146
ElectronIdentifier::setID
void setID(std::string ID)
Definition: ElectronIdentifier.cc:120
ZCounting::h_mass_Glo_fail_central
MonitorElement * h_mass_Glo_fail_central
Definition: ZCounting.h:168
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
edm::is_glob
bool is_glob(std::string const &pattern)
Definition: RegexMatch.cc:17
ZCounting::MassMin_
double MassMin_
Definition: ZCounting.h:121
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
ZCounting::fMuonHLTObjectNames
std::vector< std::string > fMuonHLTObjectNames
Definition: ZCounting.h:85
ZCounting::h_mass_SIT_pass_central
MonitorElement * h_mass_SIT_pass_central
Definition: ZCounting.h:161
ZCounting::h_yieldEE_Z
MonitorElement * h_yieldEE_Z
Definition: ZCounting.h:175
ZCounting::analyzeElectrons
void analyzeElectrons(edm::Event const &e, edm::EventSetup const &eSetup)
Definition: ZCounting.cc:582
edm::Handle< reco::VertexCollection >
ZCounting::h_mass_yield_Z
MonitorElement * h_mass_yield_Z
Definition: ZCounting.h:173
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
ZCounting::IsoTypestr_
std::string IsoTypestr_
Definition: ZCounting.h:110
TriggerDefs.h
reco::Muon
Definition: Muon.h:27
ZCounting::isMuonTriggerObj
bool isMuonTriggerObj(const ZCountingTrigger::TTrigger &triggerMenu, const TriggerObjects &hltMatchBits)
Definition: ZCounting.cc:859
ZCounting::ELE_PT_CUT_TAG
const float ELE_PT_CUT_TAG
Definition: ZCounting.h:142
ElectronIdentifier
Definition: ElectronIdentifier.h:40
ZCounting::LumiMax_
double LumiMax_
Definition: ZCounting.h:126
ZCounting::h_ee_yield_Z_ebee
MonitorElement * h_ee_yield_Z_ebee
Definition: ZCounting.h:189
ZCounting::fSCName_token
edm::EDGetTokenT< edm::View< reco::SuperCluster > > fSCName_token
Definition: ZCounting.h:95
ZCounting::PVMin_
double PVMin_
Definition: ZCounting.h:129
ZCounting::~ZCounting
~ZCounting() override
Definition: ZCounting.cc:126
ZCounting::fPVName
std::string fPVName
Definition: ZCounting.h:78
ZCountingTrigger::TTrigger::passObj
bool passObj(const std::string &iName, const std::string &iObjName, const TriggerObjects &iTrigObj) const
Definition: TTrigger.cc:74
ZCounting::MUON_MASS
const double MUON_MASS
Definition: ZCounting.h:137
ZCounting::h_ee_yield_Z_ebeb
MonitorElement * h_ee_yield_Z_ebeb
Definition: ZCounting.h:188
ZCounting::h_ee_mass_HLT_fail_central
MonitorElement * h_ee_mass_HLT_fail_central
Definition: ZCounting.h:184
TriggerTools.h
ZCounting::h_ee_mass_HLT_fail_forward
MonitorElement * h_ee_mass_HLT_fail_forward
Definition: ZCounting.h:186
ZCounting::EtaCutL2_
double EtaCutL2_
Definition: ZCounting.h:118
muon::isLooseMuon
bool isLooseMuon(const reco::Muon &)
Definition: MuonSelectors.cc:895
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
ZCounting::MediumID
Definition: ZCounting.h:46
L1TEGammaOffline_cfi.triggerNames
triggerNames
Definition: L1TEGammaOffline_cfi.py:40
MuonSelectors.h
ZCounting::isElectronTriggerObj
bool isElectronTriggerObj(ZCountingTrigger::TTrigger triggerMenu, TriggerObjects hltMatchBits)
Definition: ZCounting.cc:909
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
HLT_FULL_cff.eta2
eta2
Definition: HLT_FULL_cff.py:9542
ZCounting::passMuonIso
bool passMuonIso(const reco::Muon &muon, const MuonIsoTypes &isoType, const float isoCut)
Definition: ZCounting.cc:885
ZCountingTrigger::TTrigger::pass
bool pass(const std::string &iName, const TriggerBits &iTrig) const
Definition: TTrigger.cc:65
dqm::implementation::NavigatorBase::cd
virtual void cd()
Definition: DQMStore.cc:29
ZCounting::fMuonHLTNames
std::vector< std::string > fMuonHLTNames
Definition: ZCounting.h:84
ZCounting::IsoType_
MuonIsoTypes IsoType_
Definition: ZCounting.h:112
ZCounting::EleID_
ElectronIdentifier EleID_
Definition: ZCounting.h:153
HLT_FULL_cff.pt1
pt1
Definition: HLT_FULL_cff.py:9870
ZCounting::fGsfElectronName_token
edm::EDGetTokenT< edm::View< reco::GsfElectron > > fGsfElectronName_token
Definition: ZCounting.h:93
ZCounting::PVMax_
double PVMax_
Definition: ZCounting.h:130
ZCounting::ELE_ETA_CUT_PROBE
const float ELE_ETA_CUT_PROBE
Definition: ZCounting.h:145
q2
double q2[4]
Definition: TauolaWrapper.h:88
ZCounting::PFIso
Definition: ZCounting.h:47
ZCounting::fConversionToken
edm::EDGetTokenT< reco::ConversionCollection > fConversionToken
Definition: ZCounting.h:104
TriggerObjects
std::bitset< kNTrigObjectBit > TriggerObjects
Definition: TriggerDefs.h:9
ZCounting::fConversionTag
edm::InputTag fConversionTag
Definition: ZCounting.h:103
ZCounting::h_mass_HLT_pass_central
MonitorElement * h_mass_HLT_pass_central
Definition: ZCounting.h:156
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Vertex.h
ZCounting::PtCutL1_
double PtCutL1_
Definition: ZCounting.h:115
HLT_FULL_cff.eta1
eta1
Definition: HLT_FULL_cff.py:9541
ZCounting::ELECTRON_MASS
const float ELECTRON_MASS
Definition: ZCounting.h:140
ZCountingTrigger
Definition: TriggerRecord.h:8
ZCounting::fMuonName_token
edm::EDGetTokenT< reco::MuonCollection > fMuonName_token
Definition: ZCounting.h:83
edm::ParameterSet
Definition: ParameterSet.h:47
q1
double q1[4]
Definition: TauolaWrapper.h:87
ZCounting::h_mass_Glo_pass_central
MonitorElement * h_mass_Glo_pass_central
Definition: ZCounting.h:166
ZCounting::VtxRhoCut_
double VtxRhoCut_
Definition: ZCounting.h:135
ZCounting::TightID
Definition: ZCounting.h:46
ZCounting::fBeamspotToken
edm::EDGetTokenT< reco::BeamSpot > fBeamspotToken
Definition: ZCounting.h:101
Event.h
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:152
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
ElectronIdentifier::passID
bool passID(const reco::GsfElectronPtr &ele, edm::Handle< reco::BeamSpot > beamspot, edm::Handle< reco::ConversionCollection > conversions)
Definition: ElectronIdentifier.cc:153
muon::isTightMuon
bool isTightMuon(const reco::Muon &, const reco::Vertex &)
Definition: MuonSelectors.cc:880
ZCounting::fTrigger
std::unique_ptr< ZCountingTrigger::TTrigger > fTrigger
Definition: ZCounting.h:107
match
std::pair< typename Association::data_type::first_type, double > match(Reference key, Association association, bool bestMatchByMaxValue)
Generic matching function.
Definition: Utils.h:10
ZCounting::h_mass_HLT_fail_forward
MonitorElement * h_mass_HLT_fail_forward
Definition: ZCounting.h:159
createfilelist.int
int
Definition: createfilelist.py:10
TriggerNames.h
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
ZCounting::ELE_ID_WP
const std::string ELE_ID_WP
Definition: ZCounting.h:149
ZCounting::ZCounting
ZCounting(const edm::ParameterSet &ps)
Definition: ZCounting.cc:26
ZCounting::h_yieldBB_Z
MonitorElement * h_yieldBB_Z
Definition: ZCounting.h:174
ZCounting::ELE_ETA_CRACK_HIGH
const float ELE_ETA_CRACK_HIGH
Definition: ZCounting.h:151
topSingleLeptonDQM_PU_cfi.pattern
pattern
Definition: topSingleLeptonDQM_PU_cfi.py:39
TriggerBits
std::bitset< kNTrigBit > TriggerBits
Definition: TriggerDefs.h:7
reco::LeafCandidate::charge
int charge() const final
electric charge
Definition: LeafCandidate.h:106
ZCounting::isElectronTrigger
bool isElectronTrigger(ZCountingTrigger::TTrigger triggerMenu, TriggerBits hltBits)
Definition: ZCounting.cc:905
edm::EventSetup
Definition: EventSetup.h:58
HLT_FULL_cff.pt2
pt2
Definition: HLT_FULL_cff.py:9872
ZCounting::fHLTTag
edm::InputTag fHLTTag
Definition: ZCounting.h:75
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
muon::isMediumMuon
bool isMediumMuon(const reco::Muon &, bool run2016_hip_mitigation=false)
Definition: MuonSelectors.cc:899
ZCounting::ELE_PT_CUT_PROBE
const float ELE_PT_CUT_PROBE
Definition: ZCounting.h:143
ZCounting::VtxNTracksFitCut_
double VtxNTracksFitCut_
Definition: ZCounting.h:132
ZCounting::h_npv_yield_Z
MonitorElement * h_npv_yield_Z
Definition: ZCounting.h:172
ZCounting::h_ee_mass_HLT_pass_forward
MonitorElement * h_ee_mass_HLT_pass_forward
Definition: ZCounting.h:185
ZCounting::h_mass_Glo_pass_forward
MonitorElement * h_mass_Glo_pass_forward
Definition: ZCounting.h:167
ZCounting::MuonIsoTypes
MuonIsoTypes
Definition: ZCounting.h:47
edm::Ptr< reco::GsfElectron >
ZCounting::VtxNdofCut_
double VtxNdofCut_
Definition: ZCounting.h:133
ZCounting::IDTypestr_
std::string IDTypestr_
Definition: ZCounting.h:109
ZCounting::fSCName
std::string fSCName
Definition: ZCounting.h:94
ZCounting::IDType_
MuonIDTypes IDType_
Definition: ZCounting.h:111
ZCounting::isMuonTrigger
bool isMuonTrigger(const ZCountingTrigger::TTrigger &triggerMenu, const TriggerBits &hltBits)
Definition: ZCounting.cc:850
std
Definition: JetResolutionObject.h:76
ZCounting::h_mass_HLT_fail_central
MonitorElement * h_mass_HLT_fail_central
Definition: ZCounting.h:158
ZCounting::fTriggerNamesID
edm::ParameterSetID fTriggerNamesID
Definition: ZCounting.h:73
reco::LeafCandidate::phi
double phi() const final
momentum azimuthal angle
Definition: LeafCandidate.h:148
extraflags_cff.vtx
vtx
Definition: extraflags_cff.py:18
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
ZCounting::h_ee_mass_id_pass_central
MonitorElement * h_ee_mass_id_pass_central
Definition: ZCounting.h:178
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
ZCountingTrigger::TTrigger
Definition: TTrigger.h:8
edm::TriggerNames
Definition: TriggerNames.h:55
ZCounting::MassMax_
double MassMax_
Definition: ZCounting.h:122
ZCounting::NoneIso
Definition: ZCounting.h:47
ZCounting::PtCutL2_
double PtCutL2_
Definition: ZCounting.h:116
ZCounting::PVBin_
int PVBin_
Definition: ZCounting.h:128
ZCounting::IsoCut_
double IsoCut_
Definition: ZCounting.h:113
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
edm::Ptr::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ptr.h:146
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
ZCounting::LooseID
Definition: ZCounting.h:46
ZCounting::h_mass_Glo_fail_forward
MonitorElement * h_mass_Glo_fail_forward
Definition: ZCounting.h:169
ZCounting::MUON_BOUND
const double MUON_BOUND
Definition: ZCounting.h:138
edm::HLTGlobalStatus::accept
bool accept() const
Has at least one path accepted the event?
Definition: HLTGlobalStatus.h:49
dqm::implementation::IBooker
Definition: DQMStore.h:43
AlignmentPI::index
index
Definition: AlignmentPayloadInspectorHelper.h:46
ZCounting::NoneID
Definition: ZCounting.h:46
ZCounting::h_mass_SIT_fail_central
MonitorElement * h_mass_SIT_fail_central
Definition: ZCounting.h:163
ZCounting::fRhoToken
edm::EDGetTokenT< double > fRhoToken
Definition: ZCounting.h:98
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
ElectronIdentifier::setRho
void setRho(double rho)
Definition: ElectronIdentifier.cc:111
mps_fire.result
result
Definition: mps_fire.py:311
ZCounting::LumiBin_
int LumiBin_
Definition: ZCounting.h:124
ZCounting::ELE_ETA_CUT_TAG
const float ELE_ETA_CUT_TAG
Definition: ZCounting.h:144
ZCounting::h_mass_SIT_fail_forward
MonitorElement * h_mass_SIT_fail_forward
Definition: ZCounting.h:164
ZCounting::fMuonName
std::string fMuonName
Definition: ZCounting.h:82
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
edm::Event
Definition: Event.h:73
ZCounting::initHLT
void initHLT(const edm::TriggerResults &, const edm::TriggerNames &)
Definition: ZCounting.cc:822
ZCounting::TrackerIso
Definition: ZCounting.h:47
ZCounting::ele_tag_selection
bool ele_tag_selection(double pt, double abseta)
Definition: ZCounting.cc:809
ZCounting::fTrackName
std::string fTrackName
Definition: ZCounting.h:88
ZCounting::MassBin_
int MassBin_
Definition: ZCounting.h:120
dqm::impl::MonitorElement::setAxisTitle
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:800
ZCounting::fElectronName
std::string fElectronName
Definition: ZCounting.h:92
RegexMatch.h
edm::TriggerResults
Definition: TriggerResults.h:35
ZCounting::MuonIDTypes
MuonIDTypes
Definition: ZCounting.h:46
reco::Vertex
Definition: Vertex.h:35
ZCounting::fTrackName_token
edm::EDGetTokenT< reco::TrackCollection > fTrackName_token
Definition: ZCounting.h:89
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::h_mass_SIT_pass_forward
MonitorElement * h_mass_SIT_pass_forward
Definition: ZCounting.h:162
ZCounting::h_ee_mass_HLT_pass_central
MonitorElement * h_ee_mass_HLT_pass_central
Definition: ZCounting.h:183
ZCounting::h_ee_mass_id_fail_central
MonitorElement * h_ee_mass_id_fail_central
Definition: ZCounting.h:179
reco::isMuon
bool isMuon(const Candidate &part)
Definition: pdgIdUtils.h:9
ZCounting
Definition: ZCounting.h:41
Generated for CMSSW Reference Manual by doxygen 1.8.16