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