CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
MuonVPlusJetsIDSelectionFunctor.h
Go to the documentation of this file.
1 #ifndef PhysicsTools_PatUtils_interface_MuonVPlusJetsIDSelectionFunctor_h
2 #define PhysicsTools_PatUtils_interface_MuonVPlusJetsIDSelectionFunctor_h
3 
4 #ifndef __GCCXML__
5 #include "FWCore/Framework/interface/ConsumesCollector.h"
6 #endif
7 #include "DataFormats/PatCandidates/interface/Muon.h"
8 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
9 #include "DataFormats/VertexReco/interface/Vertex.h"
10 #include "FWCore/MessageLogger/interface/MessageLogger.h"
11 
12 #include "PhysicsTools/SelectorUtils/interface/Selector.h"
13 #include "FWCore/ParameterSet/interface/ParameterSet.h"
14 
15 #include <iostream>
16 
17 class MuonVPlusJetsIDSelectionFunctor : public Selector<pat::Muon> {
18 public: // interface
19  bool verbose_;
20 
21  enum Version_t { SUMMER08, FIRSTDATA, SPRING10, FALL10, N_VERSIONS, KITQCD };
22 
23  MuonVPlusJetsIDSelectionFunctor() {}
24 
25 #ifndef __GCCXML__
26  MuonVPlusJetsIDSelectionFunctor(edm::ParameterSet const& parameters, edm::ConsumesCollector& iC)
27  : MuonVPlusJetsIDSelectionFunctor(parameters) {
28  beamLineSrcToken_ = iC.consumes<reco::BeamSpot>(beamLineSrc_);
29  pvSrcToken_ = iC.consumes<std::vector<reco::Vertex> >(pvSrc_);
30  }
31 #endif
32 
33  MuonVPlusJetsIDSelectionFunctor(edm::ParameterSet const& parameters) {
34  verbose_ = false;
35 
36  std::string versionStr = parameters.getParameter<std::string>("version");
37 
38  Version_t version = N_VERSIONS;
39 
40  if (versionStr == "SUMMER08") {
41  version = SUMMER08;
42  } else if (versionStr == "FIRSTDATA") {
43  version = FIRSTDATA;
44  } else if (versionStr == "SPRING10") {
45  version = SPRING10;
46  } else if (versionStr == "FALL10") {
47  version = FALL10;
48  if (verbose_)
49  std::cout << "\nMUON SELECTION - you are using FALL10 Selection" << std::endl;
50  } else if (versionStr == "KITQCD") {
51  version = KITQCD;
52  if (verbose_)
53  std::cout << "\nMUON SELECTION - you are using KITQCD Selection" << std::endl;
54  } else {
55  throw cms::Exception("InvalidInput")
56  << "Expect version to be one of SUMMER08, FIRSTDATA, SPRING10, FALL10" << std::endl;
57  }
58 
59  initialize(version,
60  parameters.getParameter<double>("Chi2"),
61  parameters.getParameter<double>("D0"),
62  parameters.getParameter<double>("ED0"),
63  parameters.getParameter<double>("SD0"),
64  parameters.getParameter<int>("NHits"),
65  parameters.getParameter<int>("NValMuHits"),
66  parameters.getParameter<double>("ECalVeto"),
67  parameters.getParameter<double>("HCalVeto"),
68  parameters.getParameter<double>("RelIso"),
69  parameters.getParameter<double>("LepZ"),
70  parameters.getParameter<int>("nPixelHits"),
71  parameters.getParameter<int>("nMatchedStations"));
72  if (parameters.exists("cutsToIgnore"))
73  setIgnoredCuts(parameters.getParameter<std::vector<std::string> >("cutsToIgnore"));
74 
75  retInternal_ = getBitTemplate();
76 
77  recalcDBFromBSp_ = parameters.getParameter<bool>("RecalcFromBeamSpot");
78  pvSrc_ = parameters.getParameter<edm::InputTag>("pvSrc");
79  }
80 
81  MuonVPlusJetsIDSelectionFunctor(Version_t version,
82  double chi2 = 10.0,
83  double d0 = 0.2,
84  double ed0 = 999.0,
85  double sd0 = 999.0,
86  int nhits = 11,
87  int nValidMuonHits = 0,
88  double ecalveto = 4.0,
89  double hcalveto = 6.0,
90  double reliso = 0.05,
91  double maxLepZ = 1.0,
92  int minPixelHits = 1,
93  int minNMatches = 1)
94  : recalcDBFromBSp_(false) {
95  initialize(version,
96  chi2,
97  d0,
98  ed0,
99  sd0,
100  nhits,
101  nValidMuonHits,
102  ecalveto,
103  hcalveto,
104  reliso,
105  maxLepZ,
106  minPixelHits,
107  minNMatches);
108 
109  retInternal_ = getBitTemplate();
110  }
111 
112  void initialize(Version_t version,
113  double chi2 = 10.0,
114  double d0 = 999.0,
115  double ed0 = 999.0,
116  double sd0 = 3.0,
117  int nhits = 11,
118  int nValidMuonHits = 0,
119  double ecalveto = 4.0,
120  double hcalveto = 6.0,
121  double reliso = 0.05,
122  double maxLepZ = 1.0,
123  int minPixelHits = 1,
124  int minNMatches = 1) {
125  version_ = version;
126 
127  push_back("Chi2", chi2);
128  push_back("D0", d0);
129  push_back("ED0", ed0);
130  push_back("SD0", sd0);
131  push_back("NHits", nhits);
132  push_back("NValMuHits", nValidMuonHits);
133  push_back("ECalVeto", ecalveto);
134  push_back("HCalVeto", hcalveto);
135  push_back("RelIso", reliso);
136  push_back("LepZ", maxLepZ);
137  push_back("nPixelHits", minPixelHits);
138  push_back("nMatchedStations", minNMatches);
139 
140  set("Chi2");
141  set("D0");
142  set("ED0");
143  set("SD0");
144  set("NHits");
145  set("NValMuHits");
146  set("ECalVeto");
147  set("HCalVeto");
148  set("RelIso");
149  set("LepZ");
150  set("nPixelHits");
151  set("nMatchedStations");
152 
153  indexChi2_ = index_type(&bits_, "Chi2");
154  indexD0_ = index_type(&bits_, "D0");
155  indexED0_ = index_type(&bits_, "ED0");
156  indexSD0_ = index_type(&bits_, "SD0");
157  indexNHits_ = index_type(&bits_, "NHits");
158  indexNValMuHits_ = index_type(&bits_, "NValMuHits");
159  indexECalVeto_ = index_type(&bits_, "ECalVeto");
160  indexHCalVeto_ = index_type(&bits_, "HCalVeto");
161  indexRelIso_ = index_type(&bits_, "RelIso");
162  indexLepZ_ = index_type(&bits_, "LepZ");
163  indexPixHits_ = index_type(&bits_, "nPixelHits");
164  indexStations_ = index_type(&bits_, "nMatchedStations");
165 
166  if (version == FALL10) {
167  set("ED0", false);
168  set("SD0", false);
169  set("ECalVeto", false);
170  set("HCalVeto", false);
171  } else if (version == SPRING10) {
172  set("ED0", false);
173  set("SD0", false);
174  set("ECalVeto", false);
175  set("HCalVeto", false);
176  set("LepZ", false);
177  set("nPixelHits", false);
178  set("nMatchedStations", false);
179  } else if (version_ == FIRSTDATA) {
180  set("D0", false);
181  set("ED0", false);
182  set("NValMuHits", false);
183  set("LepZ", false);
184  set("nPixelHits", false);
185  set("nMatchedStations", false);
186  } else if (version == SUMMER08) {
187  set("SD0", false);
188  set("NValMuHits", false);
189  set("LepZ", false);
190  set("nPixelHits", false);
191  set("nMatchedStations", false);
192  }
193  }
194 
195  // Allow for multiple definitions of the cuts.
196  bool operator()(const pat::Muon& muon, edm::EventBase const& event, pat::strbitset& ret) override {
197  if (version_ == FALL10)
198  return fall10Cuts(muon, event, ret);
199  else if (version_ == SPRING10)
200  return spring10Cuts(muon, event, ret);
201  else if (version_ == SUMMER08)
202  return summer08Cuts(muon, ret);
203  else if (version_ == FIRSTDATA)
204  return firstDataCuts(muon, ret);
205  else if (version_ == KITQCD) {
206  if (verbose_)
207  std::cout << "Calling KIT selection method" << std::endl;
208  return kitQCDCuts(muon, event, ret);
209  } else {
210  return false;
211  }
212  }
213 
214  // For compatibility with older versions.
215  bool operator()(const pat::Muon& muon, pat::strbitset& ret) override {
216  if (version_ == SPRING10 || version_ == FALL10)
217  throw cms::Exception("LogicError") << "MuonVPlusJetsSelectionFunctor SPRING10 and FALL10 versions needs the "
218  "event! Call operator()(muon,event,ret)"
219  << std::endl;
220 
221  else if (version_ == SUMMER08)
222  return summer08Cuts(muon, ret);
223  else if (version_ == FIRSTDATA)
224  return firstDataCuts(muon, ret);
225  else {
226  return false;
227  }
228  }
229 
230  using Selector<pat::Muon>::operator();
231 
232  // cuts based on craft 08 analysis.
233  bool summer08Cuts(const pat::Muon& muon, pat::strbitset& ret) {
234  ret.set(false);
235 
236  double norm_chi2 = muon.normChi2();
237  double corr_d0 = muon.dB();
238  int nhits = static_cast<int>(muon.numberOfValidHits());
239 
240  double ecalVeto = muon.isolationR03().emVetoEt;
241  double hcalVeto = muon.isolationR03().hadVetoEt;
242 
243  double hcalIso = muon.hcalIso();
244  double ecalIso = muon.ecalIso();
245  double trkIso = muon.trackIso();
246  double pt = muon.pt();
247 
248  double relIso = (ecalIso + hcalIso + trkIso) / pt;
249 
250  if (norm_chi2 < cut(indexChi2_, double()) || ignoreCut(indexChi2_))
251  passCut(ret, indexChi2_);
252  if (fabs(corr_d0) < cut(indexD0_, double()) || ignoreCut(indexD0_))
253  passCut(ret, indexD0_);
254  if (nhits >= cut(indexNHits_, int()) || ignoreCut(indexNHits_))
255  passCut(ret, indexNHits_);
256  if (hcalVeto < cut(indexHCalVeto_, double()) || ignoreCut(indexHCalVeto_))
257  passCut(ret, indexHCalVeto_);
258  if (ecalVeto < cut(indexECalVeto_, double()) || ignoreCut(indexECalVeto_))
259  passCut(ret, indexECalVeto_);
260  if (relIso < cut(indexRelIso_, double()) || ignoreCut(indexRelIso_))
261  passCut(ret, indexRelIso_);
262 
263  setIgnored(ret);
264 
265  return (bool)ret;
266  }
267 
268  // cuts based on craft 08 analysis.
269  bool firstDataCuts(const pat::Muon& muon, pat::strbitset& ret) {
270  ret.set(false);
271 
272  double norm_chi2 = muon.normChi2();
273  double corr_d0 = muon.dB();
274  double corr_ed0 = muon.edB();
275  double corr_sd0 = (corr_ed0 > 0.000000001) ? corr_d0 / corr_ed0 : 999.0;
276  int nhits = static_cast<int>(muon.numberOfValidHits());
277 
278  double ecalVeto = muon.isolationR03().emVetoEt;
279  double hcalVeto = muon.isolationR03().hadVetoEt;
280 
281  double hcalIso = muon.hcalIso();
282  double ecalIso = muon.ecalIso();
283  double trkIso = muon.trackIso();
284  double pt = muon.pt();
285 
286  double relIso = (ecalIso + hcalIso + trkIso) / pt;
287 
288  if (norm_chi2 < cut(indexChi2_, double()) || ignoreCut(indexChi2_))
289  passCut(ret, indexChi2_);
290  if (fabs(corr_d0) < cut(indexD0_, double()) || ignoreCut(indexD0_))
291  passCut(ret, indexD0_);
292  if (fabs(corr_ed0) < cut(indexED0_, double()) || ignoreCut(indexED0_))
293  passCut(ret, indexED0_);
294  if (fabs(corr_sd0) < cut(indexSD0_, double()) || ignoreCut(indexSD0_))
295  passCut(ret, indexSD0_);
296  if (nhits >= cut(indexNHits_, int()) || ignoreCut(indexNHits_))
297  passCut(ret, indexNHits_);
298  if (hcalVeto < cut(indexHCalVeto_, double()) || ignoreCut(indexHCalVeto_))
299  passCut(ret, indexHCalVeto_);
300  if (ecalVeto < cut(indexECalVeto_, double()) || ignoreCut(indexECalVeto_))
301  passCut(ret, indexECalVeto_);
302  if (relIso < cut(indexRelIso_, double()) || ignoreCut(indexRelIso_))
303  passCut(ret, indexRelIso_);
304 
305  setIgnored(ret);
306 
307  return (bool)ret;
308  }
309 
310  // cuts based on top group L+J synchronization exercise
311  bool spring10Cuts(const pat::Muon& muon, edm::EventBase const& event, pat::strbitset& ret) {
312  ret.set(false);
313 
314  double norm_chi2 = muon.normChi2();
315  double corr_d0 = muon.dB();
316  double corr_ed0 = muon.edB();
317  double corr_sd0 = (corr_ed0 > 0.000000001) ? corr_d0 / corr_ed0 : 999.0;
318 
319  //If required, recalculate the impact parameter using the beam spot
320  if (recalcDBFromBSp_) {
321  //Get the beam spot
322  reco::TrackBase::Point beamPoint(0, 0, 0);
323  reco::BeamSpot beamSpot;
324  edm::Handle<reco::BeamSpot> beamSpotHandle;
325  event.getByLabel(beamLineSrc_, beamSpotHandle);
326 
327  if (beamSpotHandle.isValid()) {
328  beamSpot = *beamSpotHandle;
329  } else {
330  edm::LogError("DataNotAvailable")
331  << "No beam spot available from EventSetup, not adding high level selection \n";
332  }
333  beamPoint = reco::TrackBase::Point(beamSpot.x0(), beamSpot.y0(), beamSpot.z0());
334 
335  //Use the beamspot to correct the impact parameter and uncertainty
336  reco::TrackRef innerTrack = muon.innerTrack();
337  if (innerTrack.isNonnull() && innerTrack.isAvailable()) {
338  corr_d0 = -1.0 * innerTrack->dxy(beamPoint);
339  corr_ed0 =
340  sqrt(innerTrack->d0Error() * innerTrack->d0Error() + 0.5 * beamSpot.BeamWidthX() * beamSpot.BeamWidthX() +
341  0.5 * beamSpot.BeamWidthY() * beamSpot.BeamWidthY());
342  corr_sd0 = (corr_ed0 > 0.000000001) ? corr_d0 / corr_ed0 : 999.0;
343 
344  } else {
345  corr_d0 = 999.;
346  corr_ed0 = 999.;
347  }
348  }
349 
350  int nhits = static_cast<int>(muon.numberOfValidHits());
351  int nValidMuonHits = static_cast<int>(muon.globalTrack()->hitPattern().numberOfValidMuonHits());
352 
353  double ecalVeto = muon.isolationR03().emVetoEt;
354  double hcalVeto = muon.isolationR03().hadVetoEt;
355 
356  double hcalIso = muon.hcalIso();
357  double ecalIso = muon.ecalIso();
358  double trkIso = muon.trackIso();
359  double pt = muon.pt();
360 
361  double relIso = (ecalIso + hcalIso + trkIso) / pt;
362 
363  if (norm_chi2 < cut(indexChi2_, double()) || ignoreCut(indexChi2_))
364  passCut(ret, indexChi2_);
365  if (fabs(corr_d0) < cut(indexD0_, double()) || ignoreCut(indexD0_))
366  passCut(ret, indexD0_);
367  if (fabs(corr_ed0) < cut(indexED0_, double()) || ignoreCut(indexED0_))
368  passCut(ret, indexED0_);
369  if (fabs(corr_sd0) < cut(indexSD0_, double()) || ignoreCut(indexSD0_))
370  passCut(ret, indexSD0_);
371  if (nhits >= cut(indexNHits_, int()) || ignoreCut(indexNHits_))
372  passCut(ret, indexNHits_);
373  if (nValidMuonHits > cut(indexNValMuHits_, int()) || ignoreCut(indexNValMuHits_))
374  passCut(ret, indexNValMuHits_);
375  if (hcalVeto < cut(indexHCalVeto_, double()) || ignoreCut(indexHCalVeto_))
376  passCut(ret, indexHCalVeto_);
377  if (ecalVeto < cut(indexECalVeto_, double()) || ignoreCut(indexECalVeto_))
378  passCut(ret, indexECalVeto_);
379  if (relIso < cut(indexRelIso_, double()) || ignoreCut(indexRelIso_))
380  passCut(ret, indexRelIso_);
381 
382  setIgnored(ret);
383 
384  return (bool)ret;
385  }
386 
387  // cuts based on top group L+J synchronization exercise
388  bool fall10Cuts(const pat::Muon& muon, edm::EventBase const& event, pat::strbitset& ret) {
389  ret.set(false);
390 
391  double norm_chi2 = muon.normChi2();
392  double corr_d0 = muon.dB();
393  double corr_ed0 = muon.edB();
394  double corr_sd0 = (corr_ed0 > 0.000000001) ? corr_d0 / corr_ed0 : 999.0;
395 
396  // Get the PV for the muon z requirement
397  edm::Handle<std::vector<reco::Vertex> > pvtxHandle_;
398  event.getByLabel(pvSrc_, pvtxHandle_);
399 
400  double zvtx = -999;
401  if (!pvtxHandle_->empty()) {
402  zvtx = pvtxHandle_->at(0).z();
403  } else {
404  throw cms::Exception("InvalidInput")
405  << " There needs to be at least one primary vertex in the event." << std::endl;
406  }
407 
408  //If required, recalculate the impact parameter using the beam spot
409  if (recalcDBFromBSp_) {
410  //Get the beam spot
411  reco::TrackBase::Point beamPoint(0, 0, 0);
412  reco::BeamSpot beamSpot;
413  edm::Handle<reco::BeamSpot> beamSpotHandle;
414  event.getByLabel(beamLineSrc_, beamSpotHandle);
415 
416  if (beamSpotHandle.isValid()) {
417  beamSpot = *beamSpotHandle;
418  } else {
419  edm::LogError("DataNotAvailable")
420  << "No beam spot available from EventSetup, not adding high level selection \n";
421  }
422  beamPoint = reco::TrackBase::Point(beamSpot.x0(), beamSpot.y0(), beamSpot.z0());
423 
424  //Use the beamspot to correct the impact parameter and uncertainty
425  reco::TrackRef innerTrack = muon.innerTrack();
426  if (innerTrack.isNonnull() && innerTrack.isAvailable()) {
427  corr_d0 = -1.0 * innerTrack->dxy(beamPoint);
428  corr_ed0 =
429  sqrt(innerTrack->d0Error() * innerTrack->d0Error() + 0.5 * beamSpot.BeamWidthX() * beamSpot.BeamWidthX() +
430  0.5 * beamSpot.BeamWidthY() * beamSpot.BeamWidthY());
431  corr_sd0 = (corr_ed0 > 0.000000001) ? corr_d0 / corr_ed0 : 999.0;
432 
433  } else {
434  corr_d0 = 999.;
435  corr_ed0 = 999.;
436  }
437  }
438 
439  int nhits = static_cast<int>(muon.numberOfValidHits());
440  int nValidMuonHits = static_cast<int>(muon.globalTrack()->hitPattern().numberOfValidMuonHits());
441 
442  double ecalVeto = muon.isolationR03().emVetoEt;
443  double hcalVeto = muon.isolationR03().hadVetoEt;
444 
445  double hcalIso = muon.hcalIso();
446  double ecalIso = muon.ecalIso();
447  double trkIso = muon.trackIso();
448  double pt = muon.pt();
449 
450  double relIso = (ecalIso + hcalIso + trkIso) / pt;
451 
452  double z_mu = muon.vertex().z();
453 
454  int nPixelHits = muon.innerTrack()->hitPattern().pixelLayersWithMeasurement();
455 
456  int nMatchedStations = muon.numberOfMatches();
457 
458  if (norm_chi2 < cut(indexChi2_, double()) || ignoreCut(indexChi2_))
459  passCut(ret, indexChi2_);
460  if (fabs(corr_d0) < cut(indexD0_, double()) || ignoreCut(indexD0_))
461  passCut(ret, indexD0_);
462  if (fabs(corr_ed0) < cut(indexED0_, double()) || ignoreCut(indexED0_))
463  passCut(ret, indexED0_);
464  if (fabs(corr_sd0) < cut(indexSD0_, double()) || ignoreCut(indexSD0_))
465  passCut(ret, indexSD0_);
466  if (nhits >= cut(indexNHits_, int()) || ignoreCut(indexNHits_))
467  passCut(ret, indexNHits_);
468  if (nValidMuonHits > cut(indexNValMuHits_, int()) || ignoreCut(indexNValMuHits_))
469  passCut(ret, indexNValMuHits_);
470  if (hcalVeto < cut(indexHCalVeto_, double()) || ignoreCut(indexHCalVeto_))
471  passCut(ret, indexHCalVeto_);
472  if (ecalVeto < cut(indexECalVeto_, double()) || ignoreCut(indexECalVeto_))
473  passCut(ret, indexECalVeto_);
474  if (relIso < cut(indexRelIso_, double()) || ignoreCut(indexRelIso_))
475  passCut(ret, indexRelIso_);
476  if (fabs(z_mu - zvtx) < cut(indexLepZ_, double()) || ignoreCut(indexLepZ_))
477  passCut(ret, indexLepZ_);
478  if (nPixelHits > cut(indexPixHits_, int()) || ignoreCut(indexPixHits_))
479  passCut(ret, indexPixHits_);
480  if (nMatchedStations > cut(indexStations_, int()) || ignoreCut(indexStations_))
481  passCut(ret, indexStations_);
482 
483  setIgnored(ret);
484 
485  return (bool)ret;
486  }
487 
488  // cuts based on top group L+J synchronization exercise
489  // this is a copy of fall 10 cuts
490  // with a hack to include a double-sided reliso cut
491 
492  bool kitQCDCuts(const pat::Muon& muon, edm::EventBase const& event, pat::strbitset& ret) {
493  ret.set(false);
494 
495  double norm_chi2 = muon.normChi2();
496  double corr_d0 = muon.dB();
497  double corr_ed0 = muon.edB();
498  double corr_sd0 = (corr_ed0 > 0.000000001) ? corr_d0 / corr_ed0 : 999.0;
499 
500  // Get the PV for the muon z requirement
501  edm::Handle<std::vector<reco::Vertex> > pvtxHandle_;
502  event.getByLabel(pvSrc_, pvtxHandle_);
503 
504  double zvtx = -999;
505  if (!pvtxHandle_->empty()) {
506  zvtx = pvtxHandle_->at(0).z();
507  } else {
508  throw cms::Exception("InvalidInput")
509  << " There needs to be at least one primary vertex in the event." << std::endl;
510  }
511 
512  //If required, recalculate the impact parameter using the beam spot
513  if (recalcDBFromBSp_) {
514  //Get the beam spot
515  reco::TrackBase::Point beamPoint(0, 0, 0);
516  reco::BeamSpot beamSpot;
517  edm::Handle<reco::BeamSpot> beamSpotHandle;
518  event.getByLabel(beamLineSrc_, beamSpotHandle);
519 
520  if (beamSpotHandle.isValid()) {
521  beamSpot = *beamSpotHandle;
522  } else {
523  edm::LogError("DataNotAvailable")
524  << "No beam spot available from EventSetup, not adding high level selection \n";
525  }
526  beamPoint = reco::TrackBase::Point(beamSpot.x0(), beamSpot.y0(), beamSpot.z0());
527 
528  //Use the beamspot to correct the impact parameter and uncertainty
529  reco::TrackRef innerTrack = muon.innerTrack();
530  if (innerTrack.isNonnull() && innerTrack.isAvailable()) {
531  corr_d0 = -1.0 * innerTrack->dxy(beamPoint);
532  corr_ed0 =
533  sqrt(innerTrack->d0Error() * innerTrack->d0Error() + 0.5 * beamSpot.BeamWidthX() * beamSpot.BeamWidthX() +
534  0.5 * beamSpot.BeamWidthY() * beamSpot.BeamWidthY());
535  corr_sd0 = (corr_ed0 > 0.000000001) ? corr_d0 / corr_ed0 : 999.0;
536 
537  } else {
538  corr_d0 = 999.;
539  corr_ed0 = 999.;
540  }
541  }
542 
543  int nhits = static_cast<int>(muon.numberOfValidHits());
544  int nValidMuonHits = static_cast<int>(muon.globalTrack()->hitPattern().numberOfValidMuonHits());
545 
546  double ecalVeto = muon.isolationR03().emVetoEt;
547  double hcalVeto = muon.isolationR03().hadVetoEt;
548 
549  double hcalIso = muon.hcalIso();
550  double ecalIso = muon.ecalIso();
551  double trkIso = muon.trackIso();
552  double pt = muon.pt();
553 
554  double relIso = (ecalIso + hcalIso + trkIso) / pt;
555 
556  double z_mu = muon.vertex().z();
557 
558  int nPixelHits = muon.innerTrack()->hitPattern().pixelLayersWithMeasurement();
559 
560  int nMatchedStations = muon.numberOfMatches();
561 
562  if (norm_chi2 < cut(indexChi2_, double()) || ignoreCut(indexChi2_))
563  passCut(ret, indexChi2_);
564  if (fabs(corr_d0) < cut(indexD0_, double()) || ignoreCut(indexD0_))
565  passCut(ret, indexD0_);
566  if (fabs(corr_ed0) < cut(indexED0_, double()) || ignoreCut(indexED0_))
567  passCut(ret, indexED0_);
568  if (fabs(corr_sd0) < cut(indexSD0_, double()) || ignoreCut(indexSD0_))
569  passCut(ret, indexSD0_);
570  if (nhits >= cut(indexNHits_, int()) || ignoreCut(indexNHits_))
571  passCut(ret, indexNHits_);
572  if (nValidMuonHits > cut(indexNValMuHits_, int()) || ignoreCut(indexNValMuHits_))
573  passCut(ret, indexNValMuHits_);
574  if (hcalVeto < cut(indexHCalVeto_, double()) || ignoreCut(indexHCalVeto_))
575  passCut(ret, indexHCalVeto_);
576  if (ecalVeto < cut(indexECalVeto_, double()) || ignoreCut(indexECalVeto_))
577  passCut(ret, indexECalVeto_);
578  if (fabs(z_mu - zvtx) < cut(indexLepZ_, double()) || ignoreCut(indexLepZ_))
579  passCut(ret, indexLepZ_);
580  if (nPixelHits > cut(indexPixHits_, int()) || ignoreCut(indexPixHits_))
581  passCut(ret, indexPixHits_);
582  if (nMatchedStations > cut(indexStations_, int()) || ignoreCut(indexStations_))
583  passCut(ret, indexStations_);
584 
586  //
587  // JMS Dec 13 2010
588  // HACK
589  // Need double-sided relIso cut to implement data-driven QCD
590  //
591  //
593  if (((relIso > 0.2) && (relIso < 0.75)) || ignoreCut(indexRelIso_))
594  passCut(ret, indexRelIso_);
595 
596  setIgnored(ret);
597 
598  return (bool)ret;
599  }
600 
601 private: // member variables
602  Version_t version_;
603  bool recalcDBFromBSp_;
604  edm::InputTag beamLineSrc_;
605 #ifndef __GCCXML__
606  edm::EDGetTokenT<reco::BeamSpot> beamLineSrcToken_;
607 #endif
608  edm::InputTag pvSrc_;
609 #ifndef __GCCXML__
610  edm::EDGetTokenT<std::vector<reco::Vertex> > pvSrcToken_;
611 #endif
612 
613  index_type indexChi2_;
614  index_type indexD0_;
615  index_type indexED0_;
616  index_type indexSD0_;
617  index_type indexNHits_;
618  index_type indexNValMuHits_;
619  index_type indexECalVeto_;
620  index_type indexHCalVeto_;
621  index_type indexRelIso_;
622  index_type indexLepZ_;
623  index_type indexPixHits_;
624  index_type indexStations_;
625 };
626 
627 #endif
edm::ConsumesCollector::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: ConsumesCollector.h:55
Selector< pat::Muon >::set
void set(std::string const &s, bool val=true)
Set a given selection cut, on or off.
Definition: Selector.h:93
reco::BeamSpot::z0
double z0() const
z coordinate
Definition: BeamSpot.h:65
pat::Muon::ecalIso
float ecalIso() const
Definition: Muon.h:183
runTheMatrix.ret
tuple ret
prodAgent to be discontinued
Definition: runTheMatrix.py:603
MuonVPlusJetsIDSelectionFunctor::fall10Cuts
bool fall10Cuts(const pat::Muon &muon, edm::EventBase const &event, pat::strbitset &ret)
Definition: MuonVPlusJetsIDSelectionFunctor.h:388
MuonVPlusJetsIDSelectionFunctor::pvSrcToken_
edm::EDGetTokenT< std::vector< reco::Vertex > > pvSrcToken_
Definition: MuonVPlusJetsIDSelectionFunctor.h:610
MuonVPlusJetsIDSelectionFunctor::firstDataCuts
bool firstDataCuts(const pat::Muon &muon, pat::strbitset &ret)
Definition: MuonVPlusJetsIDSelectionFunctor.h:269
DiDispStaMuonMonitor_cfi.pt
tuple pt
Definition: DiDispStaMuonMonitor_cfi.py:39
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
MuonVPlusJetsIDSelectionFunctor::initialize
void initialize(Version_t version, double chi2=10.0, double d0=999.0, double ed0=999.0, double sd0=3.0, int nhits=11, int nValidMuonHits=0, double ecalveto=4.0, double hcalveto=6.0, double reliso=0.05, double maxLepZ=1.0, int minPixelHits=1, int minNMatches=1)
Definition: MuonVPlusJetsIDSelectionFunctor.h:112
MuonVPlusJetsIDSelectionFunctor::operator()
bool operator()(const pat::Muon &muon, edm::EventBase const &event, pat::strbitset &ret) override
This provides an alternative signature that includes extra information.
Definition: MuonVPlusJetsIDSelectionFunctor.h:196
relval_steps.version
string version
Definition: relval_steps.py:3508
beam_dqm_sourceclient-live_cfg.beamSpot
string beamSpot
Definition: beam_dqm_sourceclient-live_cfg.py:177
MuonVPlusJetsIDSelectionFunctor::MuonVPlusJetsIDSelectionFunctor
MuonVPlusJetsIDSelectionFunctor(edm::ParameterSet const &parameters, edm::ConsumesCollector &iC)
Definition: MuonVPlusJetsIDSelectionFunctor.h:26
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:681
reco::MuonIsolation::hadVetoEt
float hadVetoEt
hcal sum-et in the veto region in r-phi
Definition: MuonIsolation.h:14
pat::Muon::dB
double dB(IPTYPE type) const
Selector< pat::Muon >::index_type
pat::strbitset::index_type index_type
Definition: Selector.h:25
Selector< pat::Muon >::setIgnored
void setIgnored(pat::strbitset &ret)
set ignored bits
Definition: Selector.h:181
reco::LeafCandidate::vertex
const Point & vertex() const override
vertex position (overwritten by PF...)
Definition: LeafCandidate.h:165
Selector< pat::Muon >::retInternal_
pat::strbitset retInternal_
internal ret if users don&#39;t care about return bits
Definition: Selector.h:242
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
pat::Muon::trackIso
float trackIso() const
Definition: Muon.h:179
MuonVPlusJetsIDSelectionFunctor::summer08Cuts
bool summer08Cuts(const pat::Muon &muon, pat::strbitset &ret)
Definition: MuonVPlusJetsIDSelectionFunctor.h:233
pat::Muon::hcalIso
float hcalIso() const
Definition: Muon.h:187
Selector< pat::Muon >::bits_
pat::strbitset bits_
the bitset indexed by strings
Definition: Selector.h:241
Selector< pat::Muon >::passCut
void passCut(pat::strbitset &ret, std::string const &s)
Passing cuts.
Definition: Selector.h:142
HLT_FULL_cff.chi2
tuple chi2
Definition: HLT_FULL_cff.py:9425
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
Selector< pat::Muon >::ignoreCut
bool ignoreCut(std::string const &s) const
ignore the cut at index &quot;s&quot;
Definition: Selector.h:127
reco::BeamSpot::BeamWidthX
double BeamWidthX() const
beam width X
Definition: BeamSpot.h:82
Selector< pat::Muon >::push_back
virtual void push_back(std::string const &s)
This is the registration of an individual cut string.
Definition: Selector.h:42
reco::TrackBase::Point
math::XYZPoint Point
point in the space
Definition: TrackBase.h:80
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
Selector
Functor that operates on &lt;T&gt;
Definition: Selector.h:22
pat::Muon::edB
double edB(IPTYPE type) const
MuonVPlusJetsIDSelectionFunctor::beamLineSrcToken_
edm::EDGetTokenT< reco::BeamSpot > beamLineSrcToken_
Definition: MuonVPlusJetsIDSelectionFunctor.h:606
HLT_FULL_cff.muon
tuple muon
Definition: HLT_FULL_cff.py:10469
MuonVPlusJetsIDSelectionFunctor::MuonVPlusJetsIDSelectionFunctor
MuonVPlusJetsIDSelectionFunctor(Version_t version, double chi2=10.0, double d0=0.2, double ed0=999.0, double sd0=999.0, int nhits=11, int nValidMuonHits=0, double ecalveto=4.0, double hcalveto=6.0, double reliso=0.05, double maxLepZ=1.0, int minPixelHits=1, int minNMatches=1)
Definition: MuonVPlusJetsIDSelectionFunctor.h:81
pat::strbitset::index_type
Definition: strbitset.h:25
HLT_FULL_cff.minPixelHits
tuple minPixelHits
Definition: HLT_FULL_cff.py:26373
MuonVPlusJetsIDSelectionFunctor::spring10Cuts
bool spring10Cuts(const pat::Muon &muon, edm::EventBase const &event, pat::strbitset &ret)
Definition: MuonVPlusJetsIDSelectionFunctor.h:311
d0
static constexpr float d0
Definition: L1EGammaCrystalsEmulatorProducer.cc:85
MuonVPlusJetsIDSelectionFunctor::operator()
bool operator()(const pat::Muon &muon, pat::strbitset &ret) override
This provides the interface for base classes to select objects.
Definition: MuonVPlusJetsIDSelectionFunctor.h:215
reco::MuonIsolation::emVetoEt
float emVetoEt
ecal sum-et in the veto region in r-phi
Definition: MuonIsolation.h:13
pat::strbitset::set
strbitset & set(bool val=true)
set method of all bits
Definition: strbitset.h:126
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
reco::BeamSpot::BeamWidthY
double BeamWidthY() const
beam width Y
Definition: BeamSpot.h:84
pat::Muon::globalTrack
reco::TrackRef globalTrack() const override
reference to Track reconstructed in both tracked and muon detector (reimplemented from reco::Muon) ...
Definition: Muon.h:80
reco::Muon::numberOfMatches
int numberOfMatches(ArbitrationType type=SegmentAndTrackArbitration) const
get number of chambers with matched segments
pat::Muon::innerTrack
reco::TrackRef innerTrack() const override
reference to Track reconstructed in the tracker only (reimplemented from reco::Muon) ...
Definition: Muon.h:72
Selector< pat::Muon >::getBitTemplate
pat::strbitset getBitTemplate() const
Get an empty bitset with the proper names.
Definition: Selector.h:168
MuonVPlusJetsIDSelectionFunctor::MuonVPlusJetsIDSelectionFunctor
MuonVPlusJetsIDSelectionFunctor(edm::ParameterSet const &parameters)
Definition: MuonVPlusJetsIDSelectionFunctor.h:33
reco::BeamSpot::y0
double y0() const
y coordinate
Definition: BeamSpot.h:63
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:144
Selector< pat::Muon >::setIgnoredCuts
void setIgnoredCuts(std::vector< std::string > const &bitsToIgnore)
set the bits to ignore from a vector
Definition: Selector.h:131
pat::Muon::numberOfValidHits
unsigned int numberOfValidHits() const
numberOfValidHits returns the number of valid hits on the global track.
MuonVPlusJetsIDSelectionFunctor::kitQCDCuts
bool kitQCDCuts(const pat::Muon &muon, edm::EventBase const &event, pat::strbitset &ret)
Definition: MuonVPlusJetsIDSelectionFunctor.h:492
pat::Muon::normChi2
double normChi2() const
Norm chi2 gives the normalized chi2 of the global track.
pat::Muon
Analysis-level muon class.
Definition: Muon.h:51
reco::Muon::isolationR03
const MuonIsolation & isolationR03() const
Definition: Muon.h:166
Selector< pat::Muon >::cut
int cut(index_type const &i, int val) const
Access the int cut values at index &quot;s&quot;.
Definition: Selector.h:158
reco::BeamSpot::x0
double x0() const
x coordinate
Definition: BeamSpot.h:61
Generated for CMSSW Reference Manual by doxygen 1.8.5