CMS 3D CMS Logo
SimpleCutBasedElectronIDSelectionFunctor.h
Go to the documentation of this file.
1 #ifndef PhysicsTools_PatUtils_interface_SimpleCutBasedElectronIDSelectionFunctor_h
2 #define PhysicsTools_PatUtils_interface_SimpleCutBasedElectronIDSelectionFunctor_h
3 
4 #include "DataFormats/PatCandidates/interface/Electron.h"
5 #include "FWCore/MessageLogger/interface/MessageLogger.h"
6 
7 #include "PhysicsTools/SelectorUtils/interface/Selector.h"
8 #include "FWCore/ParameterSet/interface/ParameterSet.h"
9 
10 #include "FWCore/Utilities/interface/InputTag.h"
11 
12 /*
13 ___________________________________________________________________________________
14 
15 Description:
16 ^^^^^^^^^^^^
17  This is a class that implements the Simple Cut Based Electron
18  Identification cuts. A more detailed description of the cuts
19  and the tuning method can be found on this twiki:
20 
21  https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID
22 
23  For more information on how to calculate the magnetic field
24  look here:
25 
26  https://twiki.cern.ch/twiki/bin/viewauth/CMS/ConversionBackgroundRejection
27 ___________________________________________________________________________________
28 
29 How to use:
30 ^^^^^^^^^^^
31  From CMSSW39 onwards you can simply define an instance of this class:
32 
33  SimpleCutBasedElectronIDSelectionFunctor patSele95
34  (SimpleCutBasedElectronIDSelectionFunctor::relIso95);
35 
36  and get the decision with the following method:
37  pat::Electron *myElec = .....;
38  bool pass = patSele90(*myElec);
39 
40  The various options are listed in the enumeration Version_t. There
41  is also the option to enter as a constructor argument a PSet
42  with your favorite cuts.
43 ___________________________________________________________________________________
44 
45  Contacts: Nikolaos Rompotis and Chris Seez
46  Nikolaos dot Rompotis at Cern dot ch
47  Chris dot Seez at Cern dot ch
48 
49  Author: Nikolaos Rompotis
50  many thanks to Sal Rappoccio
51  Imperial College London
52  7 June 2010, first commit for CMSSW_3_6_1_patchX
53  11July 2010, implementing the ICHEP Egamma recommendation for
54  removing the Delta Eta cut in the endcaps
55  30Sept 2010, simplification of conversion rejection in CMSSW39X
56 ___________________________________________________________________________________
57 
58 */
59 
60 class SimpleCutBasedElectronIDSelectionFunctor : public Selector<pat::Electron> {
61 public: // interface
62  enum Version_t {
63  relIso95 = 0,
64  cIso95,
65  relIso90,
66  cIso90,
67  relIso85,
68  cIso85,
69  relIso80,
70  cIso80,
71  relIso70,
72  cIso70,
73  relIso60,
74  cIso60,
75  NONE
76  };
77 
78  SimpleCutBasedElectronIDSelectionFunctor() {}
79 
80  // initialize it by inserting directly the cut values in a parameter set
81  SimpleCutBasedElectronIDSelectionFunctor(edm::ParameterSet const& parameters) {
82  // get the cuts from the PS
83  initialize(parameters.getParameter<Double_t>("trackIso_EB"),
84  parameters.getParameter<Double_t>("ecalIso_EB"),
85  parameters.getParameter<Double_t>("hcalIso_EB"),
86  parameters.getParameter<Double_t>("sihih_EB"),
87  parameters.getParameter<Double_t>("dphi_EB"),
88  parameters.getParameter<Double_t>("deta_EB"),
89  parameters.getParameter<Double_t>("hoe_EB"),
90  parameters.getParameter<Double_t>("cIso_EB"),
91  parameters.getParameter<Double_t>("trackIso_EE"),
92  parameters.getParameter<Double_t>("ecalIso_EE"),
93  parameters.getParameter<Double_t>("hcalIso_EE"),
94  parameters.getParameter<Double_t>("sihih_EE"),
95  parameters.getParameter<Double_t>("dphi_EE"),
96  parameters.getParameter<Double_t>("deta_EE"),
97  parameters.getParameter<Double_t>("hoe_EE"),
98  parameters.getParameter<Double_t>("cIso_EE"),
99  parameters.getParameter<Int_t>("conversionRejection"),
100  parameters.getParameter<Int_t>("maxNumberOfExpectedMissingHits"));
101  retInternal_ = getBitTemplate();
102  }
103  // initialize it by using only the version name
104  SimpleCutBasedElectronIDSelectionFunctor(Version_t version) {
105  if (version == NONE) {
106  std::cout << "SimpleCutBasedElectronIDSelectionFunctor: If you want to use version NONE "
107  << "then you have also to provide the selection cuts by yourself " << std::endl;
108  std::cout << "SimpleCutBasedElectronIDSelectionFunctor: ID Version is changed to 80cIso " << std::endl;
109  version = cIso80;
110  }
111  initialize(version);
112  retInternal_ = getBitTemplate();
113  }
114 
115  void initialize(Version_t version) {
116  version_ = version;
117  // push back the variables
118  push_back("trackIso_EB");
119  push_back("ecalIso_EB");
120  push_back("hcalIso_EB");
121  push_back("sihih_EB");
122  push_back("dphi_EB");
123  push_back("deta_EB");
124  push_back("hoe_EB");
125  push_back("cIso_EB");
126 
127  push_back("trackIso_EE");
128  push_back("ecalIso_EE");
129  push_back("hcalIso_EE");
130  push_back("sihih_EE");
131  push_back("dphi_EE");
132  push_back("deta_EE");
133  push_back("hoe_EE");
134  push_back("cIso_EE");
135 
136  push_back("conversionRejection");
137  push_back("maxNumberOfExpectedMissingHits");
138 
139  if (version_ == relIso95) {
140  set("trackIso_EB", 1.5e-01);
141  set("ecalIso_EB", 2.0e+00);
142  set("hcalIso_EB", 1.2e-01);
143  set("sihih_EB", 1.0e-02);
144  set("dphi_EB", 8.0e-01);
145  set("deta_EB", 7.0e-03);
146  set("hoe_EB", 1.5e-01);
147  set("cIso_EB", 10000.);
148 
149  set("trackIso_EE", 8.0e-02);
150  set("ecalIso_EE", 6.0e-02);
151  set("hcalIso_EE", 5.0e-02);
152  set("sihih_EE", 3.0e-02);
153  set("dphi_EE", 7.0e-01);
154  set("deta_EE", 1.0e-02);
155  set("hoe_EE", 7.0e-02);
156  set("cIso_EE", 10000.);
157 
158  set("conversionRejection", 0);
159  set("maxNumberOfExpectedMissingHits", 1);
160 
161  } else if (version_ == cIso95) {
162  set("trackIso_EB", 100000.);
163  set("ecalIso_EB", 100000.);
164  set("hcalIso_EB", 100000.);
165  set("sihih_EB", 1.0e-02);
166  set("dphi_EB", 8.0e-01);
167  set("deta_EB", 7.0e-03);
168  set("hoe_EB", 1.5e-01);
169  set("cIso_EB", 1.5e-01);
170 
171  set("trackIso_EE", 100000.);
172  set("ecalIso_EE", 100000.);
173  set("hcalIso_EE", 100000.);
174  set("sihih_EE", 3.0e-02);
175  set("dphi_EE", 7.0e-01);
176  set("deta_EE", 1.0e-02);
177  set("hoe_EE", 7.0e-02);
178  set("cIso_EE", 1.0e-01);
179 
180  set("conversionRejection", 0);
181  set("maxNumberOfExpectedMissingHits", 1);
182 
183  } else if (version_ == relIso90) {
184  set("trackIso_EB", 1.2e-01);
185  set("ecalIso_EB", 9.0e-02);
186  set("hcalIso_EB", 1.0e-01);
187  set("sihih_EB", 1.0e-02);
188  set("dphi_EB", 8.0e-01);
189  set("deta_EB", 7.0e-03);
190  set("hoe_EB", 1.2e-01);
191  set("cIso_EB", 10000.);
192 
193  set("trackIso_EE", 5.0e-02);
194  set("ecalIso_EE", 6.0e-02);
195  set("hcalIso_EE", 3.0e-02);
196  set("sihih_EE", 3.0e-02);
197  set("dphi_EE", 7.0e-01);
198  set("deta_EE", 9.0e-03);
199  set("hoe_EE", 5.0e-02);
200  set("cIso_EE", 10000.);
201 
202  set("conversionRejection", 1);
203  set("maxNumberOfExpectedMissingHits", 1);
204  } else if (version_ == cIso90) {
205  set("trackIso_EB", 100000.);
206  set("ecalIso_EB", 100000.);
207  set("hcalIso_EB", 100000.);
208  set("sihih_EB", 1.0e-02);
209  set("dphi_EB", 8.0e-01);
210  set("deta_EB", 7.0e-03);
211  set("hoe_EB", 1.2e-01);
212  set("cIso_EB", 1.0e-01);
213 
214  set("trackIso_EE", 100000.);
215  set("ecalIso_EE", 100000.);
216  set("hcalIso_EE", 100000.);
217  set("sihih_EE", 3.0e-02);
218  set("dphi_EE", 7.0e-01);
219  set("deta_EE", 9.0e-03);
220  set("hoe_EE", 5.0e-02);
221  set("cIso_EE", 7.0e-02);
222 
223  set("conversionRejection", 1);
224  set("maxNumberOfExpectedMissingHits", 1);
225  } else if (version_ == relIso85) {
226  set("trackIso_EB", 9.0e-02);
227  set("ecalIso_EB", 8.0e-02);
228  set("hcalIso_EB", 1.0e-01);
229  set("sihih_EB", 1.0e-02);
230  set("dphi_EB", 6.0e-02);
231  set("deta_EB", 6.0e-03);
232  set("hoe_EB", 4.0e-02);
233  set("cIso_EB", 10000.);
234 
235  set("trackIso_EE", 5.0e-02);
236  set("ecalIso_EE", 5.0e-02);
237  set("hcalIso_EE", 2.5e-02);
238  set("sihih_EE", 3.0e-02);
239  set("dphi_EE", 4.0e-02);
240  set("deta_EE", 7.0e-03);
241  set("hoe_EE", 2.5e-02);
242  set("cIso_EE", 10000.);
243 
244  set("conversionRejection", 1);
245  set("maxNumberOfExpectedMissingHits", 1);
246  } else if (version_ == cIso85) {
247  set("trackIso_EB", 100000.);
248  set("ecalIso_EB", 100000.);
249  set("hcalIso_EB", 100000.);
250  set("sihih_EB", 1.0e-02);
251  set("dphi_EB", 6.0e-02);
252  set("deta_EB", 6.0e-03);
253  set("hoe_EB", 4.0e-02);
254  set("cIso_EB", 9.0e-02);
255 
256  set("trackIso_EE", 100000.);
257  set("ecalIso_EE", 100000.);
258  set("hcalIso_EE", 100000.);
259  set("sihih_EE", 3.0e-02);
260  set("dphi_EE", 4.0e-02);
261  set("deta_EE", 7.0e-03);
262  set("hoe_EE", 2.5e-02);
263  set("cIso_EE", 6.0e-02);
264 
265  set("conversionRejection", 1);
266  set("maxNumberOfExpectedMissingHits", 1);
267  } else if (version_ == relIso80) {
268  set("trackIso_EB", 9.0e-02);
269  set("ecalIso_EB", 7.0e-02);
270  set("hcalIso_EB", 1.0e-01);
271  set("sihih_EB", 1.0e-02);
272  set("dphi_EB", 6.0e-02);
273  set("deta_EB", 4.0e-03);
274  set("hoe_EB", 4.0e-02);
275  set("cIso_EB", 100000.);
276 
277  set("trackIso_EE", 4.0e-02);
278  set("ecalIso_EE", 5.0e-02);
279  set("hcalIso_EE", 2.5e-02);
280  set("sihih_EE", 3.0e-02);
281  set("dphi_EE", 3.0e-02);
282  set("deta_EE", 7.0e-03);
283  set("hoe_EE", 2.5e-02);
284  set("cIso_EE", 100000.);
285 
286  set("conversionRejection", 1);
287  set("maxNumberOfExpectedMissingHits", 0);
288  } else if (version_ == cIso80) {
289  set("trackIso_EB", 100000.);
290  set("ecalIso_EB", 100000.);
291  set("hcalIso_EB", 100000.);
292  set("sihih_EB", 1.0e-02);
293  set("dphi_EB", 6.0e-02);
294  set("deta_EB", 4.0e-03);
295  set("hoe_EB", 4.0e-02);
296  set("cIso_EB", 7.0e-02);
297 
298  set("trackIso_EE", 100000.);
299  set("ecalIso_EE", 100000.);
300  set("hcalIso_EE", 100000.);
301  set("sihih_EE", 3.0e-02);
302  set("dphi_EE", 3.0e-02);
303  set("deta_EE", 7.0e-03);
304  set("hoe_EE", 2.5e-02);
305  set("cIso_EE", 6.0e-02);
306 
307  set("conversionRejection", 1);
308  set("maxNumberOfExpectedMissingHits", 0);
309  } else if (version_ == relIso70) {
310  set("trackIso_EB", 5.0e-02);
311  set("ecalIso_EB", 6.0e-02);
312  set("hcalIso_EB", 3.0e-02);
313  set("sihih_EB", 1.0e-02);
314  set("dphi_EB", 3.0e-02);
315  set("deta_EB", 4.0e-03);
316  set("hoe_EB", 2.5e-02);
317  set("cIso_EB", 100000.);
318 
319  set("trackIso_EE", 2.5e-02);
320  set("ecalIso_EE", 2.5e-02);
321  set("hcalIso_EE", 2.0e-02);
322  set("sihih_EE", 3.0e-02);
323  set("dphi_EE", 2.0e-02);
324  set("deta_EE", 5.0e-03);
325  set("hoe_EE", 2.5e-02);
326  set("cIso_EE", 100000.);
327 
328  set("conversionRejection", 1);
329  set("maxNumberOfExpectedMissingHits", 0);
330  } else if (version_ == cIso70) {
331  set("trackIso_EB", 100000.);
332  set("ecalIso_EB", 100000.);
333  set("hcalIso_EB", 100000.);
334  set("sihih_EB", 1.0e-02);
335  set("dphi_EB", 3.0e-02);
336  set("deta_EB", 4.0e-03);
337  set("hoe_EB", 2.5e-02);
338  set("cIso_EB", 4.0e-02);
339 
340  set("trackIso_EE", 100000.);
341  set("ecalIso_EE", 100000.);
342  set("hcalIso_EE", 100000.);
343  set("sihih_EE", 3.0e-02);
344  set("dphi_EE", 2.0e-02);
345  set("deta_EE", 5.0e-03);
346  set("hoe_EE", 2.5e-02);
347  set("cIso_EE", 3.0e-02);
348 
349  set("conversionRejection", 1);
350  set("maxNumberOfExpectedMissingHits", 0);
351  } else if (version_ == relIso60) {
352  set("trackIso_EB", 4.0e-02);
353  set("ecalIso_EB", 4.0e-02);
354  set("hcalIso_EB", 3.0e-02);
355  set("sihih_EB", 1.0e-02);
356  set("dphi_EB", 2.5e-02);
357  set("deta_EB", 4.0e-03);
358  set("hoe_EB", 2.5e-02);
359  set("cIso_EB", 100000.);
360 
361  set("trackIso_EE", 2.5e-02);
362  set("ecalIso_EE", 2.0e-02);
363  set("hcalIso_EE", 2.0e-02);
364  set("sihih_EE", 3.0e-02);
365  set("dphi_EE", 2.0e-02);
366  set("deta_EE", 5.0e-03);
367  set("hoe_EE", 2.5e-02);
368  set("cIso_EE", 100000.);
369 
370  set("conversionRejection", 1);
371  set("maxNumberOfExpectedMissingHits", 0);
372  } else if (version_ == cIso60) {
373  set("trackIso_EB", 100000.);
374  set("ecalIso_EB", 100000.);
375  set("hcalIso_EB", 100000.);
376  set("sihih_EB", 1.0e-02);
377  set("dphi_EB", 2.5e-02);
378  set("deta_EB", 4.0e-03);
379  set("hoe_EB", 2.5e-02);
380  set("cIso_EB", 3.0e-02);
381 
382  set("trackIso_EE", 100000.);
383  set("ecalIso_EE", 100000.);
384  set("hcalIso_EE", 100000.);
385  set("sihih_EE", 3.0e-02);
386  set("dphi_EE", 2.0e-02);
387  set("deta_EE", 5.0e-03);
388  set("hoe_EE", 2.5e-02);
389  set("cIso_EE", 2.0e-02);
390 
391  set("conversionRejection", 1);
392  set("maxNumberOfExpectedMissingHits", 0);
393  }
394  }
395 
396  void initialize(Double_t trackIso_EB,
397  Double_t ecalIso_EB,
398  Double_t hcalIso_EB,
399  Double_t sihih_EB,
400  Double_t dphi_EB,
401  Double_t deta_EB,
402  Double_t hoe_EB,
403  Double_t cIso_EB,
404  Double_t trackIso_EE,
405  Double_t ecalIso_EE,
406  Double_t hcalIso_EE,
407  Double_t sihih_EE,
408  Double_t dphi_EE,
409  Double_t deta_EE,
410  Double_t hoe_EE,
411  Double_t cIso_EE,
412  Int_t conversionRejection,
413  Int_t maxNumberOfExpectedMissingHits) {
414  version_ = NONE;
415  push_back("trackIso_EB");
416  push_back("ecalIso_EB");
417  push_back("hcalIso_EB");
418  push_back("sihih_EB");
419  push_back("dphi_EB");
420  push_back("deta_EB");
421  push_back("hoe_EB");
422  push_back("cIso_EB");
423 
424  push_back("trackIso_EE");
425  push_back("ecalIso_EE");
426  push_back("hcalIso_EE");
427  push_back("sihih_EE");
428  push_back("dphi_EE");
429  push_back("deta_EE");
430  push_back("hoe_EE");
431  push_back("cIso_EE");
432 
433  push_back("conversionRejection");
434  push_back("maxNumberOfExpectedMissingHits");
435 
436  set("trackIso_EB", trackIso_EB);
437  set("ecalIso_EB", ecalIso_EB);
438  set("hcalIso_EB", hcalIso_EB);
439  set("sihih_EB", sihih_EB);
440  set("dphi_EB", dphi_EB);
441  set("deta_EB", deta_EB);
442  set("hoe_EB", hoe_EB);
443  set("cIso_EB", cIso_EB);
444 
445  set("trackIso_EE", trackIso_EE);
446  set("ecalIso_EE", ecalIso_EE);
447  set("hcalIso_EE", hcalIso_EE);
448  set("sihih_EE", sihih_EE);
449  set("dphi_EE", dphi_EE);
450  set("deta_EE", deta_EE);
451  set("hoe_EE", hoe_EE);
452  set("cIso_EE", cIso_EE);
453 
454  set("conversionRejection", conversionRejection);
455  set("maxNumberOfExpectedMissingHits", maxNumberOfExpectedMissingHits);
456  }
457 
458  bool operator()(const pat::Electron& electron, pat::strbitset& ret) override {
459  // for the time being only Spring10 variable definition
460  return spring10Variables(electron, ret);
461  }
462  using Selector<pat::Electron>::operator();
463  // function with the Spring10 variable definitions
464  bool spring10Variables(const pat::Electron& electron, pat::strbitset& ret) {
465  ret.set(false);
466  //
467  Double_t eleET = electron.p4().Pt();
468  Double_t trackIso = electron.dr03TkSumPt() / eleET;
469  Double_t ecalIso = electron.dr03EcalRecHitSumEt() / eleET;
470  Double_t hcalIso = electron.dr03HcalTowerSumEt() / eleET;
471  Double_t sihih = electron.sigmaIetaIeta();
472  Double_t Dphi = electron.deltaPhiSuperClusterTrackAtVtx();
473  Double_t Deta = electron.deltaEtaSuperClusterTrackAtVtx();
474  Double_t HoE = electron.hadronicOverEm();
475  Double_t cIso = 0;
476  if (electron.isEB()) {
477  cIso =
478  (electron.dr03TkSumPt() + std::max(0., electron.dr03EcalRecHitSumEt() - 1.) + electron.dr03HcalTowerSumEt()) /
479  eleET;
480  } else {
481  cIso = (electron.dr03TkSumPt() + electron.dr03EcalRecHitSumEt() + electron.dr03HcalTowerSumEt()) / eleET;
482  }
483  Int_t innerHits = electron.gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
484  // in 39 conversion rejection variables are accessible from Gsf electron
485  Double_t dist = electron.convDist(); // default value is -9999 if conversion partner not found
486  Double_t dcot = electron.convDcot(); // default value is -9999 if conversion partner not found
487  Bool_t isConv = fabs(dist) < 0.02 && fabs(dcot) < 0.02;
488  // now apply the cuts
489  if (electron.isEB()) { // BARREL case
490  // check the EB cuts
491  if (trackIso < cut("trackIso_EB", double()) || ignoreCut("trackIso_EB"))
492  passCut(ret, "trackIso_EB");
493  if (ecalIso < cut("ecalIso_EB", double()) || ignoreCut("ecalIso_EB"))
494  passCut(ret, "ecalIso_EB");
495  if (hcalIso < cut("hcalIso_EB", double()) || ignoreCut("hcalIso_EB"))
496  passCut(ret, "hcalIso_EB");
497  if (sihih < cut("sihih_EB", double()) || ignoreCut("sihih_EB"))
498  passCut(ret, "sihih_EB");
499  if (fabs(Dphi) < cut("dphi_EB", double()) || ignoreCut("dphi_EB"))
500  passCut(ret, "dphi_EB");
501  if (fabs(Deta) < cut("deta_EB", double()) || ignoreCut("deta_EB"))
502  passCut(ret, "deta_EB");
503  if (HoE < cut("hoe_EB", double()) || ignoreCut("hoe_EB"))
504  passCut(ret, "hoe_EB");
505  if (cIso < cut("cIso_EB", double()) || ignoreCut("cIso_EB"))
506  passCut(ret, "cIso_EB");
507  // pass all the EE cuts
508  passCut(ret, "trackIso_EE");
509  passCut(ret, "ecalIso_EE");
510  passCut(ret, "hcalIso_EE");
511  passCut(ret, "sihih_EE");
512  passCut(ret, "dphi_EE");
513  passCut(ret, "deta_EE");
514  passCut(ret, "hoe_EE");
515  passCut(ret, "cIso_EE");
516  } else { // ENDCAPS case
517  // check the EE cuts
518  if (trackIso < cut("trackIso_EE", double()) || ignoreCut("trackIso_EE"))
519  passCut(ret, "trackIso_EE");
520  if (ecalIso < cut("ecalIso_EE", double()) || ignoreCut("ecalIso_EE"))
521  passCut(ret, "ecalIso_EE");
522  if (hcalIso < cut("hcalIso_EE", double()) || ignoreCut("hcalIso_EE"))
523  passCut(ret, "hcalIso_EE");
524  if (sihih < cut("sihih_EE", double()) || ignoreCut("sihih_EE"))
525  passCut(ret, "sihih_EE");
526  if (fabs(Dphi) < cut("dphi_EE", double()) || ignoreCut("dphi_EE"))
527  passCut(ret, "dphi_EE");
528  if (fabs(Deta) < cut("deta_EE", double()) || ignoreCut("deta_EE"))
529  passCut(ret, "deta_EE");
530  if (HoE < cut("hoe_EE", double()) || ignoreCut("hoe_EE"))
531  passCut(ret, "hoe_EE");
532  if (cIso < cut("cIso_EE", double()) || ignoreCut("cIso_EE"))
533  passCut(ret, "cIso_EE");
534  // pass all the EB cuts
535  passCut(ret, "trackIso_EB");
536  passCut(ret, "ecalIso_EB");
537  passCut(ret, "hcalIso_EB");
538  passCut(ret, "sihih_EB");
539  passCut(ret, "dphi_EB");
540  passCut(ret, "deta_EB");
541  passCut(ret, "hoe_EB");
542  passCut(ret, "cIso_EB");
543  }
544 
545  // conversion rejection common for EB and EE
546  if (innerHits <= cut("maxNumberOfExpectedMissingHits", int()))
547  passCut(ret, "maxNumberOfExpectedMissingHits");
548  if (0 == cut("conversionRejection", int()) || isConv == false)
549  passCut(ret, "conversionRejection");
550  setIgnored(ret);
551  return (bool)ret;
552  }
553 
554 private: // member variables
555  // version of the cuts
556  Version_t version_;
557 };
558 
559 #endif
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:543
SimpleCutBasedElectronIDSelectionFunctor::spring10Variables
bool spring10Variables(const pat::Electron &electron, pat::strbitset &ret)
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:464
BeamSpotPI::parameters
parameters
Definition: BeamSpotPayloadInspectorHelper.h:30
Selector< pat::Electron >::setIgnored
void setIgnored(pat::strbitset &ret)
set ignored bits
Definition: Selector.h:181
Selector
Functor that operates on <T>
Definition: Selector.h:22
MessageLogger.h
SimpleCutBasedElectronIDSelectionFunctor::relIso90
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:65
SimpleCutBasedElectronIDSelectionFunctor::operator()
bool operator()(const pat::Electron &electron, pat::strbitset &ret) override
This provides the interface for base classes to select objects.
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:458
Selector< pat::Electron >::retInternal_
pat::strbitset retInternal_
internal ret if users don't care about return bits
Definition: Selector.h:242
SimpleCutBasedElectronIDSelectionFunctor::SimpleCutBasedElectronIDSelectionFunctor
SimpleCutBasedElectronIDSelectionFunctor(Version_t version)
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:104
Selector< pat::Electron >::ignoreCut
bool ignoreCut(std::string const &s) const
ignore the cut at index "s"
Definition: Selector.h:127
gather_cfg.cout
cout
Definition: gather_cfg.py:144
SimpleCutBasedElectronIDSelectionFunctor::version_
Version_t version_
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:556
SimpleCutBasedElectronIDSelectionFunctor::cIso95
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:64
SimpleCutBasedElectronIDSelectionFunctor::SimpleCutBasedElectronIDSelectionFunctor
SimpleCutBasedElectronIDSelectionFunctor()
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:78
SimpleCutBasedElectronIDSelectionFunctor::SimpleCutBasedElectronIDSelectionFunctor
SimpleCutBasedElectronIDSelectionFunctor(edm::ParameterSet const &parameters)
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:81
Utilities.operator
operator
Definition: Utilities.py:24
SimpleCutBasedElectronIDSelectionFunctor::relIso85
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:67
SimpleCutBasedElectronIDSelectionFunctor::relIso95
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:63
Selector< pat::Electron >::push_back
virtual void push_back(std::string const &s)
This is the registration of an individual cut string.
Definition: Selector.h:42
SimpleCutBasedElectronIDSelectionFunctor::cIso70
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:72
Selector< pat::Electron >::getBitTemplate
pat::strbitset getBitTemplate() const
Get an empty bitset with the proper names.
Definition: Selector.h:168
SimpleCutBasedElectronIDSelectionFunctor::cIso60
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:74
edm::ParameterSet
Definition: ParameterSet.h:47
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
Selector< pat::Electron >::passCut
void passCut(pat::strbitset &ret, std::string const &s)
Passing cuts.
Definition: Selector.h:142
SimpleCutBasedElectronIDSelectionFunctor::cIso85
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:68
SimpleCutBasedElectronIDSelectionFunctor::relIso60
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:73
SimpleCutBasedElectronIDSelectionFunctor
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:60
HPSPFTauProducerPuppi_cfi.electron
electron
Definition: HPSPFTauProducerPuppi_cfi.py:13
InputTag.h
SimpleCutBasedElectronIDSelectionFunctor::NONE
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:75
pat::strbitset
Definition: strbitset.h:23
SimpleCutBasedElectronIDSelectionFunctor::Version_t
Version_t
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:62
SimpleCutBasedElectronIDSelectionFunctor::initialize
void initialize(Version_t version)
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:115
SimpleCutBasedElectronIDSelectionFunctor::cIso90
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:66
Selector< pat::Electron >::cut
int cut(index_type const &i, int val) const
Access the int cut values at index "s".
Definition: Selector.h:158
reco::HitPattern::MISSING_INNER_HITS
Definition: HitPattern.h:155
Electron.h
Selector< pat::Electron >::set
void set(std::string const &s, bool val=true)
Set a given selection cut, on or off.
Definition: Selector.h:93
pat::Electron
Analysis-level electron class.
Definition: Electron.h:51
Selector.h
ParameterSet.h
SimpleCutBasedElectronIDSelectionFunctor::relIso70
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:71
SimpleCutBasedElectronIDSelectionFunctor::cIso80
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:70
BeamSplash_cfg.version
version
Definition: BeamSplash_cfg.py:45
SimpleCutBasedElectronIDSelectionFunctor::relIso80
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:69
SimpleCutBasedElectronIDSelectionFunctor::initialize
void initialize(Double_t trackIso_EB, Double_t ecalIso_EB, Double_t hcalIso_EB, Double_t sihih_EB, Double_t dphi_EB, Double_t deta_EB, Double_t hoe_EB, Double_t cIso_EB, Double_t trackIso_EE, Double_t ecalIso_EE, Double_t hcalIso_EE, Double_t sihih_EE, Double_t dphi_EE, Double_t deta_EE, Double_t hoe_EE, Double_t cIso_EE, Int_t conversionRejection, Int_t maxNumberOfExpectedMissingHits)
Definition: SimpleCutBasedElectronIDSelectionFunctor.h:396
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
Generated for CMSSW Reference Manual by doxygen 1.8.16