CMS 3D CMS Logo

EgHLTDQMCut.h
Go to the documentation of this file.
1 #ifndef DQMOFFLINE_TRIGGER_EGHLTDQMCUT
2 #define DQMOFFLINE_TRIGGER_EGHLTDQMCUT
3 
4 //class: EgHLTDQMCut
5 //
6 //author: Sam Harper (June 2008)
7 //
8 //WARNING: interface is NOT final, please dont use this class for now without clearing it with me
9 // as I will change it and possibly break all your code
10 //
11 //aim: to allow the user to place a cut on the electron using it or the event
12 //
13 //implimentation:
14 
17 
20 
21 //this is a pure virtual struct which defines the interface to the cut objects
22 //it is also currently uncopyable
23 
24 namespace egHLT {
25 
26  template <class T>
27  struct EgHLTDQMCut {
28  private:
29  //disabling copy and assignment for all objects
30  EgHLTDQMCut& operator=(const EgHLTDQMCut& rhs) { return *this; }
31 
32  protected:
33  //only derived classes can call the copy constructor (needed for clone...)
34  EgHLTDQMCut(const EgHLTDQMCut& rhs) = default;
35 
36  public:
37  EgHLTDQMCut() = default;
38  virtual ~EgHLTDQMCut() = default;
39  virtual bool pass(const T& obj, const OffEvt& evt) const = 0;
40  virtual EgHLTDQMCut<T>* clone() const = 0; //caller owns the pointer
41  };
42 
43  template <class T>
44  struct EgHLTDQMVarCut : public EgHLTDQMCut<T> {
45  private:
46  int cutsToPass_; //the cuts whose eff we are measuring
47  int (T::*cutCodeFunc_)() const;
48 
49  public:
50  EgHLTDQMVarCut(int cutsToPass, int (T::*cutCodeFunc)() const)
51  : cutsToPass_(cutsToPass), cutCodeFunc_(cutCodeFunc) {}
52  ~EgHLTDQMVarCut() override = default;
53 
54  bool pass(const T& obj, const OffEvt& evt) const override;
55  EgHLTDQMCut<T>* clone() const override { return new EgHLTDQMVarCut(*this); } //default copy constructor is fine
56  };
57 
58  //to understand this you need to know about
59  //1) templates
60  //2) inheritance (sort of)
61  //3) function pointers
62  //4) bitwise operations
63  //All it does is get the bitword corresponding to the cuts the electron failed and the mask the bits which correspond to cuts we dont care about and then see if any bits are still set
64  template <class T>
65  bool EgHLTDQMVarCut<T>::pass(const T& obj, const OffEvt& evt) const {
66  if (((obj.*cutCodeFunc_)() & cutsToPass_) == 0)
67  return true;
68  else
69  return false;
70  }
71 
72  //now this is similar to EgHLTDQMVarCut except that it allows a key to specified to the cut code function
73  template <class T, class Key>
74  struct EgHLTDQMUserVarCut : public EgHLTDQMCut<T> {
75  private:
76  int (T::*cutCodeFunc_)(const Key&) const;
77  const Key key_;
79 
80  public:
81  EgHLTDQMUserVarCut(int (T::*cutCodeFunc)(const Key&) const, const Key& key, int cutsNotToMask = ~0x0)
82  : cutCodeFunc_(cutCodeFunc), key_(key), cutsNotToMask_(cutsNotToMask) {}
83  ~EgHLTDQMUserVarCut() override = default;
84 
85  bool pass(const T& obj, const OffEvt& evt) const override;
86  EgHLTDQMCut<T>* clone() const override { return new EgHLTDQMUserVarCut(*this); } //default copy constructor is fine
87  };
88 
89  template <class T, class Key>
90  bool EgHLTDQMUserVarCut<T, Key>::pass(const T& obj, const OffEvt& evt) const {
91  if (((obj.*cutCodeFunc_)(key_)&cutsNotToMask_) == 0)
92  return true;
93  else
94  return false;
95  }
96 
97  template <class T, typename varType>
98  struct EgGreaterCut : public EgHLTDQMCut<T> {
99  private:
101  varType (T::*varFunc_)() const;
102 
103  public:
104  EgGreaterCut(varType cutValue, varType (T::*varFunc)() const) : cutValue_(cutValue), varFunc_(varFunc) {}
105 
106  bool pass(const T& obj, const OffEvt& evt) const override { return (obj.*varFunc_)() > cutValue_; }
107  EgHLTDQMCut<T>* clone() const override { return new EgGreaterCut(*this); } //default copy constructor is fine
108  };
109 
110  //this struct allows multiple cuts to be strung together
111  //now I could quite simply have a link to the next cut defined in the base class
112  //and the operator<< defined there also but I dont for the following reason
113  //1) I'm concerned about a circular chain of cuts (hence why you cant do a EgMultiCut << EgMultiCut)
114  //2) it requires all cuts to multi cut aware in the pass function
115  //in the future I may change it so this class isnt required
116  template <class T>
117  struct EgMultiCut : public EgHLTDQMCut<T> {
118  private:
119  std::vector<const EgHLTDQMCut<T>*> cuts_; //all the points to the cuts we own
120 
121  public:
122  EgMultiCut() = default;
123  EgMultiCut(const EgMultiCut<T>& rhs);
124  ~EgMultiCut() override {
125  for (size_t i = 0; i < cuts_.size(); i++)
126  delete cuts_[i];
127  }
128 
129  //we own any cut given to use this way
130  EgMultiCut<T>& operator<<(const EgHLTDQMCut<T>* inputCut);
131 
132  //basically an AND of all the cuts using short circuit evaluation, starting with the first cut
133  //if no cuts present, will default to true
134  bool pass(const T& obj, const OffEvt& evt) const override;
135  EgHLTDQMCut<T>* clone() const override { return new EgMultiCut(*this); }
136  };
137 
138  template <class T>
140  for (size_t cutNr = 0; cutNr < rhs.cuts_.size(); cutNr++) {
141  cuts_.push_back(rhs.cuts_[cutNr]->clone());
142  }
143  }
144 
145  template <class T>
147  if (typeid(*inputCut) == typeid(EgMultiCut)) {
148  edm::LogError("EgMultiCut") << " Error can not currently load an EgMultiCut inside a EgMultiCut, the practical "
149  "upshot is that the selection you think is being loaded isnt ";
150  } else if (inputCut == nullptr) {
151  edm::LogError("EgMultiCut") << "Error, cut being loaded is null, ignoring";
152  } else
153  cuts_.push_back(inputCut);
154  return *this;
155  }
156 
157  template <class T>
158  bool EgMultiCut<T>::pass(const T& obj, const OffEvt& evt) const {
159  for (size_t i = 0; i < cuts_.size(); i++) {
160  if (!cuts_[i]->pass(obj, evt))
161  return false;
162  }
163  return true;
164  }
165 
166  //pass in which bits you want the trigger to pass
167  //how this works
168  //1) you specify the trigger bits you want to pass
169  //2) you then specify whether you require all to be passed (AND) or just 1 (OR). It assumes OR by default
170  //3) optionally, you can then specify any trigger bits you want to ensure fail. If any of these trigger bits
171  // are passed (OR), then the cut fails, you can also specify only to fail if all are passed (AND)
172  template <class T>
173  struct EgObjTrigCut : public EgHLTDQMCut<T> {
174  public:
175  enum CutLogic { AND, OR };
176 
177  private:
178  //currently fine for default copy construction
183 
184  public:
186  CutLogic passLogic = OR,
188  CutLogic failLogic = AND)
189  : bitsToPass_(bitsToPass), passLogic_(passLogic), bitsToFail_(bitsToFail), failLogic_(failLogic) {}
190  ~EgObjTrigCut() override = default;
191 
192  bool pass(const T& obj, const OffEvt& evt) const override;
193  EgHLTDQMCut<T>* clone() const override { return new EgObjTrigCut(*this); }
194  };
195 
196  template <class T>
197  bool EgObjTrigCut<T>::pass(const T& obj, const OffEvt& evt) const {
198  TrigCodes::TrigBitSet passMasked = bitsToPass_ & obj.trigBits();
199  TrigCodes::TrigBitSet failMasked = bitsToFail_ & obj.trigBits();
200 
201  bool passResult = passLogic_ == AND ? passMasked == bitsToPass_ : passMasked != 0x0;
202  bool failResult = failLogic_ == AND ? failMasked == bitsToFail_ : failMasked != 0x0;
203  if (bitsToFail_ == 0x0)
204  failResult = false; //ensuring it has no effect if bits not specified
205  return passResult && !failResult;
206  }
207 
208  //pass in which bits you want the trigger to pass
209  //can either specify to pass all of the bits (AND) or any of the bits (OR)
210  template <class T>
211  struct EgEvtTrigCut : public EgHLTDQMCut<T> {
212  public:
213  enum CutLogic { AND, OR };
214 
215  private:
216  //currently default copy constructor is fine
219 
220  public:
222  : bitsToPass_(bitsToPass), passLogic_(passLogic) {}
223  ~EgEvtTrigCut() = default;
224 
225  bool pass(const T& obj, const OffEvt& evt) const;
226  EgHLTDQMCut<T>* clone() const { return new EgEvtTrigCut(*this); }
227  };
228 
229  template <class T>
230  bool EgEvtTrigCut<T>::pass(const T& obj, const OffEvt& evt) const {
231  TrigCodes::TrigBitSet passMasked = bitsToPass_ & evt.evtTrigBits();
232  return passLogic_ == AND ? passMasked == bitsToPass_ : passMasked != 0x0;
233  }
234 
235  //nots the cut, ie makes it return false instead of true
236  template <class T>
237  struct EgNotCut : public EgHLTDQMCut<T> {
238  private:
239  EgHLTDQMCut<T>* cut_; //we own it
240 
241  public:
243  EgNotCut(const EgNotCut<T>& rhs) : cut_(rhs.cut_->clone()) {}
244  ~EgNotCut() { delete cut_; }
245 
246  bool pass(const T& obj, const OffEvt& evt) const { return !cut_->pass(obj, evt); }
247  EgHLTDQMCut<T>* clone() const { return new EgNotCut(*this); }
248  };
249 
250  //cut on the charge of the electron
251  template <class T>
252  struct ChargeCut : public EgHLTDQMCut<T> {
253  private:
254  int charge_;
255 
256  public:
258  ~ChargeCut() override = default;
259 
260  bool pass(const T& obj, const OffEvt& evt) const override { return obj.charge() == charge_; }
261  EgHLTDQMCut<T>* clone() const override { return new ChargeCut(*this); }
262  };
263 
264  //this askes if an object statifies the probe criteria and that another electron in the event statisfies the tag
265  //although templated, its hard to think of this working for anything else other then an electron
266  template <class T>
267  struct EgTagProbeCut : public EgHLTDQMCut<T> {
268  private:
270  int (T::*probeCutCodeFunc_)() const;
273  float minMass_;
274  float maxMass_;
275 
276  public:
277  EgTagProbeCut(int probeCutCode,
278  int (T::*probeCutCodeFunc)() const,
279  int tagCutCode,
280  int (OffEle::*tagCutCodeFunc)() const,
281  float minMass = 81.,
282  float maxMass = 101.)
283  : probeCutCode_(probeCutCode),
284  probeCutCodeFunc_(probeCutCodeFunc),
285  tagCutCode_(tagCutCode),
286  tagCutCodeFunc_(tagCutCodeFunc),
287  minMass_(minMass),
288  maxMass_(maxMass) {}
289  ~EgTagProbeCut() override = default;
290 
291  bool pass(const T& obj, const OffEvt& evt) const override;
292  EgHLTDQMCut<T>* clone() const override { return new EgTagProbeCut(*this); }
293  };
294 
295  template <class T>
296  bool EgTagProbeCut<T>::pass(const T& obj, const OffEvt& evt) const {
297  int nrTags = 0;
298  const OffEle* tagEle = nullptr;
299  const std::vector<OffEle>& eles = evt.eles();
300  //we are looking for an *additional* tag
301  for (const auto& ele : eles) {
302  if (((ele.*tagCutCodeFunc_)() & tagCutCode_) == 0x0) {
303  //now a check that the tag is not the same as the probe
304  if (reco::deltaR2(obj.eta(), obj.phi(), ele.eta(), ele.phi()) >
305  0.1 * 0.1) { //not in a cone of 0.1 of probe object
306  nrTags++;
307  tagEle = &ele;
308  }
309  }
310  }
311  if (nrTags ==
312  1) { //we are requiring one and only one additional tag (the obj is automatically excluded from the tag list)
313  if (((obj.*probeCutCodeFunc_)() & probeCutCode_) == 0x0) { //passes probe requirements, lets check the mass
314  float mass = (obj.p4() + tagEle->p4()).mag();
315  if (mass > minMass_ && mass < maxMass_)
316  return true; //mass requirements
317  }
318  }
319  return false;
320  }
321 
322  template <class T>
323  struct EgJetTagProbeCut : public EgHLTDQMCut<T> {
324  private:
327 
328  float minDPhi_;
329  float maxDPhi_;
330 
331  public:
332  EgJetTagProbeCut(int probeCutCode, int (T::*probeCutCodeFunc)() const, float minDPhi = -M_PI, float maxDPhi = M_PI)
333  : probeCutCode_(probeCutCode), probeCutCodeFunc_(probeCutCodeFunc), minDPhi_(minDPhi), maxDPhi_(maxDPhi) {}
334  bool pass(const T& obj, const OffEvt& evt) const override;
335  EgHLTDQMCut<T>* clone() const override { return new EgJetTagProbeCut(*this); }
336  };
337 
338  template <class T>
339  bool EgJetTagProbeCut<T>::pass(const T& obj, const OffEvt& evt) const {
340  int nrProbes = 0;
341  const std::vector<OffEle>& eles = evt.eles();
342  for (const auto& ele : eles) {
343  if (((ele.*probeCutCodeFunc_)() & probeCutCode_) == 0x0) {
344  nrProbes++;
345  }
346  }
347  bool b2bJet = false;
348  const std::vector<reco::CaloJet>& jets = evt.jets();
349  for (const auto& jet : jets) {
350  if (reco::deltaR2(obj.eta(), obj.phi(), jet.eta(), jet.phi()) >
351  0.1 * 0.1) { //not in a cone of 0.1 of probe object
352  float dPhi = reco::deltaPhi(obj.phi(), jet.phi());
353  if (dPhi > minDPhi_ && dPhi < maxDPhi_)
354  b2bJet = true;
355  }
356  }
357 
358  return nrProbes == 1 && b2bJet;
359  }
360 
361  template <class T>
362  struct EgJetB2BCut : public EgHLTDQMCut<T> {
363  private:
364  float minDPhi_;
365  float maxDPhi_;
366  float ptRelDiff_;
367 
368  public:
369  EgJetB2BCut(float minDPhi = -M_PI, float maxDPhi = M_PI, float ptRelDiff = 999)
370  : minDPhi_(minDPhi), maxDPhi_(maxDPhi), ptRelDiff_(ptRelDiff) {}
371  bool pass(const T& obj, const OffEvt& evt) const;
372  EgHLTDQMCut<T>* clone() const { return new EgJetB2BCut(*this); }
373  };
374 
375  template <class T>
376  bool EgJetB2BCut<T>::pass(const T& obj, const OffEvt& evt) const {
377  bool b2bJet = false;
378  const std::vector<reco::CaloJet>& jets = evt.jets();
379  for (const auto& jet : jets) {
380  if (reco::deltaR2(obj.eta(), obj.phi(), jet.eta(), jet.phi()) >
381  0.1 * 0.1) { //not in a cone of 0.1 of probe object
382  float dPhi = reco::deltaPhi(obj.phi(), jet.phi());
383  if (dPhi > minDPhi_ && dPhi < maxDPhi_ && fabs(1 - jet.pt() / obj.pt()) < ptRelDiff_)
384  b2bJet = true;
385  }
386  }
387  return b2bJet;
388  }
389 
390  //requires the the passed in electron and another in the event passes the specified cuts
391  struct EgDiEleCut : public EgHLTDQMCut<OffEle> {
392  private:
393  int cutCode_;
394  int (OffEle::*cutCodeFunc_)() const;
395 
396  public:
397  EgDiEleCut(int cutCode, int (OffEle::*cutCodeFunc)() const) : cutCode_(cutCode), cutCodeFunc_(cutCodeFunc) {}
398  bool pass(const OffEle& obj, const OffEvt& evt) const override;
399  EgHLTDQMCut<OffEle>* clone() const override { return new EgDiEleCut(*this); }
400  };
401 
402  //requires the the passed in electron and another in the event passes the specified cuts
403  template <class Key>
404  struct EgDiEleUserCut : public EgHLTDQMCut<OffEle> {
405  private:
406  int (OffEle::*cutCodeFunc_)(const Key&) const;
407  const Key& key_;
409 
410  public:
411  EgDiEleUserCut(int (OffEle::*cutCodeFunc)(const Key&) const, const Key& key, int cutsNotToMask = ~0x0)
412  : cutCodeFunc_(cutCodeFunc), key_(key), cutsNotToMask_(cutsNotToMask) {}
413  ~EgDiEleUserCut() override = default;
414 
415  bool pass(const OffEle& obj, const OffEvt& evt) const override;
416  EgHLTDQMCut<OffEle>* clone() const override {
417  return new EgDiEleUserCut(*this);
418  } //default copy constructor is fine
419  };
420 
421  template <class Key>
422  bool EgDiEleUserCut<Key>::pass(const OffEle& obj, const OffEvt& evt) const {
423  const std::vector<OffEle>& eles = evt.eles();
424  for (const auto& ele : eles) {
425  if (&ele != &obj) { //different electrons
426  int diEleCutCode = (obj.*cutCodeFunc_)(key_) | (ele.*cutCodeFunc_)(key_);
427  if ((diEleCutCode & cutsNotToMask_) == 0x0)
428  return true;
429  }
430  }
431  return false;
432  }
433 
434  //requires the the passed in photon and another in the event passes the specified cuts
435  struct EgDiPhoCut : public EgHLTDQMCut<OffPho> {
436  private:
437  int cutCode_;
438  int (OffPho::*cutCodeFunc_)() const;
439 
440  public:
441  EgDiPhoCut(int cutCode, int (OffPho::*cutCodeFunc)() const) : cutCode_(cutCode), cutCodeFunc_(cutCodeFunc) {}
442  bool pass(const OffPho& obj, const OffEvt& evt) const override;
443  EgHLTDQMCut<OffPho>* clone() const override { return new EgDiPhoCut(*this); }
444  };
445 
446  //requires passed photon and another in the event passes the specified cuts
447  template <class Key>
448  struct EgDiPhoUserCut : public EgHLTDQMCut<OffPho> {
449  private:
450  int (OffPho::*cutCodeFunc_)(const Key&) const;
451  const Key& key_;
453 
454  public:
455  EgDiPhoUserCut(int (OffPho::*cutCodeFunc)(const Key&) const, const Key& key, int cutsNotToMask = ~0x0)
456  : cutCodeFunc_(cutCodeFunc), key_(key), cutsNotToMask_(cutsNotToMask) {}
457  ~EgDiPhoUserCut() override = default;
458 
459  bool pass(const OffPho& obj, const OffEvt& evt) const override;
460  EgHLTDQMCut<OffPho>* clone() const override {
461  return new EgDiPhoUserCut(*this);
462  } //default copy constructor is fine
463  };
464 
465  template <class Key>
466  bool EgDiPhoUserCut<Key>::pass(const OffPho& obj, const OffEvt& evt) const {
467  const std::vector<OffPho>& phos = evt.phos();
468  for (const auto& pho : phos) {
469  if (&pho != &obj) { //different phoctrons
470 
471  int diPhoCutCode = (obj.*cutCodeFunc_)(key_) | (pho.*cutCodeFunc_)(key_);
472  if ((diPhoCutCode & cutsNotToMask_) == 0x0)
473  return true;
474  }
475  }
476  return false;
477  }
478 
479  //a trigger tag and probe cut
480  //basically we require the electron to pass some cuts
481  //and then do tag and probe on the trigger
482  //removing templates as it makes no sense
483  struct EgTrigTagProbeCut : public EgHLTDQMCut<OffEle> {
484  private:
486  int cutCode_;
487  int (OffEle::*cutCodeFunc_)() const;
488  float minMass_;
489  float maxMass_;
490 
491  public:
493  int cutCode,
494  int (OffEle::*cutCodeFunc)() const,
495  float minMass = 81.,
496  float maxMass = 101.)
497  : bitsToPass_(bitsToPass), cutCode_(cutCode), cutCodeFunc_(cutCodeFunc), minMass_(minMass), maxMass_(maxMass) {}
498  ~EgTrigTagProbeCut() override = default;
499 
500  bool pass(const OffEle& ele, const OffEvt& evt) const override;
501  EgHLTDQMCut<OffEle>* clone() const override { return new EgTrigTagProbeCut(*this); }
502  };
503 
504  //----Morse----
505  //new tag and probe cut
506  //require two wp80 electrons
507  struct EgTrigTagProbeCut_New : public EgHLTDQMCut<OffEle> {
508  private:
511  int cutCode_;
512  int (OffEle::*cutCodeFunc_)() const;
513  float minMass_;
514  float maxMass_;
515 
516  public:
518  TrigCodes::TrigBitSet bit2ToPass,
519  int cutCode,
520  int (OffEle::*cutCodeFunc)() const,
521  float minMass = 81.,
522  float maxMass = 101.)
523  : bit1ToPass_(bit1ToPass),
524  bit2ToPass_(bit2ToPass),
525  cutCode_(cutCode),
526  cutCodeFunc_(cutCodeFunc),
527  minMass_(minMass),
528  maxMass_(maxMass) {}
529  ~EgTrigTagProbeCut_New() override = default;
530 
531  bool pass(const OffEle& ele, const OffEvt& evt) const override;
532  EgHLTDQMCut<OffEle>* clone() const override { return new EgTrigTagProbeCut_New(*this); }
533  };
534  //same for photons
535  struct EgTrigTagProbeCut_NewPho : public EgHLTDQMCut<OffPho> {
536  private:
539  int cutCode_;
540  int (OffPho::*cutCodeFunc_)() const;
541  float minMass_;
542  float maxMass_;
543 
544  public:
546  TrigCodes::TrigBitSet bit2ToPass,
547  int cutCode,
548  int (OffPho::*cutCodeFunc)() const,
549  float minMass = 81.,
550  float maxMass = 101.)
551  : bit1ToPass_(bit1ToPass),
552  bit2ToPass_(bit2ToPass),
553  cutCode_(cutCode),
554  cutCodeFunc_(cutCodeFunc),
555  minMass_(minMass),
556  maxMass_(maxMass) {}
557  ~EgTrigTagProbeCut_NewPho() override = default;
558 
559  bool pass(const OffPho& pho, const OffEvt& evt) const override;
560  EgHLTDQMCut<OffPho>* clone() const override { return new EgTrigTagProbeCut_NewPho(*this); }
561  };
562 
563 } // namespace egHLT
564 #endif
egHLT::EgJetTagProbeCut::maxDPhi_
float maxDPhi_
Definition: EgHLTDQMCut.h:329
egHLT::ChargeCut::charge_
int charge_
Definition: EgHLTDQMCut.h:254
egHLT::EgEvtTrigCut::~EgEvtTrigCut
~EgEvtTrigCut()=default
egHLT::EgGreaterCut::varFunc_
varType(T::* varFunc_)() const
Definition: EgHLTDQMCut.h:101
egHLT::EgDiPhoCut::pass
bool pass(const OffPho &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.cc:111
egHLT::EgTagProbeCut::minMass_
float minMass_
Definition: EgHLTDQMCut.h:273
egHLT::EgDiPhoCut
Definition: EgHLTDQMCut.h:435
egHLT::EgDiEleCut::EgDiEleCut
EgDiEleCut(int cutCode, int(OffEle::*cutCodeFunc)() const)
Definition: EgHLTDQMCut.h:397
mps_fire.i
i
Definition: mps_fire.py:428
egHLT::EgHLTDQMUserVarCut::pass
bool pass(const T &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:90
egHLT::EgJetB2BCut::pass
bool pass(const T &obj, const OffEvt &evt) const
Definition: EgHLTDQMCut.h:376
egHLT::ChargeCut::pass
bool pass(const T &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:260
MessageLogger.h
egHLT::EgTrigTagProbeCut_New::~EgTrigTagProbeCut_New
~EgTrigTagProbeCut_New() override=default
egHLT::EgDiPhoCut::clone
EgHLTDQMCut< OffPho > * clone() const override
Definition: EgHLTDQMCut.h:443
egHLT::EgTrigTagProbeCut::bitsToPass_
TrigCodes::TrigBitSet bitsToPass_
Definition: EgHLTDQMCut.h:485
TkAlMuonSelectors_cfi.cut
cut
Definition: TkAlMuonSelectors_cfi.py:5
egHLT::EgDiPhoUserCut::key_
const Key & key_
Definition: EgHLTDQMCut.h:451
egHLT::ChargeCut::ChargeCut
ChargeCut(int charge)
Definition: EgHLTDQMCut.h:257
egHLT::EgTrigTagProbeCut_New::cutCode_
int cutCode_
Definition: EgHLTDQMCut.h:511
egHLT::EgHLTDQMVarCut::cutsToPass_
int cutsToPass_
Definition: EgHLTDQMCut.h:46
egHLT::EgTagProbeCut::probeCutCode_
int probeCutCode_
Definition: EgHLTDQMCut.h:269
egHLT::EgJetTagProbeCut::probeCutCode_
int probeCutCode_
Definition: EgHLTDQMCut.h:325
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
egHLT::EgTrigTagProbeCut
Definition: EgHLTDQMCut.h:483
egHLT::EgHLTDQMCut::EgHLTDQMCut
EgHLTDQMCut()=default
egHLT::OffEvt::phos
const std::vector< OffPho > & phos() const
Definition: EgHLTOffEvt.h:50
egHLT::EgJetTagProbeCut::EgJetTagProbeCut
EgJetTagProbeCut(int probeCutCode, int(T::*probeCutCodeFunc)() const, float minDPhi=-M_PI, float maxDPhi=M_PI)
Definition: EgHLTDQMCut.h:332
egHLT::EgDiPhoCut::EgDiPhoCut
EgDiPhoCut(int cutCode, int(OffPho::*cutCodeFunc)() const)
Definition: EgHLTDQMCut.h:441
egHLT::EgJetB2BCut::EgJetB2BCut
EgJetB2BCut(float minDPhi=-M_PI, float maxDPhi=M_PI, float ptRelDiff=999)
Definition: EgHLTDQMCut.h:369
egHLT::EgObjTrigCut::AND
Definition: EgHLTDQMCut.h:175
egHLT::EgTrigTagProbeCut_NewPho::bit1ToPass_
TrigCodes::TrigBitSet bit1ToPass_
Definition: EgHLTDQMCut.h:537
egHLT::EgTrigTagProbeCut::cutCode_
int cutCode_
Definition: EgHLTDQMCut.h:486
egHLT::EgTagProbeCut::clone
EgHLTDQMCut< T > * clone() const override
Definition: EgHLTDQMCut.h:292
egHLT::OffEvt
Definition: EgHLTOffEvt.h:29
egHLT::EgNotCut::~EgNotCut
~EgNotCut()
Definition: EgHLTDQMCut.h:244
egHLT::EgMultiCut
Definition: EgHLTDQMCut.h:117
egHLT::EgMultiCut::EgMultiCut
EgMultiCut()=default
HLT_FULL_cff.maxDPhi
maxDPhi
Definition: HLT_FULL_cff.py:9146
singleTopDQM_cfi.jets
jets
Definition: singleTopDQM_cfi.py:42
egHLT::EgHLTDQMVarCut::EgHLTDQMVarCut
EgHLTDQMVarCut(int cutsToPass, int(T::*cutCodeFunc)() const)
Definition: EgHLTDQMCut.h:50
egHLT::EgGreaterCut::clone
EgHLTDQMCut< T > * clone() const override
Definition: EgHLTDQMCut.h:107
egHLT::EgHLTDQMUserVarCut::clone
EgHLTDQMCut< T > * clone() const override
Definition: EgHLTDQMCut.h:86
HLT_FULL_cff.dPhi
dPhi
Definition: HLT_FULL_cff.py:13703
egHLT::EgMultiCut::operator<<
EgMultiCut< T > & operator<<(const EgHLTDQMCut< T > *inputCut)
Definition: EgHLTDQMCut.h:146
egHLT::EgObjTrigCut::OR
Definition: EgHLTDQMCut.h:175
egHLT::OffEle
Definition: EgHLTOffEle.h:29
egHLT::EgTagProbeCut::probeCutCodeFunc_
int(T::* probeCutCodeFunc_)() const
Definition: EgHLTDQMCut.h:270
egHLT::EgTrigTagProbeCut::EgTrigTagProbeCut
EgTrigTagProbeCut(TrigCodes::TrigBitSet bitsToPass, int cutCode, int(OffEle::*cutCodeFunc)() const, float minMass=81., float maxMass=101.)
Definition: EgHLTDQMCut.h:492
egHLT::EgHLTDQMVarCut::pass
bool pass(const T &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:65
egHLT::ChargeCut::clone
EgHLTDQMCut< T > * clone() const override
Definition: EgHLTDQMCut.h:261
egHLT::EgDiEleCut::cutCodeFunc_
int(OffEle::* cutCodeFunc_)() const
Definition: EgHLTDQMCut.h:394
egHLT::EgEvtTrigCut::CutLogic
CutLogic
Definition: EgHLTDQMCut.h:213
egHLT::OffEvt::jets
const std::vector< reco::CaloJet > & jets() const
Definition: EgHLTOffEvt.h:53
egHLT::EgEvtTrigCut::EgEvtTrigCut
EgEvtTrigCut(TrigCodes::TrigBitSet bitsToPass, CutLogic passLogic=OR)
Definition: EgHLTDQMCut.h:221
egHLT::EgObjTrigCut::failLogic_
CutLogic failLogic_
Definition: EgHLTDQMCut.h:182
egHLT::EgObjTrigCut::clone
EgHLTDQMCut< T > * clone() const override
Definition: EgHLTDQMCut.h:193
egHLT::EgNotCut::pass
bool pass(const T &obj, const OffEvt &evt) const
Definition: EgHLTDQMCut.h:246
egHLT::EgTrigTagProbeCut_New::bit2ToPass_
TrigCodes::TrigBitSet bit2ToPass_
Definition: EgHLTDQMCut.h:510
Key
Definition: GoldenPattern.h:15
egHLT::EgDiPhoUserCut::~EgDiPhoUserCut
~EgDiPhoUserCut() override=default
egHLT::OffEvt::evtTrigBits
TrigCodes::TrigBitSet evtTrigBits() const
Definition: EgHLTOffEvt.h:52
egHLT::EgHLTDQMUserVarCut::~EgHLTDQMUserVarCut
~EgHLTDQMUserVarCut() override=default
egHLT::EgDiPhoCut::cutCodeFunc_
int(OffPho::* cutCodeFunc_)() const
Definition: EgHLTDQMCut.h:438
egHLT::EgDiEleUserCut::key_
const Key & key_
Definition: EgHLTDQMCut.h:407
egHLT::EgTrigTagProbeCut_New::maxMass_
float maxMass_
Definition: EgHLTDQMCut.h:514
egHLT::OffPho
Definition: EgHLTOffPho.h:26
egHLT::EgTrigTagProbeCut_New
Definition: EgHLTDQMCut.h:507
egHLT::EgHLTDQMCut
Definition: EgHLTDQMCut.h:27
egHLT::TrigCodes::TrigBitSet
std::bitset< maxNrBits_ > TrigBitSet
Definition: EgHLTTrigCodes.h:23
egHLT::EgTrigTagProbeCut_New::cutCodeFunc_
int(OffEle::* cutCodeFunc_)() const
Definition: EgHLTDQMCut.h:512
egHLT::EgDiPhoUserCut::cutCodeFunc_
int(OffPho::* cutCodeFunc_)(const Key &) const
Definition: EgHLTDQMCut.h:450
egHLT::EgJetB2BCut::ptRelDiff_
float ptRelDiff_
Definition: EgHLTDQMCut.h:366
egHLT::EgDiEleUserCut::pass
bool pass(const OffEle &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:422
egHLT::EgDiPhoUserCut::EgDiPhoUserCut
EgDiPhoUserCut(int(OffPho::*cutCodeFunc)(const Key &) const, const Key &key, int cutsNotToMask=~0x0)
Definition: EgHLTDQMCut.h:455
egHLT::ChargeCut::~ChargeCut
~ChargeCut() override=default
egHLT::EgObjTrigCut::pass
bool pass(const T &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:197
egHLT::EgDiEleUserCut::clone
EgHLTDQMCut< OffEle > * clone() const override
Definition: EgHLTDQMCut.h:416
egHLT::EgDiPhoUserCut::clone
EgHLTDQMCut< OffPho > * clone() const override
Definition: EgHLTDQMCut.h:460
egHLT::EgTrigTagProbeCut_New::pass
bool pass(const OffEle &ele, const OffEvt &evt) const override
Definition: EgHLTDQMCut.cc:34
egHLT::EgHLTDQMUserVarCut::cutsNotToMask_
int cutsNotToMask_
Definition: EgHLTDQMCut.h:78
dumpRecoGeometry_cfg.varType
varType
Definition: dumpRecoGeometry_cfg.py:8
egHLT::EgJetTagProbeCut::clone
EgHLTDQMCut< T > * clone() const override
Definition: EgHLTDQMCut.h:335
egHLT::EgHLTDQMVarCut::cutCodeFunc_
int(T::* cutCodeFunc_)() const
Definition: EgHLTDQMCut.h:47
getGTfromDQMFile.obj
obj
Definition: getGTfromDQMFile.py:32
egHLT::EgDiEleUserCut::cutCodeFunc_
int(OffEle::* cutCodeFunc_)(const Key &) const
Definition: EgHLTDQMCut.h:406
egHLT::EgTagProbeCut::maxMass_
float maxMass_
Definition: EgHLTDQMCut.h:274
egHLT::EgTrigTagProbeCut::cutCodeFunc_
int(OffEle::* cutCodeFunc_)() const
Definition: EgHLTDQMCut.h:487
egHLT::EgNotCut::cut_
EgHLTDQMCut< T > * cut_
Definition: EgHLTDQMCut.h:239
egHLT::EgHLTDQMUserVarCut::key_
const Key key_
Definition: EgHLTDQMCut.h:77
egHLT::EgJetTagProbeCut::pass
bool pass(const T &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:339
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
egHLT::EgHLTDQMUserVarCut::EgHLTDQMUserVarCut
EgHLTDQMUserVarCut(int(T::*cutCodeFunc)(const Key &) const, const Key &key, int cutsNotToMask=~0x0)
Definition: EgHLTDQMCut.h:81
egHLT::EgHLTDQMVarCut::clone
EgHLTDQMCut< T > * clone() const override
Definition: EgHLTDQMCut.h:55
egHLT::EgDiEleCut
Definition: EgHLTDQMCut.h:391
egHLT::EgHLTDQMVarCut
Definition: EgHLTDQMCut.h:44
egHLT::EgJetB2BCut
Definition: EgHLTDQMCut.h:362
egHLT::EgMultiCut::~EgMultiCut
~EgMultiCut() override
Definition: EgHLTDQMCut.h:124
egHLT::ChargeCut
Definition: EgHLTDQMCut.h:252
deltaR.h
egHLT::EgTrigTagProbeCut_NewPho::bit2ToPass_
TrigCodes::TrigBitSet bit2ToPass_
Definition: EgHLTDQMCut.h:538
egHLT::EgJetTagProbeCut::minDPhi_
float minDPhi_
Definition: EgHLTDQMCut.h:328
egHLT::EgMultiCut::clone
EgHLTDQMCut< T > * clone() const override
Definition: EgHLTDQMCut.h:135
egHLT::EgTrigTagProbeCut_NewPho
Definition: EgHLTDQMCut.h:535
egHLT::EgTrigTagProbeCut_New::EgTrigTagProbeCut_New
EgTrigTagProbeCut_New(TrigCodes::TrigBitSet bit1ToPass, TrigCodes::TrigBitSet bit2ToPass, int cutCode, int(OffEle::*cutCodeFunc)() const, float minMass=81., float maxMass=101.)
Definition: EgHLTDQMCut.h:517
B2GTnPMonitor_cfi.maxMass
maxMass
Definition: B2GTnPMonitor_cfi.py:55
egHLT::EgEvtTrigCut::bitsToPass_
TrigCodes::TrigBitSet bitsToPass_
Definition: EgHLTDQMCut.h:217
egHLT::EgDiPhoUserCut
Definition: EgHLTDQMCut.h:448
egHLT::EgNotCut::EgNotCut
EgNotCut(EgHLTDQMCut< T > *cut)
Definition: EgHLTDQMCut.h:242
egHLT::EgObjTrigCut
Definition: EgHLTDQMCut.h:173
reco::deltaR2
constexpr auto deltaR2(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:16
egHLT::EgNotCut::clone
EgHLTDQMCut< T > * clone() const
Definition: EgHLTDQMCut.h:247
egHLT::EgTrigTagProbeCut_NewPho::~EgTrigTagProbeCut_NewPho
~EgTrigTagProbeCut_NewPho() override=default
egHLT::EgTrigTagProbeCut_NewPho::EgTrigTagProbeCut_NewPho
EgTrigTagProbeCut_NewPho(TrigCodes::TrigBitSet bit1ToPass, TrigCodes::TrigBitSet bit2ToPass, int cutCode, int(OffPho::*cutCodeFunc)() const, float minMass=81., float maxMass=101.)
Definition: EgHLTDQMCut.h:545
egHLT::EgGreaterCut
Definition: EgHLTDQMCut.h:98
egHLT::EgObjTrigCut::EgObjTrigCut
EgObjTrigCut(TrigCodes::TrigBitSet bitsToPass, CutLogic passLogic=OR, TrigCodes::TrigBitSet bitsToFail=TrigCodes::TrigBitSet(), CutLogic failLogic=AND)
Definition: EgHLTDQMCut.h:185
createfilelist.int
int
Definition: createfilelist.py:10
egHLT::EgJetTagProbeCut::probeCutCodeFunc_
int(OffEle::* probeCutCodeFunc_)() const
Definition: EgHLTDQMCut.h:326
egHLT::EgTagProbeCut::EgTagProbeCut
EgTagProbeCut(int probeCutCode, int(T::*probeCutCodeFunc)() const, int tagCutCode, int(OffEle::*tagCutCodeFunc)() const, float minMass=81., float maxMass=101.)
Definition: EgHLTDQMCut.h:277
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:49
egHLT::EgHLTDQMUserVarCut
Definition: EgHLTDQMCut.h:74
egHLT::EgDiEleUserCut::~EgDiEleUserCut
~EgDiEleUserCut() override=default
egHLT::EgEvtTrigCut::pass
bool pass(const T &obj, const OffEvt &evt) const
Definition: EgHLTDQMCut.h:230
EgHLTOfflineSource_cfi.tagEle
tagEle
Definition: EgHLTOfflineSource_cfi.py:75
egHLT::EgTagProbeCut::tagCutCodeFunc_
int(OffEle::* tagCutCodeFunc_)() const
Definition: EgHLTDQMCut.h:272
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
egHLT::EgTagProbeCut
Definition: EgHLTDQMCut.h:267
egHLT::EgJetB2BCut::clone
EgHLTDQMCut< T > * clone() const
Definition: EgHLTDQMCut.h:372
egHLT::EgDiEleUserCut::cutsNotToMask_
int cutsNotToMask_
Definition: EgHLTDQMCut.h:408
egHLT::EgTrigTagProbeCut_NewPho::cutCode_
int cutCode_
Definition: EgHLTDQMCut.h:539
egHLT::EgEvtTrigCut
Definition: EgHLTDQMCut.h:211
egHLT::EgJetB2BCut::minDPhi_
float minDPhi_
Definition: EgHLTDQMCut.h:364
egHLT::EgHLTDQMCut::pass
virtual bool pass(const T &obj, const OffEvt &evt) const =0
egHLT::EgGreaterCut::EgGreaterCut
EgGreaterCut(varType cutValue, varType(T::*varFunc)() const)
Definition: EgHLTDQMCut.h:104
egHLT::EgEvtTrigCut::clone
EgHLTDQMCut< T > * clone() const
Definition: EgHLTDQMCut.h:226
mag
T mag() const
The vector magnitude. Equivalent to sqrt(vec.mag2())
Definition: Basic3DVectorLD.h:127
egHLT::EgObjTrigCut::passLogic_
CutLogic passLogic_
Definition: EgHLTDQMCut.h:180
egHLT::EgHLTDQMCut::operator=
EgHLTDQMCut & operator=(const EgHLTDQMCut &rhs)
Definition: EgHLTDQMCut.h:30
egHLT::EgObjTrigCut::bitsToPass_
TrigCodes::TrigBitSet bitsToPass_
Definition: EgHLTDQMCut.h:179
egHLT::EgTrigTagProbeCut_NewPho::minMass_
float minMass_
Definition: EgHLTDQMCut.h:541
egHLT::EgObjTrigCut::bitsToFail_
TrigCodes::TrigBitSet bitsToFail_
Definition: EgHLTDQMCut.h:181
egHLT::EgTrigTagProbeCut_NewPho::cutCodeFunc_
int(OffPho::* cutCodeFunc_)() const
Definition: EgHLTDQMCut.h:540
egHLT::EgObjTrigCut::CutLogic
CutLogic
Definition: EgHLTDQMCut.h:175
T
long double T
Definition: Basic3DVectorLD.h:48
metsig::jet
Definition: SignAlgoResolutions.h:47
egHLT::EgTagProbeCut::tagCutCode_
int tagCutCode_
Definition: EgHLTDQMCut.h:271
egHLT::EgDiEleUserCut::EgDiEleUserCut
EgDiEleUserCut(int(OffEle::*cutCodeFunc)(const Key &) const, const Key &key, int cutsNotToMask=~0x0)
Definition: EgHLTDQMCut.h:411
egHLT::EgTrigTagProbeCut_NewPho::maxMass_
float maxMass_
Definition: EgHLTDQMCut.h:542
egHLT::EgJetB2BCut::maxDPhi_
float maxDPhi_
Definition: EgHLTDQMCut.h:365
EgHLTOffHistBins_cfi.mass
mass
Definition: EgHLTOffHistBins_cfi.py:34
egHLT::EgTrigTagProbeCut_New::clone
EgHLTDQMCut< OffEle > * clone() const override
Definition: EgHLTDQMCut.h:532
egHLT::EgEvtTrigCut::OR
Definition: EgHLTDQMCut.h:213
egHLT::EgTrigTagProbeCut::~EgTrigTagProbeCut
~EgTrigTagProbeCut() override=default
B2GTnPMonitor_cfi.minMass
minMass
Definition: B2GTnPMonitor_cfi.py:54
egHLT::EgDiEleUserCut
Definition: EgHLTDQMCut.h:404
egHLT::EgNotCut
Definition: EgHLTDQMCut.h:237
egHLT::EgDiPhoCut::cutCode_
int cutCode_
Definition: EgHLTDQMCut.h:437
egHLT::EgTrigTagProbeCut::maxMass_
float maxMass_
Definition: EgHLTDQMCut.h:489
egHLT::EgDiEleCut::pass
bool pass(const OffEle &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.cc:98
egHLT::EgTagProbeCut::~EgTagProbeCut
~EgTagProbeCut() override=default
egHLT::EgGreaterCut::pass
bool pass(const T &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:106
EgHLTTrigCodes.h
egHLT::EgTrigTagProbeCut_New::minMass_
float minMass_
Definition: EgHLTDQMCut.h:513
egHLT::EgTagProbeCut::pass
bool pass(const T &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:296
egHLT::EgJetTagProbeCut
Definition: EgHLTDQMCut.h:323
egHLT::EgDiPhoUserCut::pass
bool pass(const OffPho &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:466
egHLT::EgEvtTrigCut::AND
Definition: EgHLTDQMCut.h:213
egHLT::EgDiPhoUserCut::cutsNotToMask_
int cutsNotToMask_
Definition: EgHLTDQMCut.h:452
EgHLTOffEvt.h
egHLT::OffEvt::eles
const std::vector< OffEle > & eles() const
Definition: EgHLTOffEvt.h:48
egHLT::EgTrigTagProbeCut::pass
bool pass(const OffEle &ele, const OffEvt &evt) const override
Definition: EgHLTDQMCut.cc:5
egHLT
Definition: EgHLTBinData.h:10
crabWrapper.key
key
Definition: crabWrapper.py:19
egHLT::EgHLTDQMCut::~EgHLTDQMCut
virtual ~EgHLTDQMCut()=default
egHLT::EgMultiCut::pass
bool pass(const T &obj, const OffEvt &evt) const override
Definition: EgHLTDQMCut.h:158
egHLT::EgHLTDQMUserVarCut::cutCodeFunc_
int(T::* cutCodeFunc_)(const Key &) const
Definition: EgHLTDQMCut.h:76
egHLT::EgEvtTrigCut::passLogic_
CutLogic passLogic_
Definition: EgHLTDQMCut.h:218
egHLT::EgHLTDQMCut::clone
virtual EgHLTDQMCut< T > * clone() const =0
egHLT::EgObjTrigCut::~EgObjTrigCut
~EgObjTrigCut() override=default
egHLT::EgHLTDQMVarCut::~EgHLTDQMVarCut
~EgHLTDQMVarCut() override=default
egHLT::EgGreaterCut::cutValue_
varType cutValue_
Definition: EgHLTDQMCut.h:100
egHLT::EgTrigTagProbeCut::clone
EgHLTDQMCut< OffEle > * clone() const override
Definition: EgHLTDQMCut.h:501
egHLT::EgDiEleCut::clone
EgHLTDQMCut< OffEle > * clone() const override
Definition: EgHLTDQMCut.h:399
egHLT::EgTrigTagProbeCut_NewPho::clone
EgHLTDQMCut< OffPho > * clone() const override
Definition: EgHLTDQMCut.h:560
egHLT::EgDiEleCut::cutCode_
int cutCode_
Definition: EgHLTDQMCut.h:393
egHLT::EgTrigTagProbeCut_New::bit1ToPass_
TrigCodes::TrigBitSet bit1ToPass_
Definition: EgHLTDQMCut.h:509
egHLT::EgNotCut::EgNotCut
EgNotCut(const EgNotCut< T > &rhs)
Definition: EgHLTDQMCut.h:243
egHLT::EgMultiCut::cuts_
std::vector< const EgHLTDQMCut< T > * > cuts_
Definition: EgHLTDQMCut.h:119
egHLT::EgTrigTagProbeCut_NewPho::pass
bool pass(const OffPho &pho, const OffEvt &evt) const override
Definition: EgHLTDQMCut.cc:66
egHLT::EgTrigTagProbeCut::minMass_
float minMass_
Definition: EgHLTDQMCut.h:488