def makeHadTopDecays(self, event):
event.lightJets = [ j for j in event.cleanJets if not j.btagWP("CSVv2IVFM") ]
event.minMWjj = 999
event.minMWjjPt = 0
event.bestMWjj = 0
event.bestMWjjPt = 0
event.bestMTopHad = 0
event.bestMTopHadPt = 0
for i1,j1 in enumerate(event.lightJets):
for i2 in xrange(i1+1,len(event.lightJets)):
j2 = event.lightJets[i2]
jjp4 = j1.p4() + j2.p4()
mjj = jjp4.M()
if mjj > 30 and mjj < event.minMWjj:
event.minMWjj = mjj
event.minMWjjPt = jjp4.Pt()
if abs(mjj-80.4) < abs(event.bestMWjj-80.4):
event.bestMWjj = mjj
event.bestMWjjPt = jjp4.Pt()
for bj in event.bjetsLoose:
if deltaR(bj.eta(),bj.phi(),j1.eta(),j1.phi()) < 0.1 or deltaR(bj.eta(),bj.phi(),j2.eta(),j2.phi()) < 0.1: continue
tp4 = jjp4 + bj.p4()
mtop = tp4.M()
if abs(mtop-172) < abs(event.bestMTopHad - 172):
event.bestMTopHad = mtop
event.bestMTopHadPt = tp4.Pt()
def process(self, event):
self.readCollections( event.input )
self.counters.counter('events').inc('all events')
objects = []
selectedObjects = getattr(event, self.cfg_ana.objects)
for obj, ptCut in zip(selectedObjects, self.ptCuts):
allowTrack = False
for i in range (0,len(event.selectedMuons)) :
if (i == self.cfg_ana.allowedMuon): break
if(deltaR(event.selectedMuons[i].eta(), event.selectedMuons[i].phi(), obj.eta(), obj.phi()) < 0.02) : allowTrack=True
for i in range (0,len(event.selectedElectrons)) :
if (i == self.cfg_ana.allowedElectron): break
if(deltaR(event.selectedElectrons[i].eta(), event.selectedElectrons[i].phi(), obj.eta(), obj.phi()) < 0.02) : allowTrack=True
if not self.idFunc(obj):
continue
if obj.pt() > ptCut and not allowTrack:
objects.append(obj)
ret = False
if len(objects) >= self.cfg_ana.minObjects:
ret = True
else:
self.counters.counter('events').inc('too few objects')
if len(objects) > self.cfg_ana.maxObjects:
self.counters.counter('events').inc('too many objects')
ret = False
if ret: self.counters.counter('events').inc('accepted events')
return ret
def process(self, event):
self.readCollections( event.input )
pf = map( PhysicsObject, self.handles['pf'].product() )
leptons = getattr(event,self.leptonTag)
self.IsolationComputer.setPackedCandidates(self.handles['pf'].product())
#first trim the photons that are only near leptons
direct=[]
forIso=[]
for p in pf:
if p.pdgId() != 22 or not( p.pt() > 2.0 and abs(p.eta()) < 2.4 ):
continue
scVetoed = False
for l in leptons:
if abs(l.pdgId())==11 and self.electronID(l):
#print "Testing photon pt %5.1f eta %+7.4f phi %+7.4f vs ele pt %.1f eta %+7.4f phi %+7.4f sc eta %+7.4f phi %+7.4f" % ( p.pt(), p.eta(), p.phi(), l.pt(), l.eta(), l.phi(), l.superCluster().eta(), l.superCluster().phi() )
#print "Testing deta %+7.4f dphi %+7.4f sc deta %+7.4f dphi %+7.4f" % ( abs(p.eta()-l.eta()), deltaPhi(p.phi(),l.phi()), abs(p.eta()-l.superCluster().eta()), deltaPhi(p.phi(),l.superCluster().phi()))
if self.cfg_ana.electronVeto == "superclusterEta":
if (abs(p.eta()-l.superCluster().eta())<0.05 and abs(deltaPhi(p.phi(),l.superCluster().phi()))<2) or deltaR(p.eta(),p.phi(),l.superCluster().eta(),l.superCluster().phi())<0.15:
scVetoed = True; break
elif self.cfg_ana.electronVeto == "electronEta":
if (abs(p.eta()-l.eta())<0.05 and abs(deltaPhi(p.phi(),l.phi()))<2) or deltaR(p.eta(),p.phi(),l.eta(),l.phi())<0.15:
scVetoed = True; break
else:
raise RuntimeError, "electronVeto option %r not implemented" % self.cfg_ana.electronVeto
if scVetoed: continue
okNoIso = False; okIfIso = False
for l in leptons:
DR =deltaR(l.eta(),l.phi(),p.eta(),p.phi())
if DR<0.07 and p.pt()>2.0:
direct.append(p)
okNoIso = True
break;
elif DR<0.5 and p.pt()>4.0:
okIfIso = True
if okIfIso and not okNoIso:
forIso.append(p)
isolatedPhotons=[]
for g in forIso:
g.absIsoCH = self.IsolationComputer.chargedAbsIso(g.physObj,0.3,0.0001,0.2)
g.absIsoPU = self.IsolationComputer.puAbsIso(g.physObj,0.3,0.0001,0.2)
g.absIsoNH = self.IsolationComputer.neutralHadAbsIsoRaw(g.physObj,0.3,0.01,0.5)
g.absIsoPH = self.IsolationComputer.photonAbsIsoRaw(g.physObj,0.3,0.01,0.5)
g.relIso = (g.absIsoCH+g.absIsoPU+g.absIsoNH+g.absIsoPH)/g.pt()
if g.relIso<1.0:
isolatedPhotons.append(g)
event.fsrPhotons = isolatedPhotons+direct
# save all, for debugging
event.fsrPhotonsNoIso = forIso + direct
for fsr in event.fsrPhotonsNoIso:
closest = min(leptons, key = lambda l : deltaR(fsr.eta(),fsr.phi(),l.eta(),l.phi()))
fsr.globalClosestLepton = closest
return True
def matchPhotons(self, event):
event.genPhotons = [ x for x in event.genParticles if x.status() == 1 and abs(x.pdgId()) == 22 ]
event.genPhotonsWithMom = [ x for x in event.genPhotons if x.numberOfMothers()>0 ]
event.genPhotonsWithoutMom = [ x for x in event.genPhotons if x.numberOfMothers()==0 ]
event.genPhotonsMatched = [ x for x in event.genPhotonsWithMom if abs(x.mother(0).pdgId())<23 or x.mother(0).pdgId()==2212 ]
match = matchObjectCollection3(event.allphotons, event.genPhotonsMatched, deltaRMax = 0.1)
matchNoMom = matchObjectCollection3(event.allphotons, event.genPhotonsWithoutMom, deltaRMax = 0.1)
packedGenParts = [ p for p in self.mchandles['packedGen'].product() if abs(p.eta()) < 3.1 ]
for gamma in event.allphotons:
gen = match[gamma]
gamma.mcGamma = gen
if gen and gen.pt()>=0.5*gamma.pt() and gen.pt()<=2.*gamma.pt():
gamma.mcMatchId = 22
sumPt03 = 0.;
sumPt04 = 0.;
for part in packedGenParts:
if abs(part.pdgId())==12: continue # exclude neutrinos
if abs(part.pdgId())==14: continue
if abs(part.pdgId())==16: continue
if abs(part.pdgId())==18: continue
deltar = deltaR(gen.eta(), gen.phi(), part.eta(), part.phi())
if deltar <= 0.3:
sumPt03 += part.pt()
if deltar <= 0.4:
sumPt04 += part.pt()
sumPt03 -= gen.pt()
sumPt04 -= gen.pt()
if sumPt03<0. : sumPt03=0.
if sumPt04<0. : sumPt04=0.
gamma.genIso03 = sumPt03
gamma.genIso04 = sumPt04
else:
genNoMom = matchNoMom[gamma]
if genNoMom:
gamma.mcMatchId = 7
sumPt03 = 0.;
sumPt04 = 0.;
for part in packedGenParts:
if abs(part.pdgId())==12: continue # exclude neutrinos
if abs(part.pdgId())==14: continue
if abs(part.pdgId())==16: continue
if abs(part.pdgId())==18: continue
deltar = deltaR(genNoMom.eta(), genNoMom.phi(), part.eta(), part.phi());
if deltar <= 0.3:
sumPt03 += part.pt()
if deltar <= 0.4:
sumPt04 += part.pt()
sumPt03 -= genNoMom.pt()
sumPt04 -= genNoMom.pt()
if sumPt03<0. : sumPt03=0.
if sumPt04<0. : sumPt04=0.
gamma.genIso03 = sumPt03
gamma.genIso04 = sumPt04
else:
gamma.mcMatchId = 0
gamma.genIso03 = -1.
gamma.genIso04 = -1.
def selectFatJet(self, event):
if not len(event.cleanFatJets) >= 1:
return False
if not event.cleanFatJets[0].pt() > self.cfg_ana.fatjet_pt:
return False
# Add n-subjettiness
for i, j in enumerate(event.cleanFatJets):
j.tau21 = j.userFloat("NjettinessAK8:tau2")/j.userFloat("NjettinessAK8:tau1")
#########
# FIXME dirty hack: count the number of ak4 b-tagged jet close instead
# Count number of b-tagged subjets
nSubJetTags = 0
for f in event.cleanFatJets:
subJets = []
for j in event.cleanJets:
if deltaR(f.eta(), f.phi(), j.eta(), j.phi())<0.8:
subJets.append(j)
subJets.sort(key = lambda x : x.btag('combinedInclusiveSecondaryVertexV2BJetTags'), reverse = True)
f.nSubJets = len(subJets)
if len(subJets) >= 1:
f.subJet1 = subJets[0]
if len(subJets) >= 2:
f.subJet2 = subJets[1]
#########
# FatJet selections
if not event.cleanFatJets[0].nSubJets >= 1 or not event.cleanFatJets[0].subJet1.btag('combinedInclusiveSecondaryVertexV2BJetTags') > self.cfg_ana.fatjet_tag1:
return False
# if not event.cleanFatJets[0].nSubJets >= 2 or not event.cleanFatJets[0].subJet2.btag('combinedInclusiveSecondaryVertexV2BJetTags') > self.cfg_ana.fatjet_tag2:
# return False
if not event.cleanFatJets[0].userFloat("ak8PFJetsCHSPrunedLinks") > self.cfg_ana.fatjet_mass:
return False
if not hasattr(event.cleanFatJets[0], "tau21") or not event.cleanFatJets[0].tau21 > self.cfg_ana.fatjet_tau21:
return False
# Higgs candidate
prunedJet = copy.deepcopy(event.cleanFatJets[0]) # Copy fatJet...
prunedJet.setMass(prunedJet.userFloat("ak8PFJetsCHSPrunedLinks")) # ... and set the mass to the pruned mass
theH = prunedJet.p4()
theH.charge = event.cleanFatJets[0].charge()
theH.deltaR = deltaR(event.cleanFatJets[0].subJet1.eta(), event.cleanFatJets[0].subJet1.phi(), event.cleanFatJets[0].subJet2.eta(), event.cleanFatJets[0].subJet2.phi()) if hasattr(event.cleanFatJets[0], "subJet2") else -1.
theH.deltaEta = abs(event.cleanFatJets[0].subJet1.eta() - event.cleanFatJets[0].subJet2.eta()) if hasattr(event.cleanFatJets[0], "subJet2") else -9.
theH.deltaPhi = deltaPhi(event.cleanFatJets[0].subJet1.phi(), event.cleanFatJets[0].subJet2.phi()) if hasattr(event.cleanFatJets[0], "subJet2") else -9.
theH.deltaPhi_met = deltaPhi(theH.phi(), event.met.phi())
theH.deltaPhi_jet1 = deltaPhi(theH.phi(), event.cleanFatJets[0].phi())
event.H = theH
return True
def fillTauIndices(self,event) :
for j in event.cleanJetsAll :
j.tauIdxs = [event.inclusiveTaus.index(x) for x in j.taus if j.taus in event.inclusiveTaus]
for t in event.inclusiveTaus :
dRmin = 1.e+3
t.jetIdx = -1
for jIdx, j in enumerate(event.cleanJetsAll) :
dR = None
if t.isPFTau():
dR = deltaR(t.p4Jet().eta(),t.p4Jet().phi(),j.eta(),j.phi())
else:
dR = deltaR(t.pfEssential().p4CorrJet_.eta(),t.pfEssential().p4CorrJet_.phi(),j.eta(),j.phi())
if dR < 0.3 and dR < dRmin :
t.jetIdx = jIdx
dRmin = dR
def evaluateRegression(self, event, attrName="pt_reg"):
#self.readCollections( event.input )
self.rho[0] = event.rho
for j in event.jetsForHiggs :
self.Jet_pt[0] = j.pt()
self.Jet_eta[0] = j.eta()
self.Jet_rawPt[0] = j.pt()*j.rawFactor()
self.Jet_mt[0] = j.mt()
self.Jet_leadTrackPt[0] = j.leadTrackPt()
if len(j.leptons) > 0 :
self.Jet_leptonPtRel[0] = ptRel(j.leptons[0].p4(),j.p4())
self.Jet_leptonPt[0] = j.leptons[0].pt()
self.Jet_leptonDeltaR[0] = deltaR(j.leptons[0].p4().eta(),j.leptons[0].p4().phi(),j.p4().eta(),j.p4().phi())
else:
self.Jet_leptonPtRel[0] = -99
self.Jet_leptonPt[0] = -99
self.Jet_leptonDeltaR[0] =-99
self.Jet_chEmEF[0] = j.chargedEmEnergyFraction()
self.Jet_chHEF[0] = j.chargedHadronEnergyFraction()
self.Jet_neHEF[0] = j.neutralHadronEnergyFraction()
self.Jet_neEmEF[0] = j.neutralEmEnergyFraction()
self.Jet_chMult[0] = j.chargedMultiplicity()
self.Jet_vtxPt[0] = sqrt(j.userFloat("vtxPx")**2 + j.userFloat("vtxPy")**2)
self.Jet_vtxMass[0] = j.userFloat("vtxMass")
self.Jet_vtx3dL[0] = j.userFloat("vtx3dL")
self.Jet_vtxNtrk[0] = j.userFloat("vtxNtrk")
self.Jet_vtx3deL[0] = j.userFloat("vtx3deL")
setattr(j,attrName,self.reader.EvaluateRegression(self.name)[0])
def matchToGenHadron(particle, event, minDR=0.05, minDpt=0.1):
match = ( None, minDR, 2 )
myeta, myphi = particle.eta(), particle.phi()
# now, we don't loop over all the packed gen candidates, but rather do fast bisection to find the rightmost with eta > particle.eta() - 0.05
etacut = myeta - match[1]
ileft, iright = 0, len(event.packedGenForHadMatch)
while iright - ileft > 1:
imid = (iright + ileft)/2
if event.packedGenForHadMatch[imid][0] > etacut:
iright = imid
else:
ileft = imid
# now scan from imid to the end (but stop much earlier)
etacut = myeta + match[1]
for i in xrange(ileft,len(event.packedGenForHadMatch)):
(eta,phi,pg) = event.packedGenForHadMatch[i]
if eta > etacut: break
dr = deltaR(myeta,myphi,eta,phi)
if dr > match[1]: continue
if pg.charge() != particle.charge(): continue
dpt = abs(particle.pt() - pg.pt())/(particle.pt()+pg.pt())
if pg.pt() > 10: dpt /= 2; # scale down
if dpt < minDpt:
match = ( pg, dr, dpt )
return match
def process(self, event):
self.readCollections( event.input )
muons = [ mu for mu in event.selectedLeptons if abs(mu.pdgId())==13 and self.cfg_ana.selectedMuCut(mu) ]
muons += [ mu for mu in event.otherLeptons if abs(mu.pdgId())==13 and self.cfg_ana.otherMuCut(mu) ]
selectedElectrons = [ ]
selectedLeptons = [ mu for mu in event.selectedLeptons if abs(mu.pdgId())==13 ]
for ele in event.selectedLeptons:
if abs(ele.pdgId()) != 11: continue
good = True
for mu in muons:
dr = deltaR(mu.eta(), mu.phi(), ele.eta(), ele.phi())
if self.cfg_ana.mustClean(ele,mu,dr):
good = False
break
if good:
selectedLeptons.append(ele)
else: # move to the discarded ones
event.otherLeptons.append(ele)
# re-sort
selectedLeptons.sort(key = lambda l : l.pt(), reverse = True)
selectedElectrons.sort(key = lambda l : l.pt(), reverse = True)
event.otherLeptons.sort(key = lambda l : l.pt(), reverse = True)
event.selectedLeptons = selectedLeptons
event.selectedElectrons = selectedElectrons
return True
def checkMatch( self, eta, phi, particles, deltar ):
for part in particles:
if deltaR(eta, phi, part.eta(), part.phi()) < deltar:
return True
return False
def selectFatJet(self, event):
if not len(event.cleanJetsAK8) >= 1:
return False
if not event.cleanJetsAK8[0].pt() > self.cfg_ana.fatjet_pt:
return False
# FatJet selections
if not event.cleanJetsAK8[0].nSubJetTags >= 2:
return False
if not event.cleanJetsAK8[0].userFloat(self.cfg_ana.fatjet_mass_algo) > self.cfg_ana.fatjet_mass:
return False
if not hasattr(event.cleanJetsAK8[0], "tau21") or not event.cleanJetsAK8[0].tau21 > self.cfg_ana.fatjet_tau21:
return False
# Add subjets to the event
event.SubJets = event.cleanJetsAK8[0].subjets('SoftDrop')
# Higgs candidate
theV = event.cleanJetsAK8[0].p4()
theV.charge = event.cleanJetsAK8[0].charge()
theV.deltaR = deltaR(event.SubJets[0].eta(), event.SubJets[0].phi(), event.SubJets[1].eta(), event.SubJets[1].phi())
theV.deltaEta = abs(event.SubJets[0].eta() - event.SubJets[1].eta())
theV.deltaPhi = deltaPhi(event.SubJets[0].phi(), event.SubJets[1].phi())
theV.deltaPhi_met = deltaPhi(theV.phi(), event.met.phi())
theV.deltaPhi_jet1 = deltaPhi(theV.phi(), event.cleanJetsAK8[0].phi())
event.V = theV
return True
def process(self, event):
for l in event.genParticles:
if abs(l.pdgId()) in [11, 13] and l.status() == 2:
hasFSR = False
for d in range(0, l.numberOfDaughters()):
daughter = l.daughter(d)
if daughter.pdgId() == 22:
hasFSR = True
if hasFSR:
self.vars["mZ"][0] = l.mother(0).mother(0).mass()
self.vars["mStar"][0] = (l.daughter(0).p4() + l.daughter(1).p4()).M()
self.vars["P"][0] = l.daughter(0).p()
self.vars["E"][0] = l.daughter(1).energy()
self.vars["ET"][0] = l.daughter(1).pt()
self.vars["cosTheta"][0] = l.daughter(0).p4().Vect().Dot(l.daughter(1).p4().Vect()) / (
l.daughter(0).p() * l.daughter(1).energy()
)
self.vars["DR"][0] = deltaR(
l.daughter(0).eta(), l.daughter(0).phi(), l.daughter(1).eta(), l.daughter(1).phi()
)
finalStateLeptons = self.fetchFinalStateLeptons(l.mother(0).mother(0))
if len(finalStateLeptons) < 2:
continue
print "Final state leptons", len(finalStateLeptons)
self.vars["mll"][0] = (finalStateLeptons[0].p4() + finalStateLeptons[1].p4()).M()
self.vars["mllgamma"][0] = (
finalStateLeptons[0].p4() + finalStateLeptons[1].p4() + l.daughter(1).p4()
).M()
self.tree.Fill()
return False
def selectZ(self, event):
event.isZtoEE = False
event.isZtoMM = False
if hasattr(event, "muon1") and hasattr(event, "muon2"):
event.isZtoMM = True
event.Leptons.append(event.muon1)
event.Leptons.append(event.muon2)
elif hasattr(event, "electron1") and hasattr(event, "electron2"):
event.isZtoEE = True
event.Leptons.append(event.electron1)
event.Leptons.append(event.electron2)
else:
return False
theZ = event.Leptons[0].p4() + event.Leptons[1].p4()
if theZ.mass() < self.cfg_ana.mass_low or theZ.mass() > self.cfg_ana.mass_high:
return False
theZ.charge = event.Leptons[0].charge() + event.Leptons[1].charge()
theZ.deltaR = deltaR(event.Leptons[0].eta(), event.Leptons[0].phi(), event.Leptons[1].eta(), event.Leptons[1].phi())
theZ.deltaEta = abs(event.Leptons[0].eta() - event.Leptons[1].eta())
theZ.deltaPhi = deltaPhi(event.Leptons[0].phi(), event.Leptons[1].phi())
theZ.deltaPhi_met = deltaPhi(theZ.phi(), event.met.phi())
theZ.deltaPhi_jet1 = deltaPhi(theZ.phi(), event.Jets[0].phi())
event.Z = theZ
return True
def makeZGenVars(self, event):
if len(event.genleps) > 1:
event.genl1l2_m = (event.genleps[0].p4() + event.genleps[1].p4()).M()
event.genl1l2_pt = (event.genleps[0].p4() + event.genleps[1].p4()).pt()
event.genl1l2_eta = (event.genleps[0].p4() + event.genleps[1].p4()).eta()
event.genl1l2_phi = (event.genleps[0].p4() + event.genleps[1].p4()).phi()
event.genl1l2_DR = deltaR(event.genleps[0].eta(), event.genleps[0].phi(), event.genleps[1].eta(), event.genleps[1].phi())
def makeZVars(self, event):
if len(event.selectedLeptons) > 1:
event.l1l2_m = (event.selectedLeptons[0].p4() + event.selectedLeptons[1].p4()).M()
event.l1l2_pt = (event.selectedLeptons[0].p4() + event.selectedLeptons[1].p4()).pt()
event.l1l2_eta = (event.selectedLeptons[0].p4() + event.selectedLeptons[1].p4()).eta()
event.l1l2_phi = (event.selectedLeptons[0].p4() + event.selectedLeptons[1].p4()).phi()
event.l1l2_DR = deltaR(event.selectedLeptons[0].eta(), event.selectedLeptons[0].phi(), event.selectedLeptons[1].eta(), event.selectedLeptons[1].phi())
def partonCount(self, event):
if not self.cfg_comp.isMC:
return True
partons = [
p
for p in event.generatorSummary
if abs(p.pdgId()) in [1, 2, 3, 4, 5, 21, 22] and p.pt() > self.cfg_ana.mcPartonPtCut
]
leptons = [l for l in event.genleps + event.gentauleps if l.pt() > self.cfg_ana.mcLeptonPtCut]
taus = [t for t in event.gentaus if t.pt() > self.cfg_ana.mcTauPtCut]
for i, j in enumerate(event.jets):
j.mcNumPartons = sum([(deltaR(p, j) < 0.4) for p in partons])
j.mcNumLeptons = sum([(deltaR(p, j) < 0.4) for p in leptons])
j.mcNumTaus = sum([(deltaR(p, j) < 0.4) for p in taus])
p4any = None
for p in partons + leptons + taus:
if deltaR(p, j) < 0.4:
p4any = p.p4() + p4any if p4any != None else p.p4()
j.mcAnyPartonMass = p4any.M() if p4any != None else 0.0
def countBPartons(self,event):
event.allBPartons = [ q for q in event.genParticles if abs(q.pdgId()) == 5 and abs(q.status()) == 2 and abs(q.pt()) > 15 ]
event.allBPartons.sort(key = lambda q : q.pt(), reverse = True)
event.bPartons = []
for q in event.allBPartons:
duplicate = False
for q2 in event.bPartons:
if deltaR(q.eta(),q.phi(),q2.eta(),q2.phi()) < 0.5:
duplicate = True
continue
if not duplicate: event.bPartons.append(q)
def __call__(self,object):
hasOverlap=False
if abs(object.pdgId()) ==self.sourcePdgId:
for p in self.collection:
if abs(p.pdgId()) ==self.targetPdgId:
if self.targetID(p)==True:
if deltaR(object.eta(),object.phi(),p.eta(),p.phi())<self.dr:
hasOverlap=True
if hasOverlap:
return False
else:
return True
def selectW(self, event):
if not hasattr(event, "muon1"):
return False
theW = event.selectedMuons[0].p4() + event.met.p4()
theW.deltaPhi_met = deltaPhi(event.selectedMuons[0].phi(), event.met.phi())
theW.mT = math.sqrt( 2.*event.selectedMuons[0].et()*event.met.pt()*(1.-math.cos(theW.deltaPhi_met)) )
if theW.mT < self.cfg_ana.mt_low or theW.mT > self.cfg_ana.mt_high:
return False
theW.charge = event.selectedMuons[0].charge()
theW.deltaEta = abs(event.selectedMuons[0].eta())
theW.deltaPhi = deltaPhi(event.selectedMuons[0].phi(), event.met.phi())
theW.deltaR = deltaR(event.selectedMuons[0].eta(), event.selectedMuons[0].phi(), 0, event.met.phi())
event.W = theW
return True
def makeTaus(self, event):
event.selectedTaus = []
event.looseTaus = []
event.inclusiveTaus = []
#get all
alltaus = map( Tau, self.handles['taus'].product() )
foundTau = False
for tau in alltaus:
tau.associatedVertex = event.goodVertices[0]
tau.lepVeto = False
if self.cfg_ana.vetoLeptons:
for lep in event.selectedLeptons:
if deltaR(lep.eta(), lep.phi(), tau.eta(), tau.phi()) < self.cfg_ana.leptonVetoDR:
tau.lepVeto = True
if tau.lepVeto: continue
if self.cfg_ana.vetoLeptonsPOG:
if not tau.tauID("againstMuonTight"):
tau.lepVeto = True
if not tau.tauID("againstElectronLoose"):
tau.lepVeto = True
if tau.lepVeto: continue
if tau.pt() < self.cfg_ana.ptMin: continue
if abs(tau.eta()) > self.cfg_ana.etaMax: continue
### tau.dxy and tau.dz are zero
### if abs(tau.dxy()) > self.cfg_ana.dxyMax or abs(tau.dz()) > self.cfg_ana.dzMax: continue
foundTau = True
def id3(tau,X):
"""Create an integer equal to 1-2-3 for (loose,medium,tight)"""
return tau.tauID(X%"Loose") + tau.tauID(X%"Medium") + tau.tauID(X%"Tight")
#tau.idMVA2 = id3(tau, "by%sIsolationMVA2")
tau.idCI3hit = id3(tau, "by%sCombinedIsolationDeltaBetaCorr3Hits")
#print "Tau pt %5.1f: idMVA2 %d, idCI3hit %d, %s, %s" % (tau.pt(), tau.idMVA2, tau.idCI3hit, tau.tauID(self.cfg_ana.tauID), tau.tauID(self.cfg_ana.tauLooseID))
if tau.tauID(self.cfg_ana.tauID):
event.selectedTaus.append(tau)
event.inclusiveTaus.append(tau)
elif tau.tauID(self.cfg_ana.tauLooseID):
event.looseTaus.append(tau)
event.inclusiveTaus.append(tau)
event.selectedTaus.sort(key = lambda l : l.pt(), reverse = True)
event.looseTaus.sort(key = lambda l : l.pt(), reverse = True)
self.counters.counter('events').inc('all events')
if foundTau: self.counters.counter('events').inc('has >=1 tau at preselection')
if len(event.selectedTaus): self.counters.counter('events').inc('has >=1 selected taus')
if len(event.looseTaus): self.counters.counter('events').inc('has >=1 loose taus')
if len(event.inclusiveTaus): self.counters.counter('events').inc('has >=1 inclusive taus')
def makeNearestLeptons(leptons,track, event):
minDeltaR = 99999
nearestLepton = []
ibest=-1
for i,lepton in enumerate(leptons):
minDeltaRtemp=deltaR(lepton.eta(),lepton.phi(),track.eta(),track.phi())
if minDeltaRtemp < minDeltaR:
minDeltaR = minDeltaRtemp
ibest=i
if len(leptons) > 0 and ibest!=-1:
nearestLepton.append(leptons[ibest])
return nearestLepton
def makeDeltaRPhoJet(self, event):
event.minDeltaRPhoJet = []
for i,photon in enumerate(event.selectedPhotons):
if i == self.maxPhotons: break
minDeltaR = 999
for jet in event.cleanJets:
minDeltaR=min(deltaR(photon.eta(),photon.phi(),jet.eta(),jet.phi()), minDeltaR)
# Fill event with the min deltaR for each photon
event.minDeltaRPhoJet.append(minDeltaR)
return
def twoLeptonIsolation(self,twoLepton):
##First ! attach the FSR photons of this candidate to the leptons!
leptons = twoLepton.daughterLeptons()
photons = twoLepton.daughterPhotons()
for l in leptons:
l.fsrPhotons=[]
for g in photons:
if deltaR(g.eta(),g.phi(),l.eta(),l.phi())<0.4:
l.fsrPhotons.append(g)
if abs(l.pdgId())==11:
if not self.electronIsolation(l):
return False
if abs(l.pdgId())==13:
if not self.muonIsolation(l):
return False
return True
def absIsoWithFSR(self, R=0.4, puCorr="rhoArea", dBetaFactor=0.5):
'''
Calculate Isolation, subtract FSR, apply specific PU corrections"
'''
photonIso = self.photonIsoR(R)
if hasattr(self,'fsrPhotons'):
for gamma in self.fsrPhotons:
dr = deltaR(gamma.eta(), gamma.phi(), self.physObj.eta(), self.physObj.phi())
if (self.isEB() or dr > 0.08) and dr < R:
photonIso = max(photonIso-gamma.pt(),0.0)
if puCorr == "deltaBeta":
offset = dBetaFactor * self.puChargedHadronIsoR(R)
elif puCorr == "rhoArea":
offset = self.rho*getattr(self,"EffectiveArea"+(str(R).replace(".","")))
elif puCorr in ["none","None",None]:
offset = 0
else:
raise RuntimeError, "Unsupported PU correction scheme %s" % puCorr
return self.chargedHadronIsoR(R)+max(0.,photonIso+self.neutralHadronIsoR(R)-offset)
def computeRandomCone( self, event, eta, phi, deltarmax, charged, jets, photons ):
if self.checkMatch( eta, phi, jets, 2.*deltarmax ):
return -1.
if self.checkMatch( eta, phi, photons, 2.*deltarmax ):
return -1.
if self.checkMatch( eta, phi, event.selectedLeptons, deltarmax ):
return -1.
iso = 0.
for part in charged:
if deltaR(eta, phi, part.eta(), part.phi()) > deltarmax : continue
#if deltaR(eta, phi, part.eta(), part.phi()) < 0.02: continue
iso += part.pt()
return iso
def process(self, event):
self.readCollections(event.input)
puppi = self.handles['puppi'].product()
for tau in self.getter(event):
puppi_iso_cands = []
puppi_iso_cands_04 = []
puppi_iso_cands_03 = []
isoPtSumOld = 0.
tau_eta = tau.eta()
tau_phi = tau.phi()
# Normal loop crashes for some reason...
for i_iso in range(len(tau.isolationCands())):
isoPtSumOld += tau.isolationCands()[i_iso].pt()
eta = tau.isolationCands()[i_iso].eta()
phi = tau.isolationCands()[i_iso].phi()
n_p = 0
for c_p in puppi:
if abs(eta - c_p.eta()) < 0.00001 and \
abs(deltaPhi(phi, c_p.phi())) < 0.00001:
pdgId = c_p.pdgId()
if abs(pdgId) not in [22, 211]:
print 'Found puppi particle with pdgID', pdgId, 'ignoring...'
continue
puppi_iso_cands.append(c_p)
n_p += 1
dr = deltaR(c_p.eta(), c_p.phi(), tau_eta, tau_phi)
if dr < 0.4:
puppi_iso_cands_04.append(c_p)
if dr < 0.3:
puppi_iso_cands_03.append(c_p)
if n_p > 1:
print 'WARNING, found more than 2 matching puppi particles'
tau.puppi_iso_pt = sum(c_p.pt() for c_p in puppi_iso_cands)
tau.puppi_iso04_pt = sum(c_p.pt() for c_p in puppi_iso_cands_04)
tau.puppi_iso03_pt = sum(c_p.pt() for c_p in puppi_iso_cands_03)
# Add puppi isolation
return True
def evaluateRegression(self, event, attrName="pt_reg", analysis=""):
#self.readCollections( event.input )
# uniform with https://github.com/degrutto/HbbRegression
#self.rho[0] = event.rho
self.nPVs[0] = len(event.goodVertices)
for j in event.jetsForHiggs :
pt_corr = 1.0
if ("JEC" in analysis and hasattr(j, analysis)):
pt_corr = getattr(j, analysis)/getattr(j, "corr") if hasattr(j, "corr") and getattr(j, "corr") !=0 else 1.0
#print "JEC"+analysis, pt_corr
elif ("JER" in analysis and hasattr(j, analysis)):
pt_corr = getattr(j, analysis)/getattr(j, "corrJER") if hasattr(j, "corrJER") and getattr(j, "corrJER")!=0 else 1.0
#print "JER"+analysis, pt_corr
if pt_corr<=0.:
pt_corr = 1.0
self.Jet_pt[0] = j.pt()*pt_corr
#self.Jet_corr[0] = j.rawFactor()/(pt_corr if "JER" not in analysis else 1.0)
# self.Jet_corr[0] = (1/ j.rawFactor() ) / j.corrJER * ( pt_corr if "JER" not in analysis else 1.0 )
self.Jet_corr[0] = getattr(j, "corr") if hasattr(j, "corr") * (pt_corr if "JER" not in analysis else 1.0 ) else 0.0
self.Jet_mt[0] = j.mt()*pt_corr
self.Jet_eta[0] = j.eta()
self.Jet_leadTrackPt[0] = j.leadTrackPt()
if len(j.leptons) > 0 :
self.Jet_leptonPtRel[0] = ptRel(j.leptons[0].p4(),j.p4()*pt_corr)
self.Jet_leptonPt[0] = j.leptons[0].pt()
self.Jet_leptonDeltaR[0] = deltaR(j.leptons[0].p4().eta(),j.leptons[0].p4().phi(),j.p4().eta(),j.p4().phi())
else:
self.Jet_leptonPtRel[0] = 0
self.Jet_leptonPt[0] = 0
self.Jet_leptonDeltaR[0] =0
#self.Jet_chEmEF[0] = min(1,0, j.chargedEmEnergyFraction())
#self.Jet_chHEF[0] = min(1.-, j.chargedHadronEnergyFraction())
#self.Jet_neHEF[0] = min(1.0,j.neutralHadronEnergyFraction())
self.Jet_totHEF[0] = min(1.0, j.chargedHadronEnergyFraction() + j.neutralHadronEnergyFraction())
self.Jet_neEmEF[0] = min(1.0,j.neutralEmEnergyFraction())
#self.Jet_chMult[0] = j.chargedMultiplicity()
self.Jet_vtxPt[0] = sqrt(j.userFloat("vtxPx")**2 + j.userFloat("vtxPy")**2)
self.Jet_vtxMass[0] = j.userFloat("vtxMass")
self.Jet_vtx3dL[0] = max(0., j.userFloat("vtx3DVal"))
self.Jet_vtxNtrk[0] = j.userFloat("vtxNtracks")
self.Jet_vtx3deL[0] = self.Jet_vtx3dL[0]/j.userFloat("vtx3DSig") if j.userFloat("vtx3DSig") > 0 else 0
setattr(j,attrName+analysis,self.reader.EvaluateRegression(self.name)[0] * self.Jet_pt[0])
def doHiggsAddJetsdR08(self,event) :
if ( len(event.jetsForHiggs) >= 2):
event.hJetsaddJetsdR08 = [x for x in event.hJetsCSV]
event.dRaddJetsdR08 = []
event.aJetsaddJetsdR08 = [x for x in event.aJetsCSV]
event.hjidxaddJetsdR08 = [x for x in event.hjidxCSV]
event.ajidxaddJetsdR08 = [x for x in event.ajidxCSV]
#multiple jets interpretations, for central jets closest to dR<0.8 from higgs jets
jetsForHiggsAddJetsdR08 = [x for x in event.cleanJetsAll if (x.pt()>15 and abs(x.eta())<3.0 and x.puJetId() > 0 and x.jetID('POG_PFID_Loose') ) ]
if (len(jetsForHiggsAddJetsdR08) > 2):
addJetsForHiggs = [x for x in jetsForHiggsAddJetsdR08 if ( x not in event.hJetsCSV and min(deltaR( x.eta(), x.phi(), event.hJetsCSV[0].eta(), event.hJetsCSV[0].phi()),deltaR( x.eta(), x.phi(), event.hJetsCSV[1].eta(), event.hJetsCSV[1].phi()))<0.8 ) ]
for x in addJetsForHiggs:
event.hJetsaddJetsdR08.append(x)
event.dRaddJetsdR08.append( min(deltaR( x.eta(), x.phi(), event.hJetsCSV[0].eta(), event.hJetsCSV[0].phi()),deltaR( x.eta(), x.phi(), event.hJetsCSV[1].eta(), event.hJetsCSV[1].phi() )) )
event.hjidxaddJetsdR08=[event.cleanJetsAll.index(x) for x in event.hJetsaddJetsdR08 ]
event.aJetsaddJetsdR08 = [x for x in event.cleanJets if x not in event.hJetsaddJetsdR08]
event.aJetsaddJetsdR08+=event.cleanJetsFwd
event.ajidxaddJetsdR08=[event.cleanJetsAll.index(x) for x in event.aJetsaddJetsdR08 ]
event.HaddJetsdR08 = sum(map(lambda x:x.p4(), event.hJetsaddJetsdR08), ROOT.reco.Particle.LorentzVector(0.,0.,0.,0.))
def softActivity(self,event,j1,j2,excludedJets,dR0=0.4) :
if not hasattr(event,"pfCands") :
event.pfCands = list(self.handles['pfCands'].product())
inputs=ROOT.std.vector(ROOT.heppy.ReclusterJets.LorentzVector)()
used=[]
for j in excludedJets :
for i in xrange(0,j.numberOfSourceCandidatePtrs()) :
if j.sourceCandidatePtr(i).isAvailable() :
used.append(j.sourceCandidatePtr(i))
#get the pointed objects
used = [x.get() for x in used]
remainingPF = [x for x in event.pfCands if x.charge() != 0 and abs(x.eta()) < 2.5 and x.pt() > 0.3 and x.fromPV() >= 2 and abs(x.dz()) < 0.2 and x not in used]
dRbb = deltaR(j1.eta(),j1.phi(),j2.eta(),j2.phi())
map(lambda x:inputs.push_back(x.p4()), remainingPF)
softActivity=ROOT.heppy.FastSoftActivity(inputs,-1,0.4,j1.p4(),j2.p4(),dRbb+2*dR0)
jets=softActivity.getGrouping(1)
softActivityJets = [ ROOT.reco.Particle.LorentzVector(p4) for p4 in jets ]
softActivityJets.sort(key=lambda x:x.pt(), reverse=True)
return softActivityJets
def absIsoWithFSR(self, R=0.4, puCorr="deltaBeta", dBetaFactor=0.5):
'''
Calculate Isolation, subtract FSR, apply specific PU corrections"
'''
photonIso = self.photonIsoR(R)
if hasattr(self, 'fsrPhotons'):
for gamma in self.fsrPhotons:
dr = deltaR(gamma.eta(), gamma.phi(), self.physObj.eta(),
self.physObj.phi())
if dr > 0.01 and dr < R:
photonIso = max(photonIso - gamma.pt(), 0.0)
if puCorr == "deltaBeta":
offset = dBetaFactor * self.puChargedHadronIsoR(R)
elif puCorr == "rhoArea":
offset = self.rho * getattr(
self, "EffectiveArea" + (str(R).replace(".", "")))
elif puCorr in ["none", "None", None]:
offset = 0
else:
raise RuntimeError("Unsupported PU correction scheme %s" % puCorr)
return self.chargedHadronIsoR(R) + max(
0., photonIso + self.neutralHadronIsoR(R) - offset)
def pt_weighted_dx(tau, mode=0, var=0, decaymode=-1):
sum_pt = 0.
sum_dx_pt = 0.
signalrad = max(0.05, min(0.1, 3. / max(1., tau.pt())))
cands = getGammas(tau, mode < 2)
for cand in cands:
if cand.pt() < 0.5:
continue
dr = deltaR(cand, tau)
deta = abs(cand.eta() - tau.eta())
dphi = abs(deltaPhi(cand.phi(), tau.phi()))
pt = cand.pt()
flag = isInside(pt, deta, dphi)
if decaymode != 10:
if mode == 2 or (mode == 0
and dr < signalrad) or (mode == 1
and dr > signalrad):
sum_pt += pt
if var == 0:
sum_dx_pt += pt * dr
elif var == 1:
sum_dx_pt += pt * deta
elif var == 2:
sum_dx_pt += pt * dphi
else:
if (mode == 2
and flag == False) or (mode == 1
and flag == True) or mode == 0:
sum_pt += pt
if var == 0:
sum_dx_pt += pt * dr
elif var == 1:
sum_dx_pt += pt * deta
elif var == 2:
sum_dx_pt += pt * dphi
if sum_pt > 0.:
return sum_dx_pt / sum_pt
return 0.
def attachPuppiIso(self, muon, puppi, name='puppi'):
puppi_iso_cands = []
puppi_iso_cands_04 = []
puppi_iso_cands_03 = []
muon_eta = muon.eta()
muon_phi = muon.phi()
for c_p in puppi:
pdgId = c_p.pdgId()
if abs(pdgId) not in [22, 130, 211]:
continue
eta = c_p.eta()
phi = c_p.phi()
# Neutral hadrons or photons
inner_cone = 0.01
if abs(pdgId) in [211]:
inner_cone = 0.0001
elif c_p.pt() < 0.5:
continue
if abs(muon_eta - eta) < 0.5:
dr = deltaR(eta, phi, muon_eta, muon_phi)
if inner_cone < dr:
if dr < 0.5:
puppi_iso_cands.append(c_p)
if dr < 0.4:
puppi_iso_cands_04.append(c_p)
if dr < 0.3:
puppi_iso_cands_03.append(c_p)
setattr(muon, name + '_iso_pt',
sum(c_p.pt() for c_p in puppi_iso_cands))
setattr(muon, name + '_iso04_pt',
sum(c_p.pt() for c_p in puppi_iso_cands_04))
setattr(muon, name + '_iso03_pt',
sum(c_p.pt() for c_p in puppi_iso_cands_03))
def nIsrMatch(self, event):
event.nisrMatch = 0
jets = [j for j in event.cleanJets if j.pt() > self.jetPt]
for jet in jets:
matched = False
for mc in event.genParticles: #WithMotherId:
if matched: break
if (mc.status() != 23 or abs(mc.pdgId()) > 5): continue
momid = abs(mc.mother().pdgId())
if not (momid == 6 or momid == 23 or momid == 24 or momid == 25
or momid > 1e6):
continue # MT
#check against daughter in case of hard initial splitting
for idau in range(mc.numberOfDaughters()):
dR = deltaR(jet.eta(), jet.phi(),
mc.daughter(idau).p4().eta(),
mc.daughter(idau).p4().phi())
if dR < 0.3:
matched = True
break
if not matched:
event.nisrMatch += 1
def chargedHadronIso(event, dRCone, PU=False):
if PU == True:
charged_pfs = [
ipf for ipf in event.pfs if (ipf.charge() != 0 and ipf.pt() > 0.5)
]
charged_pfs = [ipf for ipf in charged_pfs if ipf.fromPV() <= 1]
if PU == False:
charged_pfs = [
ipf for ipf in event.pfs
if (ipf.charge() != 0 and abs(ipf.pdgId()) != 11
and abs(ipf.pdgId()) != 13 and ipf.pt() > 0.5)
]
charged_pfs = [
ipf for ipf in charged_pfs
if (ipf.fromPV() > 1 and abs(ipf.pdgId()) == 211)
]
charged_pfs = [
ipf for ipf in charged_pfs
if deltaR(ipf, event.the_3lep_cand.hnVisP4()) < dRCone
]
ch_iso = sum([ipf.pt() for ipf in charged_pfs])
# for i in charged_pfs: print 'charged hadron, pile up:\t', dRCone, PU, i.dz(), i.dxy(), i.pt(), i.pdgId()
return ch_iso
def makeLeptonPairs(self, event, electrons, muons):
''' Create all the possible di-lepton pairs
out of the different collections'''
if self.cfg_ana.L1L2LeptonType == 'ee':
leptons = electrons
if self.cfg_ana.L1L2LeptonType == 'mm':
leptons = muons
if self.cfg_ana.L1L2LeptonType == 'em':
leptons = electrons + muons
dileptons = combinations(leptons, 2)
dileptons = [(lep1, lep2) for lep1, lep2 in dileptons
if deltaR(lep1, lep2) > 0.01]
if self.cfg_ana.L1L2LeptonType == 'em':
dileptons = [(lep1, lep2) for lep1, lep2 in dileptons
if abs(lep1.pdgId()) + abs(lep2.pdgId()) == 24]
for pair in dileptons:
pair = sorted(pair,
key=lambda lep: (abs(lep.pdgId()), -lep.pt()),
reverse=False)
return dileptons
def selectResolvedJet(self, event):
if not len(event.cleanJets) >= 2:
return False
if not event.cleanJets[0].pt() > self.cfg_ana.jet1_pt:
return False
# if not event.cleanJets[0].btag('combinedInclusiveSecondaryVertexV2BJetTags') > self.cfg_ana.jet1_tag:
# return False
if not event.cleanJets[1].pt() > self.cfg_ana.jet2_pt:
return False
# if not event.cleanJets[1].btag('combinedInclusiveSecondaryVertexV2BJetTags') > self.cfg_ana.jet2_tag:
# return False
# Higgs candidate
theH = event.cleanJets[0].p4() + event.cleanJets[1].p4()
theH.charge = event.cleanJets[0].charge() + event.cleanJets[1].charge()
theH.deltaR = deltaR(event.cleanJets[0].eta(), event.cleanJets[0].phi(), event.cleanJets[1].eta(), event.cleanJets[1].phi())
theH.deltaEta = abs(event.cleanJets[0].eta() - event.cleanJets[1].eta())
theH.deltaPhi = deltaPhi(event.cleanJets[0].phi(), event.cleanJets[1].phi())
theH.deltaPhi_met = deltaPhi(theH.phi(), event.met.phi())
theH.deltaPhi_jet1 = deltaPhi(theH.phi(), event.cleanJets[0].phi())
event.H = theH
return True
def selectResolvedJet(self, event):
if not len(event.cleanJets) >= 2:
return False
if not event.cleanJets[0].pt() > self.cfg_ana.jet1_pt:
return False
# if not event.cleanJets[0].btag('combinedInclusiveSecondaryVertexV2BJetTags') > self.cfg_ana.jet1_tag:
# return False
if not event.cleanJets[1].pt() > self.cfg_ana.jet2_pt:
return False
# if not event.cleanJets[1].btag('combinedInclusiveSecondaryVertexV2BJetTags') > self.cfg_ana.jet2_tag:
# return False
# Higgs candidate
theH = event.cleanJets[0].p4() + event.cleanJets[1].p4()
theH.charge = event.cleanJets[0].charge() + event.cleanJets[1].charge()
theH.deltaR = deltaR(event.cleanJets[0].eta(), event.cleanJets[0].phi(), event.cleanJets[1].eta(), event.cleanJets[1].phi())
theH.deltaEta = abs(event.cleanJets[0].eta() - event.cleanJets[1].eta())
theH.deltaPhi = deltaPhi(event.cleanJets[0].phi(), event.cleanJets[1].phi())
theH.deltaPhi_met = deltaPhi(theH.phi(), event.met.phi())
theH.deltaPhi_jet1 = deltaPhi(theH.phi(), event.cleanJets[0].phi())
event.H = theH
return True
def process(self, event):
self.readCollections(event.input)
muons = [
mu for mu in event.selectedLeptons
if abs(mu.pdgId()) == 13 and self.cfg_ana.selectedMuCut(mu)
]
muons += [
mu for mu in event.otherLeptons
if abs(mu.pdgId()) == 13 and self.cfg_ana.otherMuCut(mu)
]
selectedElectrons = []
selectedLeptons = [
mu for mu in event.selectedLeptons if abs(mu.pdgId()) == 13
]
for ele in event.selectedLeptons:
if abs(ele.pdgId()) != 11: continue
good = True
for mu in muons:
dr = deltaR(mu.eta(), mu.phi(), ele.eta(), ele.phi())
if self.cfg_ana.mustClean(ele, mu, dr):
good = False
break
if good:
selectedLeptons.append(ele)
else: # move to the discarded ones
event.otherLeptons.append(ele)
# re-sort
selectedLeptons.sort(key=lambda l: l.pt(), reverse=True)
selectedElectrons.sort(key=lambda l: l.pt(), reverse=True)
event.otherLeptons.sort(key=lambda l: l.pt(), reverse=True)
event.selectedLeptons = selectedLeptons
event.selectedElectrons = selectedElectrons
return True
def doJets(self, event):
event.cleanJetsAll = []
event.cleanJetsFwd = []
event.cleanJets = []
if self.mchandles['jetsNoNu'].isValid():
jets = [j for j in self.mchandles['jetsNoNu'].product()]
else:
jets = []
for j in self.mchandles['jets'].product():
#print "(pass 0) gen jet pt %7.1f eta %+5.2f phi %+5.2f invEnF %.3f " % (j.pt(), j.eta(), j.phi(), j.invisibleEnergy()/j.energy())
if j.invisibleEnergy() > 0:
p4noNu = j.p4()
for idau in xrange(j.numberOfDaughters()):
dau = j.daughter(idau)
if abs(dau.pdgId()) in [12, 14, 16]:
p4noNu -= dau.p4()
j.setP4(p4noNu)
#print " w/o nu pt %7.1f eta %+5.2f phi %+5.2f " % (j.pt(), j.eta(), j.phi())
jets.append(j)
jets.sort(key=lambda l: -l.pt())
for j in jets:
good = True
if j.pt() < 25: continue
#print "(pass 1) gen jet pt %7.1f eta %+5.2f phi %+5.2f" % (j.pt(), j.eta(), j.phi())
for l in event.selectedLeptons:
if l.pt() > 10 and deltaR(l.eta(), l.phi(), j.eta(),
j.phi()) < 0.4:
#print " ov lep pt %7.1f eta %+5.2f phi %+5.2f dr %.3f" % (l.pt(), l.eta(), l.phi(), deltaR(l.eta(),l.phi(),j.eta(),j.phi()))
good = False
break
if not good: continue
jo = JetFromGen(j)
event.cleanJetsAll.append(jo)
if abs(j.eta()) < 2.4:
event.cleanJets.append(jo)
else:
event.cleanJetsFwd.append(jo)
def leptonAccept(self, leptons, event):
'''Di-lepton veto: returns false if >= 1 OS same flavour lepton pair,
e.g. >= 1 OS mu pair in the mu tau channel'''
looseLeptons = [
muon for muon in leptons
if self.testLegKine(muon, ptcut=15, etacut=2.4)
and muon.isLooseMuon() and self.testVertex(muon)
and self.testLeg1Iso(muon, 0.3)
]
nLeptons = len(looseLeptons)
if event.leg1 not in looseLeptons:
looseLeptons.append(event.leg1) #TODO why ?
# by comparison with TauEleAnalyser.py
if nLeptons < 2:
return True
##
# if there is an opposite-charge muon pair in the event with muons separated by dR>0.15 and both passing the loose selection
if any(l.charge() > 0 for l in looseLeptons) and \
any(l.charge() < 0 for l in looseLeptons):
looseLeptons_positives = [
l for l in looseLeptons if l.charge() > 0
]
looseLeptons_negatives = [
l for l in looseLeptons if l.charge() < 0
]
for l_pos in looseLeptons_positives:
for l_neg in looseLeptons_negatives:
dR = deltaR(l_pos.eta(), l_pos.phi(), l_neg.eta(),
l_neg.phi())
if dR > 0.15:
return False
return True
def process(self, event):
self.readCollections(event.input)
self.counters.counter('RecoGenTreeAnalyzer').inc('all events')
# produce collections and map our objects to convenient Heppy objects
event.muons = map(Muon, self.handles['muons'].product())
event.electrons = map(Electron, self.handles['electrons'].product())
event.photons = map(Photon, self.handles['photons'].product())
event.taus = map(Tau, self.handles['taus'].product())
event.jets = map(Jet, self.handles['jets'].product())
event.dsmuons = self.buildDisplacedMuons(
self.handles['dsmuons'].product())
event.dgmuons = self.buildDisplacedMuons(
self.handles['dgmuons'].product())
# vertex stuff
event.pvs = self.handles['pvs'].product()
event.svs = self.handles['svs'].product()
event.beamspot = self.handles['beamspot'].product()
# met
event.met = self.handles['met'].product().at(0)
# assign to the leptons the primary vertex, will be needed to compute a few quantities
# FIXME! understand exactly to which extent it is reasonable to assign the PV to *all* leptons
# regardless whether they're displaced or not
if len(event.pvs):
myvtx = event.pvs[0]
else:
myvtx = event.beamspot
self.assignVtx(event.muons, myvtx)
self.assignVtx(event.electrons, myvtx)
self.assignVtx(event.photons, myvtx)
self.assignVtx(event.taus, myvtx)
# all matchable objects
# matchable = event.electrons + event.photons + event.muons + event.taus + event.dsmuons + event.dgmuons
matchable = event.electrons + event.photons + event.muons + event.taus + event.dsmuons
# match gen to reco
for ip in [event.the_hnl.l0(), event.the_hnl.l1(), event.the_hnl.l2()]:
ip.bestmatch = None
ip.bestmatchtype = None
ip.matches = inConeCollection(ip, matchable,
getattr(self.cfg_ana, 'drmax', 0.2),
0.)
# matches the corresponding "slimmed electron" to the gen particle
if len(event.electrons):
dr2 = np.inf
match, dr2 = bestMatch(ip, event.electrons)
if dr2 < 0.04:
ip.bestelectron = match
# matches the corresponding "slimmed photon" to the gen particle
if len(event.photons):
dr2 = np.inf
match, dr2 = bestMatch(ip, event.photons)
if dr2 < 0.04:
ip.bestphoton = match
# matches the corresponding "slimmed muon" to the gen particle
if len(event.muons):
dr2 = np.inf
match, dr2 = bestMatch(ip, event.muons)
if dr2 < 0.04:
ip.bestmuon = match
# matches the corresponding "slimmed tau" to the gen particle
if len(event.taus):
dr2 = np.inf
match, dr2 = bestMatch(ip, event.taus)
if dr2 < 0.04:
ip.besttau = match
# matches the corresponding "displaced stand alone muon" to the gen particle
if len(event.dsmuons):
dr2 = np.inf
match, dr2 = bestMatch(ip, event.dsmuons)
if dr2 < 0.04:
ip.bestdsmuon = match
# matches the corresponding "displaced global muon" to the gen particle
if len(event.dgmuons):
dr2 = np.inf
match, dr2 = bestMatch(ip, event.dgmuons)
if dr2 < 0.04:
ip.bestdgmuon = match
# to find the best match, give precedence to any matched
# particle in the matching cone with the correct PDG ID
# then to the one which is closest
ip.matches.sort(key=lambda x:
(x.pdgId() == ip.pdgId(), -deltaR(x, ip)),
reverse=True)
if len(ip.matches) and abs(ip.pdgId()) == abs(
ip.matches[0].pdgId()):
ip.bestmatch = ip.matches[0]
# remove already matched particles, avoid multiple matches to the same candidate while recording the type of reconstruction
matchable.remove(ip.bestmatch)
# record which is which
if ip.bestmatch in event.electrons: ip.bestmatchtype = 11
if ip.bestmatch in event.photons: ip.bestmatchtype = 22
if ip.bestmatch in event.muons: ip.bestmatchtype = 13
if ip.bestmatch in event.taus: ip.bestmatchtype = 15
if ip.bestmatch in event.dsmuons: ip.bestmatchtype = 26
if ip.bestmatch in event.dgmuons: ip.bestmatchtype = 39
else:
ip.bestmatchtype = -1
# clear it before doing it again
event.recoSv = None
# if hasattr(event.the_hnl.l2().bestmatch, 'pt'):
# set_trace()
# if (abs(event.the_hnl.l1().pt()-13.851562)<0.001):
# set_trace()
######### DEBUG VTX MADE OUT OF DSA MUONS
# if len(event.dsmuons) > 2:
# # clear the vector
# self.tofit.clear()
# # create a RecoChargedCandidate for each reconstructed lepton and flush it into the vector
# for il in [event.dsmuons[0], event.dsmuons[1]]:
# # if the reco particle is a displaced thing, it does not have the p4() method, so let's build it
# myp4 = ROOT.Math.LorentzVector('<ROOT::Math::PxPyPzE4D<double> >')(il.px(), il.py(), il.pz(), math.sqrt(il.mass()**2 + il.px()**2 + il.py()**2 + il.pz()**2))
# ic = ROOT.reco.RecoChargedCandidate() # instantiate a dummy RecoChargedCandidate
# ic.setCharge(il.charge()) # assign the correct charge
# ic.setP4(myp4) # assign the correct p4
# ic.setTrack(il.track()) # set the correct TrackRef
# if ic.track().isNonnull(): # check that the track is valid, there are photons around too!
# self.tofit.push_back(ic)
# # further sanity check: two *distinct* tracks
# if self.tofit.size()==2 and self.tofit[0].track() != self.tofit[1].track():
# # fit it!
# svtree = self.vtxfit.Fit(self.tofit) # actual vertex fitting
# # check that the vertex is good
# if not svtree.get().isEmpty() and svtree.get().isValid():
# svtree.movePointerToTheTop()
# sv = svtree.currentDecayVertex().get()
# event.recoSv = makeRecoVertex(sv, kinVtxTrkSize=2) # need to do some gymastics
# print 'good double dsa vertex! vx=%.2f, vy=%.2f, vz=%.2f' %(event.recoSv.x(), event.recoSv.y(), event.recoSv.z())
# import pdb ; pdb.set_trace()
# let's refit the secondary vertex, IF both leptons match to some reco particle
if not(event.the_hnl.l1().bestmatch is None or \
event.the_hnl.l2().bestmatch is None):
# clear the vector
self.tofit.clear()
# create a RecoChargedCandidate for each reconstructed lepton and flush it into the vector
for il in [
event.the_hnl.l1().bestmatch,
event.the_hnl.l2().bestmatch
]:
# if the reco particle is a displaced thing, it does not have the p4() method, so let's build it
myp4 = ROOT.Math.LorentzVector(
'<ROOT::Math::PxPyPzE4D<double> >')(
il.px(), il.py(), il.pz(),
math.sqrt(il.mass()**2 + il.px()**2 + il.py()**2 +
il.pz()**2))
ic = ROOT.reco.RecoChargedCandidate(
) # instantiate a dummy RecoChargedCandidate
ic.setCharge(il.charge()) # assign the correct charge
ic.setP4(myp4) # assign the correct p4
ic.setTrack(il.track()) # set the correct TrackRef
if ic.track().isNonnull(
): # check that the track is valid, there are photons around too!
self.tofit.push_back(ic)
# further sanity check: two *distinct* tracks
if self.tofit.size(
) == 2 and self.tofit[0].track() != self.tofit[1].track():
# fit it!
svtree = self.vtxfit.Fit(self.tofit) # actual vertex fitting
# check that the vertex is good
if not svtree.get().isEmpty() and svtree.get().isValid():
svtree.movePointerToTheTop()
sv = svtree.currentDecayVertex().get()
event.recoSv = makeRecoVertex(
sv, kinVtxTrkSize=2) # need to do some gymastics
if event.recoSv:
# primary vertex
pv = event.goodVertices[0]
event.recoSv.disp3DFromBS = ROOT.VertexDistance3D().distance(
event.recoSv, pv)
event.recoSv.disp3DFromBS_sig = event.recoSv.disp3DFromBS.significance(
)
# create an 'ideal' vertex out of the BS
point = ROOT.reco.Vertex.Point(
event.beamspot.position().x(),
event.beamspot.position().y(),
event.beamspot.position().z(),
)
error = event.beamspot.covariance3D()
chi2 = 0.
ndof = 0.
bsvtx = ROOT.reco.Vertex(point, error, chi2, ndof,
2) # size? say 3? does it matter?
event.recoSv.disp2DFromBS = ROOT.VertexDistanceXY().distance(
event.recoSv, bsvtx)
event.recoSv.disp2DFromBS_sig = event.recoSv.disp2DFromBS.significance(
)
event.recoSv.prob = ROOT.TMath.Prob(event.recoSv.chi2(),
int(event.recoSv.ndof()))
dilep_p4 = event.the_hnl.l1().bestmatch.p4(
) + event.the_hnl.l2().bestmatch.p4()
perp = ROOT.math.XYZVector(dilep_p4.px(), dilep_p4.py(), 0.)
dxybs = ROOT.GlobalPoint(
-1 * ((event.beamspot.x0() - event.recoSv.x()) +
(event.recoSv.z() - event.beamspot.z0()) *
event.beamspot.dxdz()),
-1 * ((event.beamspot.y0() - event.recoSv.y()) +
(event.recoSv.z() - event.beamspot.z0()) *
event.beamspot.dydz()), 0)
vperp = ROOT.math.XYZVector(dxybs.x(), dxybs.y(), 0.)
cos = vperp.Dot(perp) / (vperp.R() * perp.R())
event.recoSv.disp2DFromBS_cos = cos
# if (abs(event.the_hnl.l1().pdgId()) == 11 or abs(event.the_hnl.l2().pdgId()) == 11):
# if (abs(event.the_hnl.l1().bestmatch.pdgId()) == 11 or abs(event.the_hnl.l2().bestmatch.pdgId()) == 11):
# if event.recoSv:
# print 'lept1 \t', event.the_hnl.l1()
# print 'lept2 \t', event.the_hnl.l2()
# print 'lept1 match\t', event.the_hnl.l1().bestmatch
# print 'lept2 match\t', event.the_hnl.l2().bestmatch
# import pdb ; pdb.set_trace()
return True
def dR12(self):
return deltaR(self.l1().p4(), self.l2().p4())
def dR02(self):
return deltaR(self.l0().p4(), self.l2().p4())
def makeIsoTrack(self, event):
event.selectedIsoTrack = []
event.selectedIsoCleanTrack = []
#event.preIsoTrack = []
pfcands = self.handles['cmgCand'].product()
charged = [ p for p in pfcands if ( p.charge() != 0 and abs(p.dz())<=self.cfg_ana.dzMax ) ]
alltrack = map( IsoTrack, charged )
for track in alltrack:
foundNonIsoTrack = False
## ===> require Track Candidate above some pt and charged
if ( (abs(track.pdgId())!=11) and (abs(track.pdgId())!=13) and (track.pt() < self.cfg_ana.ptMin) ): continue
if ( track.pt() < self.cfg_ana.ptMinEMU ): continue
## ===> require is not the leading lepton and opposite to the leading lepton
if( (self.cfg_ana.doSecondVeto) and len(event.selectedLeptons)>0) :
if( deltaR(event.selectedLeptons[0].eta(), event.selectedLeptons[0].phi(), track.eta(), track.phi()) <0.01) : continue
if ( (abs(track.pdgId())!=11) and (abs(track.pdgId())!=13) and (track.charge()*event.selectedLeptons[0].charge()) ): continue
## ===> Redundant:: require the Track Candidate with a minimum dz
track.associatedVertex = event.goodVertices[0]
## ===> compute the isolation and find the most isolated track
othertracks = [ p for p in charged if( deltaR(p.eta(), p.phi(), track.eta(), track.phi()) < self.cfg_ana.isoDR and p.pt()>self.cfg_ana.ptPartMin ) ]
#othertracks = alltrack
isoSum=0
for part in othertracks:
#### ===> skip pfcands with a pt min (this should be 0)
#if part.pt()<self.cfg_ana.ptPartMin : continue
#### ===> skip pfcands outside the cone (this should be 0.3)
#if deltaR(part.eta(), part.phi(), track.eta(), track.phi()) > self.cfg_ana.isoDR : continue
isoSum += part.pt()
### break the loop to save time
if(isoSum > (self.cfg_ana.maxAbsIso + track.pt())):
foundNonIsoTrack = True
break
if foundNonIsoTrack: continue
## reset
#isoSum=0
#for part in othertracks :
#### ===> skip pfcands with a pt min (this should be 0)
# if part.pt()<self.cfg_ana.ptPartMin : continue
#### ===> skip pfcands outside the cone (this should be 0.3)
# if deltaR(part.eta(), part.phi(), track.eta(), track.phi()) > self.cfg_ana.isoDR : continue
# isoSum += part.pt()
# ### isoSum = isoSum/track.pt() ## <--- this is for relIso
### ===> the sum should not contain the track candidate
track.absIso = isoSum - track.pt()
#### store a preIso track
#event.preIsoTrack.append(track)
# if (isoSum < minIsoSum ) :
if(track.absIso < min(0.2*track.pt(), self.cfg_ana.maxAbsIso)):
event.selectedIsoTrack.append(track)
if self.cfg_ana.doPrune:
myMet = self.handles['met'].product()[0]
mtwIsoTrack = mtw(track, myMet)
if mtwIsoTrack < 100:
if abs(track.pdgId()) == 11 or abs(track.pdgId()) == 13:
if track.pt()>5 and track.absIso/track.pt()<0.2:
myLeptons = [ l for l in event.selectedLeptons if l.pt() > 10 ]
nearestSelectedLeptons = makeNearestLeptons(myLeptons,track, event)
if len(nearestSelectedLeptons) > 0:
for lep in nearestSelectedLeptons:
if deltaR(lep.eta(), lep.phi(), track.eta(), track.phi()) > 0.1:
event.selectedIsoCleanTrack.append(track)
else:
event.selectedIsoCleanTrack.append(track)
event.selectedIsoTrack.sort(key = lambda l : l.pt(), reverse = True)
event.selectedIsoCleanTrack.sort(key = lambda l : l.pt(), reverse = True)
self.counters.counter('events').inc('all events')
#if(len(event.preIsoTrack)): self.counters.counter('events').inc('has >=1 selected Track')
if(len(event.selectedIsoTrack)): self.counters.counter('events').inc('has >=1 selected Iso Track')
def process(self, event):
'''
'''
self.readCollections(event.input)
self.tree.reset()
if not eval(self.skimFunction):
return False
self.fillEvent(self.tree, event)
self.fillTriplet(self.tree, 'cand', event.tau3mu)
self.fillTriplet(self.tree, 'cand', event.tau3mu)
self.fillMuon(self.tree, 'mu1', event.tau3mu.mu1())
self.fillMuon(self.tree, 'mu2', event.tau3mu.mu2())
self.fillMuon(self.tree, 'mu3', event.tau3mu.mu3())
self.fillParticle(self.tree, 'met', event.tau3mu.met())
self.fillTriplet(self.tree, 'cand_refit', event.tau3muRefit)
self.fillMuon(self.tree, 'mu1_refit', event.tau3muRefit.mu1())
self.fillMuon(self.tree, 'mu2_refit', event.tau3muRefit.mu2())
self.fillMuon(self.tree, 'mu3_refit', event.tau3muRefit.mu3())
if hasattr(event.tau3muRefit, 'refittedVertex'
) and event.tau3muRefit.refittedVertex is not None:
self.fillVertex(self.tree, 'tau_sv',
event.tau3muRefit.refittedVertex)
# generator information
if hasattr(event, 'genw') and event.genw is not None:
self.fillGenParticle(self.tree, 'w', event.genw)
if hasattr(event.tau3muRefit.mu1(),
'genp') and event.tau3muRefit.mu1().genp is not None:
self.fillGenParticle(self.tree, 'mu1_refit_gen',
event.tau3muRefit.mu1().genp)
if hasattr(event.tau3muRefit.mu2(),
'genp') and event.tau3muRefit.mu2().genp is not None:
self.fillGenParticle(self.tree, 'mu2_refit_gen',
event.tau3muRefit.mu2().genp)
if hasattr(event.tau3muRefit.mu3(),
'genp') and event.tau3muRefit.mu3().genp is not None:
self.fillGenParticle(self.tree, 'mu3_refit_gen',
event.tau3muRefit.mu3().genp)
if hasattr(event, 'genmet') and event.genmet is not None:
self.fillParticle(self.tree, 'genmet', event.genmet)
if hasattr(event, 'gentau') and event.gentau is not None:
self.fillParticle(self.tree, 'gentau', event.gentau)
# trigger information
if hasattr(event.tau3muRefit.mu1(), 'L1'):
self.fillL1object(self.tree, 'mu1_L1', event.tau3muRefit.mu1().L1)
if hasattr(event.tau3muRefit.mu2(), 'L1'):
self.fillL1object(self.tree, 'mu2_L1', event.tau3muRefit.mu2().L1)
if hasattr(event.tau3muRefit.mu3(), 'L1'):
self.fillL1object(self.tree, 'mu3_L1', event.tau3muRefit.mu3().L1)
if hasattr(event.tau3muRefit.mu1(), 'L1') and \
hasattr(event.tau3muRefit.mu2(), 'L1'):
l1mu1 = ROOT.TLorentzVector()
l1mu1.SetPtEtaPhiM(
event.tau3muRefit.mu1().L1.pt(),
event.tau3muRefit.mu1().L1.eta(),
event.tau3muRefit.mu1().L1.phi(),
0.1056583745,
)
l1mu2 = ROOT.TLorentzVector()
l1mu2.SetPtEtaPhiM(
event.tau3muRefit.mu2().L1.pt(),
event.tau3muRefit.mu2().L1.eta(),
event.tau3muRefit.mu2().L1.phi(),
0.1056583745,
)
l1mass12 = (l1mu1 + l1mu2).M()
l1dR12 = deltaR(l1mu1.Eta(), l1mu1.Phi(), l1mu2.Eta(), l1mu2.Phi())
l1pt12 = (l1mu1 + l1mu2).Pt()
self.fill(self.tree, 'L1_mass12', l1mass12)
self.fill(self.tree, 'L1_dR12', l1dR12)
self.fill(self.tree, 'L1_pt12', l1pt12)
if hasattr(event.tau3muRefit.mu1(), 'L1') and \
hasattr(event.tau3muRefit.mu3(), 'L1'):
l1mu1 = ROOT.TLorentzVector()
l1mu1.SetPtEtaPhiM(
event.tau3muRefit.mu1().L1.pt(),
event.tau3muRefit.mu1().L1.eta(),
event.tau3muRefit.mu1().L1.phi(),
0.1056583745,
)
l1mu3 = ROOT.TLorentzVector()
l1mu3.SetPtEtaPhiM(
event.tau3muRefit.mu3().L1.pt(),
event.tau3muRefit.mu3().L1.eta(),
event.tau3muRefit.mu3().L1.phi(),
0.1056583745,
)
l1mass13 = (l1mu1 + l1mu3).M()
l1dR13 = deltaR(l1mu1.Eta(), l1mu1.Phi(), l1mu3.Eta(), l1mu3.Phi())
l1pt13 = (l1mu1 + l1mu3).Pt()
self.fill(self.tree, 'L1_mass13', l1mass13)
self.fill(self.tree, 'L1_dR13', l1dR13)
self.fill(self.tree, 'L1_pt13', l1pt13)
if hasattr(event.tau3muRefit.mu2(), 'L1') and \
hasattr(event.tau3muRefit.mu3(), 'L1'):
l1mu2 = ROOT.TLorentzVector()
l1mu2.SetPtEtaPhiM(
event.tau3muRefit.mu2().L1.pt(),
event.tau3muRefit.mu2().L1.eta(),
event.tau3muRefit.mu2().L1.phi(),
0.1056583745,
)
l1mu3 = ROOT.TLorentzVector()
l1mu3.SetPtEtaPhiM(
event.tau3muRefit.mu3().L1.pt(),
event.tau3muRefit.mu3().L1.eta(),
event.tau3muRefit.mu3().L1.phi(),
0.1056583745,
)
l1mass23 = (l1mu2 + l1mu3).M()
l1dR23 = deltaR(l1mu2.Eta(), l1mu2.Phi(), l1mu3.Eta(), l1mu3.Phi())
l1pt23 = (l1mu2 + l1mu3).Pt()
self.fill(self.tree, 'L1_mass23', l1mass23)
self.fill(self.tree, 'L1_dR23', l1dR23)
self.fill(self.tree, 'L1_pt23', l1pt23)
# BDT output
if hasattr(event, 'bdt_proba'):
self.fill(self.tree, 'bdt_proba', event.bdt_proba)
if hasattr(event, 'bdt_decision'):
self.fill(self.tree, 'bdt_decision', event.bdt_decision)
self.fillTree(event)
if abs(lepton.pdgId()) == 11 else lepton.muonBestTrackType(),
int,
help="Muon best track type"),
NTupleVariable("ptErrTk",
lambda lepton: (lepton.gsfTrack().ptError())
if abs(lepton.pdgId()) == 11 else
(lepton.muonBestTrack().ptError()),
help="pt error, for the gsf track or muon best track"),
NTupleVariable(
"matchedTrgObjMuPt",
lambda x: x.matchedTrgObjwmassMu.pt()
if x.matchedTrgObjwmassMu else -999.,
help="Matched trigger object (cone dR<0.3) pT to IsoMu24"),
NTupleVariable(
"matchedTrgObjMuDR",
lambda x: deltaR(x, x.matchedTrgObjwmassMu)
if x.matchedTrgObjwmassMu else -999.,
help="Matched trigger object (cone dR<0.3) dR to IsoMu24"),
NTupleVariable(
"matchedTrgObjTkMuPt",
lambda x: x.matchedTrgObjwmassTkMu.pt()
if x.matchedTrgObjwmassTkMu else -999.,
help="Matched trigger object (cone dR<0.3) pT to IsoTkMu24"),
NTupleVariable(
"matchedTrgObjTkMuDR",
lambda x: deltaR(x, x.matchedTrgObjwmassTkMu)
if x.matchedTrgObjwmassTkMu else -999.,
help="Matched trigger object (cone dR<0.3) dR to IsoTkMu24"),
NTupleVariable("matchedTrgObjMu50Pt",
lambda x: x.matchedTrgObjwmassMu50.pt()
if x.matchedTrgObjwmassMu50 else -999.,
def dRHn0(self):
return deltaR(self.hnP4(), self.l0()) if self.met() else None
def build_dilepton(self, l1, l2):
dr = deltaR(l1.eta(), l1.phi(), l2.eta(), l2.phi())
if dr < self.cfg_ana.dr_min:
return None
else:
return DiLepton(l1, l2)
tofill['mu3_y'] = extra_mu.y()
tofill['mu3_phi'] = extra_mu.phi()
tofill['mu3_q'] = extra_mu.charge()
three_mu_p4 = extra_mu.p4() + jpsi_muons[0].p4(
) + jpsi_muons[1].p4()
b_scaled_p4 = three_mu_p4 * (6.275 / three_mu_p4.mass())
tofill['mmm_pt'] = three_mu_p4.pt()
tofill['mmm_eta'] = three_mu_p4.eta()
tofill['mmm_y'] = three_mu_p4.y()
tofill['mmm_phi'] = three_mu_p4.phi()
tofill['mmm_m'] = three_mu_p4.mass()
tofill['mmm_q'] = extra_mu.charge()
tofill['dr_jpsi_m'] = deltaR(extra_mu, jpsi)
tofill['n_extra_mu'] = len(final_state_muons_non_jpsi)
# how the hell does one boost LorentzVectors back and forth?!
# using TLorentzVectors of course... shit.
three_mu_p4_tlv = ROOT.TLorentzVector()
three_mu_p4_tlv.SetPtEtaPhiE(three_mu_p4.pt(), three_mu_p4.eta(),
three_mu_p4.phi(),
three_mu_p4.energy())
b_scaled_p4_tlv = ROOT.TLorentzVector()
b_scaled_p4_tlv.SetPtEtaPhiE(b_scaled_p4.pt(), b_scaled_p4.eta(),
b_scaled_p4.phi(),
b_scaled_p4.energy())
jpsi_p4_tlv = ROOT.TLorentzVector()
jpsi_p4_tlv.SetPtEtaPhiE(jpsi.p4().pt(),
def drllValues(self, event, pairSelection, maxLeps):
return self.llValues(event, lambda l1,l2: deltaR(l1.eta(), l1.phi(), l2.eta(), l2.phi()), pairSelection, maxLeps)
def process(self, event):
self.readCollections(event.input)
self.counters.counter('BKstLLGenAnalyzer').inc('all events')
# attach qscale (pt hat) to the event
event.qscale = self.mchandles['genInfo'].product().qScale()
# get the tracks
allpf = map(PhysicsObject, self.handles['pfcands'].product())
losttracks = map(PhysicsObject, self.handles['losttracks'].product())
# merge the track collections
event.alltracks = sorted([
tt for tt in allpf + losttracks
if tt.charge() != 0 and abs(tt.pdgId()) not in (11, 13)
],
key=lambda x: x.pt(),
reverse=True)
# import pdb ; pdb.set_trace()
# get the offline electrons and muons
event.electrons = map(Electron, self.handles['electrons'].product())
event.muons = map(Muon, self.handles['muons'].product())
# find the gen B mesons from the hard scattering
pruned_gen_particles = self.mchandles['prunedGenParticles'].product()
packed_gen_particles = self.mchandles['packedGenParticles'].product()
all_gen_particles = [ip for ip in pruned_gen_particles
] + [ip for ip in packed_gen_particles]
# match gen mu to offline mu
genmus = [
ii for ii in all_gen_particles
if abs(ii.pdgId()) == 13 and ii.status() == 1
]
for imu in genmus:
bm, dr = bestMatch(imu, event.muons)
if dr < 0.3:
imu.reco = bm
if len(genmus) > 0:
event.thetagmu = sorted(genmus, key=lambda x: x.pt(),
reverse=True)[0]
# match gen ele to offline ele
geneles = [
ii for ii in all_gen_particles
if abs(ii.pdgId()) == 11 and ii.status() == 1
]
for iele in geneles:
bm, dr = bestMatch(iele, event.electrons)
if dr < 0.3:
iele.reco = bm
event.gen_bmesons = [
pp for pp in pruned_gen_particles if abs(pp.pdgId()) > 500
and abs(pp.pdgId()) < 600 and pp.isPromptDecayed()
]
event.gen_b0mesons = [
pp for pp in pruned_gen_particles if abs(pp.pdgId()) == 511
]
# walk down the lineage of the B mesons and find the final state muons and charged particles
for ip in event.gen_b0mesons + event.gen_bmesons:
if getattr(self.cfg_ana, 'verbose', False):
print 'PdgId : %s pt : %s eta : %s phi : %s' % (
ip.pdgId(), ip.pt(), ip.eta(), ip.phi())
print ' daughters'
finaldaughters = []
finalcharged = []
finalmuons = []
for ipp in packed_gen_particles:
mother = ipp.mother(0)
if mother and self.isAncestor(ip, mother):
if abs(ipp.pdgId()) == 13:
finalmuons.append(ipp)
if abs(ipp.charge()) == 1:
finalcharged.append(ipp)
if getattr(self.cfg_ana, 'verbose', False):
print ' PdgId : %s pt : %s eta : %s phi : %s' % (
ipp.pdgId(), ipp.pt(), ipp.eta(), ipp.phi())
finaldaughters.append(ipp)
if getattr(self.cfg_ana, 'verbose', False):
print ' PdgId : %s pt : %s eta : %s phi : %s' % (
ipp.pdgId(), ipp.pt(), ipp.eta(), ipp.phi())
ip.finalmuondaughters = sorted(finalmuons,
key=lambda x: x.pt(),
reverse=True)
ip.finalchargeddaughters = sorted(finalcharged,
key=lambda x: x.pt(),
reverse=True)
ip.finaldaughters = sorted(finaldaughters,
key=lambda x: x.pt(),
reverse=True)
for ib0 in event.gen_b0mesons:
if abs(self.cfg_ana.flavour) == 11:
togenmatchleptons = event.electrons
elif abs(self.cfg_ana.flavour) == 13:
togenmatchleptons = event.muons
else:
print 'you can only pick either pdgId 11 or 13'
raise
isit, lp, lm, pi, k = self.isKstLL(ib0, togenmatchleptons,
event.alltracks,
abs(self.cfg_ana.flavour))
if isit:
event.kstll = ib0
event.kstll.lp = lp
event.kstll.lm = lm
event.kstll.pi = pi
event.kstll.k = k
event.kstll.dr = min(
[deltaR(event.kstll, jj) for jj in [lp, lm, pi, k]])
break # yeah, only one at a time, mate!
# if hasattr(event.kstll.lp, 'reco') and hasattr(event.kstll.lm, 'reco'):
# if event.kstll.lp.reco.pt() == event.kstll.lm.reco.pt():
# import pdb ; pdb.set_trace()
if not hasattr(event, 'kstll'):
return False
self.counters.counter('BKstLLGenAnalyzer').inc(
'has a good gen B0->K*LL')
toclean = None
if event.kstll.isPromptDecayed():
toclean = event.kstll
else:
for ip in event.gen_bmesons:
if self.isAncestor(ip, event.kstll):
toclean = ip
break
# if toclean is None:
# print 'nothing to clean lumi %d, ev %d' %(event.lumi, event.eventId)
# return False
# import pdb ; pdb.set_trace()
#
# self.counters.counter('BKstLLGenAnalyzer').inc('no f**k ups')
# elif abs(event.kstll.mother(0).pdgId())>500 and abs(event.kstll.mother(0).pdgId())<600:
# if toclean = event.kstll.mother(0)
# elif abs(event.kstll.mother(0).mother(0).pdgId())>500 and abs(event.kstll.mother(0).mother(0).pdgId())<600:
# else:
# print 'nothing to clean lumi %d, ev %d' %(event.lumi, event.eventId)
# import pdb ; pdb.set_trace()
if toclean is not None:
event.clean_gen_bmesons = [
ib for ib in event.gen_bmesons if ib != toclean
]
else:
event.clean_gen_bmesons = event.gen_bmesons
# import pdb ; pdb.set_trace()
# now find the L1 muons from BX = 0
L1muons_allbx = self.handles['L1muons'].product()
L1_muons = []
for jj in range(L1muons_allbx.size(0)):
L1_muons.append(L1muons_allbx.at(0, jj))
event.L1_muons = L1_muons
event.selectedLeptons = [
] # don't really care about isolated leptons, right?
return True
def process(self, event):
self.readCollections(event.input)
event.run = event.input.eventAuxiliary().id().run()
event.lumi = event.input.eventAuxiliary().id().luminosityBlock()
event.eventId = event.input.eventAuxiliary().id().event()
triggerBits = self.handles['triggerResultsHLT'].product()
names = event.input.object().triggerNames(triggerBits)
preScales = self.handles['triggerPrescales'].product()
self.counters.counter('Trigger').inc('All events')
trigger_passed = False
trigger_infos = []
triggers_fired = []
for trigger_name in self.triggerList + self.extraTrig:
index = names.triggerIndex(trigger_name)
if index == len(triggerBits):
continue
prescale = preScales.getPrescaleForIndex(index)
fired = triggerBits.accept(index)
trigger_infos.append(
TriggerInfo(trigger_name, index, fired, prescale))
#print trigger_name, fired, prescale
#if fired:
# import pdb ; pdb.set_trace()
if fired and (prescale == 1 or self.cfg_ana.usePrescaled):
if trigger_name in self.triggerList:
trigger_passed = True
self.counters.counter('Trigger').inc(trigger_name)
triggers_fired.append(trigger_name)
elif fired:
print 'WARNING: Trigger not passing because of prescale', trigger_name
self.counters.counter('Trigger').inc(trigger_name +
'prescaled')
if self.cfg_ana.requireTrigger:
if not trigger_passed:
return False
# if event.eventId == 104644585: import pdb ; pdb.set_trace()
if self.cfg_ana.addTriggerObjects:
triggerObjects = self.handles['triggerObjects'].product()
# if event.eventId == 104644585: import pdb ; pdb.set_trace()
for to in triggerObjects:
to.unpackPathNames(names)
for info in trigger_infos:
# if event.eventId == 104644585: import pdb ; pdb.set_trace()
if to.hasPathName(info.name):
if to in info.objects:
continue
# print 'TO name', [n for n in to.filterLabels()], to.hasPathName(info.name, False)
if self.triggerObjects or self.extraTriggerObjects:
if not any(n in to.filterLabels()
for n in self.triggerObjects +
self.extraTriggerObjects):
continue
info.object_names.append([
obj_n for obj_n in self.triggerObjects
if obj_n in to.filterLabels()
])
else:
info.object_names.append('')
info.objects.append(to)
info.objIds.add(abs(to.pdgId()))
# RIC: remove duplicated trigger objects
# (is this something that may happen in first place?)
for info in trigger_infos:
# if event.eventId == 104644585:
# for oo in info.objects: print oo.pt(), oo.eta(), oo.phi()
objs = info.objects
for to1, to2 in combinations(info.objects, 2):
to1Filter = set(sorted(list(to1.filterLabels())))
to2Filter = set(sorted(list(to2.filterLabels())))
if to1Filter != to2Filter:
continue
dR = deltaR(to1.eta(), to1.phi(), to2.eta(), to2.phi())
if dR < 0.01 and to2 in objs:
objs.remove(to2)
info.objects = objs
# if event.eventId == 104644585:
# for oo in info.objects: print oo.pt(), oo.eta(), oo.phi()
event.trigger_infos = trigger_infos
if self.cfg_ana.verbose:
print 'run %d, lumi %d,event %d' % (
event.run, event.lumi,
event.eventId), 'Triggers_fired: ', triggers_fired
if hasattr(self.cfg_ana, 'saveFlag'):
if self.cfg_ana.saveFlag:
setattr(event, 'tag', False)
setattr(event, 'probe', False)
for trig in self.triggerList:
if trig in triggers_fired:
setattr(event, 'tag', True)
break
for trig in self.extraTrig:
if trig in triggers_fired:
setattr(event, 'probe', True)
break
self.counters.counter('Trigger').inc('HLT')
return True
def makeTaus(self, event):
event.inclusiveTaus = []
event.selectedTaus = []
event.otherTaus = []
#get all
alltaus = map( Tau, self.handles['taus'].product() )
#make inclusive taus
goodVertices = getattr(event, self.vertexChoice)
for tau in alltaus:
tau.associatedVertex = goodVertices[0] if len(goodVertices)>0 else event.vertices[0]
tau.lepVeto = False
tau.idDecayMode = tau.tauID("decayModeFinding")
tau.idDecayModeNewDMs = tau.tauID("decayModeFindingNewDMs")
if hasattr(self.cfg_ana, 'inclusive_decayModeID') and self.cfg_ana.inclusive_decayModeID and not tau.tauID(self.cfg_ana.inclusive_decayModeID):
continue
tau.inclusive_lepVeto = False
if self.cfg_ana.inclusive_vetoLeptons:
for lep in event.selectedLeptons:
if deltaR(lep.eta(), lep.phi(), tau.eta(), tau.phi()) < self.cfg_ana.inclusive_leptonVetoDR:
tau.inclusive_lepVeto = True
if tau.inclusive_lepVeto: continue
if self.cfg_ana.inclusive_vetoLeptonsPOG:
if not tau.tauID(self.cfg_ana.inclusive_tauAntiMuonID):
tau.inclusive_lepVeto = True
if not tau.tauID(self.cfg_ana.inclusive_tauAntiElectronID):
tau.inclusive_lepVeto = True
if tau.inclusive_lepVeto: continue
if tau.pt() < self.cfg_ana.inclusive_ptMin: continue
if abs(tau.eta()) > self.cfg_ana.inclusive_etaMax: continue
if abs(tau.dxy()) > self.cfg_ana.inclusive_dxyMax or abs(tau.dz()) > self.cfg_ana.inclusive_dzMax: continue
def id3(tau,X):
"""Create an integer equal to 1-2-3 for (loose,medium,tight)"""
return tau.tauID(X%"Loose") + tau.tauID(X%"Medium") + tau.tauID(X%"Tight")
def id5(tau,X):
"""Create an integer equal to 1-2-3-4-5 for (very loose,
loose, medium, tight, very tight)"""
return id3(tau, X) + tau.tauID(X%"VLoose") + tau.tauID(X%"VTight")
def id6(tau,X):
"""Create an integer equal to 1-2-3-4-5-6 for (very loose,
loose, medium, tight, very tight, very very tight)"""
return id5(tau, X) + tau.tauID(X%"VVTight")
tau.idMVA = id6(tau, "by%sIsolationMVArun2v1DBoldDMwLT")
tau.idMVAdR03 = id6(tau, "by%sIsolationMVArun2v1DBdR03oldDMwLT")
tau.idMVANewDM = id6(tau, "by%sIsolationMVArun2v1DBnewDMwLT")
tau.idCI3hit = id3(tau, "by%sCombinedIsolationDeltaBetaCorr3Hits")
tau.idAntiMu = tau.tauID("againstMuonLoose3") + tau.tauID("againstMuonTight3")
tau.idAntiE = id5(tau, "againstElectron%sMVA6")
#print "Tau pt %5.1f: idMVA2 %d, idCI3hit %d, %s, %s" % (tau.pt(), tau.idMVA2, tau.idCI3hit, tau.tauID(self.cfg_ana.tauID), tau.tauID(self.cfg_ana.tauLooseID))
if self._mvaId2017: tau.mvaId2017 = self._mvaId2017(tau.physObj)
if tau.tauID(self.cfg_ana.inclusive_tauID):
event.inclusiveTaus.append(tau)
for tau in event.inclusiveTaus:
tau.loose_lepVeto = False
if self.cfg_ana.loose_vetoLeptons:
for lep in event.selectedLeptons:
if deltaR(lep.eta(), lep.phi(), tau.eta(), tau.phi()) < self.cfg_ana.loose_leptonVetoDR:
tau.loose_lepVeto = True
if self.cfg_ana.loose_vetoLeptonsPOG:
if not tau.tauID(self.cfg_ana.loose_tauAntiMuonID):
tau.loose_lepVeto = True
if not tau.tauID(self.cfg_ana.loose_tauAntiElectronID):
tau.loose_lepVeto = True
if tau.tauID(self.cfg_ana.loose_decayModeID) and \
tau.pt() > self.cfg_ana.loose_ptMin and abs(tau.eta()) < self.cfg_ana.loose_etaMax and \
abs(tau.dxy()) < self.cfg_ana.loose_dxyMax and abs(tau.dz()) < self.cfg_ana.loose_dzMax and \
tau.tauID(self.cfg_ana.loose_tauID) and not tau.loose_lepVeto:
event.selectedTaus.append(tau)
else:
event.otherTaus.append(tau)
event.inclusiveTaus.sort(key = lambda l : l.pt(), reverse = True)
event.selectedTaus.sort(key = lambda l : l.pt(), reverse = True)
event.otherTaus.sort(key = lambda l : l.pt(), reverse = True)
self.counters.counter('events').inc('all events')
if len(event.inclusiveTaus): self.counters.counter('events').inc('has >=1 tau at preselection')
if len(event.selectedTaus): self.counters.counter('events').inc('has >=1 selected taus')
if len(event.otherTaus): self.counters.counter('events').inc('has >=1 other taus')
def matchPhotons(self, event):
event.genPhotons = [ x for x in event.genParticles if x.status() == 1 and abs(x.pdgId()) == 22 ]
event.genPhotonsWithMom = [ x for x in event.genPhotons if x.numberOfMothers()>0 ]
event.genPhotonsWithoutMom = [ x for x in event.genPhotons if x.numberOfMothers()==0 ]
event.genPhotonsMatched = [ x for x in event.genPhotonsWithMom if abs(x.mother(0).pdgId())<23 or x.mother(0).pdgId()==2212 ]
match = matchObjectCollection3(event.allphotons, event.genPhotonsMatched, deltaRMax = 0.1)
matchNoMom = matchObjectCollection3(event.allphotons, event.genPhotonsWithoutMom, deltaRMax = 0.1)
packedGenParts = [ p for p in self.mchandles['packedGen'].product() if abs(p.eta()) < 3.1 ]
partons = [ p for p in self.mchandles['prunedGen'].product() if (p.status()==23 or p.status()==22) and abs(p.pdgId())<22 ]
for gamma in event.allphotons:
gen = match[gamma]
gamma.mcGamma = gen
if gen and gen.pt()>=0.5*gamma.pt() and gen.pt()<=2.*gamma.pt():
gamma.mcMatchId = 22
sumPt03 = 0.;
sumPt04 = 0.;
for part in packedGenParts:
if abs(part.pdgId())==12: continue # exclude neutrinos
if abs(part.pdgId())==14: continue
if abs(part.pdgId())==16: continue
if abs(part.pdgId())==18: continue
deltar = deltaR(gen.eta(), gen.phi(), part.eta(), part.phi())
if deltar <= 0.3:
sumPt03 += part.pt()
if deltar <= 0.4:
sumPt04 += part.pt()
sumPt03 -= gen.pt()
sumPt04 -= gen.pt()
if sumPt03<0. : sumPt03=0.
if sumPt04<0. : sumPt04=0.
gamma.genIso03 = sumPt03
gamma.genIso04 = sumPt04
# match to parton
deltaRmin = 999.
for p in partons:
deltar = deltaR(gen.eta(), gen.phi(), p.eta(), p.phi())
if deltar < deltaRmin:
deltaRmin = deltar
gamma.drMinParton = deltaRmin
else:
genNoMom = matchNoMom[gamma]
if genNoMom:
gamma.mcMatchId = 7
sumPt03 = 0.;
sumPt04 = 0.;
for part in packedGenParts:
if abs(part.pdgId())==12: continue # exclude neutrinos
if abs(part.pdgId())==14: continue
if abs(part.pdgId())==16: continue
if abs(part.pdgId())==18: continue
deltar = deltaR(genNoMom.eta(), genNoMom.phi(), part.eta(), part.phi())
if deltar <= 0.3:
sumPt03 += part.pt()
if deltar <= 0.4:
sumPt04 += part.pt()
sumPt03 -= genNoMom.pt()
sumPt04 -= genNoMom.pt()
if sumPt03<0. : sumPt03=0.
if sumPt04<0. : sumPt04=0.
gamma.genIso03 = sumPt03
gamma.genIso04 = sumPt04
# match to parton
deltaRmin = 999.
for p in partons:
deltar = deltaR(genNoMom.eta(), genNoMom.phi(), p.eta(), p.phi())
if deltar < deltaRmin:
deltaRmin = deltar
gamma.drMinParton = deltaRmin
else:
gamma.mcMatchId = 0
gamma.genIso03 = -1.
gamma.genIso04 = -1.
gamma.drMinParton = -1.
def process(self, event):
self.readCollections(event.input)
try:
event.hltL2TauPixelIsoTagProducerLegacy = self.handles[
'hltL2TauPixelIsoTagProducerLegacy'].product()
event.hltL2TauPixelIsoTagProducer = self.handles[
'hltL2TauPixelIsoTagProducer'].product()
event.hltL2TauJetsIso = self.handles['hltL2TauJetsIso'].product()
event.hltL2TauIsoFilter = self.handles[
'hltL2TauIsoFilter'].product()
event.hltL2TausForPixelIsolation = self.handles[
'hltL2TausForPixelIsolation'].product()
except:
pass
if self.cfg_ana.verbose:
if hasattr(event, 'hltL2TauPixelIsoTagProducer' ) or \
hasattr(event, 'hltL2TauPixelIsoTagProducerLegacy') or \
hasattr(event, 'hltL2TauJetsIso' ) or \
hasattr(event, 'hltL2TauIsoFilter' ) or \
hasattr(event, 'hltL2TausForPixelIsolation' ):
print '\n\n===================== event', event.eventId
for jet in event.hltL2TausForPixelIsolation:
print '\t====>\thltL2TausForPixelIsolation pt, eta, phi ', jet.pt(
), jet.eta(), jet.phi()
for j in range(event.hltL2TauPixelIsoTagProducer.size()):
jet = event.hltL2TauPixelIsoTagProducer.keyProduct(
).product().at(j)
iso = event.hltL2TauPixelIsoTagProducer.value(j)
print '\t====>\thltL2TauPixelIsoTagProducer pt, eta, phi, iso', jet.pt(
), jet.eta(), jet.phi(), iso
for jet in event.hltL2TauIsoFilter.jetRefs():
print '\t====>\thltL2TauIsoFilter pt, eta, phi ', jet.pt(
), jet.eta(), jet.phi()
self.dRmax = 0.5
if hasattr(self.cfg_ana, 'dR'):
self.dRmax = self.cfg_ana.dR
event.L2jets = []
# stop here if there are no L2 jets
if not hasattr(event, 'hltL2TauPixelIsoTagProducer'):
return True
nL2jets = event.hltL2TauPixelIsoTagProducer.size()
for l2jIndex in range(nL2jets):
jet = event.hltL2TauPixelIsoTagProducer.keyProduct().product().at(
l2jIndex)
iso = event.hltL2TauPixelIsoTagProducer.value(l2jIndex)
isolegacy = event.hltL2TauPixelIsoTagProducerLegacy.value(l2jIndex)
l2jet = Jet(jet)
l2jet.L2iso = iso
l2jet.L2isolegacy = isolegacy
event.L2jets.append(l2jet)
for ti in event.trigger_infos:
for to, jet in product(ti.objects, event.L2jets):
dR = deltaR(jet.eta(), jet.phi(), to.eta(), to.phi())
if hasattr(to, 'L2dR'):
dRmax = to.L2dR
else:
dRmax = self.dRmax
if dR < dRmax:
to.L2 = jet
to.L2iso = jet.L2iso
to.L2isolegacy = jet.L2isolegacy
to.L2dR = dR
# stop here if there's no diLepton. Useful for rate studies
if not hasattr(event, 'diLepton'):
return True
legs = {
event.diLepton.leg1(): self.dRmax,
event.diLepton.leg2(): self.dRmax
}
event.diLepton.leg1().L2 = None
event.diLepton.leg1().L2iso = None
event.diLepton.leg1().L2isolegacy = None
event.diLepton.leg2().L2 = None
event.diLepton.leg2().L2iso = None
event.diLepton.leg2().L2isolegacy = None
for leg, l2jIndex in product(legs.keys(), range(nL2jets)):
dR = deltaR(jet.eta(), jet.phi(), leg.eta(), leg.phi())
if dR < legs[leg]:
leg.L2 = jet
leg.L2iso = jet.L2iso
leg.L2isolegacy = jet.L2isolegacy
leg.L2dR = dR
legs[leg] = dR
if self.cfg_ana.verbose:
if event.diLepton.leg1().L2:
print 'leg1 L2 jet pt, eta, phi, iso, dR', event.diLepton.leg1(
).L2.pt(), event.diLepton.leg1().L2.eta(), event.diLepton.leg1(
).L2.phi(), event.diLepton.leg1().L2iso, event.diLepton.leg1(
).L2dR
if event.diLepton.leg2().L2:
print 'leg2 L2 jet pt, eta, phi, iso, dR', event.diLepton.leg2(
).L2.pt(), event.diLepton.leg2().L2.eta(), event.diLepton.leg2(
).L2.phi(), event.diLepton.leg2().L2iso, event.diLepton.leg2(
).L2dR
return True
def ghostSuppression(self, fourLepton):
leptons = fourLepton.daughterLeptons()
for l1, l2 in itertools.combinations(leptons, 2):
if deltaR(l1.eta(), l1.phi(), l2.eta(), l2.phi()) < 0.02:
return False
return True
def dR01(self):
return deltaR(self.l0().p4(), self.l1().p4())
def dR2MET(self):
return deltaR(self.l2().p4(), self.met().p4()) if self.met() else None
def dRvisHn0(self):
return deltaR(self.hnVisP4(), self.l0())
def dRvisHnMET(self):
return deltaR(self.hnVisP4(), self.met()) if self.met() else None
