CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros 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 attachMiniIsolation
 
def beginLoop
 
def declareHandles
 
def isFromB
 
def makeAllElectrons
 
def makeAllMuons
 
def makeLeptons
 
def matchAnyLeptons
 
def matchLeptons
 
def process
 

Public Attributes

 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
 
 muscleCorr
 

Static Public Attributes

 class_object = LeptonAnalyzer,
 
string electrons = 'slimmedElectrons'
 
string muons = 'slimmedMuons'
 
string rhoElectron = 'fixedGridRhoFastjetAll'
 
string rhoMuon = 'fixedGridRhoFastjetAll'
 

Detailed Description

Definition at line 20 of file LeptonAnalyzer.py.

Constructor & Destructor Documentation

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

Definition at line 23 of file LeptonAnalyzer.py.

23 
24  def __init__(self, cfg_ana, cfg_comp, looperName ):
25  super(LeptonAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName)
26  if self.cfg_ana.doMuScleFitCorrections and self.cfg_ana.doMuScleFitCorrections != "none":
27  if self.cfg_ana.doMuScleFitCorrections not in [ "none", "prompt", "prompt-sync", "rereco", "rereco-sync" ]:
28  raise RuntimeError, 'doMuScleFitCorrections must be one of "none", "prompt", "prompt-sync", "rereco", "rereco-sync"'
29  rereco = ("prompt" not in self.cfg_ana.doMuScleFitCorrections)
30  sync = ("sync" in self.cfg_ana.doMuScleFitCorrections)
31  self.muscleCorr = MuScleFitCorr(cfg_comp.isMC, rereco, sync)
32  if hasattr(self.cfg_ana, "doRochesterCorrections") and self.cfg_ana.doRochesterCorrections:
33  raise RuntimeError, "You can't run both Rochester and MuScleFit corrections!"
34  else:
self.cfg_ana.doMuScleFitCorrections = False

Member Function Documentation

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

Definition at line 350 of file LeptonAnalyzer.py.

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

350 
351  def attachMiniIsolation(self, mu):
352  mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200)
353  # -- version with increasing cone at low pT, gives slightly better performance for tight cuts and low pt leptons
354  # mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200) if mu.pt() > 20 else 4.0/min(max(mu.pt(),10),20)
355  what = "mu" if (abs(mu.pdgId()) == 13) else ("eleB" if mu.isEB() else "eleE")
356  if what == "mu":
357  mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0);
358  else:
359  mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0,self.IsolationComputer.selfVetoNone);
360  if self.miniIsolationPUCorr == "weights":
361  if what == "mu":
362  mu.miniAbsIsoNeutral = self.IsolationComputer.neutralAbsIsoWeighted(mu.physObj, mu.miniIsoR, 0.01, 0.5);
363  else:
364  mu.miniAbsIsoNeutral = ( self.IsolationComputer.photonAbsIsoWeighted( mu.physObj, mu.miniIsoR, 0.08 if what == "eleE" else 0.0, 0.0, self.IsolationComputer.selfVetoNone) +
365  self.IsolationComputer.neutralHadAbsIsoWeighted(mu.physObj, mu.miniIsoR, 0.0, 0.0, self.IsolationComputer.selfVetoNone) )
366  else:
367  if what == "mu":
368  mu.miniAbsIsoNeutral = self.IsolationComputer.neutralAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.01, 0.5);
369  else:
370  mu.miniAbsIsoPho = self.IsolationComputer.photonAbsIsoRaw( mu.physObj, mu.miniIsoR, 0.08 if what == "eleE" else 0.0, 0.0, self.IsolationComputer.selfVetoNone)
371  mu.miniAbsIsoNHad = self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.0, 0.0, self.IsolationComputer.selfVetoNone)
372  mu.miniAbsIsoNeutral = mu.miniAbsIsoPho + mu.miniAbsIsoNHad
373  # -- version relying on PF candidate vetos; apparently less performant, and the isolation computed at RECO level doesn't have them
374  #mu.miniAbsIsoPhoSV = self.IsolationComputer.photonAbsIsoRaw( mu.physObj, mu.miniIsoR, 0.0, 0.0)
375  #mu.miniAbsIsoNHadSV = self.IsolationComputer.neutralHadAbsIsoRaw(mu.physObj, mu.miniIsoR, 0.0, 0.0)
376  #mu.miniAbsIsoNeutral = mu.miniAbsIsoPhoSV + mu.miniAbsIsoNHadSV
377  if self.miniIsolationPUCorr == "rhoArea":
378  mu.miniAbsIsoNeutral = max(0.0, mu.miniAbsIsoNeutral - mu.rho * mu.EffectiveArea03 * (mu.miniIsoR/0.3)**2)
379  elif self.miniIsolationPUCorr == "deltaBeta":
380  if what == "mu":
381  mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.01, 0.5);
382  else:
383  mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.015 if what == "eleE" else 0.0, 0.0,self.IsolationComputer.selfVetoNone);
384  mu.miniAbsIsoNeutral = max(0.0, mu.miniAbsIsoNeutral - 0.5*mu.miniAbsIsoPU)
385  elif self.miniIsolationPUCorr != 'raw':
386  raise RuntimeError, "Unsupported miniIsolationCorr name '" + str(self.cfg_ana.miniIsolationCorr) + "'! For now only 'rhoArea', 'deltaBeta', 'raw', 'weights' are supported (and 'weights' is not tested)."
387  mu.miniAbsIso = mu.miniAbsIsoCharged + mu.miniAbsIsoNeutral
388  mu.miniRelIso = mu.miniAbsIso/mu.pt()
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
min
T min(T a, T b)
Definition: MathUtil.h:58
def objects.LeptonAnalyzer.LeptonAnalyzer.beginLoop (   self,
  setup 
)

Definition at line 87 of file LeptonAnalyzer.py.

87 
88  def beginLoop(self, setup):
89  super(LeptonAnalyzer,self).beginLoop(setup)
90  self.counters.addCounter('events')
91  count = self.counters.counter('events')
92  count.register('all events')
def objects.LeptonAnalyzer.LeptonAnalyzer.declareHandles (   self)

Definition at line 73 of file LeptonAnalyzer.py.

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

73 
74  def declareHandles(self):
75  super(LeptonAnalyzer, self).declareHandles()
76 
77  #leptons
78  self.handles['muons'] = AutoHandle(self.cfg_ana.muons,"std::vector<pat::Muon>")
79  self.handles['electrons'] = AutoHandle(self.cfg_ana.electrons,"std::vector<pat::Electron>")
80 
81  #rho for muons
82  self.handles['rhoMu'] = AutoHandle( self.cfg_ana.rhoMuon, 'double')
83  #rho for electrons
84  self.handles['rhoEle'] = AutoHandle( self.cfg_ana.rhoElectron, 'double')
85 
86  if self.doMiniIsolation:
self.handles['packedCandidates'] = AutoHandle( self.cfg_ana.packedCandidates, 'std::vector<pat::PackedCandidate>')
def objects.LeptonAnalyzer.LeptonAnalyzer.isFromB (   self,
  particle,
  bid = 5,
  done = {} 
)

Definition at line 410 of file LeptonAnalyzer.py.

References funct.abs(), and objects.LeptonAnalyzer.LeptonAnalyzer.isFromB().

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

410 
411  def isFromB(self,particle,bid=5, done={}):
412  for i in xrange( particle.numberOfMothers() ):
413  mom = particle.mother(i)
414  momid = abs(mom.pdgId())
415  if momid / 1000 == bid or momid / 100 == bid or momid == bid:
416  return True
417  elif mom.status() == 2 and self.isFromB(mom, done=done):
418  return True
419  return False
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 259 of file LeptonAnalyzer.py.

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

259 
260  def makeAllElectrons(self, event):
261  """
262  make a list of all electrons, and apply basic corrections to them
263  """
264  allelectrons = map( Electron, self.handles['electrons'].product() )
265 
266  ## Duplicate removal for fast sim (to be checked if still necessary in latest greatest 5.3.X releases)
267  allelenodup = []
268  for e in allelectrons:
269  dup = False
270  for e2 in allelenodup:
271  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():
272  dup = True
273  break
274  if not dup: allelenodup.append(e)
275  allelectrons = allelenodup
276 
277  # fill EA for rho-corrected isolation
278  for ele in allelectrons:
279  ele.rho = float(self.handles['rhoEle'].product()[0])
280  if self.eleEffectiveArea == "Data2012":
281  # https://twiki.cern.ch/twiki/bin/viewauth/CMS/EgammaEARhoCorrection?rev=14
282  SCEta = abs(ele.superCluster().eta())
283  if SCEta < 1.0 : ele.EffectiveArea03 = 0.13 # 0.130;
284  elif SCEta < 1.479: ele.EffectiveArea03 = 0.14 # 0.137;
285  elif SCEta < 2.0 : ele.EffectiveArea03 = 0.07 # 0.067;
286  elif SCEta < 2.2 : ele.EffectiveArea03 = 0.09 # 0.089;
287  elif SCEta < 2.3 : ele.EffectiveArea03 = 0.11 # 0.107;
288  elif SCEta < 2.4 : ele.EffectiveArea03 = 0.11 # 0.110;
289  else : ele.EffectiveArea03 = 0.14 # 0.138;
290  if SCEta < 1.0 : ele.EffectiveArea04 = 0.208;
291  elif SCEta < 1.479: ele.EffectiveArea04 = 0.209;
292  elif SCEta < 2.0 : ele.EffectiveArea04 = 0.115;
293  elif SCEta < 2.2 : ele.EffectiveArea04 = 0.143;
294  elif SCEta < 2.3 : ele.EffectiveArea04 = 0.183;
295  elif SCEta < 2.4 : ele.EffectiveArea04 = 0.194;
296  else : ele.EffectiveArea04 = 0.261;
297  elif self.eleEffectiveArea == "Phys14_25ns_v1":
298  aeta = abs(ele.eta())
299  if aeta < 0.800: ele.EffectiveArea03 = 0.1013
300  elif aeta < 1.300: ele.EffectiveArea03 = 0.0988
301  elif aeta < 2.000: ele.EffectiveArea03 = 0.0572
302  elif aeta < 2.200: ele.EffectiveArea03 = 0.0842
303  else: ele.EffectiveArea03 = 0.1530
304  if aeta < 0.800: ele.EffectiveArea04 = 0.1830
305  elif aeta < 1.300: ele.EffectiveArea04 = 0.1734
306  elif aeta < 2.000: ele.EffectiveArea04 = 0.1077
307  elif aeta < 2.200: ele.EffectiveArea04 = 0.1565
308  else: ele.EffectiveArea04 = 0.2680
309  else: raise RuntimeError, "Unsupported value for ele_effectiveAreas: can only use Data2012 (rho: ?) and Phys14_v1 (rho: fixedGridRhoFastjetAll)"
310 
311  # Electron scale calibrations
312  if self.cfg_ana.doElectronScaleCorrections:
313  for ele in allelectrons:
314  self.electronEnergyCalibrator.correct(ele, event.run)
315 
316  # Attach the vertex
317  for ele in allelectrons:
318  ele.associatedVertex = event.goodVertices[0] if len(event.goodVertices)>0 else event.vertices[0]
319 
320  # Compute relIso with R=0.3 and R=0.4 cones
321  for ele in allelectrons:
322  if self.cfg_ana.ele_isoCorr=="rhoArea" :
323  ele.absIso03 = (ele.chargedHadronIsoR(0.3) + max(ele.neutralHadronIsoR(0.3)+ele.photonIsoR(0.3)-ele.rho*ele.EffectiveArea03,0))
324  ele.absIso04 = (ele.chargedHadronIsoR(0.4) + max(ele.neutralHadronIsoR(0.4)+ele.photonIsoR(0.4)-ele.rho*ele.EffectiveArea04,0))
325  elif self.cfg_ana.ele_isoCorr=="deltaBeta" :
326  ele.absIso03 = (ele.chargedHadronIsoR(0.3) + max( ele.neutralHadronIsoR(0.3)+ele.photonIsoR(0.3) - ele.puChargedHadronIsoR(0.3)/2, 0.0))
327  ele.absIso04 = (ele.chargedHadronIsoR(0.4) + max( ele.neutralHadronIsoR(0.4)+ele.photonIsoR(0.4) - ele.puChargedHadronIsoR(0.4)/2, 0.0))
328  else :
329  raise RuntimeError, "Unsupported ele_isoCorr name '" + str(self.cfg_ana.ele_isoCorr) + "'! For now only 'rhoArea' and 'deltaBeta' are supported."
330  ele.relIso03 = ele.absIso03/ele.pt()
331  ele.relIso04 = ele.absIso04/ele.pt()
332 
333  # Set tight MVA id
334  for ele in allelectrons:
335  if self.cfg_ana.ele_tightId=="MVA" :
336  ele.tightIdResult = ele.electronID("POG_MVA_ID_Trig_full5x5")
337  elif self.cfg_ana.ele_tightId=="Cuts_2012" :
338  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")
339  elif self.cfg_ana.ele_tightId=="Cuts_PHYS14_25ns_v1_ConvVetoDxyDz" :
340  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")
341 
342  else :
343  try:
344  ele.tightIdResult = ele.electronID(self.cfg_ana.ele_tightId)
345  except RuntimeError:
346  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."
347 
348 
349  return allelectrons
eta
T eta() const
Definition: Basic3DVectorLD.h:177
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:279
def objects.LeptonAnalyzer.LeptonAnalyzer.makeAllMuons (   self,
  event 
) 
       make a list of all muons, and apply basic corrections to them

Definition at line 182 of file LeptonAnalyzer.py.

References core.AutoHandle.AutoHandle.handles, core.Analyzer.Analyzer.handles, HTTP.RequestManager.handles, and python.multivaluedict.map().

182 
183  def makeAllMuons(self, event):
184  """
185  make a list of all muons, and apply basic corrections to them
186  """
187  # Start from all muons
188  allmuons = map( Muon, self.handles['muons'].product() )
189 
190  # Muon scale and resolution corrections (if enabled)
191  if self.cfg_ana.doMuScleFitCorrections:
192  for mu in allmuons:
193  self.muscleCorr.correct(mu, event.run)
194  elif self.cfg_ana.doRochesterCorrections:
195  for mu in allmuons:
196  corp4 = rochcor.corrected_p4(mu, event.run)
197  mu.setP4( corp4 )
198 
199  # Clean up dulicate muons (note: has no effect unless the muon id is removed)
200  if self.cfg_ana.doSegmentBasedMuonCleaning:
201  isgood = cmgMuonCleanerBySegments.clean( self.handles['muons'].product() )
202  newmu = []
203  for i,mu in enumerate(allmuons):
204  if isgood[i]: newmu.append(mu)
205  allmuons = newmu
206 
207  # Attach EAs for isolation:
208  for mu in allmuons:
209  mu.rho = float(self.handles['rhoMu'].product()[0])
210  if self.muEffectiveArea == "Data2012":
211  if aeta < 1.0 : mu.EffectiveArea03 = 0.382;
212  elif aeta < 1.47 : mu.EffectiveArea03 = 0.317;
213  elif aeta < 2.0 : mu.EffectiveArea03 = 0.242;
214  elif aeta < 2.2 : mu.EffectiveArea03 = 0.326;
215  elif aeta < 2.3 : mu.EffectiveArea03 = 0.462;
216  else : mu.EffectiveArea03 = 0.372;
217  if aeta < 1.0 : mu.EffectiveArea04 = 0.674;
218  elif aeta < 1.47 : mu.EffectiveArea04 = 0.565;
219  elif aeta < 2.0 : mu.EffectiveArea04 = 0.442;
220  elif aeta < 2.2 : mu.EffectiveArea04 = 0.515;
221  elif aeta < 2.3 : mu.EffectiveArea04 = 0.821;
222  else : mu.EffectiveArea04 = 0.660;
223  elif self.muEffectiveArea == "Phys14_25ns_v1":
224  aeta = abs(mu.eta())
225  if aeta < 0.800: mu.EffectiveArea03 = 0.0913
226  elif aeta < 1.300: mu.EffectiveArea03 = 0.0765
227  elif aeta < 2.000: mu.EffectiveArea03 = 0.0546
228  elif aeta < 2.200: mu.EffectiveArea03 = 0.0728
229  else: mu.EffectiveArea03 = 0.1177
230  if aeta < 0.800: mu.EffectiveArea04 = 0.1564
231  elif aeta < 1.300: mu.EffectiveArea04 = 0.1325
232  elif aeta < 2.000: mu.EffectiveArea04 = 0.0913
233  elif aeta < 2.200: mu.EffectiveArea04 = 0.1212
234  else: mu.EffectiveArea04 = 0.2085
235  else: raise RuntimeError, "Unsupported value for mu_effectiveAreas: can only use Data2012 (rho: ?) and Phys14_v1 (rho: fixedGridRhoFastjetAll)"
236  # Attach the vertex to them, for dxy/dz calculation
237  for mu in allmuons:
238  mu.associatedVertex = event.goodVertices[0] if len(event.goodVertices)>0 else event.vertices[0]
239  mu.setTrackForDxyDz(self.cfg_ana.muon_dxydz_track)
240 
241  # Set tight id if specified
242  if hasattr(self.cfg_ana, "mu_tightId"):
243  for mu in allmuons:
244  mu.tightIdResult = mu.muonID(self.cfg_ana.mu_tightId)
245 
246  # Compute relIso in 0.3 and 0.4 cones
247  for mu in allmuons:
248  if self.cfg_ana.mu_isoCorr=="rhoArea" :
249  mu.absIso03 = (mu.pfIsolationR03().sumChargedHadronPt + max( mu.pfIsolationR03().sumNeutralHadronEt + mu.pfIsolationR03().sumPhotonEt - mu.rho * mu.EffectiveArea03,0.0))
250  mu.absIso04 = (mu.pfIsolationR04().sumChargedHadronPt + max( mu.pfIsolationR04().sumNeutralHadronEt + mu.pfIsolationR04().sumPhotonEt - mu.rho * mu.EffectiveArea04,0.0))
251  elif self.cfg_ana.mu_isoCorr=="deltaBeta" :
252  mu.absIso03 = (mu.pfIsolationR03().sumChargedHadronPt + max( mu.pfIsolationR03().sumNeutralHadronEt + mu.pfIsolationR03().sumPhotonEt - mu.pfIsolationR03().sumPUPt/2,0.0))
253  mu.absIso04 = (mu.pfIsolationR04().sumChargedHadronPt + max( mu.pfIsolationR04().sumNeutralHadronEt + mu.pfIsolationR04().sumPhotonEt - mu.pfIsolationR04().sumPUPt/2,0.0))
254  else :
255  raise RuntimeError, "Unsupported mu_isoCorr name '" + str(self.cfg_ana.mu_isoCorr) + "'! For now only 'rhoArea' and 'deltaBeta' are supported."
256  mu.relIso03 = mu.absIso03/mu.pt()
257  mu.relIso04 = mu.absIso04/mu.pt()
258  return allmuons
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
def objects.LeptonAnalyzer.LeptonAnalyzer.makeLeptons (   self,
  event 
)

Definition at line 98 of file LeptonAnalyzer.py.

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

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

98 
99  def makeLeptons(self, event):
100  ### inclusive leptons = all leptons that could be considered somewhere in the analysis, with minimal requirements (used e.g. to match to MC)
101  event.inclusiveLeptons = []
102  ### selected leptons = subset of inclusive leptons passing some basic id definition and pt requirement
103  ### other leptons = subset of inclusive leptons failing some basic id definition and pt requirement
104  event.selectedLeptons = []
105  event.selectedMuons = []
106  event.selectedElectrons = []
107  event.otherLeptons = []
108 
109  if self.doMiniIsolation:
110  self.IsolationComputer.setPackedCandidates(self.handles['packedCandidates'].product())
111  if self.miniIsolationVetoLeptons == "any":
112  for lep in self.handles['muons'].product():
113  self.IsolationComputer.addVeto(lep)
114  for lep in self.handles['electrons'].product():
115  self.IsolationComputer.addVeto(lep)
116 
117  #muons
118  allmuons = self.makeAllMuons(event)
119 
120  #electrons
121  allelectrons = self.makeAllElectrons(event)
122 
123  #make inclusive leptons
124  inclusiveMuons = []
125  inclusiveElectrons = []
126  for mu in allmuons:
127  if (mu.track().isNonnull() and mu.muonID(self.cfg_ana.inclusive_muon_id) and
128  mu.pt()>self.cfg_ana.inclusive_muon_pt and abs(mu.eta())<self.cfg_ana.inclusive_muon_eta and
129  abs(mu.dxy())<self.cfg_ana.inclusive_muon_dxy and abs(mu.dz())<self.cfg_ana.inclusive_muon_dz):
130  inclusiveMuons.append(mu)
131  for ele in allelectrons:
132  if ( ele.electronID(self.cfg_ana.inclusive_electron_id) and
133  ele.pt()>self.cfg_ana.inclusive_electron_pt and abs(ele.eta())<self.cfg_ana.inclusive_electron_eta and
134  abs(ele.dxy())<self.cfg_ana.inclusive_electron_dxy and abs(ele.dz())<self.cfg_ana.inclusive_electron_dz and
135  ele.lostInner()<=self.cfg_ana.inclusive_electron_lostHits ):
136  inclusiveElectrons.append(ele)
137  event.inclusiveLeptons = inclusiveMuons + inclusiveElectrons
138 
139  if self.doMiniIsolation:
140  if self.miniIsolationVetoLeptons == "inclusive":
141  for lep in event.inclusiveLeptons:
142  self.IsolationComputer.addVeto(lep)
143  for lep in event.inclusiveLeptons:
144  self.attachMiniIsolation(lep)
145 
146  # make loose leptons (basic selection)
147  for mu in inclusiveMuons:
148  if (mu.muonID(self.cfg_ana.loose_muon_id) and
149  mu.pt() > self.cfg_ana.loose_muon_pt and abs(mu.eta()) < self.cfg_ana.loose_muon_eta and
150  abs(mu.dxy()) < self.cfg_ana.loose_muon_dxy and abs(mu.dz()) < self.cfg_ana.loose_muon_dz and
151  self.muIsoCut(mu)):
152  mu.looseIdSusy = True
153  event.selectedLeptons.append(mu)
154  event.selectedMuons.append(mu)
155  else:
156  mu.looseIdSusy = False
157  event.otherLeptons.append(mu)
158  looseMuons = event.selectedLeptons[:]
159  for ele in inclusiveElectrons:
160  if (ele.electronID(self.cfg_ana.loose_electron_id) and
161  ele.pt()>self.cfg_ana.loose_electron_pt and abs(ele.eta())<self.cfg_ana.loose_electron_eta and
162  abs(ele.dxy()) < self.cfg_ana.loose_electron_dxy and abs(ele.dz())<self.cfg_ana.loose_electron_dz and
163  self.eleIsoCut(ele) and
164  ele.lostInner() <= self.cfg_ana.loose_electron_lostHits and
165  ( True if getattr(self.cfg_ana,'notCleaningElectrons',False) else (bestMatch(ele, looseMuons)[1] > (self.cfg_ana.min_dr_electron_muon**2)) )):
166  event.selectedLeptons.append(ele)
167  event.selectedElectrons.append(ele)
168  ele.looseIdSusy = True
169  else:
170  event.otherLeptons.append(ele)
171  ele.looseIdSusy = False
172 
173  event.otherLeptons.sort(key = lambda l : l.pt(), reverse = True)
174  event.selectedLeptons.sort(key = lambda l : l.pt(), reverse = True)
175  event.selectedMuons.sort(key = lambda l : l.pt(), reverse = True)
176  event.selectedElectrons.sort(key = lambda l : l.pt(), reverse = True)
177  event.inclusiveLeptons.sort(key = lambda l : l.pt(), reverse = True)
178 
179  for lepton in event.selectedLeptons:
180  if hasattr(self,'efficiency'):
181  self.efficiency.attachToObject(lepton)
deltar.bestMatch
def bestMatch
Definition: deltar.py:139
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:110
def objects.LeptonAnalyzer.LeptonAnalyzer.matchAnyLeptons (   self,
  event 
)

Definition at line 420 of file LeptonAnalyzer.py.

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

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

420 
421  def matchAnyLeptons(self, event):
422  event.anyLeptons = [ x for x in event.genParticles if x.status() == 1 and abs(x.pdgId()) in [11,13] ]
423  leps = event.inclusiveLeptons if hasattr(event, 'inclusiveLeptons') else event.selectedLeptons
424  match = matchObjectCollection3(leps, event.anyLeptons, deltaRMax = 0.3, filter = lambda x,y : abs(x.pdgId()) == abs(y.pdgId()))
425  for lep in leps:
426  gen = match[lep]
427  lep.mcMatchAny_gp = gen
428  if gen:
429  if self.isFromB(gen): lep.mcMatchAny = 5 # B (inclusive of B->D)
430  elif self.isFromB(gen,bid=4): lep.mcMatchAny = 4 # Charm
431  else: lep.mcMatchAny = 1
432  else:
433  lep.mcMatchAny = 0
434  # fix case where the matching with the only prompt leptons failed, but we still ended up with a prompt match
435  if gen != None and hasattr(lep,'mcMatchId') and lep.mcMatchId == 0:
436  if isPromptLepton(gen, False): lep.mcMatchId = 100
437  elif not hasattr(lep,'mcMatchId'):
438  lep.mcMatchId = 0
439  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:49
deltar.matchObjectCollection3
def matchObjectCollection3
Definition: deltar.py:41
def objects.LeptonAnalyzer.LeptonAnalyzer.matchLeptons (   self,
  event 
)

Definition at line 389 of file LeptonAnalyzer.py.

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

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

389 
390  def matchLeptons(self, event):
391  def plausible(rec,gen):
392  if abs(rec.pdgId()) == 11 and abs(gen.pdgId()) != 11: return False
393  if abs(rec.pdgId()) == 13 and abs(gen.pdgId()) != 13: return False
394  dr = deltaR(rec.eta(),rec.phi(),gen.eta(),gen.phi())
395  if dr < 0.3: return True
396  if rec.pt() < 10 and abs(rec.pdgId()) == 13 and gen.pdgId() != rec.pdgId(): return False
397  if dr < 0.7: return True
398  if min(rec.pt(),gen.pt())/max(rec.pt(),gen.pt()) < 0.3: return False
399  return True
400 
401  leps = event.inclusiveLeptons if self.cfg_ana.match_inclusiveLeptons else event.selectedLeptons
402  match = matchObjectCollection3(leps,
403  event.genleps + event.gentauleps,
404  deltaRMax = 1.2, filter = plausible)
405  for lep in leps:
406  gen = match[lep]
407  lep.mcMatchId = (gen.sourceId if gen != None else 0)
408  lep.mcMatchTau = (gen in event.gentauleps if gen else -99)
409  lep.mcLep=gen
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
min
T min(T a, T b)
Definition: MathUtil.h:58
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
deltar.matchObjectCollection3
def matchObjectCollection3
Definition: deltar.py:41
def objects.LeptonAnalyzer.LeptonAnalyzer.process (   self,
  event 
)

Definition at line 440 of file LeptonAnalyzer.py.

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

Referenced by ConfigBuilder.ConfigBuilder.addExtraStream(), ConfigBuilder.ConfigBuilder.completeInputCommand(), ConfigBuilder.ConfigBuilder.doNotInlineEventContent(), ConfigBuilder.ConfigBuilder.PrintAllModules.leave(), ConfigBuilder.ConfigBuilder.prepare_HLT(), ConfigBuilder.ConfigBuilder.prepare_LHE(), ConfigBuilder.ConfigBuilder.prepare_PATFILTER(), ConfigBuilder.ConfigBuilder.prepare_VALIDATION(), ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence(), ConfigBuilder.ConfigBuilder.renameInputTagsInSequence(), and ConfigBuilder.ConfigBuilder.scheduleSequence().

440 
441  def process(self, event):
442  self.readCollections( event.input )
443  self.counters.counter('events').inc('all events')
444 
445  #call the leptons functions
446  self.makeLeptons(event)
447 
448  if self.cfg_comp.isMC and self.cfg_ana.do_mc_match:
449  self.matchLeptons(event)
450  self.matchAnyLeptons(event)
451 
452  return True
453 
454 #A default config
setattr(LeptonAnalyzer,"defaultConfig",cfg.Analyzer(

Member Data Documentation

objects.LeptonAnalyzer.LeptonAnalyzer.class_object = LeptonAnalyzer,
static

Definition at line 456 of file LeptonAnalyzer.py.

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

Definition at line 459 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)

Definition at line 279 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.miniIsolationPUCorr

Definition at line 359 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 110 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.muEffectiveArea

Definition at line 209 of file LeptonAnalyzer.py.

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

Definition at line 458 of file LeptonAnalyzer.py.

objects.LeptonAnalyzer.LeptonAnalyzer.muscleCorr

Definition at line 30 of file LeptonAnalyzer.py.

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

Definition at line 461 of file LeptonAnalyzer.py.

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

Definition at line 460 of file LeptonAnalyzer.py.

Generated for CMSSW Reference Manual by doxygen 1.8.5