CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
JetIDSelectionFunctor.h
Go to the documentation of this file.
1 #ifndef PhysicsTools_PatUtils_interface_JetIDSelectionFunctor_h
2 #define PhysicsTools_PatUtils_interface_JetIDSelectionFunctor_h
3 
4 
22 #ifndef __GCCXML__
23 #include "FWCore/Framework/interface/ConsumesCollector.h"
24 #endif
25 #include "DataFormats/PatCandidates/interface/Jet.h"
26 #include "FWCore/MessageLogger/interface/MessageLogger.h"
27 
28 #include "PhysicsTools/SelectorUtils/interface/Selector.h"
29 #include "FWCore/ParameterSet/interface/ParameterSet.h"
30 
31 #include <TMath.h>
32 class JetIDSelectionFunctor : public Selector<pat::Jet> {
33 
34  public: // interface
35 
36  enum Version_t { CRAFT08, PURE09, DQM09, N_VERSIONS };
37  enum Quality_t { MINIMAL, LOOSE_AOD, LOOSE, TIGHT, N_QUALITY};
38 
39  JetIDSelectionFunctor() {}
40 
41 #ifndef __GCCXML__
42  JetIDSelectionFunctor( edm::ParameterSet const & parameters, edm::ConsumesCollector& iC ) :
43  JetIDSelectionFunctor(parameters)
44  {}
45 #endif
46 
47 
48  JetIDSelectionFunctor( edm::ParameterSet const & parameters ) {
49  std::string versionStr = parameters.getParameter<std::string>("version");
50  std::string qualityStr = parameters.getParameter<std::string>("quality");
51  Quality_t quality = N_QUALITY;
52 
53  if ( qualityStr == "MINIMAL" ) quality = MINIMAL;
54  else if ( qualityStr == "LOOSE_AOD" ) quality = LOOSE_AOD;
55  else if ( qualityStr == "LOOSE" ) quality = LOOSE;
56  else if ( qualityStr == "TIGHT" ) quality = TIGHT;
57  else
58  throw cms::Exception("InvalidInput") << "Expect quality to be one of MINIMAL, LOOSE_AOD, LOOSE,TIGHT" << std::endl;
59 
60 
61  if ( versionStr == "CRAFT08" ) {
62  initialize( CRAFT08, quality );
63  }
64  else if ( versionStr == "PURE09" ) {
65  initialize( PURE09, quality );
66  }
67  else if ( versionStr == "DQM09" ) {
68  initialize( DQM09, quality );
69  }
70  else {
71  throw cms::Exception("InvalidInput") << "Expect version to be one of CRAFT08, PURE09, DQM09" << std::endl;
72  }
73  }
74 
75  JetIDSelectionFunctor( Version_t version, Quality_t quality ) {
76  initialize(version, quality);
77  }
78 
79  void initialize( Version_t version, Quality_t quality )
80  {
81 
82  version_ = version;
83  quality_ = quality;
84 
85  push_back("MINIMAL_EMF");
86 
87  push_back("LOOSE_AOD_fHPD");
88  push_back("LOOSE_AOD_N90Hits");
89  push_back("LOOSE_AOD_EMF");
90 
91  push_back("LOOSE_fHPD");
92  push_back("LOOSE_N90Hits");
93  push_back("LOOSE_EMF");
94 
95  push_back("TIGHT_fHPD");
96  push_back("TIGHT_EMF");
97 
98  push_back("LOOSE_nHit");
99  push_back("LOOSE_als");
100  push_back("LOOSE_fls");
101  push_back("LOOSE_foot");
102 
103  push_back("TIGHT_nHit");
104  push_back("TIGHT_als");
105  push_back("TIGHT_fls");
106  push_back("TIGHT_foot");
107  push_back("widths");
108  push_back("EF_N90Hits");
109  push_back("EF_EMF");
110 
111 
112  bool use_09_fwd_id = version_ != CRAFT08; // CRAFT08 predates the 09 forward ID cuts
113  bool use_dqm_09 = version_ == DQM09 && quality_ != LOOSE_AOD;
114 
115  // all appropriate for version and format (AOD complications) are on by default
116  set( "MINIMAL_EMF" );
117  set( "LOOSE_AOD_fHPD" );
118  set( "LOOSE_AOD_N90Hits" );
119  set( "LOOSE_AOD_EMF", ! use_09_fwd_id ); // except in CRAFT08, this devolves into MINIMAL_EMF
120  set( "LOOSE_fHPD" );
121  set( "LOOSE_N90Hits" );
122  set( "LOOSE_EMF", ! use_09_fwd_id ); // except in CRAFT08, this devolves into MINIMAL_EMF
123  set( "TIGHT_fHPD" );
124  set( "TIGHT_EMF" );
125 
126  set( "LOOSE_nHit", use_09_fwd_id );
127  set( "LOOSE_als", use_09_fwd_id );
128  set( "TIGHT_nHit", use_09_fwd_id );
129  set( "TIGHT_als", use_09_fwd_id );
130  set( "widths", use_09_fwd_id );
131  set( "EF_N90Hits", use_09_fwd_id );
132  set( "EF_EMF", use_09_fwd_id );
133 
134  set( "LOOSE_fls", use_dqm_09 );
135  set( "LOOSE_foot", use_dqm_09 );
136  set( "TIGHT_fls", use_dqm_09 );
137  set( "TIGHT_foot", use_dqm_09 );
138 
139 
140 
141 
142  index_MINIMAL_EMF_ = index_type(&bits_, "MINIMAL_EMF");
143 
144  index_LOOSE_AOD_fHPD_ = index_type(&bits_, "LOOSE_AOD_fHPD");
145  index_LOOSE_AOD_N90Hits_ = index_type(&bits_, "LOOSE_AOD_N90Hits");
146  index_LOOSE_AOD_EMF_ = index_type(&bits_, "LOOSE_AOD_EMF");
147 
148  index_LOOSE_fHPD_ = index_type(&bits_, "LOOSE_fHPD");
149  index_LOOSE_N90Hits_ = index_type(&bits_, "LOOSE_N90Hits");
150  index_LOOSE_EMF_ = index_type(&bits_, "LOOSE_EMF");
151 
152  index_TIGHT_fHPD_ = index_type(&bits_, "TIGHT_fHPD");
153  index_TIGHT_EMF_ = index_type(&bits_, "TIGHT_EMF");
154 
155  index_LOOSE_nHit_ = index_type(&bits_, "LOOSE_nHit");
156  index_LOOSE_als_ = index_type(&bits_, "LOOSE_als");
157  index_LOOSE_fls_ = index_type(&bits_, "LOOSE_fls");
158  index_LOOSE_foot_ = index_type(&bits_, "LOOSE_foot");
159 
160  index_TIGHT_nHit_ = index_type(&bits_, "TIGHT_nHit");
161  index_TIGHT_als_ = index_type(&bits_, "TIGHT_als");
162  index_TIGHT_fls_ = index_type(&bits_, "TIGHT_fls");
163  index_TIGHT_foot_ = index_type(&bits_, "TIGHT_foot");
164  index_widths_ = index_type(&bits_, "widths");
165  index_EF_N90Hits_ = index_type(&bits_, "EF_N90Hits");
166  index_EF_EMF_ = index_type(&bits_, "EF_EMF");
167 
168  // now set the return values for the ignored parts
169  bool use_loose_aod = false;
170  bool use_loose = false;
171  bool use_tight = false;
172  bool use_tight_09_fwd_id = false;
173  bool use_loose_09_fwd_id = false;
174  // if ( quality_ == MINIMAL ) nothing to do...
175  if ( quality_ == LOOSE ) {
176  use_loose = true;
177  if( use_09_fwd_id ) use_loose_09_fwd_id = true;
178  }
179  if ( quality_ == LOOSE_AOD ) {
180  use_loose_aod = true;
181  if( use_09_fwd_id ) use_loose_09_fwd_id = true;
182  }
183  if ( quality_ == TIGHT ) {
184  use_tight = true;
185  if( use_09_fwd_id ) use_tight_09_fwd_id = true;
186  }
187 
188  if( ! use_loose_aod ) {
189  set("LOOSE_AOD_fHPD", false );
190  set("LOOSE_AOD_N90Hits", false );
191  set("LOOSE_AOD_EMF", false );
192  }
193 
194  if( ! ( use_loose || use_tight ) ) { // the CRAFT08 cuts are cumulative
195  set("LOOSE_N90Hits", false );
196  set("LOOSE_fHPD", false );
197  set("LOOSE_EMF", false );
198  }
199 
200  if( ! use_tight ) {
201  set("TIGHT_fHPD", false );
202  set("TIGHT_EMF", false );
203  }
204 
205  if( ! use_loose_09_fwd_id ) { // the FWD09 cuts are not
206  set( "LOOSE_nHit", false );
207  set( "LOOSE_als", false );
208  if( use_dqm_09 ) {
209  set( "LOOSE_fls", false );
210  set( "LOOSE_foot", false );
211  }
212  } // not using loose 09 fwd ID
213 
214  if( ! use_tight_09_fwd_id ) {
215  set( "TIGHT_nHit", false );
216  set( "TIGHT_als", false );
217  set( "widths", false );
218  set( "EF_N90Hits", false );
219  set( "EF_EMF", false );
220  if( use_dqm_09 ) {
221  set( "TIGHT_fls", false );
222  set( "TIGHT_foot", false );
223  }
224  } // not using tight 09 fwd ID
225 
226  retInternal_ = getBitTemplate();
227  }
228 
229  // this functionality should be migrated into JetIDHelper in future releases
230  unsigned int count_hits( const std::vector<CaloTowerPtr> & towers )
231  {
232  unsigned int nHit = 0;
233  for ( unsigned int iTower = 0; iTower < towers.size() ; ++iTower ) {
234  const std::vector<DetId>& cellIDs = towers[iTower]->constituents(); // cell == recHit
235  nHit += cellIDs.size();
236  }
237  return nHit;
238  }
239 
240  //
241  // Accessor from PAT jets
242  //
243  bool operator()( const pat::Jet & jet, pat::strbitset & ret )
244  {
245  if ( ! jet.isCaloJet() && !jet.isJPTJet() ) {
246  edm::LogWarning( "NYI" )<<"Criteria for pat::Jet-s other than CaloJets and JPTJets are not yet implemented";
247  return false;
248  }
249  if ( version_ == CRAFT08 ) return craft08Cuts( jet.p4(), jet.emEnergyFraction(), jet.jetID(), ret );
250  if ( version_ == PURE09 || version_ == DQM09 ) {
251  unsigned int nHit = count_hits( jet.getCaloConstituents() );
252  if ( jet.currentJECLevel() == "Uncorrected" ) {
253  return fwd09Cuts( jet.p4(), jet.emEnergyFraction(), jet.etaetaMoment(), jet.phiphiMoment(), nHit,
254  jet.jetID(), ret );
255  }
256  else {
257  return fwd09Cuts( jet.correctedP4("Uncorrected"), jet.emEnergyFraction(), jet.etaetaMoment(), jet.phiphiMoment(), nHit,
258  jet.jetID(), ret );
259  }
260  }
261  edm::LogWarning( "BadInput | NYI" )<<"Requested version ("<<version_<<") is unknown";
262  return false;
263  }
264 
265  // accessor from PAT jets without the ret
266  using Selector<pat::Jet>::operator();
267 
268  //
269  // Accessor from *CORRECTED* 4-vector, EMF, and Jet ID.
270  // This can be used with reco quantities.
271  //
272  bool operator()( reco::Candidate::LorentzVector const & correctedP4,
273  double emEnergyFraction,
274  reco::JetID const & jetID,
275  pat::strbitset & ret )
276  {
277  if ( version_ == CRAFT08 ) return craft08Cuts( correctedP4, emEnergyFraction, jetID, ret );
278  edm::LogWarning( "BadInput | NYI" )<<"Requested version ("<<version_
279  <<") is unknown or doesn't match the depreceated interface used";
280  return false;
281  }
283  virtual bool operator()( reco::Candidate::LorentzVector const & correctedP4,
284  double emEnergyFraction,
285  reco::JetID const & jetID )
286  {
287  retInternal_.set(false);
288  operator()(correctedP4,emEnergyFraction, jetID, retInternal_);
289  setIgnored(retInternal_);
290  return (bool)retInternal_;
291  }
292 
293  //
294  // Accessor from CaloJet and Jet ID. Jets MUST BE corrected for craft08, but uncorrected for later cuts...
295  // This can be used with reco quantities.
296  //
297  bool operator()( reco::CaloJet const & jet,
298  reco::JetID const & jetID,
299  pat::strbitset & ret )
300  {
301  if ( version_ == CRAFT08 ) return craft08Cuts( jet.p4(), jet.emEnergyFraction(), jetID, ret );
302  if ( version_ == PURE09 || version_ == DQM09 ) {
303  unsigned int nHit = count_hits( jet.getCaloConstituents() );
304  return fwd09Cuts( jet.p4(), jet.emEnergyFraction(), jet.etaetaMoment(), jet.phiphiMoment(), nHit,
305  jetID, ret );
306  }
307  edm::LogWarning( "BadInput | NYI" )<<"Requested version ("<<version_<<") is unknown";
308  return false;
309  }
310 
312  virtual bool operator()( reco::CaloJet const & jet,
313  reco::JetID const & jetID )
314  {
315  retInternal_.set(false);
316  operator()(jet, jetID, retInternal_);
317  setIgnored(retInternal_);
318  return (bool)retInternal_;
319  }
320 
321  //
322  // cuts based on craft 08 analysis.
323  //
324  bool craft08Cuts( reco::Candidate::LorentzVector const & correctedP4,
325  double emEnergyFraction,
326  reco::JetID const & jetID,
327  pat::strbitset & ret)
328  {
329 
330  ret.set(false);
331 
332  // cache some variables
333  double abs_eta = TMath::Abs( correctedP4.eta() );
334  double corrPt = correctedP4.pt();
335  double emf = emEnergyFraction;
336 
337  if ( ignoreCut(index_MINIMAL_EMF_) || abs_eta > 2.6 || emf > 0.01 ) passCut( ret, index_MINIMAL_EMF_);
338 
339  if ( quality_ == LOOSE_AOD ) {
340  // loose fhpd cut from aod
341  if ( ignoreCut(index_LOOSE_AOD_fHPD_) || jetID.approximatefHPD < 0.98 ) passCut( ret, index_LOOSE_AOD_fHPD_);
342  // loose n90 hits cut
343  if ( ignoreCut(index_LOOSE_AOD_N90Hits_) || jetID.hitsInN90 > 1 ) passCut( ret, index_LOOSE_AOD_N90Hits_);
344 
345  // loose EMF Cut from aod
346  bool emf_loose = true;
347  if( abs_eta <= 2.6 ) { // HBHE
348  if( emEnergyFraction <= 0.01 ) emf_loose = false;
349  } else { // HF
350  if( emEnergyFraction <= -0.9 ) emf_loose = false;
351  if( corrPt > 80 && emEnergyFraction >= 1 ) emf_loose = false;
352  }
353  if ( ignoreCut(index_LOOSE_AOD_EMF_) || emf_loose ) passCut(ret, index_LOOSE_AOD_EMF_);
354 
355  }
356  else if ( quality_ == LOOSE || quality_ == TIGHT ) {
357  // loose fhpd cut
358  if ( ignoreCut(index_LOOSE_fHPD_) || jetID.fHPD < 0.98 ) passCut( ret, index_LOOSE_fHPD_);
359  // loose n90 hits cut
360  if ( ignoreCut(index_LOOSE_N90Hits_) || jetID.n90Hits > 1 ) passCut( ret, index_LOOSE_N90Hits_);
361 
362  // loose EMF Cut
363  bool emf_loose = true;
364  if( abs_eta <= 2.6 ) { // HBHE
365  if( emEnergyFraction <= 0.01 ) emf_loose = false;
366  } else { // HF
367  if( emEnergyFraction <= -0.9 ) emf_loose = false;
368  if( corrPt > 80 && emEnergyFraction >= 1 ) emf_loose = false;
369  }
370  if ( ignoreCut(index_LOOSE_EMF_) || emf_loose ) passCut(ret, index_LOOSE_EMF_);
371 
372  if ( quality_ == TIGHT ) {
373  // tight fhpd cut
374  bool tight_fhpd = true;
375  if ( corrPt >= 25 && jetID.fHPD >= 0.95 ) tight_fhpd = false; // this was supposed to use raw pT, see AN2009/087 :-(
376  if ( ignoreCut(index_TIGHT_fHPD_) || tight_fhpd ) passCut(ret, index_TIGHT_fHPD_);
377 
378  // tight emf cut
379  bool tight_emf = true;
380  if( abs_eta >= 1 && corrPt >= 80 && emEnergyFraction >= 1 ) tight_emf = false; // outside HB
381  if( abs_eta >= 2.6 ) { // outside HBHE
382  if( emEnergyFraction <= -0.3 ) tight_emf = false;
383  if( abs_eta < 3.25 ) { // HE-HF transition region
384  if( corrPt >= 50 && emEnergyFraction <= -0.2 ) tight_emf = false;
385  if( corrPt >= 80 && emEnergyFraction <= -0.1 ) tight_emf = false;
386  if( corrPt >= 340 && emEnergyFraction >= 0.95 ) tight_emf = false;
387  } else { // HF
388  if( emEnergyFraction >= 0.9 ) tight_emf = false;
389  if( corrPt >= 50 && emEnergyFraction <= -0.2 ) tight_emf = false;
390  if( corrPt >= 50 && emEnergyFraction >= 0.8 ) tight_emf = false;
391  if( corrPt >= 130 && emEnergyFraction <= -0.1 ) tight_emf = false;
392  if( corrPt >= 130 && emEnergyFraction >= 0.7 ) tight_emf = false;
393 
394  } // end if HF
395  }// end if outside HBHE
396  if ( ignoreCut(index_TIGHT_EMF_) || tight_emf ) passCut(ret, index_TIGHT_EMF_);
397  }// end if tight
398  }// end if loose or tight
399 
400  setIgnored( ret );
401 
402  return (bool)ret;
403  }
404 
405  //
406  // cuts based on craft 08 analysis + forward jet ID based on 09 data
407  //
408  bool fwd09Cuts( reco::Candidate::LorentzVector const & rawP4,
409  double emEnergyFraction, double etaWidth, double phiWidth, unsigned int nHit,
410  reco::JetID const & jetID,
411  pat::strbitset & ret)
412  {
413  ret.set(false);
414 
415  // cache some variables
416  double abs_eta = TMath::Abs( rawP4.eta() );
417  double rawPt = rawP4.pt();
418  double emf = emEnergyFraction;
419  double fhf = jetID.fLong + jetID.fShort;
420  double lnpt = ( rawPt > 0 ) ? TMath::Log( rawPt ) : -10;
421  double lnE = ( rawP4.energy() > 0 ) ? TMath::Log( rawP4.energy() ) : -10;
422 
423  bool HB = abs_eta < 1.0;
424  bool EF = 2.6 <= abs_eta && abs_eta < 3.4 && 0.1 <= fhf && fhf < 0.9;
425  bool HBHE = abs_eta < 2.6 || ( abs_eta < 3.4 && fhf < 0.1 );
426  bool HF = 3.4 <= abs_eta || ( 2.6 <= abs_eta && 0.9 <= fhf );
427  bool HFa = HF && abs_eta < 3.8;
428  bool HFb = HF && ! HFa;
429 
430  // HBHE cuts as in CRAFT08
431  // - but using raw pTs
432  // ========================
433 
434  if ( (!HBHE) || ignoreCut(index_MINIMAL_EMF_) || emf > 0.01 ) passCut( ret, index_MINIMAL_EMF_);
435 
436  // loose fhpd cut from AOD
437  if ( (!HBHE) || ignoreCut(index_LOOSE_AOD_fHPD_) || jetID.approximatefHPD < 0.98 ) passCut( ret, index_LOOSE_AOD_fHPD_);
438  // loose n90 hits cut from AOD
439  if ( (!HBHE) || ignoreCut(index_LOOSE_AOD_N90Hits_) || jetID.hitsInN90 > 1 ) passCut( ret, index_LOOSE_AOD_N90Hits_);
440 
441  // loose fhpd cut
442  if ( (!HBHE) || ignoreCut(index_LOOSE_fHPD_) || jetID.fHPD < 0.98 ) passCut( ret, index_LOOSE_fHPD_);
443  // loose n90 hits cut
444  if ( (!HBHE) || ignoreCut(index_LOOSE_N90Hits_) || jetID.n90Hits > 1 ) passCut( ret, index_LOOSE_N90Hits_);
445 
446  // tight fhpd cut
447  if ( (!HBHE) || ignoreCut(index_TIGHT_fHPD_) || rawPt < 25 || jetID.fHPD < 0.95 ) passCut(ret, index_TIGHT_fHPD_);
448 
449  // tight emf cut
450  if ( (!HBHE) || ignoreCut(index_TIGHT_EMF_) || HB || rawPt < 55 || emf < 1 ) passCut(ret, index_TIGHT_EMF_);
451 
452 
453  // EF - these cuts are only used in "tight", but there's no need for this test here.
454 
455  if( (!EF) || ignoreCut( index_EF_N90Hits_ )
456  || jetID.n90Hits > 1 + 1.5 * TMath::Max( 0., lnpt - 1.5 ) )
457  passCut( ret, index_EF_N90Hits_ );
458 
459  if( (!EF) || ignoreCut( index_EF_EMF_ )
460  || emf > TMath::Max( -0.9, -0.1 - 0.05 * TMath::Power( TMath::Max( 0., 5 - lnpt ), 2. ) ) )
461  passCut( ret, index_EF_EMF_ );
462 
463  // both EF and HF
464 
465  if( ( !( EF || HF ) ) || ignoreCut( index_TIGHT_fls_ )
466  || ( EF && jetID.fLS < TMath::Min( 0.8, 0.1 + 0.016 * TMath::Power( TMath::Max( 0., 6 - lnpt ), 2.5 ) ) )
467  || ( HFa && jetID.fLS < TMath::Min( 0.6, 0.05 + 0.045 * TMath::Power( TMath::Max( 0., 7.5 - lnE ), 2.2 ) ) )
468  || ( HFb && jetID.fLS < TMath::Min( 0.1, 0.05 + 0.07 * TMath::Power( TMath::Max( 0., 7.8 - lnE ), 2. ) ) ) )
469  passCut( ret, index_TIGHT_fls_ );
470 
471  if( ( !( EF || HF ) ) || ignoreCut( index_widths_ )
472  || ( 1E-10 < etaWidth && etaWidth < 0.12 &&
473  1E-10 < phiWidth && phiWidth < 0.12 ) )
474  passCut( ret, index_widths_ );
475 
476  // HF cuts
477 
478  if( (!HF) || ignoreCut( index_LOOSE_nHit_ )
479  || ( HFa && nHit > 1 + 2.4*( lnpt - 1. ) )
480  || ( HFb && nHit > 1 + 3.*( lnpt - 1. ) ) )
481  passCut( ret, index_LOOSE_nHit_ );
482 
483  if( (!HF) || ignoreCut( index_LOOSE_als_ )
484  || ( emf < 0.6 + 0.05 * TMath::Power( TMath::Max( 0., 9 - lnE ), 1.5 ) &&
485  emf > -0.2 - 0.041 * TMath::Power( TMath::Max( 0., 7.5 - lnE ), 2.2 ) ) )
486  passCut( ret, index_LOOSE_als_ );
487 
488  if( (!HF) || ignoreCut( index_LOOSE_fls_ )
489  || ( HFa && jetID.fLS < TMath::Min( 0.9, 0.1 + 0.05 * TMath::Power( TMath::Max( 0., 7.5 - lnE ), 2.2 ) ) )
490  || ( HFb && jetID.fLS < TMath::Min( 0.6, 0.1 + 0.065 * TMath::Power( TMath::Max( 0., 7.5 - lnE ), 2.2 ) ) ) )
491  passCut( ret, index_LOOSE_fls_ );
492 
493  if( (!HF) || ignoreCut( index_LOOSE_foot_ )
494  || jetID.fHFOOT < 0.9 )
495  passCut( ret, index_LOOSE_foot_ );
496 
497  if( (!HF) || ignoreCut( index_TIGHT_nHit_ )
498  || ( HFa && nHit > 1 + 2.7*( lnpt - 0.8 ) )
499  || ( HFb && nHit > 1 + 3.5*( lnpt - 0.8 ) ) )
500  passCut( ret, index_TIGHT_nHit_ );
501 
502  if( (!HF) || ignoreCut( index_TIGHT_als_ )
503  || ( emf < 0.5 + 0.057 * TMath::Power( TMath::Max( 0., 9 - lnE ), 1.5 ) &&
504  emf > TMath::Max( -0.6, -0.1 - 0.026 * TMath::Power( TMath::Max( 0., 8 - lnE ), 2.2 ) ) ) )
505  passCut( ret, index_TIGHT_als_ );
506 
507  if( (!HF) || ignoreCut( index_TIGHT_foot_ )
508  || jetID.fLS < 0.5 )
509  passCut( ret, index_TIGHT_foot_ );
510 
511  setIgnored( ret );
512 
513  return (bool)ret;
514  }
515 
516  private: // member variables
517 
518  Version_t version_;
519  Quality_t quality_;
520 
521  index_type index_MINIMAL_EMF_ ;
522 
523  index_type index_LOOSE_AOD_fHPD_ ;
524  index_type index_LOOSE_AOD_N90Hits_ ;
525  index_type index_LOOSE_AOD_EMF_ ;
526 
527  index_type index_LOOSE_fHPD_ ;
528  index_type index_LOOSE_N90Hits_ ;
529  index_type index_LOOSE_EMF_ ;
530 
531  index_type index_TIGHT_fHPD_ ;
532  index_type index_TIGHT_EMF_ ;
533 
534  index_type index_LOOSE_nHit_ ;
535  index_type index_LOOSE_als_ ;
536  index_type index_LOOSE_fls_ ;
537  index_type index_LOOSE_foot_ ;
538 
539  index_type index_TIGHT_nHit_ ;
540  index_type index_TIGHT_als_ ;
541  index_type index_TIGHT_fls_ ;
542  index_type index_TIGHT_foot_ ;
543  index_type index_widths_ ;
544  index_type index_EF_N90Hits_ ;
545  index_type index_EF_EMF_ ;
546 
547 };
548 
549 #endif
pat::Jet::correctedP4
const LorentzVector correctedP4(const std::string &level, const std::string &flavor="none", const std::string &set="") const
Definition: Jet.h:155
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Selector< pat::Jet >::set
void set(std::string const &s, bool val=true)
Set a given selection cut, on or off.
Definition: Selector.h:105
Parameters.parameters
dictionary parameters
Definition: Parameters.py:2
reco::JetID::hitsInN90
short hitsInN90
Definition: JetID.h:57
JetIDSelectionFunctor::initialize
void initialize(Version_t version, Quality_t quality)
Definition: JetIDSelectionFunctor.h:79
JetIDSelectionFunctor::JetIDSelectionFunctor
JetIDSelectionFunctor(Version_t version, Quality_t quality)
Definition: JetIDSelectionFunctor.h:75
reco::CaloJet
Jets made from CaloTowers.
Definition: CaloJet.h:29
reco::JetID::approximatefHPD
float approximatefHPD
Definition: JetID.h:55
JetIDSelectionFunctor::count_hits
unsigned int count_hits(const std::vector< CaloTowerPtr > &towers)
Definition: JetIDSelectionFunctor.h:230
reco::JetID::fHPD
float fHPD
Definition: JetID.h:45
JetIDSelectionFunctor::operator()
virtual bool operator()(reco::Candidate::LorentzVector const &correctedP4, double emEnergyFraction, reco::JetID const &jetID)
accessor like previous, without the ret
Definition: JetIDSelectionFunctor.h:283
run_regression.ret
int ret
Definition: run_regression.py:388
JetIDSelectionFunctor::operator()
bool operator()(const pat::Jet &jet, pat::strbitset &ret)
This provides the interface for base classes to select objects.
Definition: JetIDSelectionFunctor.h:243
reco::JetID::fLS
float fLS
Definition: JetID.h:64
relval_steps.version
string version
Definition: relval_steps.py:1572
reco::Jet::etaetaMoment
float etaetaMoment() const
eta-eta second moment, ET weighted
Selector< pat::Jet >::index_type
pat::strbitset::index_type index_type
Definition: Selector.h:29
reco::JetID::fLong
float fLong
Definition: JetID.h:63
Selector< pat::Jet >::setIgnored
void setIgnored(pat::strbitset &ret)
set ignored bits
Definition: Selector.h:224
Selector< pat::Jet >::retInternal_
pat::strbitset retInternal_
internal ret if users don&#39;t care about return bits
Definition: Selector.h:287
JetIDSelectionFunctor::JetIDSelectionFunctor
JetIDSelectionFunctor(edm::ParameterSet const &parameters)
Definition: JetIDSelectionFunctor.h:48
Min
T Min(T a, T b)
Definition: MathUtil.h:39
reco::JetID
Jet ID object.
Definition: JetID.h:16
reco::CaloJet::getCaloConstituents
virtual std::vector< CaloTowerPtr > getCaloConstituents() const
get all constituents
Definition: CaloJet.cc:93
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
JetIDSelectionFunctor::operator()
bool operator()(reco::Candidate::LorentzVector const &correctedP4, double emEnergyFraction, reco::JetID const &jetID, pat::strbitset &ret)
Definition: JetIDSelectionFunctor.h:272
JetIDSelectionFunctor::craft08Cuts
bool craft08Cuts(reco::Candidate::LorentzVector const &correctedP4, double emEnergyFraction, reco::JetID const &jetID, pat::strbitset &ret)
Definition: JetIDSelectionFunctor.h:324
pat::Jet::isCaloJet
bool isCaloJet() const
check to see if the jet is a reco::CaloJet
Definition: Jet.h:247
pat::Jet::getCaloConstituents
std::vector< CaloTowerPtr > const & getCaloConstituents() const
Selector< pat::Jet >::bits_
pat::strbitset bits_
the bitset indexed by strings
Definition: Selector.h:286
Selector< pat::Jet >::passCut
void passCut(pat::strbitset &ret, std::string const &s)
Passing cuts.
Definition: Selector.h:176
Selector< pat::Jet >::ignoreCut
bool ignoreCut(std::string const &s) const
ignore the cut at index &quot;s&quot;
Definition: Selector.h:159
Abs
T Abs(T a)
Definition: MathUtil.h:49
JetIDSelectionFunctor::JetIDSelectionFunctor
JetIDSelectionFunctor(edm::ParameterSet const &parameters, edm::ConsumesCollector &iC)
Definition: JetIDSelectionFunctor.h:42
reco::JetID::fShort
float fShort
Definition: JetID.h:63
JetIDSelectionFunctor::operator()
bool operator()(reco::CaloJet const &jet, reco::JetID const &jetID, pat::strbitset &ret)
Definition: JetIDSelectionFunctor.h:297
Selector< pat::Jet >::push_back
virtual void push_back(std::string const &s)
This is the registration of an individual cut string.
Definition: Selector.h:46
Selector
Functor that operates on &lt;T&gt;
Definition: Selector.h:24
CorrectedMETProducer_namespace::correctedP4
reco::Candidate::LorentzVector correctedP4(const T &rawMEt, const CorrMETData &correction)
Definition: CorrectedMETProducerT.h:37
JetIDSelectionFunctor::fwd09Cuts
bool fwd09Cuts(reco::Candidate::LorentzVector const &rawP4, double emEnergyFraction, double etaWidth, double phiWidth, unsigned int nHit, reco::JetID const &jetID, pat::strbitset &ret)
Definition: JetIDSelectionFunctor.h:408
pat::Jet::emEnergyFraction
float emEnergyFraction() const
returns the jet electromagnetic energy fraction
Definition: Jet.h:294
pat::strbitset::index_type
Definition: strbitset.h:28
Max
T Max(T a, T b)
Definition: MathUtil.h:44
pat::Jet::isJPTJet
bool isJPTJet() const
check to see if the jet is a reco::JPTJet
Definition: Jet.h:249
JetIDSelectionFunctor
Jet selector for pat::Jets and for CaloJets.
Definition: JetIDSelectionFunctor.h:32
pat::Jet::jetID
reco::JetID const & jetID() const
accessing Jet ID information
Definition: Jet.h:447
pat::strbitset::set
strbitset & set(bool val=true)
set method of all bits
Definition: strbitset.h:144
pat::Jet::currentJECLevel
std::string currentJECLevel() const
return the name of the current step of jet energy corrections
Definition: Jet.h:138
pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:77
reco::Candidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:37
Selector< pat::Jet >::getBitTemplate
pat::strbitset getBitTemplate() const
Get an empty bitset with the proper names.
Definition: Selector.h:212
HLT_25ns14e33_v1_cff.towers
tuple towers
Definition: HLT_25ns14e33_v1_cff.py:8669
reco::Jet::phiphiMoment
float phiphiMoment() const
phi-phi second moment, ET weighted
HLT_25ns14e33_v1_cff.quality
tuple quality
Definition: HLT_25ns14e33_v1_cff.py:33032
JetIDSelectionFunctor::operator()
virtual bool operator()(reco::CaloJet const &jet, reco::JetID const &jetID)
accessor like previous, without the ret
Definition: JetIDSelectionFunctor.h:312
reco::LeafCandidate::p4
virtual const LorentzVector & p4() const
four-momentum Lorentz vector
Definition: LeafCandidate.h:99
reco::JetID::fHFOOT
float fHFOOT
Definition: JetID.h:64
reco::JetID::n90Hits
short n90Hits
Definition: JetID.h:47
reco::CaloJet::emEnergyFraction
float emEnergyFraction() const
Definition: CaloJet.h:102
Generated for CMSSW Reference Manual by doxygen 1.8.5