def FillLeg(self, leg, weight):
dbetaFactor = 0.5
self.h_pt.Fill(leg.pt(), weight)
self.h_eta.Fill(leg.eta(), weight)
self.h_iso.Fill(leg.relIso(), weight)
self.h_iso_dbeta.Fill(leg.relIso(dbetaFactor), weight)
self.h_iso_abs.Fill(leg.absIso(), weight)
self.h_iso_abs_dbeta.Fill(leg.absIso(dbetaFactor), weight)
self.h_iso_ch.Fill(leg.chargedHadronIso(), weight)
self.h_iso_nh.Fill(leg.neutralHadronIso(), weight)
self.h_iso_ph.Fill(leg.photonIso(), weight)
if isTau(leg):
tau = Tau(leg)
self.h_eOverP.Fill(tau.calcEOverP(), weight)
self.h_decMode.Fill(tau.decayMode(), weight)
def FillLeg(self, leg, weight ):
dbetaFactor = 0.5
self.h_pt.Fill( leg.pt(), weight )
self.h_eta.Fill( leg.eta(), weight )
self.h_iso.Fill( leg.relIso(), weight )
self.h_iso_dbeta.Fill( leg.relIso(dbetaFactor), weight )
self.h_iso_abs.Fill( leg.absIso(), weight )
self.h_iso_abs_dbeta.Fill( leg.absIso(dbetaFactor), weight )
self.h_iso_ch.Fill( leg.chargedHadronIso(), weight )
self.h_iso_nh.Fill( leg.neutralHadronIso(), weight )
self.h_iso_ph.Fill( leg.photonIso(), weight )
if isTau(leg):
tau = Tau( leg )
self.h_eOverP.Fill( tau.calcEOverP(), weight )
self.h_decMode.Fill( tau.decayMode(), weight )
def __init__(self, diobject):
super(TauMuon, self).__init__(diobject)
self.tau = Tau(diobject.leg1())
self.mu = Muon(diobject.leg2())
#COLIN some of the matching stuff could go up
self.leg1Gen = None
self.leg2Gen = None
self.leg1DeltaR = -1
self.leg2DeltaR = -1
def buildLeptonList(self,event):
self.hadtaus = []
for ptj in self.handles['taus'].product():
thistau=Tau(ptj)
# add only "good" pftaus
if thistau.tauID("decayModeFinding")!=1.0:
continue
if thistau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")<=0.:
continue
self.hadtaus.append(Tau(ptj))
self.jets = []
for ptj in self.handles['jets'].product():
# check if they are close to jets and then remove them from the jet list
thisjet=Jet(ptj)
matched=False
# use the following if you want to remove hadtaus from jets
# for tau in self.hadtaus:
# if deltaR(tau.eta(),tau.phi(),thisjet.eta(),thisjet.phi()) < 0.2:
# matched=True
# break
if not matched:
self.jets.append(Jet(ptj))
self.leptons = []
for pte in self.handles['electrons'].product():
self.leptons.append(Lepton(pte))
for ptm in self.handles['muons'].product():
self.leptons.append(Lepton(ptm))
self.photons = []
for ptg in self.handles['photons'].product():
if ptg.energy() > 1.0 : self.photons.append(Photon(ptg))
# Find FSR
tmpLept = set(self.leptons)
for lept in self.leptons :
leptonIso = self.leptonIso(lept)
if leptonIso > 0.05 :
tmpLept.remove(lept)
continue
#if (self.eleele or self.mumu or self.tautau ) :
# print self.eleele, self.mumu, self.tautau,lept, leptonIso
for i,ph in enumerate(self.photons) :
dr = deltaR(lept.eta(),lept.phi(),ph.eta(),ph.phi())
if abs(lept.pdgId()) == 13 and dr < 0.4 :
#print 'found ISR ',ph,lept
leph = lept.p4()
p4ph = ph.p4()
p4 = ph.p4() + lept.p4()
lept.setP4(p4)
#print 'added ISR ',ph,lept
self.leptons = []
for lept in tmpLept :
self.leptons.append(lept)
self.leptonJets = []
for lept in self.leptons :
drmin = 999.
ijet = -1
for i,jet in enumerate(self.jets) :
dr = deltaR(lept.eta(),lept.phi(),jet.eta(),jet.phi())
if dr < drmin :
drmin = dr
ijet = i
if ijet >= 0 :
if drmin < 0.1 :
self.jets[ijet].setP4(lept.p4())
self.jets[ijet].setPdgId(lept.pdgId())
self.leptonJets.append(self.jets[ijet])
def process(self, iEvent, event):
self.readCollections( iEvent )
eventNumber = iEvent.eventAuxiliary().id().event()
# print "========================================================="
# print "event:",eventNumber
myEvent = Event(event.iEv)
setattr(event, self.name, myEvent)
event = myEvent
self.buildMCinfo( event )
self.counters.counter('h_gen').inc('All events')
self.counters.counter('h_rec').inc('All events')
if self.isHZ: self.counters.counter('h_gen').inc('All hz events')
if len(self.tau)==2:
self.counters.counter('h_gen').inc('h->tt')
if self.isHZqq:
self.counters.counter('h_gen').inc('Z->qq and h->tt')
if self.isHZbb:
self.counters.counter('h_gen').inc('Z->bb and h->tt')
event.isHZ = 0
event.isHZqq = 0
event.isHZbb = 0
if self.isHZ:
event.isHZ=1
event.H=self.H
event.Z=self.Z
if self.isHZqq:
event.isHZqq=1
if self.isHZbb:
event.isHZbb=1
event.ishtt = 0
if len(self.tau)==2:
event.ishtt =1
event.tau1=self.tau[0]
event.tau2=self.tau[1]
#save the two leading muons and the two leading electrons
self.muons = []
for muon in self.handles['muons'].product():
self.muons.append(Muon(muon))
self.muons.sort(key=lambda a: a.energy(), reverse = True)
event.leadingMuon_en=-1
if len(self.muons)>=1:
event.leadingMuon_en=self.muons[0].energy()
event.leadingMuons = []
for muon in self.muons:
if len(event.leadingMuons) >= 2: break
event.leadingMuons.append(muon)
# this is needed because the energy of the muon is changed later on if it is a tau candidate
self.electrons = []
for electron in self.handles['electrons'].product():
self.electrons.append(Electron(electron))
self.electrons.sort(key=lambda a: a.energy(), reverse = True)
event.leadingElectron_en=-1
if len(self.electrons)>=1:
event.leadingElectron_en=self.electrons[0].energy()
event.leadingElectrons = []
for electron in self.electrons:
if len(event.leadingElectrons) >= 2: break
event.leadingElectrons.append(electron)
self.hadtaus = []
for tau in self.handles['taus'].product():
self.hadtaus.append(Tau(tau))
self.hadtaus.sort(key=lambda a: a.energy(), reverse = True)
# prepare jets ordered in energy
self.jets=[]
for ptj in self.handles['jets'].product():
self.jets.append(Jet(ptj))
# order them in energy
self.jets.sort(key=lambda a: a.energy(), reverse = True)
event.njets=len(self.jets)
# loop over ele,muo,hadtaus and define "isolation", and jetindex
# iso is the closest jet (excluding itself) distance
# index is the pfjet index of the object (ele,muo,tau)
# dist is the distance of the object to the matched pfjet (it is trivially 1 for pfjets)
self.jetiso,self.jetindex,self.jetdist=self.findiso(self.jets,self.jets)
self.muoiso,self.muoindex,self.muodist=self.findiso(self.jets,self.muons)
self.eleiso,self.eleindex,self.eledist=self.findiso(self.jets,self.electrons)
self.hadtauiso,self.hadtauindex,self.hadtaudist=self.findiso(self.jets,self.hadtaus)
# look now at the tau jets
self.taugenjet=[]
self.taucos=[]
self.tauiso=[]
self.taumatchingjetindex=[]
# self.nontaugenjet = copy.copy(self.jets)
# self.nontaugenjetiso = copy.copy(self.jetiso)
if event.ishtt==1:
# loop over jets and find closest gen tau
if event.njets>=2:
for thistau in self.tau:
cosmax=-2
tauindex=-10
for ind in range(0,len(self.jets)):
thisjet=self.jets[ind]
thiscos=self.cosdelta(thistau,thisjet)
if thiscos>cosmax:
cosmax=thiscos
taucand=thisjet
iso=self.jetiso[ind]
tauindex=ind
if cosmax!=-2:
self.taugenjet.append(taucand)
self.tauiso.append(iso)
#self.nontaugenjet.pop(tauindex)
#self.nontaugenjetiso.pop(tauindex)
self.taumatchingjetindex.append(tauindex)
else:
self.taugenjet.append(thistau) # just to fill it up
self.taucos.append(cosmax)
event.tau1genjet = self.taugenjet[0]
event.tau1cosjet = self.taucos[0]
event.tau1iso = self.tauiso[0]
event.tau2genjet = self.taugenjet[1]
event.tau2cosjet = self.taucos[1]
event.tau2iso = self.tauiso[1]
event.tau1matchingjetindex=self.taumatchingjetindex[0]
event.tau2matchingjetindex=self.taumatchingjetindex[1]
# self.nontaugenjet.sort(key=lambda a: a.energy(), reverse = True)
# event.nontaugenjet = self.nontaugenjet
# event.nontaugenjetiso = self.nontaugenjetiso
# debug
# if event.ishtt==1 and event.isHZqq==1:
# print "tau gen:"
#
# print event.tau1
# print event.tau2
#
# print "jets"
# for jet in self.jets:
# print jet
# print "muons"
# for jet in self.muons:
# print jet
# print "electrons"
# for jet in self.electrons:
# print jet
# print "taus"
# for jet in self.hadtaus:
# print jet
# start here the real selection
event.step=0
event.matchedRecGenDistances = []
event.hz = []
# first look for at least four jets and two of them isolated and low #tracks
if event.njets<4:
return
event.step+=1 # 1
#test for jets above threshold
etest = self.testE()
if etest:
self.counters.counter('h_rec').inc('4 jets above threshold')
else:
return
event.step+=1 #2
# print "njets=",event.njets,len(self.jets)
# requires at least 2 taucandidates as isolated jets (0.5) and with 1 or 3 tracks
event.taucand=[]
event.taucandtype=[]
event.taucandiso=[]
event.taucandindex=[]
event.taucandcharge=[]
event.nontaucand=[]
event.nontaucandiso=[]
event.acoll = -99.
event.acopl = -99.
removedjet=[]
# first build up tau dandidates from hadtaus, electrons and muons
# print "#jets,muons,elec,hadtaus:",len(self.jets),len(self.muons),len(self.electrons),len(self.hadtaus)
for ind in range(0,len(self.muons)):
if self.testmuoId(ind):
if self.muoindex[ind] not in removedjet: # be sure you get only one copy
event.taucand.append(self.muons[ind])
event.taucandtype.append(0)
event.taucandiso.append(self.muoiso[ind])
event.taucandindex.append(self.muoindex[ind])
removedjet.append(self.muoindex[ind])
# print "added muon ",event.taucandindex[len(event.taucand)-1]
for ind in range(0,len(self.electrons)):
if self.testeleId(ind):
if self.eleindex[ind] not in removedjet: # prefer muons over ele if belonging to same matched jet
event.taucand.append(self.electrons[ind])
event.taucandtype.append(1)
event.taucandiso.append(self.eleiso[ind])
event.taucandindex.append(self.eleindex[ind])
removedjet.append(self.eleindex[ind])
# print "added ele ",event.taucandindex[len(event.taucand)-1]
for ind in range(0,len(self.hadtaus)):
if self.testhadtauId(ind):
if self.hadtauindex[ind] not in removedjet: # prefer electrons,muons over had taus if belonging to same matched jet
event.taucand.append(self.hadtaus[ind])
event.taucandtype.append(2)
event.taucandiso.append(self.hadtauiso[ind])
event.taucandindex.append(self.hadtauindex[ind])
removedjet.append(self.hadtauindex[ind])
# print "added hadtau ",event.taucandindex[len(event.taucand)-1]
# now we can add the jets not associated to candidate taus (ele, muo, hadtau) to the jet list
for ind in range(0,len(self.jets)):
if ind not in removedjet:
event.nontaucand.append(self.jets[ind])
event.nontaucandiso.append(self.jetiso[ind])
# print "added jet ",event.nontaucand[len(event.nontaucand)-1].energy()
# check for 2 tau candidates
if len(event.taucand)<2:
return
self.counters.counter('h_rec').inc('2 tau candidates')
event.step+=1 #3
if len(event.taucand)==2:
#electrons + muons + charged hadrons
ntr1=self.ntrtaucand(event.taucand[0],event.taucandtype[0])
ntr2=self.ntrtaucand(event.taucand[1],event.taucandtype[1])
if (ntr1*ntr2)!=1 and (ntr1*ntr2)!=3:
return
# now iterate on all possible pairs of tau candidates, if more than two, and keep only the ones which give
# opposite mass closer to Z peak
if len(event.taucand)>2:
dm=9999.
taupair=(-1,-1)
# fit version of tau finding optimization
for ind1, ind2 in itertools.combinations(range(len(event.taucand)), 2):
ntr1=self.ntrtaucand(event.taucand[0],event.taucandtype[0])
ntr2=self.ntrtaucand(event.taucand[1],event.taucandtype[1])
# consider only combination 1,1 1,3 3,1
if (ntr1*ntr2)!=1 and (ntr1*ntr2)!=3:
continue
nt=[]
nj=[]
nt.append(event.taucand[ind1])
nt.append(event.taucand[ind2])
nj=copy.copy(event.nontaucand)
for i in range(len(event.taucand)):
if i!=ind1 and i!=ind2:
nj.append(self.jets[event.taucandindex[i]])
# nt and nj are potential tau and nontaucandidates
# now clusterize the nontaucand
tmpJets=list(self.buildClusteredJets(nj))
# poor man kf
chi2,newjets,newtaus = self.beta4(tmpJets, nt, 120.,False)
jet0=newjets[0]
jet1=newjets[1]
mnontau=(jet0[3]+jet1[3])**2-(jet0[2]+jet1[2])**2-(jet0[1]+jet1[1])**2-(jet0[0]+jet1[0])**2
if mnontau>0:
mnontau=sqrt(mnontau)
else:
mnontau=0
# print ind1,ind2,mnontau
if abs(mnontau-91.2)<dm:
taupair=(ind1,ind2)
dm=abs(mnontau-91.2)
# now we have taupair and we can adapt the candidates
(t1,t2)=taupair
# print "chosen",t1,t2
if t1<0 or t2<0:
return
# print "chosen",t1,t2
t1temp=event.taucand[t1]
t1isotemp=event.taucandiso[t1]
t1typetemp=event.taucandtype[t1]
t1indextemp=event.taucandindex[t1]
t2temp=event.taucand[t2]
t2isotemp=event.taucandiso[t2]
t2typetemp=event.taucandtype[t2]
t2indextemp=event.taucandindex[t2]
for tauind in range(0,len(event.taucand)):
if tauind!=t1 and tauind!=t2:
#remove thsi tau candidate and add it to nontaucandidate
# print "removing ",tauind
event.nontaucand.append(self.jets[event.taucandindex[tauind]])
event.nontaucandiso.append(self.jetiso[event.taucandindex[tauind]])
# cleanup the taucand list
event.taucand=[t1temp,t2temp]
event.taucandiso=[t1isotemp,t2isotemp]
event.taucandtype=[t1typetemp,t2typetemp]
event.taucandindex=[t1indextemp,t2indextemp]
self.counters.counter('h_rec').inc('2 tau candidates good pair')
event.step+=1 #4
#fill jet charges for tau candidates
# for tau in event.taucand:
# print tau.numberOfSourceCandidatePtrs()
# constituents = tau.sourcePtr().getPFConstituents()
# charge = 0
# for constituent in constituents:
# charge += constituent.charge()
# event.taucandcharge.append[charge]
#fill acollinearity for tau candidates
tnorm1 = event.taucand[0].p4().P()
tnorm2 = event.taucand[1].p4().P()
ttdot = event.taucand[0].px()*event.taucand[1].px() + event.taucand[0].py()*event.taucand[1].py() + event.taucand[0].pz()*event.taucand[1].pz()
event.acoll = ttdot/(tnorm1*tnorm2)
#MC matching
if event.ishtt==1 and event.isHZqq==1:
#check the closest gen tau
self.matched=[]
self.matcheddistance=[]
for taucand in event.taucand:
cosmax=-2
for gentau in self.tau:
thiscos=self.cosdelta(taucand,gentau)
if thiscos>cosmax:
cosmax=thiscos
event.matchedRecGenDistances.append(cosmax)
#cluster the remaining part of the event
# self.buildClusteredJets_old(event)
tmpJets=self.buildClusteredJets(event.nontaucand)
# rewrites the jets after clustering
event.nontaucand = []
for jet in tmpJets:
event.nontaucand.append(jet)
# debug
# if event.ishtt==1 and event.isHZqq==1:
# print "tau cand"
# for jet in event.taucand:
# print jet
# print "non taucand"
# for jet in event.nontaucand:
# print jet
jnorm1 = event.nontaucand[0].p4().P()
jnorm2 = event.nontaucand[1].p4().P()
jjdot = event.nontaucand[0].px()*event.nontaucand[1].px() + event.nontaucand[0].py()*event.nontaucand[1].py() + event.nontaucand[0].pz()*event.nontaucand[1].pz()
event.jcoll = jjdot/(jnorm1*jnorm2)
event.btag_tt=0
event.btag_jj=0
# for jet in event.taucand:
# event.btag_tt+=jet.btag(7)
for jet in event.nontaucand:
event.btag_jj+=jet.btag(7)
# store variables before rescaling
event.t1_px=event.taucand[0].px()
event.t1_py=event.taucand[0].py()
event.t1_pz=event.taucand[0].pz()
event.t1_en=event.taucand[0].energy()
event.t2_px=event.taucand[1].px()
event.t2_py=event.taucand[1].py()
event.t2_pz=event.taucand[1].pz()
event.t2_en=event.taucand[1].energy()
# store variables before rescaling
event.j1_px=event.nontaucand[0].px()
event.j1_py=event.nontaucand[0].py()
event.j1_pz=event.nontaucand[0].pz()
event.j1_en=event.nontaucand[0].energy()
event.j2_px=event.nontaucand[1].px()
event.j2_py=event.nontaucand[1].py()
event.j2_pz=event.nontaucand[1].pz()
event.j2_en=event.nontaucand[1].energy()
# print "before rescaling:",event.t1_en,event.t2_en,event.j1_en,event.j2_en
# print "before rescaling from jet:",self.jets[event.taucandindex[0]].energy(),self.jets[event.taucandindex[1]].energy()
#check that the clustered jets pass id (this also does the momentum rescaling)
idpass,newjets,newtaus = self.testId(event.nontaucand, event.taucand,True)
# we need also to replace self.jets px,py,pz (will be used for findww,findzz and findhz)
for ind in range(0,len(event.taucand)):
j_ind=event.taucandindex[ind]
p4=self.jets[j_ind].p4()
p4.SetPxPyPzE(event.taucand[ind].px(),event.taucand[ind].py(),event.taucand[ind].pz(),event.taucand[ind].energy())
self.jets[j_ind].setP4(p4)
#fill acoplanarity between met and the plane containinf the taus
t1 = numpy.array([event.taucand[0].px(), event.taucand[0].py(), event.taucand[0].pz()])
t2 = numpy.array([event.taucand[1].px(), event.taucand[1].py(), event.taucand[1].pz()])
norm = numpy.cross(t1,t2)
#now extract the angle wrt mmissing energy
me = ([-self.px, -self.py, -self.pz])
pscal = numpy.dot(norm,me)
norm_p = numpy.linalg.norm(norm)
me_p = numpy.linalg.norm(me)
if norm_p>0 and me_p>0:
event.acopl = pscal/(norm_p * me_p)
# store variables after rescaling
event.t1s_px=event.taucand[0].px()
event.t1s_py=event.taucand[0].py()
event.t1s_pz=event.taucand[0].pz()
event.t1s_en=event.taucand[0].energy()
event.t2s_px=event.taucand[1].px()
event.t2s_py=event.taucand[1].py()
event.t2s_pz=event.taucand[1].pz()
event.t2s_en=event.taucand[1].energy()
# store variables after rescaling
event.j1s_px=event.nontaucand[0].px()
event.j1s_py=event.nontaucand[0].py()
event.j1s_pz=event.nontaucand[0].pz()
event.j1s_en=event.nontaucand[0].energy()
event.j2s_px=event.nontaucand[1].px()
event.j2s_py=event.nontaucand[1].py()
event.j2s_pz=event.nontaucand[1].pz()
event.j2s_en=event.nontaucand[1].energy()
# print "after rescaling:",event.t1s_en,event.t2s_en,event.j1s_en,event.j2s_en
# print "after rescaling from jet:",self.jets[event.taucandindex[0]].energy(),self.jets[event.taucandindex[1]].energy()
event.mvis = self.mvis
event.px = self.px
event.py = self.py
event.pz = self.pz
event.evis = self.evis
event.chi2 = self.chi2
event.mmin = self.mmin
event.alljets=[]
# print "alljets",len(self.jets),event.taucandindex[0],event.taucandindex[1]
# this is needed to use findXX (for Diobject, otherwise btag is not defined)
event.taucandjets=[self.jets[event.taucandindex[0]],self.jets[event.taucandindex[1]]]
for jet in event.nontaucand:
event.alljets.append(jet)
for jet in event.taucandjets:
event.alljets.append(jet)
#event.alljets contains all jets now (j1,j2,t1,t2)
event.jetPairs = self.findPairs( event.alljets )
event.ww, event.wwMin = self.findWW ( event.jetPairs )
event.zz, event.zzMin = self.findZZ ( event.jetPairs )
if not idpass:
return
self.counters.counter('h_rec').inc('2 jets with id')
event.step+=1 #5
#finally find the HZ candidates
reshz,self.hz = self.findHZ(event.nontaucand, event.taucandjets)
event.hz = self.hz
# print "dijetmass ",event.hz[1].M()
if not reshz:
return
event.step+=1 #6
self.counters.counter('h_rec').inc('passed')
if event.ishtt==1 and event.isHZqq==1:
self.counters.counter('h_gen').inc('Z->qq and h->tt selected')
if event.ishtt==1 and event.isHZbb==1:
self.counters.counter('h_gen').inc('Z->bb and h->tt selected')
# apply btag here
if event.btag_jj<0.95:
return
event.step+=1 #7
if event.ishtt==1 and event.isHZqq==1:
self.counters.counter('h_gen').inc('Z->qq and h->tt b-selected')
if event.ishtt==1 and event.isHZbb==1:
self.counters.counter('h_gen').inc('Z->bb and h->tt b-selected')
return True
def __init__(self, diobject):
super(TauTau, self).__init__(diobject)
self.tau = Tau(diobject.leg1())
self.tau2 = Tau(diobject.leg2())
def __init__(self, diobject):
super(TauElectron, self).__init__(diobject)
self.tau = Tau(diobject.leg1())
self.ele = HTauTauElectron(diobject.leg2())
def __init__(self, diobject):
super(TauMuon, self).__init__(diobject)
self.tau = Tau(diobject.leg1())
self.mu = Muon(diobject.leg2())
def buildLeptonList(self, event):
self.hadtaus = []
for ptj in self.handles['taus'].product():
thistau = Tau(ptj)
# add only "good" pftaus
if thistau.tauID("decayModeFinding") != 1.0:
continue
if thistau.tauID("byVLooseCombinedIsolationDeltaBetaCorr") <= 0.:
continue
self.hadtaus.append(Tau(ptj))
self.jets = []
for ptj in self.handles['jets'].product():
# check if they are close to jets and then remove them from the jet list
thisjet = Jet(ptj)
matched = False
# use the following if you want to remove hadtaus from jets
# for tau in self.hadtaus:
# if deltaR(tau.eta(),tau.phi(),thisjet.eta(),thisjet.phi()) < 0.2:
# matched=True
# break
if not matched:
self.jets.append(Jet(ptj))
self.leptons = []
for pte in self.handles['electrons'].product():
self.leptons.append(Lepton(pte))
for ptm in self.handles['muons'].product():
self.leptons.append(Lepton(ptm))
self.photons = []
for ptg in self.handles['photons'].product():
if ptg.energy() > 1.0: self.photons.append(Photon(ptg))
# Find FSR
tmpLept = set(self.leptons)
for lept in self.leptons:
leptonIso = self.leptonIso(lept)
if leptonIso > 0.05:
tmpLept.remove(lept)
continue
#if (self.eleele or self.mumu or self.tautau ) :
# print self.eleele, self.mumu, self.tautau,lept, leptonIso
for i, ph in enumerate(self.photons):
dr = deltaR(lept.eta(), lept.phi(), ph.eta(), ph.phi())
if abs(lept.pdgId()) == 13 and dr < 0.4:
#print 'found ISR ',ph,lept
leph = lept.p4()
p4ph = ph.p4()
p4 = ph.p4() + lept.p4()
lept.setP4(p4)
#print 'added ISR ',ph,lept
self.leptons = []
for lept in tmpLept:
self.leptons.append(lept)
self.leptonJets = []
for lept in self.leptons:
drmin = 999.
ijet = -1
for i, jet in enumerate(self.jets):
dr = deltaR(lept.eta(), lept.phi(), jet.eta(), jet.phi())
if dr < drmin:
drmin = dr
ijet = i
if ijet >= 0:
if drmin < 0.1:
self.jets[ijet].setP4(lept.p4())
self.jets[ijet].setPdgId(lept.pdgId())
self.leptonJets.append(self.jets[ijet])