CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
List of all members | Public Member Functions | Public Attributes | Static Public Attributes
objects.LeptonAnalyzer.LeptonAnalyzer Class Reference
Inheritance diagram for objects.LeptonAnalyzer.LeptonAnalyzer:

Public Member Functions

def __init__
 
def attachIsoAnnulus04
 
def attachIsolationScan
 
def attachMiniIsolation
 
def beginLoop
 
def declareHandles
 
def isFromB
 
def makeAllElectrons
 
def makeAllMuons
 
def makeLeptons
 
def matchAnyLeptons
 
def matchLeptons
 
def matchToPhotons
 
def process
 

Public Attributes

 doMatchToPhotons
 
 eleEffectiveArea
 Duplicate removal for fast sim (to be checked if still necessary in latest greatest 5.3.X releases) More...
 
 miniIsolationPUCorr
 
 miniIsolationVetoLeptons
 inclusive leptons = all leptons that could be considered somewhere in the analysis, with minimal requirements (used e.g. More...
 
 muEffectiveArea
 
 muonScaleCorrector
 

Static Public Attributes

 class_object = LeptonAnalyzer,
 
 conf = cfg_ana.doElectronScaleCorrections
 
string electrons = 'slimmedElectrons'
 
string muons = 'slimmedMuons'
 
string rhoElectron = 'fixedGridRhoFastjetAll'
 
string rhoMuon = 'fixedGridRhoFastjetAll'
 

Detailed Description

Definition at line 23 of file LeptonAnalyzer.py.

Constructor & Destructor Documentation

def objects.LeptonAnalyzer.LeptonAnalyzer.__init__ (   self,
  cfg_ana,
  cfg_comp,
  looperName 
)

Definition at line 26 of file LeptonAnalyzer.py.

References analyzer.Analyzer.cfg_ana.

26 
27  def __init__(self, cfg_ana, cfg_comp, looperName ):
28  super(LeptonAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName)
29  if hasattr(self.cfg_ana, 'doMuScleFitCorrections'):
30  raise RuntimeError("doMuScleFitCorrections is not supported. Please set instead doMuonScaleCorrections = ( 'MuScleFit', <name> )")
31  if hasattr(self.cfg_ana, 'doRochesterCorrections'):
32  raise RuntimeError("doRochesterCorrections is not supported. Please set instead doMuonScaleCorrections = ( 'Rochester', <name> )")
33  if self.cfg_ana.doMuonScaleCorrections:
34  algo, options = self.cfg_ana.doMuonScaleCorrections
35  if algo == "Kalman":
36  corr = options['MC' if self.cfg_comp.isMC else 'Data']
37  self.muonScaleCorrector = KalmanMuonCorrector(corr,
38  self.cfg_comp.isMC,
39  options['isSync'] if 'isSync' in options else False,
40  options['smearMode'] if 'smearMode' in options else "ebe")
41  elif algo == "Rochester":
42  print("WARNING: the Rochester correction in heppy is still from Run 1")
43  self.muonScaleCorrector = RochesterCorrections()
44  elif algo == "MuScleFit":
45  print("WARNING: the MuScleFit correction in heppy is still from Run 1 (and probably no longer functional)")
46  if options not in [ "prompt", "prompt-sync", "rereco", "rereco-sync" ]:
47  raise RuntimeError('MuScleFit correction name must be one of [ "prompt", "prompt-sync", "rereco", "rereco-sync" ] ')
48  rereco = ("prompt" not in self.cfg_ana.doMuScleFitCorrections)
49  sync = ("sync" in self.cfg_ana.doMuScleFitCorrections)
50  self.muonScaleCorrector = MuScleFitCorr(cfg_comp.isMC, rereco, sync)
51  else: raise RuntimeError("Unknown muon scale correction algorithm")
52  else:
self.muonScaleCorrector = None
print
void print(TMatrixD &m, const char *label=nullptr, bool mathematicaFormat=false)
Definition: Utilities.cc:47

Member Function Documentation

def objects.LeptonAnalyzer.LeptonAnalyzer.attachIsoAnnulus04 (   self,
  mu 
)

Definition at line 480 of file LeptonAnalyzer.py.

References SiStripPI.max, and SiStripPI.min.

480 
481  def attachIsoAnnulus04(self, mu): # annulus isolation with outer cone of 0.4 and delta beta PU correction
482  mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200)
483  mu.absIsoAnCharged = self.IsolationComputer.chargedAbsIso (mu.physObj, 0.4, mu.miniIsoR, 0.0, self.IsolationComputer.selfVetoNone)
484  mu.absIsoAnPho = self.IsolationComputer.photonAbsIsoRaw (mu.physObj, 0.4, mu.miniIsoR, 0.0, self.IsolationComputer.selfVetoNone)
485  mu.absIsoAnNHad = self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.4, mu.miniIsoR, 0.0, self.IsolationComputer.selfVetoNone)
486  mu.absIsoAnPU = self.IsolationComputer.puAbsIso (mu.physObj, 0.4, mu.miniIsoR, 0.0, self.IsolationComputer.selfVetoNone)
487  mu.absIsoAnNeutral = max(0.0, mu.absIsoAnPho + mu.absIsoAnNHad - 0.5*mu.absIsoAnPU)
488 
489  mu.absIsoAn04 = mu.absIsoAnCharged + mu.absIsoAnNeutral
490  mu.relIsoAn04 = mu.absIsoAn04/mu.pt()
491 
def objects.LeptonAnalyzer.LeptonAnalyzer.attachIsolationScan (   self,
  mu 
)

Definition at line 492 of file LeptonAnalyzer.py.

References funct.abs().

492 
493  def attachIsolationScan(self, mu):
494 
495  what = "mu" if (abs(mu.pdgId()) == 13) else ("eleB" if mu.isEB() else "eleE")
496  vetoreg = {"mu":0.0001,"eleB":0,"eleE":0.015}[what]
497 
498  if what=="mu":
499  mu.ScanAbsIsoCharged005 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.05, vetoreg, 0.0)
500  mu.ScanAbsIsoCharged01 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.1, vetoreg, 0.0)
501  mu.ScanAbsIsoCharged02 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.2, vetoreg, 0.0)
502  mu.ScanAbsIsoCharged03 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.3, vetoreg, 0.0)
503  mu.ScanAbsIsoCharged04 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.4, vetoreg, 0.0)
504  else:
505  mu.ScanAbsIsoCharged005 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.05, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
506  mu.ScanAbsIsoCharged01 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.1, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
507  mu.ScanAbsIsoCharged02 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.2, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
508  mu.ScanAbsIsoCharged03 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.3, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
509  mu.ScanAbsIsoCharged04 = self.IsolationComputer.chargedAbsIso(mu.physObj, 0.4, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)
510 
511  if what=="mu":
512  mu.ScanAbsIsoNeutral005 = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.05, 0.01, 0.5)
513  mu.ScanAbsIsoNeutral01 = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.1, 0.01, 0.5)
514  mu.ScanAbsIsoNeutral02 = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.2, 0.01, 0.5)
515  mu.ScanAbsIsoNeutral03 = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.3, 0.01, 0.5)
516  mu.ScanAbsIsoNeutral04 = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, 0.4, 0.01, 0.5)
517  else:
518  vetoreg = {"eleB":0.0,"eleE":0.08}[what]
519  mu.ScanAbsIsoNeutral005 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.05, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.05, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
520  mu.ScanAbsIsoNeutral01 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.1, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.1, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
521  mu.ScanAbsIsoNeutral02 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.2, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.2, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
522  mu.ScanAbsIsoNeutral03 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.3, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.3, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
523  mu.ScanAbsIsoNeutral04 = self.IsolationComputer.photonAbsIsoRaw(mu.physObj, 0.4, vetoreg, 0.0, self.IsolationComputer.selfVetoNone)+self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, 0.4, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
524 
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
def objects.LeptonAnalyzer.LeptonAnalyzer.attachMiniIsolation (   self,
  mu 
)

Definition at line 435 of file LeptonAnalyzer.py.

References funct.abs(), SiStripPI.max, and SiStripPI.min.

435 
436  def attachMiniIsolation(self, mu):
437  mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200)
438  # -- version with increasing cone at low pT, gives slightly better performance for tight cuts and low pt leptons
439  # mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200) if mu.pt() > 20 else 4.0/min(max(mu.pt(),10),20)
440  what = "mu" if (abs(mu.pdgId()) == 13) else ("eleB" if mu.isEB() else "eleE")
441  if what == "mu":
442  mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0);
443  else:
444  mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0,self.IsolationComputer.selfVetoNone);
445 
446  if self.miniIsolationPUCorr == None: puCorr = self.cfg_ana.mu_isoCorr if what=="mu" else self.cfg_ana.ele_isoCorr
447  else: puCorr = self.miniIsolationPUCorr
448 
449  if puCorr == "weights":
450  if what == "mu":
451  mu.miniAbsIsoNeutral = self.IsolationComputer.neutralAbsIsoWeighted(mu.physObj, mu.miniIsoR, 0.01, 0.5);
452  else:
453  mu.miniAbsIsoNeutral = ( self.IsolationComputer.photonAbsIsoWeighted( mu.physObj, mu.miniIsoR, 0.08 if what == "eleE" else 0.0, 0.0, self.IsolationComputer.selfVetoNone) +
454  self.IsolationComputer.neutralHadAbsIsoWeighted(mu.physObj, mu.miniIsoR, 0.0, 0.0, self.IsolationComputer.selfVetoNone) )
455  else:
456  if what == "mu":
457  mu.miniAbsIsoNeutral = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.01, 0.5);
458  else:
459  mu.miniAbsIsoPho = self.IsolationComputer.photonAbsIsoRaw( mu.physObj, mu.miniIsoR, 0.08 if what == "eleE" else 0.0, 0.0, self.IsolationComputer.selfVetoNone)
460  mu.miniAbsIsoNHad = self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
461  mu.miniAbsIsoNeutral = mu.miniAbsIsoPho + mu.miniAbsIsoNHad
462  # -- version relying on PF candidate vetos; apparently less performant, and the isolation computed at RECO level doesn't have them
463  #mu.miniAbsIsoPhoSV = self.IsolationComputer.photonAbsIsoRaw( mu.physObj, mu.miniIsoR, 0.0, 0.0)
464  #mu.miniAbsIsoNHadSV = self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.0, 0.0)
465  #mu.miniAbsIsoNeutral = mu.miniAbsIsoPhoSV + mu.miniAbsIsoNHadSV
466  if puCorr == "rhoArea":
467  mu.miniAbsIsoNeutral = max(0.0, mu.miniAbsIsoNeutral - mu.rho * mu.EffectiveArea03 * (mu.miniIsoR/0.3)**2)
468  elif puCorr == "deltaBeta":
469  if what == "mu":
470  mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.01, 0.5);
471  else:
472  mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.015 if what == "eleE" else 0.0, 0.0,self.IsolationComputer.selfVetoNone);
473  mu.miniAbsIsoNeutral = max(0.0, mu.miniAbsIsoNeutral - 0.5*mu.miniAbsIsoPU)
474  elif puCorr != 'raw':
475  raise RuntimeError("Unsupported miniIsolationCorr name '" + puCorr + "'! For now only 'rhoArea', 'deltaBeta', 'raw', 'weights' are supported (and 'weights' is not tested).")
476 
477  mu.miniAbsIso = mu.miniAbsIsoCharged + mu.miniAbsIsoNeutral
478  mu.miniRelIso = mu.miniAbsIso/mu.pt()
479 
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
def objects.LeptonAnalyzer.LeptonAnalyzer.beginLoop (   self,
  setup 
)

Definition at line 136 of file LeptonAnalyzer.py.

136 
137  def beginLoop(self, setup):
138  super(LeptonAnalyzer,self).beginLoop(setup)
139  self.counters.addCounter('events')
140  count = self.counters.counter('events')
141  count.register('all events')
def objects.LeptonAnalyzer.LeptonAnalyzer.declareHandles (   self)

Definition at line 115 of file LeptonAnalyzer.py.

References objects.LeptonAnalyzer.LeptonAnalyzer.doMatchToPhotons, core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, and HTTP.RequestManager.handles.

115 
116  def declareHandles(self):
117  super(LeptonAnalyzer, self).declareHandles()
118 
119  #leptons
120  self.handles['muons'] = AutoHandle(self.cfg_ana.muons,"std::vector<pat::Muon>")
121  self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons,"std::vector<pat::Electron>")
122 
123  #rho for muons
124  self.handles['rhoMu'] = AutoHandle( self.cfg_ana.rhoMuon, 'double')
125  #rho for electrons
126  self.handles['rhoEle'] = AutoHandle( self.cfg_ana.rhoElectron, 'double')
127 
128  if self.doMiniIsolation or self.doIsolationScan:
129  self.handles['packedCandidates'] = AutoHandle( self.cfg_ana.packedCandidates, 'std::vector<pat::PackedCandidate>')
130 
131  if self.doMatchToPhotons:
132  if self.doMatchToPhotons == "any":
133  self.mchandles['genPhotons'] = AutoHandle( 'packedGenParticles', 'std::vector<pat::PackedGenParticle>' )
134  else:
135  self.mchandles['genPhotons'] = AutoHandle( 'prunedGenParticles', 'std::vector<reco::GenParticle>' )
def objects.LeptonAnalyzer.LeptonAnalyzer.isFromB (   self,
  particle,
  bid = 5,
  done = {} 
)

Definition at line 546 of file LeptonAnalyzer.py.

References funct.abs(), objects.LeptonAnalyzer.LeptonAnalyzer.isFromB(), and sistrip::SpyUtilities.range().

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.isFromB(), and objects.LeptonAnalyzer.LeptonAnalyzer.matchAnyLeptons().

546 
547  def isFromB(self,particle,bid=5, done={}):
548  for i in range( particle.numberOfMothers() ):
549  mom = particle.mother(i)
550  momid = abs(mom.pdgId())
551  if momid / 1000 == bid or momid / 100 == bid or momid == bid:
552  return True
553  elif mom.status() == 2 and self.isFromB(mom, done=done, bid=bid):
554  return True
555  return False
sistrip::SpyUtilities::range
const uint16_t range(const Frame &aFrame)
Definition: SiStripSpyUtilities.cc:76
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
def objects.LeptonAnalyzer.LeptonAnalyzer.makeAllElectrons (   self,
  event 
) 
       make a list of all electrons, and apply basic corrections to them

Definition at line 320 of file LeptonAnalyzer.py.

References funct.abs(), core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, and HTTP.RequestManager.handles.

320 
321  def makeAllElectrons(self, event):
322  """
323  make a list of all electrons, and apply basic corrections to them
324  """
325  allelectrons = map( Electron, self.handles['electrons'].product() )
326 
327  ## Duplicate removal for fast sim (to be checked if still necessary in latest greatest 5.3.X releases)
328  allelenodup = []
329  for e in allelectrons:
330  dup = False
331  for e2 in allelenodup:
332  if abs(e.pt()-e2.pt()) < 1e-6 and abs(e.eta()-e2.eta()) < 1e-6 and abs(e.phi()-e2.phi()) < 1e-6 and e.charge() == e2.charge():
333  dup = True
334  break
335  if not dup: allelenodup.append(e)
336  allelectrons = allelenodup
337 
338  # fill EA for rho-corrected isolation
339  for ele in allelectrons:
340  ele.rho = float(self.handles['rhoEle'].product()[0])
341  if self.eleEffectiveArea == "Data2012":
342  # https://twiki.cern.ch/twiki/bin/viewauth/CMS/EgammaEARhoCorrection?rev=14
343  SCEta = abs(ele.superCluster().eta())
344  if SCEta < 1.0 : ele.EffectiveArea03 = 0.13 # 0.130;
345  elif SCEta < 1.479: ele.EffectiveArea03 = 0.14 # 0.137;
346  elif SCEta < 2.0 : ele.EffectiveArea03 = 0.07 # 0.067;
347  elif SCEta < 2.2 : ele.EffectiveArea03 = 0.09 # 0.089;
348  elif SCEta < 2.3 : ele.EffectiveArea03 = 0.11 # 0.107;
349  elif SCEta < 2.4 : ele.EffectiveArea03 = 0.11 # 0.110;
350  else : ele.EffectiveArea03 = 0.14 # 0.138;
351  if SCEta < 1.0 : ele.EffectiveArea04 = 0.208;
352  elif SCEta < 1.479: ele.EffectiveArea04 = 0.209;
353  elif SCEta < 2.0 : ele.EffectiveArea04 = 0.115;
354  elif SCEta < 2.2 : ele.EffectiveArea04 = 0.143;
355  elif SCEta < 2.3 : ele.EffectiveArea04 = 0.183;
356  elif SCEta < 2.4 : ele.EffectiveArea04 = 0.194;
357  else : ele.EffectiveArea04 = 0.261;
358  elif self.eleEffectiveArea == "Phys14_25ns_v1":
359  aeta = abs(ele.eta())
360  if aeta < 0.800: ele.EffectiveArea03 = 0.1013
361  elif aeta < 1.300: ele.EffectiveArea03 = 0.0988
362  elif aeta < 2.000: ele.EffectiveArea03 = 0.0572
363  elif aeta < 2.200: ele.EffectiveArea03 = 0.0842
364  else: ele.EffectiveArea03 = 0.1530
365  if aeta < 0.800: ele.EffectiveArea04 = 0.1830
366  elif aeta < 1.300: ele.EffectiveArea04 = 0.1734
367  elif aeta < 2.000: ele.EffectiveArea04 = 0.1077
368  elif aeta < 2.200: ele.EffectiveArea04 = 0.1565
369  else: ele.EffectiveArea04 = 0.2680
370  elif self.eleEffectiveArea == "Spring15_50ns_v1":
371  SCEta = abs(ele.superCluster().eta())
372  ## ----- https://github.com/ikrav/cmssw/blob/egm_id_747_v2/RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_50ns.txt
373  if SCEta < 0.800: ele.EffectiveArea03 = 0.0973
374  elif SCEta < 1.300: ele.EffectiveArea03 = 0.0954
375  elif SCEta < 2.000: ele.EffectiveArea03 = 0.0632
376  elif SCEta < 2.200: ele.EffectiveArea03 = 0.0727
377  else: ele.EffectiveArea03 = 0.1337
378  # warning: EAs not computed for cone DR=0.4 yet. Do not correct
379  ele.EffectiveArea04 = 0.0
380  elif self.eleEffectiveArea == "Spring15_25ns_v1":
381  SCEta = abs(ele.superCluster().eta())
382  ## ----- https://github.com/ikrav/cmssw/blob/egm_id_747_v2/RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_25ns.txt
383  if SCEta < 1.000: ele.EffectiveArea03 = 0.1752
384  elif SCEta < 1.479: ele.EffectiveArea03 = 0.1862
385  elif SCEta < 2.000: ele.EffectiveArea03 = 0.1411
386  elif SCEta < 2.200: ele.EffectiveArea03 = 0.1534
387  elif SCEta < 2.300: ele.EffectiveArea03 = 0.1903
388  elif SCEta < 2.400: ele.EffectiveArea03 = 0.2243
389  else: ele.EffectiveArea03 = 0.2687
390  # warning: EAs not computed for cone DR=0.4 yet. Do not correct
391  ele.EffectiveArea04 = 0.0
392  else: raise RuntimeError("Unsupported value for ele_effectiveAreas: can only use Data2012 (rho: ?), Phys14_v1 and Spring15_v1 (rho: fixedGridRhoFastjetAll)")
393 
394  # Electron scale calibrations
395  if self.cfg_ana.doElectronScaleCorrections:
396  for ele in allelectrons:
397  self.electronEnergyCalibrator.correct(ele, event.run)
398 
399  # Attach the vertex
400  for ele in allelectrons:
401  ele.associatedVertex = event.goodVertices[0] if len(event.goodVertices)>0 else event.vertices[0]
402 
403  # Compute relIso with R=0.3 and R=0.4 cones
404  for ele in allelectrons:
405  if self.cfg_ana.ele_isoCorr=="rhoArea" :
406  ele.absIso03 = (ele.chargedHadronIsoR(0.3) + max(ele.neutralHadronIsoR(0.3)+ele.photonIsoR(0.3)-ele.rho*ele.EffectiveArea03,0))
407  ele.absIso04 = (ele.chargedHadronIsoR(0.4) + max(ele.neutralHadronIsoR(0.4)+ele.photonIsoR(0.4)-ele.rho*ele.EffectiveArea04,0))
408  elif self.cfg_ana.ele_isoCorr=="deltaBeta" :
409  ele.absIso03 = (ele.chargedHadronIsoR(0.3) + max( ele.neutralHadronIsoR(0.3)+ele.photonIsoR(0.3) - ele.puChargedHadronIsoR(0.3)/2, 0.0))
410  ele.absIso04 = (ele.chargedHadronIsoR(0.4) + max( ele.neutralHadronIsoR(0.4)+ele.photonIsoR(0.4) - ele.puChargedHadronIsoR(0.4)/2, 0.0))
411  else :
412  raise RuntimeError("Unsupported ele_isoCorr name '" + str(self.cfg_ana.ele_isoCorr) + "'! For now only 'rhoArea' and 'deltaBeta' are supported.")
413  ele.relIso03 = ele.absIso03/ele.pt()
414  ele.relIso04 = ele.absIso04/ele.pt()
415 
416  # Set tight MVA id
417  for ele in allelectrons:
418  if self.cfg_ana.ele_tightId=="MVA" :
419  ele.tightIdResult = ele.electronID("POG_MVA_ID_Trig_full5x5")
420  elif self.cfg_ana.ele_tightId=="Cuts_2012" :
421  ele.tightIdResult = -1 + 1*ele.electronID("POG_Cuts_ID_2012_Veto_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Loose_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Medium_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Tight_full5x5")
422  elif self.cfg_ana.ele_tightId=="Cuts_PHYS14_25ns_v1_ConvVetoDxyDz" :
423  ele.tightIdResult = -1 + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Veto_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Loose_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Medium_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Tight_full5x5")
424  elif self.cfg_ana.ele_tightId=="Cuts_SPRING15_25ns_v1_ConvVetoDxyDz" :
425  ele.tightIdResult = -1 + 1*ele.electronID("POG_Cuts_ID_SPRING15_25ns_v1_ConvVetoDxyDz_Veto_full5x5") + 1*ele.electronID("POG_Cuts_ID_SPRING15_25ns_v1_ConvVetoDxyDz_Loose_full5x5") + 1*ele.electronID("POG_Cuts_ID_SPRING15_25ns_v1_ConvVetoDxyDz_Medium_full5x5") + 1*ele.electronID("POG_Cuts_ID_SPRING15_25ns_v1_ConvVetoDxyDz_Tight_full5x5")
426 
427  else :
428  try:
429  ele.tightIdResult = ele.electronID(self.cfg_ana.ele_tightId)
430  except RuntimeError:
431  raise RuntimeError("Unsupported ele_tightId name '" + str(self.cfg_ana.ele_tightId) + "'! For now only 'MVA' and 'Cuts_2012' are supported, in addition to what provided in Electron.py.")
432 
433 
434  return allelectrons
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
objects.LeptonAnalyzer.LeptonAnalyzer.eleEffectiveArea
eleEffectiveArea
Duplicate removal for fast sim (to be checked if still necessary in latest greatest 5...
Definition: LeptonAnalyzer.py:340
str
#define str(s)
Definition: TestProcessor.cc:54
def objects.LeptonAnalyzer.LeptonAnalyzer.makeAllMuons (   self,
  event 
) 
       make a list of all muons, and apply basic corrections to them

Definition at line 240 of file LeptonAnalyzer.py.

References core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, and objects.LeptonAnalyzer.LeptonAnalyzer.muonScaleCorrector.

240 
241  def makeAllMuons(self, event):
242  """
243  make a list of all muons, and apply basic corrections to them
244  """
245  # Start from all muons
246  allmuons = map( Muon, self.handles['muons'].product() )
247 
248  # Muon scale and resolution corrections (if enabled)
249  if self.muonScaleCorrector:
250  self.muonScaleCorrector.correct_all(allmuons, event.run)
251 
252  # Clean up dulicate muons (note: has no effect unless the muon id is removed)
253  if self.cfg_ana.doSegmentBasedMuonCleaning:
254  isgood = cmgMuonCleanerBySegments.clean( self.handles['muons'].product() )
255  newmu = []
256  for i,mu in enumerate(allmuons):
257  if isgood[i]: newmu.append(mu)
258  allmuons = newmu
259 
260  # Attach EAs for isolation:
261  for mu in allmuons:
262  mu.rho = float(self.handles['rhoMu'].product()[0])
263  if self.muEffectiveArea == "Data2012":
264  if aeta < 1.0 : mu.EffectiveArea03 = 0.382;
265  elif aeta < 1.47 : mu.EffectiveArea03 = 0.317;
266  elif aeta < 2.0 : mu.EffectiveArea03 = 0.242;
267  elif aeta < 2.2 : mu.EffectiveArea03 = 0.326;
268  elif aeta < 2.3 : mu.EffectiveArea03 = 0.462;
269  else : mu.EffectiveArea03 = 0.372;
270  if aeta < 1.0 : mu.EffectiveArea04 = 0.674;
271  elif aeta < 1.47 : mu.EffectiveArea04 = 0.565;
272  elif aeta < 2.0 : mu.EffectiveArea04 = 0.442;
273  elif aeta < 2.2 : mu.EffectiveArea04 = 0.515;
274  elif aeta < 2.3 : mu.EffectiveArea04 = 0.821;
275  else : mu.EffectiveArea04 = 0.660;
276  elif self.muEffectiveArea == "Phys14_25ns_v1":
277  aeta = abs(mu.eta())
278  if aeta < 0.800: mu.EffectiveArea03 = 0.0913
279  elif aeta < 1.300: mu.EffectiveArea03 = 0.0765
280  elif aeta < 2.000: mu.EffectiveArea03 = 0.0546
281  elif aeta < 2.200: mu.EffectiveArea03 = 0.0728
282  else: mu.EffectiveArea03 = 0.1177
283  if aeta < 0.800: mu.EffectiveArea04 = 0.1564
284  elif aeta < 1.300: mu.EffectiveArea04 = 0.1325
285  elif aeta < 2.000: mu.EffectiveArea04 = 0.0913
286  elif aeta < 2.200: mu.EffectiveArea04 = 0.1212
287  else: mu.EffectiveArea04 = 0.2085
288  elif self.muEffectiveArea == "Spring15_25ns_v1":
289  aeta = abs(mu.eta())
290  if aeta < 0.800: mu.EffectiveArea03 = 0.0735
291  elif aeta < 1.300: mu.EffectiveArea03 = 0.0619
292  elif aeta < 2.000: mu.EffectiveArea03 = 0.0465
293  elif aeta < 2.200: mu.EffectiveArea03 = 0.0433
294  else: mu.EffectiveArea03 = 0.0577
295  mu.EffectiveArea04 = 0 # not computed
296  else: raise RuntimeError("Unsupported value for mu_effectiveAreas: can only use Data2012 (rho: ?) and Phys14_25ns_v1 or Spring15_25ns_v1 (rho: fixedGridRhoFastjetAll)")
297  # Attach the vertex to them, for dxy/dz calculation
298  for mu in allmuons:
299  mu.associatedVertex = event.goodVertices[0] if len(event.goodVertices)>0 else event.vertices[0]
300  mu.setTrackForDxyDz(self.cfg_ana.muon_dxydz_track)
301 
302  # Set tight id if specified
303  if hasattr(self.cfg_ana, "mu_tightId"):
304  for mu in allmuons:
305  mu.tightIdResult = mu.muonID(self.cfg_ana.mu_tightId)
306 
307  # Compute relIso in 0.3 and 0.4 cones
308  for mu in allmuons:
309  if self.cfg_ana.mu_isoCorr=="rhoArea" :
310  mu.absIso03 = (mu.pfIsolationR03().sumChargedHadronPt + max( mu.pfIsolationR03().sumNeutralHadronEt + mu.pfIsolationR03().sumPhotonEt - mu.rho * mu.EffectiveArea03,0.0))
311  mu.absIso04 = (mu.pfIsolationR04().sumChargedHadronPt + max( mu.pfIsolationR04().sumNeutralHadronEt + mu.pfIsolationR04().sumPhotonEt - mu.rho * mu.EffectiveArea04,0.0))
312  elif self.cfg_ana.mu_isoCorr=="deltaBeta" :
313  mu.absIso03 = (mu.pfIsolationR03().sumChargedHadronPt + max( mu.pfIsolationR03().sumNeutralHadronEt + mu.pfIsolationR03().sumPhotonEt - mu.pfIsolationR03().sumPUPt/2,0.0))
314  mu.absIso04 = (mu.pfIsolationR04().sumChargedHadronPt + max( mu.pfIsolationR04().sumNeutralHadronEt + mu.pfIsolationR04().sumPhotonEt - mu.pfIsolationR04().sumPUPt/2,0.0))
315  else :
316  raise RuntimeError("Unsupported mu_isoCorr name '" + str(self.cfg_ana.mu_isoCorr) + "'! For now only 'rhoArea' and 'deltaBeta' are supported.")
317  mu.relIso03 = mu.absIso03/mu.pt()
318  mu.relIso04 = mu.absIso04/mu.pt()
319  return allmuons
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
str
#define str(s)
Definition: TestProcessor.cc:54
def objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons (   self,
  event 
)

Definition at line 147 of file LeptonAnalyzer.py.

References core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, and HTTP.RequestManager.handles.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.process().

147 
148  def makeLeptons(self, event):
149  ### inclusive leptons = all leptons that could be considered somewhere in the analysis, with minimal requirements (used e.g. to match to MC)
150  event.inclusiveLeptons = []
151  ### selected leptons = subset of inclusive leptons passing some basic id definition and pt requirement
152  ### other leptons = subset of inclusive leptons failing some basic id definition and pt requirement
153  event.selectedLeptons = []
154  event.selectedMuons = []
155  event.selectedElectrons = []
156  event.otherLeptons = []
157 
158  if self.doMiniIsolation or self.doIsolationScan:
159  self.IsolationComputer.setPackedCandidates(self.handles['packedCandidates'].product())
160  if self.doMiniIsolation:
161  if self.miniIsolationVetoLeptons == "any":
162  for lep in self.handles['muons'].product():
163  self.IsolationComputer.addVetos(lep)
164  for lep in self.handles['electrons'].product():
165  self.IsolationComputer.addVetos(lep)
166 
167  #muons
168  allmuons = self.makeAllMuons(event)
169 
170  #electrons
171  allelectrons = self.makeAllElectrons(event)
172 
173  #make inclusive leptons
174  inclusiveMuons = []
175  inclusiveElectrons = []
176  for mu in allmuons:
177  if (mu.track().isNonnull() and mu.muonID(self.cfg_ana.inclusive_muon_id) and
178  mu.pt()>self.cfg_ana.inclusive_muon_pt and abs(mu.eta())<self.cfg_ana.inclusive_muon_eta and
179  abs(mu.dxy())<self.cfg_ana.inclusive_muon_dxy and abs(mu.dz())<self.cfg_ana.inclusive_muon_dz):
180  inclusiveMuons.append(mu)
181  for ele in allelectrons:
182  if ( ele.electronID(self.cfg_ana.inclusive_electron_id) and
183  ele.pt()>self.cfg_ana.inclusive_electron_pt and abs(ele.eta())<self.cfg_ana.inclusive_electron_eta and
184  abs(ele.dxy())<self.cfg_ana.inclusive_electron_dxy and abs(ele.dz())<self.cfg_ana.inclusive_electron_dz and
185  ele.lostInner()<=self.cfg_ana.inclusive_electron_lostHits ):
186  inclusiveElectrons.append(ele)
187  event.inclusiveLeptons = inclusiveMuons + inclusiveElectrons
188 
189  if self.doMiniIsolation:
190  if self.miniIsolationVetoLeptons == "inclusive":
191  for lep in event.inclusiveLeptons:
192  self.IsolationComputer.addVetos(lep.physObj)
193  for lep in event.inclusiveLeptons:
194  self.attachMiniIsolation(lep)
195 
196  if self.doIsoAnnulus:
197  for lep in event.inclusiveLeptons:
198  self.attachIsoAnnulus04(lep)
199 
200  if self.doIsolationScan:
201  for lep in event.inclusiveLeptons:
202  self.attachIsolationScan(lep)
203 
204  # make loose leptons (basic selection)
205  for mu in inclusiveMuons:
206  if (mu.muonID(self.cfg_ana.loose_muon_id) and
207  mu.pt() > self.cfg_ana.loose_muon_pt and abs(mu.eta()) < self.cfg_ana.loose_muon_eta and
208  abs(mu.dxy()) < self.cfg_ana.loose_muon_dxy and abs(mu.dz()) < self.cfg_ana.loose_muon_dz and
209  self.muIsoCut(mu)):
210  mu.looseIdSusy = True
211  event.selectedLeptons.append(mu)
212  event.selectedMuons.append(mu)
213  else:
214  mu.looseIdSusy = False
215  event.otherLeptons.append(mu)
216  looseMuons = event.selectedLeptons[:]
217  for ele in inclusiveElectrons:
218  if (ele.electronID(self.cfg_ana.loose_electron_id) and
219  ele.pt()>self.cfg_ana.loose_electron_pt and abs(ele.eta())<self.cfg_ana.loose_electron_eta and
220  abs(ele.dxy()) < self.cfg_ana.loose_electron_dxy and abs(ele.dz())<self.cfg_ana.loose_electron_dz and
221  self.eleIsoCut(ele) and
222  ele.lostInner() <= self.cfg_ana.loose_electron_lostHits and
223  ( True if getattr(self.cfg_ana,'notCleaningElectrons',False) else (bestMatch(ele, looseMuons)[1] > (self.cfg_ana.min_dr_electron_muon**2)) )):
224  event.selectedLeptons.append(ele)
225  event.selectedElectrons.append(ele)
226  ele.looseIdSusy = True
227  else:
228  event.otherLeptons.append(ele)
229  ele.looseIdSusy = False
230 
231  event.otherLeptons.sort(key = lambda l : l.pt(), reverse = True)
232  event.selectedLeptons.sort(key = lambda l : l.pt(), reverse = True)
233  event.selectedMuons.sort(key = lambda l : l.pt(), reverse = True)
234  event.selectedElectrons.sort(key = lambda l : l.pt(), reverse = True)
235  event.inclusiveLeptons.sort(key = lambda l : l.pt(), reverse = True)
236 
237  for lepton in event.selectedLeptons:
238  if hasattr(self,'efficiency'):
239  self.efficiency.attachToObject(lepton)
deltar.bestMatch
def bestMatch
Definition: deltar.py:138
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
objects.LeptonAnalyzer.LeptonAnalyzer.miniIsolationVetoLeptons
miniIsolationVetoLeptons
inclusive leptons = all leptons that could be considered somewhere in the analysis, with minimal requirements (used e.g.
Definition: LeptonAnalyzer.py:160
def objects.LeptonAnalyzer.LeptonAnalyzer.matchAnyLeptons (   self,
  event 
)

Definition at line 556 of file LeptonAnalyzer.py.

References funct.abs(), objects.LeptonAnalyzer.LeptonAnalyzer.isFromB(), genutils.isPromptLepton(), and deltar.matchObjectCollection3().

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.process().

556 
557  def matchAnyLeptons(self, event):
558  event.anyLeptons = [ x for x in event.genParticles if x.status() == 1 and abs(x.pdgId()) in [11,13] ]
559  leps = event.inclusiveLeptons if hasattr(event, 'inclusiveLeptons') else event.selectedLeptons
560  match = matchObjectCollection3(leps, event.anyLeptons, deltaRMax = 0.3, filter = lambda x,y : abs(x.pdgId()) == abs(y.pdgId()))
561  for lep in leps:
562  gen = match[lep]
563  lep.mcMatchAny_gp = gen
564  if gen:
565  if self.isFromB(gen): lep.mcMatchAny = 5 # B (inclusive of B->D)
566  elif self.isFromB(gen,bid=4): lep.mcMatchAny = 4 # Charm
567  else: lep.mcMatchAny = 1
568  if not getattr(lep, 'mcLep', None): lep.mcLep = gen
569  else:
570  if not getattr(lep, 'mcLep', None): lep.mcLep = None
571  lep.mcMatchAny = 0
572  # fix case where the matching with the only prompt leptons failed, but we still ended up with a prompt match
573  if gen != None and hasattr(lep,'mcMatchId') and lep.mcMatchId == 0:
574  if isPromptLepton(gen, False) or (gen.isPromptFinalState() or gen.isDirectPromptTauDecayProductFinalState()):
575  lep.mcMatchId = 100
576  lep.mcLep = gen
577  elif not hasattr(lep,'mcMatchId'):
578  lep.mcMatchId = 0
579  if not hasattr(lep,'mcMatchTau'): lep.mcMatchTau = 0
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
genutils.isPromptLepton
def isPromptLepton
Definition: genutils.py:50
deltar.matchObjectCollection3
def matchObjectCollection3
Definition: deltar.py:41
def objects.LeptonAnalyzer.LeptonAnalyzer.matchLeptons (   self,
  event 
)

Definition at line 525 of file LeptonAnalyzer.py.

References funct.abs(), HLT_FULL_cff.deltaR, deltar.matchObjectCollection3(), SiStripPI.max, and SiStripPI.min.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.process().

525 
526  def matchLeptons(self, event):
527  def plausible(rec,gen):
528  if abs(rec.pdgId()) == 11 and abs(gen.pdgId()) != 11: return False
529  if abs(rec.pdgId()) == 13 and abs(gen.pdgId()) != 13: return False
530  dr = deltaR(rec.eta(),rec.phi(),gen.eta(),gen.phi())
531  if dr < 0.3: return True
532  if rec.pt() < 10 and abs(rec.pdgId()) == 13 and gen.pdgId() != rec.pdgId(): return False
533  if dr < 0.7: return True
534  if min(rec.pt(),gen.pt())/max(rec.pt(),gen.pt()) < 0.3: return False
535  return True
536 
537  leps = event.inclusiveLeptons if self.cfg_ana.match_inclusiveLeptons else event.selectedLeptons
538  match = matchObjectCollection3(leps,
539  event.genleps + event.gentauleps,
540  deltaRMax = 1.2, filter = plausible)
541  for lep in leps:
542  gen = match[lep]
543  lep.mcMatchId = (gen.sourceId if gen != None else 0)
544  lep.mcMatchTau = (gen in event.gentauleps if gen else -99)
545  lep.mcLep=gen
HLT_FULL_cff.deltaR
tuple deltaR
Definition: HLT_FULL_cff.py:6144
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
deltar.matchObjectCollection3
def matchObjectCollection3
Definition: deltar.py:41
def objects.LeptonAnalyzer.LeptonAnalyzer.matchToPhotons (   self,
  event 
)

Definition at line 580 of file LeptonAnalyzer.py.

References funct.abs(), HLT_FULL_cff.deltaR, HLT_FULL_cff.distance, deltar.matchObjectCollection3(), core.Analyzer.Analyzer.mchandles, and SiStripPI.min.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.process().

580 
581  def matchToPhotons(self, event):
582  event.anyPho = [ x for x in self.mchandles['genPhotons'].product() if x.status() == 1 and x.pdgId() == 22 and x.pt() > 1.0 ]
583  leps = event.inclusiveLeptons if hasattr(event, 'inclusiveLeptons') else event.selectedLeptons
584  leps = [ l for l in leps if abs(l.pdgId()) == 11 ]
585  plausible = lambda rec, gen : 0.3*gen.pt() < rec.pt() and rec.pt() < 1.5*gen.pt()
586  match = matchObjectCollection3(leps, event.anyPho, deltaRMax = 0.3, filter = plausible)
587  for lep in leps:
588  gen = match[lep]
589  lep.mcPho = gen
590  if lep.mcPho and lep.mcLep:
591  # I have both, I should keep the best one
592  def distance(rec,gen):
593  dr = deltaR(rec.eta(),rec.phi(),gen.eta(),gen.phi())
594  dptRel = abs(rec.pt()-gen.pt())/gen.pt()
595  return dr + 0.2*dptRel
596  dpho = distance(lep,lep.mcPho)
597  dlep = distance(lep,lep.mcLep)
598  if getattr(lep,'mcMatchAny_gp',None) and lep.mcMatchAny_gp != lep.mcLep:
599  dlep = min(dlep, distance(lep,lep.mcMatchAny_gp))
600  if dlep <= dpho: lep.mcPho = None
HLT_FULL_cff.deltaR
tuple deltaR
Definition: HLT_FULL_cff.py:6144
HLT_FULL_cff.distance
tuple distance
Definition: HLT_FULL_cff.py:7092
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
deltar.matchObjectCollection3
def matchObjectCollection3
Definition: deltar.py:41
def objects.LeptonAnalyzer.LeptonAnalyzer.process (   self,
  event 
)

Definition at line 601 of file LeptonAnalyzer.py.

References objects.LeptonAnalyzer.LeptonAnalyzer.doMatchToPhotons, objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons(), objects.LeptonAnalyzer.LeptonAnalyzer.matchAnyLeptons(), objects.LeptonAnalyzer.LeptonAnalyzer.matchLeptons(), objects.LeptonAnalyzer.LeptonAnalyzer.matchToPhotons(), and core.Analyzer.Analyzer.readCollections().

601 
602  def process(self, event):
603  self.readCollections( event.input )
604  self.counters.counter('events').inc('all events')
605 
606  #call the leptons functions
607  self.makeLeptons(event)
608 
609  if self.cfg_comp.isMC and self.cfg_ana.do_mc_match:
610  self.matchLeptons(event)
611  self.matchAnyLeptons(event)
612  if self.doMatchToPhotons:
613  self.matchToPhotons(event)
614 
615  return True
616 
617 #A default config
setattr(LeptonAnalyzer,"defaultConfig",cfg.Analyzer(

Member Data Documentation

objects.LeptonAnalyzer.LeptonAnalyzer.class_object = LeptonAnalyzer,
static

Definition at line 619 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.conf = cfg_ana.doElectronScaleCorrections
static

Definition at line 55 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.doMatchToPhotons

Definition at line 131 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.declareHandles(), and objects.LeptonAnalyzer.LeptonAnalyzer.process().

string objects.LeptonAnalyzer.LeptonAnalyzer.electrons = 'slimmedElectrons'
static

Definition at line 622 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.eleEffectiveArea

Duplicate removal for fast sim (to be checked if still necessary in latest greatest 5.3.X releases)

--— https://github.com/ikrav/cmssw/blob/egm_id_747_v2/RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_50ns.txt

Definition at line 340 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.miniIsolationPUCorr

Definition at line 445 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.miniIsolationVetoLeptons

inclusive leptons = all leptons that could be considered somewhere in the analysis, with minimal requirements (used e.g.

to match to MC) selected leptons = subset of inclusive leptons passing some basic id definition and pt requirement other leptons = subset of inclusive leptons failing some basic id definition and pt requirement

Definition at line 160 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.muEffectiveArea

Definition at line 262 of file LeptonAnalyzer.py.

string objects.LeptonAnalyzer.LeptonAnalyzer.muons = 'slimmedMuons'
static

Definition at line 621 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.muonScaleCorrector

Definition at line 36 of file LeptonAnalyzer.py.

Referenced by objects.LeptonAnalyzer.LeptonAnalyzer.makeAllMuons().

string objects.LeptonAnalyzer.LeptonAnalyzer.rhoElectron = 'fixedGridRhoFastjetAll'
static

Definition at line 624 of file LeptonAnalyzer.py.

string objects.LeptonAnalyzer.LeptonAnalyzer.rhoMuon = 'fixedGridRhoFastjetAll'
static

Definition at line 623 of file LeptonAnalyzer.py.

Generated for CMSSW Reference Manual by doxygen 1.8.5