def makeObservables(event, sample, level):
''' Compute all relevant observables
'''
# double b kinematic
event.bbdPhi = deltaPhi(event.bj0['phi'], event.bj1['phi'])
event.bbdR = deltaR(event.bj0, event.bj1)
# lep gamma kinematic
event.l0gammadPhi = deltaPhi(event.l0['phi'], event.gamma0['phi'])
event.l0gammadR = deltaR(event.l0, event.gamma0)
# Make leptonic W, Nan if any component is Nan
event.Wlep_vec2D = event.MET['vec2D'] + event.l0['vec2D']
# Lp, Nan if any component is Nan
event.Wlep_Lp = (event.Wlep_vec2D *
event.l0['vec2D']) / (event.Wlep_vec2D * event.Wlep_vec2D)
# classic MT, Nan if any component is Nan
event.Wlep_MT = sqrt(MTSquared(event.MET, event.l0))
# blep+lep subsystem, Nan if len(event.lepsNotFromZ == 0)
event.bleplep_vec2D = event.bj0lep['vec2D'] + event.l0['vec2D']
event.bleplep_vec4D = event.bj0lep['vec4D'] + event.l0['vec4D']
event.minLeptonG0dR = min(
[deltaR(lepton, event.gamma0)
for lepton in event.leps]) if len(event.leps) > 0 and event.gamma0[
'pt'] == event.gamma0['pt'] else float('nan')
event.minLeptonG1dR = min(
[deltaR(lepton, event.gamma1)
for lepton in event.leps]) if len(event.leps) > 0 and event.gamma1[
'pt'] == event.gamma1['pt'] else float('nan')
event.minLeptonG2dR = min(
[deltaR(lepton, event.gamma2)
for lepton in event.leps]) if len(event.leps) > 0 and event.gamma2[
'pt'] == event.gamma2['pt'] else float('nan')
event.minJetG0dR = min([deltaR(jet, event.gamma0) for jet in event.jets
]) if len(event.jets) > 0 and event.gamma0[
'pt'] == event.gamma0['pt'] else float('nan')
event.minJetG1dR = min([deltaR(jet, event.gamma1) for jet in event.jets
]) if len(event.jets) > 0 and event.gamma1[
'pt'] == event.gamma1['pt'] else float('nan')
event.minJetG2dR = min([deltaR(jet, event.gamma2) for jet in event.jets
]) if len(event.jets) > 0 and event.gamma2[
'pt'] == event.gamma2['pt'] else float('nan')
# transverse mass of top, Nan if len(event.lepsNotFromZ == 0)
event.t_MT = sqrt(
MTSquared(event.l0, event.MET) + MSquared(event.l0, event.bj0lep) +
MTSquared(event.MET, event.bj0lep))
event.t_vec2D = event.l0['vec2D'] + event.MET['vec2D'] + event.bj0lep[
'vec2D']
# signed lepton pt, Nan if len(event.lepsNotFromZ == 0)
event.lep0chargept = event.l0[
'pt'] if event.l0['pdgId'] > 0 else -event.l0['pt']
# event.lep1chargept = event.l1['pt'] if event.l1['pdgId']>0 else -event.l1['pt']
# choose your final selection
event.passing_checks = event.passing_leptons and event.passing_bjets and event.passing_photons
def makeObservables(event, sample, level):
''' Compute all relevant observables
'''
# double b kinematic
event.bbdPhi = deltaPhi(event.bj0['phi'], event.bj1['phi'])
event.bbdR = deltaR(event.bj0, event.bj1)
# lep gamma kinematic
event.l0gammadPhi = deltaPhi(event.l0['phi'], event.gamma0['phi'])
event.l0gammadR = deltaR(event.l0, event.gamma0)
event.l1gammadPhi = deltaPhi(event.l1['phi'], event.gamma0['phi'])
event.l1gammadR = deltaR(event.l1, event.gamma0)
# double l kinematic
event.lldPhi = deltaPhi(event.l0['phi'], event.l1['phi'])
event.lldR = deltaR(event.l0, event.l1)
event.minLeptonG0dR = min(
[deltaR(lepton, event.gamma0)
for lepton in event.leps]) if len(event.leps) > 0 and event.gamma0[
'pt'] == event.gamma0['pt'] else float('nan')
event.minLeptonG1dR = min(
[deltaR(lepton, event.gamma1)
for lepton in event.leps]) if len(event.leps) > 0 and event.gamma1[
'pt'] == event.gamma1['pt'] else float('nan')
event.minLeptonG2dR = min(
[deltaR(lepton, event.gamma2)
for lepton in event.leps]) if len(event.leps) > 0 and event.gamma2[
'pt'] == event.gamma2['pt'] else float('nan')
event.minJetG0dR = min([deltaR(jet, event.gamma0) for jet in event.jets
]) if len(event.jets) > 0 and event.gamma0[
'pt'] == event.gamma0['pt'] else float('nan')
event.minJetG1dR = min([deltaR(jet, event.gamma1) for jet in event.jets
]) if len(event.jets) > 0 and event.gamma1[
'pt'] == event.gamma1['pt'] else float('nan')
event.minJetG2dR = min([deltaR(jet, event.gamma2) for jet in event.jets
]) if len(event.jets) > 0 and event.gamma2[
'pt'] == event.gamma2['pt'] else float('nan')
# signed lepton pt, Nan if len(event.lepsNotFromZ == 0)
event.lep0chargept = event.l0[
'pt'] if event.l0['pdgId'] > 0 else -event.l0['pt']
event.lep1chargept = event.l1[
'pt'] if event.l1['pdgId'] > 0 else -event.l1['pt']
event.mll = (event.l0['vec4D'] + event.l1['vec4D']).M()
event.mllgamma = (event.l0['vec4D'] + event.l1['vec4D'] +
event.gamma_vec4D).M()
#cut the Z window in same flavor lepton region
event.offZ = (
abs(event.mll - 91.2) > 10 and abs(event.mllgamma - 91.2) > 10
) or event.mll is float('nan') or event.mllgamma is float('nan') or abs(
event.l0['pdgId']) != abs(event.l1['pdgId'])
event.mllCut = event.mll > 40
# choose your final selection
event.passing_checks = event.passing_leptons and event.passing_bjets and event.passing_photons and event.mllCut and event.offZ
def makeObservables(event, sample, level):
''' Compute all relevant observables
'''
# double b kinematic
event.bbdPhi = deltaPhi(event.bj0['phi'], event.bj1['phi'])
event.bbdR = deltaR(event.bj0, event.bj1)
# Make leptonic W, Nan if any component is Nan
event.Wlep_vec2D = event.MET['vec2D'] + event.NonZ_l0['vec2D']
# Lp, Nan if any component is Nan
event.Wlep_Lp = (event.Wlep_vec2D * event.NonZ_l0['vec2D']) / (
event.Wlep_vec2D * event.Wlep_vec2D)
# classic MT, Nan if any component is Nan
event.Wlep_MT = sqrt(MTSquared(event.MET, event.NonZ_l0))
# blep+lep subsystem, Nan if len(event.lepsNotFromZ == 0)
event.bleplep_vec2D = event.bjNonZlep['vec2D'] + event.NonZ_l0['vec2D']
event.bleplep_vec4D = event.bjNonZlep['vec4D'] + event.NonZ_l0['vec4D']
# transverse mass of top, Nan if len(event.lepsNotFromZ == 0)
event.t_MT = sqrt(
MTSquared(event.NonZ_l0, event.MET) +
MSquared(event.NonZ_l0, event.bjNonZlep) +
MTSquared(event.MET, event.bjNonZlep))
event.t_vec2D = event.NonZ_l0['vec2D'] + event.MET[
'vec2D'] + event.bjNonZlep['vec2D']
# signed lepton pt, Nan if len(event.lepsNotFromZ == 0)
event.getnonZlepchargept = event.NonZ_l0[
'pt'] if event.NonZ_l0['pdgId'] > 0 else -event.NonZ_l0['pt']
# choose your final selection
event.passing_checks = event.passing_leptons and event.passing_bjets
def makeLeps( event, sample ):
# Read leptons, do not yet filter
event.leps = getCollection( event, 'GenLep', ['pt', 'eta', 'phi', 'pdgId', 'motherPdgId'], 'nGenLep' )
# Add extra vectors
for p in event.leps:
addTransverseVector( p )
addTLorentzVector( p )
# Sort
event.leps = sorted( event.leps, key=lambda k: -k['pt'] )
# Cross-cleaning: remove leptons that overlap with a jet within 0.4
# event.leps = list(filter( lambda l: min( [ deltaR(l, j) for j in event.jets ] + [999] ) > 0.4 , event.leps ))
# find leptons from Z
event.lepsFromZ = list( filter( lambda j: j['motherPdgId'] == 23 , event.leps ) )
event.foundZ = len( event.lepsFromZ )==2 and event.lepsFromZ[0]['pdgId'] * event.lepsFromZ[1]['pdgId'] < 0
event.Z_deltaPhi_ll = deltaPhi( event.lepsFromZ[0]['phi'], event.lepsFromZ[1]['phi']) if event.foundZ else float('nan')
event.Z_deltaR_ll = deltaR( *event.lepsFromZ) if event.foundZ else float('nan')
# convinience
event.Z_unitVec2D = UnitVectorT2( event.Z_phi )
event.Z_vec4D = ROOT.TLorentzVector()
event.Z_vec4D.SetPtEtaPhiM( event.Z_pt, event.Z_eta, event.Z_phi, event.Z_mass )
event.Z_unitVec3D = event.Z_vec4D.Vect()
#event.Z_unitVec3D /= event.Z_unitVec3D.Mag()
# find leptons that are NOT from Z
event.leptonsNotFromZ = [lepton for lepton in event.leps if lepton not in event.lepsFromZ]
# We may loose some events by cross-cleaning or by thresholds. Make a bool for that.
event.passing_3lep = event.foundZ and len(event.leptonsNotFromZ)==1
def makeLeps(event, sample):
''' Add a list of filtered leptons to the event
'''
# load leps
event.leps = getCollection(event, 'GenLep',
['pt', 'eta', 'phi', 'pdgId', 'motherPdgId'],
'nGenLep')
# filter, pre-selection requires 2 leptons (no default leptons necessary)
event.leps = list(filter(lambda l: isGoodGenLepton(l), event.leps))
# Cross-cleaning: remove leptons that overlap with a jet within 0.4
event.leps = list(
filter(lambda l: min([deltaR(l, j) for j in event.jets] + [999]) > 0.4,
event.leps))
# sort
event.leps = sorted(event.leps, key=lambda l: -l['pt'])
# Add extra vectors
for p in event.leps:
addTransverseVector(p)
addTLorentzVector(p)
# Define W leptons
event.l0, event.l1 = (event.leps + [NanLepton(), NanLepton()])[:2]
event.deltaPhi_ll = deltaPhi(event.l0['phi'], event.l1['phi'])
event.deltaR_ll = deltaR(event.l0, event.l1)
# # We may loose some events by cross-cleaning or by thresholds.
event.passing_2lep = len(
event.leps) >= 2 and event.l0['pdgId'] * event.l1['pdgId'] > 0.
def makeObservables(event, sample):
''' Compute all relevant observables
'''
# double b kinematic
event.deltaPhi_bb = deltaPhi(event.bj0['phi'], event.bj1['phi'])
event.deltaR_bb = deltaR(event.bj0, event.bj1)
# double l kinematic
event.nonZ_deltaPhi_ll = deltaPhi(event.l0['phi'], event.l1['phi'])
event.nonZ_deltaR_ll = deltaR(event.l0, event.l1)
# signed lepton pt, Nan if len(event.lepsNotFromZ == 0)
event.getnonZlep0chargept = event.l0[
'pt'] if event.l0['pdgId'] > 0 else -event.l1['pt']
event.getnonZlep1chargept = event.l1[
'pt'] if event.l1['pdgId'] > 0 else -event.l1['pt']
def addZCut(event, sample):
recoLep = getCollection(
event, 'recoLep',
["pt", "eta", "phi", "pdgId", "sumPt", "isolationVar"], 'nrecoLep')
recoLep = list(filter(lambda l: isGoodRecoLepton(l), recoLep))
# recoLep = list( filter( lambda l: (l["sumPt"]-l["pt"])/l["pt"] < 0.2, recoLep ) )
recoLep = list(filter(lambda l: l["isolationVar"] < 0.2, recoLep))
event.nrecoLep = len(recoLep)
event.recoZ_mass = -999 #float("nan")
event.recoZ_pt = -999 #float("nan")
event.recoZ_phi = -999 #float("nan")
event.recoZ_eta = -999 #float("nan")
event.recoZ_lldPhi = -999 #float("nan")
event.recoZ_lldR = -999 #float("nan")
if event.nrecoLep < 2:
event.lumiweight1fb = 0
return
if event.nrecoLep > 1:
event.recoZ_mass, event.recoZ_l1_index, event.recoZ_l2_index = closestOSDLMassToMZ(
recoLep)
l1 = recoLep[event.recoZ_l1_index]
l2 = recoLep[event.recoZ_l2_index]
# print deltaR(l1,l2), l1["pt"], l2["pt"], event.recoZ_l1_index, event.recoZ_l2_index, event.recoZ_mass
if event.recoZ_mass:
Z_l1 = ROOT.TLorentzVector()
Z_l1.SetPtEtaPhiM(recoLep[event.recoZ_l1_index]['pt'],
recoLep[event.recoZ_l1_index]['eta'],
recoLep[event.recoZ_l1_index]['phi'], 0)
Z_l2 = ROOT.TLorentzVector()
Z_l2.SetPtEtaPhiM(recoLep[event.recoZ_l2_index]['pt'],
recoLep[event.recoZ_l2_index]['eta'],
recoLep[event.recoZ_l2_index]['phi'], 0)
Z = Z_l1 + Z_l2
event.recoZ_pt = Z.Pt()
event.recoZ_eta = Z.Eta()
event.recoZ_phi = Z.Phi()
event.recoZ_lldPhi = deltaPhi(recoLep[event.recoZ_l1_index]['phi'],
recoLep[event.recoZ_l2_index]['phi'])
event.recoZ_lldR = deltaR(recoLep[event.recoZ_l1_index],
recoLep[event.recoZ_l2_index])
lm_index = event.recoZ_l1_index if recoLep[
event.recoZ_l1_index]['pdgId'] > 0 else event.recoZ_l2_index
event.recoZ_cosThetaStar = cosThetaStar(
event.recoZ_mass, event.recoZ_pt, event.recoZ_eta,
event.recoZ_phi, recoLep[lm_index]['pt'],
recoLep[lm_index]['eta'], recoLep[lm_index]['phi'])
if abs(event.recoZ_mass - 91) > 15:
event.lumiweight1fb = 0
return
else:
event.lumiweight1fb = 0
def makeObservables(event, sample, level):
''' Compute all relevant observables
'''
# double b kinematic
event.bbdPhi = deltaPhi(event.bj0['phi'], event.bj1['phi'])
event.bbdR = deltaR(event.bj0, event.bj1)
# double l kinematic
event.lldPhi = deltaPhi(event.W_l0['phi'], event.W_l1['phi'])
event.lldR = deltaR(event.W_l0, event.W_l1)
# signed lepton pt
event.lep0chargept = event.W_l0[
'pt'] if event.W_l0['pdgId'] > 0 else -event.W_l0['pt']
event.lep1chargept = event.W_l1[
'pt'] if event.W_l1['pdgId'] > 0 else -event.W_l1['pt']
# choose your final selection
event.passing_checks = event.passing_leptons and event.passing_bjets
def makeObservables(event, sample):
''' Compute all relevant observables
'''
# double b kinematic
event.deltaPhi_bb = deltaPhi(event.bj0['phi'], event.bj1['phi'])
event.deltaR_bb = deltaR(event.bj0, event.bj1)
# signed lepton pt
event.getlep0chargept = event.l0[
'pt'] if event.l0['pdgId'] > 0 else -event.l0['pt']
event.getlep1chargept = event.l1[
'pt'] if event.l1['pdgId'] > 0 else -event.l1['pt']
def makeLeps(event, sample):
''' Add a list of filtered leptons to the event
'''
# load leps
event.leps = getCollection(event, 'GenLep',
['pt', 'eta', 'phi', 'pdgId', 'motherPdgId'],
'nGenLep')
# filter, pre-selection requires 3 leptons (no default leptons necessary)
event.leps = list(filter(lambda l: isGoodGenLepton(l), event.leps))
# Cross-cleaning: remove leptons that overlap with a jet within 0.4
event.leps = list(
filter(lambda l: min([deltaR(l, j) for j in event.jets] + [999]) > 0.4,
event.leps))
# sort
event.leps = sorted(event.leps, key=lambda l: -l['pt'])
# Add extra vectors
for p in event.leps:
addTransverseVector(p)
addTLorentzVector(p)
# find leptons from Z
event.lepsFromZ = list(filter(lambda j: j['motherPdgId'] == 23,
event.leps))
event.foundZ = len(event.lepsFromZ) == 2 and event.lepsFromZ[0][
'pdgId'] * event.lepsFromZ[1]['pdgId'] < 0 and abs(
event.lepsFromZ[0]['pdgId']) == abs(event.lepsFromZ[1]['pdgId'])
event.Z_deltaPhi_ll = deltaPhi(
event.lepsFromZ[0]['phi'],
event.lepsFromZ[1]['phi']) if event.foundZ else float('nan')
event.Z_deltaR_ll = deltaR(
*event.lepsFromZ) if event.foundZ else float('nan')
# find leptons that are NOT from Z
event.lepsNotFromZ = list(
filter(lambda j: j['motherPdgId'] != 23, event.leps))
# We may loose some events by cross-cleaning or by thresholds.
event.passing_4lep = event.foundZ and len(
event.lepsNotFromZ) >= 2 and event.lepsNotFromZ[0][
'pdgId'] * event.lepsNotFromZ[1]['pdgId'] < 0.
# Add default lepton if leptons got filtered
event.lepsNotFromZ += [NanLepton(), NanLepton()]
# Define non-Z leptons
event.l0, event.l1 = event.lepsNotFromZ[:2]
def makeObservables(event, sample):
''' Compute all relevant observables
'''
# double b kinematic
event.lldPhi = deltaPhi(event.recoLep_phi[0], event.recoLep_phi[1])
event.lldR = deltaR(
{
"pt": event.recoLep_pt[0],
"eta": event.recoLep_eta[0],
"phi": event.recoLep_phi[0]
}, {
"pt": event.recoLep_pt[0],
"eta": event.recoLep_eta[0],
"phi": event.recoLep_phi[0]
})
def makeObservables(event, sample):
''' Compute all relevant observables
'''
# double b kinematic
event.deltaPhi_bb = deltaPhi(event.bj0['phi'], event.bj1['phi'])
event.deltaR_bb = deltaR(event.bj0, event.bj1)
# Resolve pairing ambiguity by maximizing resulting top-lep pt
event.b_lep, event.b_had = NanJet(), NanJet()
if (event.bj0['vec2D'] + event.l0['vec2D'] + event.MET['vec2D']).Mod2() > (
event.bj1['vec2D'] + event.l0['vec2D'] +
event.MET['vec2D']).Mod2():
event.b_lep = event.bj0
event.b_had = event.bj1
# Cross check if not NaN in particles
elif (event.bj0['vec2D'] + event.l0['vec2D'] + event.MET['vec2D']).Mod2(
) < (event.bj1['vec2D'] + event.l0['vec2D'] + event.MET['vec2D']).Mod2():
event.b_lep = event.bj1
event.b_had = event.bj0
# Make leptonic W, Nan if l0 == NaN
event.Wlep_vec2D = event.MET['vec2D'] + event.l0['vec2D']
# Lp, Nan if l0 == NaN
event.Wlep_Lp = (event.Wlep_vec2D *
event.l0['vec2D']) / (event.Wlep_vec2D * event.Wlep_vec2D)
# classic MT, Nan if l0 == NaN
event.Wlep_MT = sqrt(MTSquared(event.MET, event.l0))
# blep+lep subsystem, NaN if l0 == NaN
event.bleplep_vec2D = event.b_lep['vec2D'] + event.l0['vec2D']
event.bleplep_vec4D = event.b_lep['vec4D'] + event.l0['vec4D']
# transverse mass of top, Nan if l0 == NaN
event.t_MT = sqrt(
MTSquared(event.l0, event.MET) + MSquared(event.l0, event.b_lep) +
MTSquared(event.MET, event.b_lep))
event.t_vec2D = event.l0['vec2D'] + event.MET['vec2D'] + event.b_lep[
'vec2D']
# signed lepton pt, Nan if len(event.lepsNotFromZ == 0)
event.getlepchargept = event.l0[
'pt'] if event.l0['pdgId'] > 0 else -event.l0['pt']
def makeSpinCorrelationObservables( event, sample, level ):
if level != 'gen': return
event.tops = getCollection( event, 'genTop', ['pt', 'eta', 'phi'], 'ngenTop' )
# We now match leptons and tops by charge
# Once I have the gen-top pdgId, this code will be replaced by a gen-level based
# matching which ensures that top_pos/lep_pos and top_neg/lep_neg are the top-parton/lepton pair with 'p'lus and 'm'inus charge.
if len(event.tops)>=2 and event.l0['pdgId']*event.l1['pdgId']<0:
if event.l0['pdgId']<0:
event.lep_pos, event.lep_neg = event.l0, event.l1
event.top_pos, event.top_neg = event.tops[:2] # <- arbitrary for now! FIXME
else:
event.lep_pos, event.lep_neg = event.l1, event.l0
event.top_pos, event.top_neg = event.tops[:2] # <- arbitrary for now! FIXME
# Alexander, here are the leptons (plus and minus): event.lep_pos, event.lep_neg
# Here are the tops (plus and minus): event.tp, event.tm
# Store numbers, objects, etc. in the 'event' like this:
# dPhi (repeated below, just a proof of principle, remove, FIXME)
event.lldPhi = deltaPhi( event.lep_neg['phi'], event.lep_pos['phi'] )
def makeObservables( event, sample):
''' Compute all relevant observables
'''
# Only continue if we pass the 3-lep selection at least
#if not event.passing_3lep: return
# Resolve pairing ambiguity by maximizing resulting top-lep pt
if ( event.bj0['vec2D'] + event.leptonsNotFromZ[0]['vec2D'] + event.MET['vec2D'] ).Mod() > ( event.bj1['vec2D'] + event.leptonsNotFromZ[0]['vec2D'] + event.MET['vec2D'] ).Mod():
event.b_lep = event.bj0
event.b_had = event.bj1
else:
event.b_lep = event.bj1
event.b_had = event.bj0
# Make leptonic W
event.Wlep_vec2D = event.MET['vec2D'] + event.leptonsNotFromZ[0]['vec2D']
# Lp
event.W_Lp = (event.Wlep_vec2D*event.leptonsNotFromZ[0]['vec2D'] ) / ( event.Wlep_vec2D*event.Wlep_vec2D )
# classic MT
event.W_MT = sqrt( MTSquared( event.MET, event.leptonsNotFromZ[0] ) )
# blep+lep subsystem
event.bleplep_vec2D = event.b_lep['vec2D'] + event.leptonsNotFromZ[0]['vec2D']
event.bleplep_vec4D = event.b_lep['vec4D'] + event.leptonsNotFromZ[0]['vec4D']
# transverse mass of top
event.t_MT = sqrt( MTSquared( event.leptonsNotFromZ[0], event.MET) + MSquared( event.leptonsNotFromZ[0], event.b_lep ) + MTSquared( event.MET, event.b_lep ) )
event.t_vec2D = event.leptonsNotFromZ[0]['vec2D'] + event.MET['vec2D'], event.b_lep['vec2D']
# double b kinematic
event.deltaPhi_bb = deltaPhi(event.bj0['phi'], event.bj1['phi'])
event.deltaR_bb = deltaR(event.bj0, event.bj1)
# Well... signed lepton pt.
event.getnonZlepchargept = event.leptonsNotFromZ[0]['pt'] if event.leptonsNotFromZ[0]['pdgId']>0 else -event.leptonsNotFromZ[0]['pt']
def filler(event):
event.lumiweight1fb = lumiweight1fb
if not args.HEPMC:
event.run, event.lumi, event.evt = fwliteReader.evt
if fwliteReader.position % 100 == 0:
logger.info("At event %i/%i", fwliteReader.position,
fwliteReader.nEvents)
if args.addReweights:
event.nrw = weightInfo.nid
lhe_weights = fwliteReader.products['lhe'].weights()
weights = []
param_points = []
for weight in lhe_weights:
# Store nominal weight (First position!)
if weight.id == 'rwgt_1': event.rw_nominal = weight.wgt
if not weight.id in weightInfo.id: continue
pos = weightInfo.data[weight.id]
event.rw_w[pos] = weight.wgt
weights.append(weight.wgt)
interpreted_weight = interpret_weight(weight.id)
for var in weightInfo.variables:
getattr(event, "rw_" + var)[pos] = interpreted_weight[var]
# weight data for interpolation
if not hyperPoly.initialized:
param_points.append(
tuple(interpreted_weight[var]
for var in weightInfo.variables))
# get list of values of ref point in specific order
ref_point_coordinates = [
weightInfo.ref_point_coordinates[var]
for var in weightInfo.variables
]
# Initialize with Reference Point
if not hyperPoly.initialized:
hyperPoly.initialize(param_points, ref_point_coordinates)
coeff = hyperPoly.get_parametrization(weights)
# = HyperPoly(weight_data, args.interpolationOrder)
event.np = hyperPoly.ndof
event.chi2_ndof = hyperPoly.chi2_ndof(coeff, weights)
#logger.debug( "chi2_ndof %f coeff %r", event.chi2_ndof, coeff )
if event.chi2_ndof > 10**-6:
logger.warning("chi2_ndof is large: %f", event.chi2_ndof)
for n in xrange(hyperPoly.ndof):
event.p_C[n] = coeff[n]
# lumi weight / w0
event.ref_lumiweight1fb = event.lumiweight1fb / coeff[0]
if not args.HEPMC:
# All gen particles
gp = fwliteReader.products['gp']
# for searching
search = GenSearch(gp)
# find heavy objects before they decay
genTops = map(
lambda t: {var: getattr(t, var)()
for var in top_varnames},
filter(lambda p: abs(p.pdgId()) == 6 and search.isLast(p), gp))
genTops.sort(key=lambda p: -p['pt'])
fill_vector_collection(event, "genTop", top_varnames, genTops)
# generated Z's
genZs = filter(
lambda p: abs(p.pdgId()) == 23 and search.isLast(p) and abs(
p.daughter(0).pdgId()) in [11, 13], gp)
genZs.sort(key=lambda p: -p.pt())
if len(genZs) > 0:
genZ = genZs[0]
for var in boson_read_varnames:
setattr(event, "genZ_" + var, getattr(genZ, var)())
else:
genZ = None
event.signalZ = 0 #ttZ with Z from gluon or top
if genZ is not None:
if abs(search.ascend(genZ).mother(0).pdgId()) in [6, 21]:
event.signalZ = 1 #ttZ with Z from gluon or top
d1, d2 = genZ.daughter(0), genZ.daughter(1)
if d1.pdgId() > 0:
lm, lp = d1, d2
else:
lm, lp = d2, d1
event.genZ_daughterPdg = lm.pdgId()
event.genZ_cosThetaStar = cosThetaStar(genZ.mass(), genZ.pt(),
genZ.eta(), genZ.phi(),
lm.pt(), lm.eta(), lm.phi())
# generated W's
genWs = filter(lambda p: abs(p.pdgId()) == 24 and search.isLast(p), gp)
genWs.sort(key=lambda p: -p.pt())
# W can't have a top-mother - We're looking for the extra boson (there is always an extra boson)
genWs = filter(lambda p: abs(search.ascend(p).mother(0).pdgId()) != 6,
genWs)
if len(genWs) > 0:
genW = genWs[0]
for var in boson_read_varnames:
setattr(event, "genW_" + var, getattr(genW, var)())
else:
genW = None
if genW is not None:
d1, d2 = genW.daughter(0), genW.daughter(1)
if abs(d1.pdgId()) in [11, 13, 15]:
lep, neu = d1, d2
else:
lep, neu = d2, d1
event.genW_daughterPdg = lep.pdgId()
## this def should only be called in debug mode
# def printTopMothers():
# genTopCheck = [ (search.ascend(l), l, search.ancestry( search.ascend(l) )) for l in filter( lambda p:abs(p.pdgId())==6, gp) ]
#
# print genTopCheck
# genTopCheck.sort( key = lambda p: -p[1].pt() )
# if len(genTopCheck) > 0:
# topPdg_ids = filter( lambda p:p!=2212, [abs(particle.pdgId()) for particle in genTopCheck[0][2]])
# print 'TOP 1'
# print topPdg_ids
# previous = genTopCheck[0][0].mother(1)
# print 'first', genTopCheck[0][0].pdgId()
# for i, pdg in enumerate(topPdg_ids):
# try:
# print 'mother', i, previous.pdgId()
# print 'mothers', i, [p.pdgId() for p in search.ancestry( previous )]
# previous = previous.mother(0)
# except Exception as val:
# print val
# break
# if len(genTopCheck) > 1:
# topPdg_ids = filter( lambda p:p!=2212, [abs(particle.pdgId()) for particle in genTopCheck[1][2]])
# print 'TOP 2'
# print topPdg_ids
# previous = genTopCheck[1][0].mother(1)
# print 'first', genTopCheck[1][0].pdgId()
# for i, pdg in enumerate(topPdg_ids):
# try:
# print 'mother', i, previous.pdgId()
# print 'mothers', i, [p.pdgId() for p in search.ancestry( previous )]
# previous = previous.mother(0)
# except Exception as val:
# print val
# break
# MET
genMet = {
'pt': fwliteReader.products['genMET'][0].pt(),
'phi': fwliteReader.products['genMET'][0].phi()
}
event.genMet_pt = genMet['pt']
event.genMet_phi = genMet['phi']
# for ttgamma and tt events, categorize events:
# a1) ttgamma vertex, gamma from t/g, isolated, must be in ttgamma sample = ttgamma signal (photonSignal == 1)
# -> gamma isolated
# -> gamma with only tops/gluons in ancestry
# a2) ttgamma, gamma from ISR, must be in ttgamma sample = tt ISR bg (photonISR == 1)
# -> gamma isolated
# -> gamma with no top in ancestry
# -> gamma with only gluons and light quarks in ancestry
# -> direct gamma mother != gluon!!! (this is a1)
# b) tt + isolated gamma from W, l, tau, must be in tt sample = ttgamma (W,l,tau) bg (photonLep == 1)
# -> gamma isolated
# -> gamma with direct abs mother being 11, 13, 15 or 24
# c1) tt + non isolated gamma from anything including mesons = tt bg (ttBg == 1)
# -> gamma non isolated or meson in ancestry
# c2) tt + isolated gamma from bottom quark (from t decay) or jets (from W) = tt bottom bg (ttBg == 1)
# -> gamma isolated from b or j (from t/W decay)
# ATTENTION: gammas from bottoms with off-shell tops where the
# top decay is done by pythia are currently labeled as ISR!
# However this case is currently not simulated in any sample
# d) tt + gamma fake = ttgamma fake (photonFake == 1)
# -> everything else does not contain a photon
# -> if it still passes selection: it is a photon fake
genPhotonsSignalCheck = [
(search.ascend(l), l, search.ancestry(search.ascend(l)))
for l in filter(
lambda p: abs(p.pdgId()) == 22 and p.pt() > 10 and abs(p.eta())
< 2.5 and search.isLast(p) and p.status() == 1, gp)
]
genPhotonsSignalCheck.sort(key=lambda p: -p[1].pt())
photonSignal = 0 #a1
photonISR = 0 #a2
photonLep = 0 #b
ttBg = 0 #c1
photonJets = 0 #c2
photonFake = 0 #d
if len(genPhotonsSignalCheck) > 0:
# check hardest photon with pT>13 and abs(eta)<2.5
first, last, ancestry = genPhotonsSignalCheck[0]
# get abs pdgIDs of ancestry
pdg_ids = filter(lambda p: p != 2212,
[abs(particle.pdgId()) for particle in ancestry])
# check if particles are close by
close_particles = filter(
lambda p: p != last and p.pt() > 5 and deltaR2(
{
'phi': last.phi(),
'eta': last.eta()
}, {
'phi': p.phi(),
'eta': p.eta()
}) < 0.2**2, search.final_state_particles_no_neutrinos)
# print 'mothers pdg', pdg_ids
# print 'close', [p.pdgId() for p in close_particles]
# print 'first mother pdg', first.mother(0).pdgId()
# if len(pdg_ids) < 999:
# previous = first.mother(0)
# for i, pdg in enumerate(pdg_ids):
# try:
# print 'mother', i, previous.pdgId()
# previous = previous.mother(0)
# except Exception as val:
# print val
# break
# deside the categories
if max(pdg_ids) > 100 or len(close_particles) != 0:
#photon with meson in ancestry or non isolated -> cat c1)
ttBg = 1
elif abs(first.mother(0).pdgId()) in [11, 13, 15, 24]:
#isolated photon with W, l or tau direct mother -> cat b)
photonLep = 1
# elif all( [ p in [ 6, 21 ] for p in pdg_ids ] ) or abs(first.mother(0).pdgId()) == 21: # not working for photons from top, as the gluons can come from light quarks
elif abs(first.mother(0).pdgId()) in [6, 21]:
#isolated photon with photon from top or gluon -> cat a1)
photonSignal = 1
# printTopMothers()
elif all([p in [1, 2, 3, 4, 5, 21] for p in pdg_ids]):
#isolated photon with photon ancestry only containing light quarks or gluons (ISR) -> cat a1)
photonISR = 1
else:
#isolated gammas from bottoms originating from the top decay or jets from W -> cat c2)
photonJets = 1
else:
# if events with photonFake == 1 pass selection: fake gamma -> cat d)
photonFake = 1
# if all flags are 0, it is an isolated gamma from a process I havn't thought of!
# should not be there! - check!
event.signalPhoton = photonSignal
event.isrPhoton = photonISR
event.lepPhoton = photonLep
event.nonIsoPhoton = ttBg
event.jetPhoton = photonJets
event.fakePhoton = photonFake
# gen photons: particle-level isolated gen photons
genPhotons = [(search.ascend(l), l) for l in filter(
lambda p: abs(p.pdgId()) == 22 and p.pt() > 15 and search.isLast(p)
and p.status() == 1, gp)]
genPhotons.sort(key=lambda p: -p[1].pt())
genPhotons_ = []
for first, last in genPhotons[:100]:
mother_pdgId = first.mother(
0).pdgId() if first.numberOfMothers() > 0 else 0
genPhoton_ = {
var: getattr(last, var)()
for var in boson_read_varnames
}
# kinematic photon selection
if not isGoodGenPhoton(genPhoton_): continue
genPhoton_['motherPdgId'] = mother_pdgId
genPhoton_['status'] = last.status()
close_particles = filter(
lambda p: p != last and deltaR2(
{
'phi': last.phi(),
'eta': last.eta()
}, {
'phi': p.phi(),
'eta': p.eta()
}) < 0.4**2, search.final_state_particles_no_neutrinos)
genPhoton_['relIso04'] = sum([p.pt() for p in close_particles],
0) / last.pt()
# require isolation
if genPhoton_['relIso04'] < 0.4:
genPhotons_.append(genPhoton_)
# genLeptons: prompt gen-leptons
genLeptons = [(search.ascend(l), l) for l in filter(
lambda p: abs(p.pdgId()) in [11, 13] and search.isLast(p) and p.pt(
) >= 0 and p.status() == 1, gp)]
promptGenLeps = []
allGenLeps = []
for first, last in genLeptons:
mother = first.mother(0) if first.numberOfMothers() > 0 else None
if mother is not None:
mother_pdgId = mother.pdgId()
mother_ascend = search.ascend(mother)
grandmother = mother_ascend.mother(
0) if mother.numberOfMothers() > 0 else None
grandmother_pdgId = grandmother.pdgId(
) if grandmother is not None else 0
else:
mother_pdgId = 0
grandmother_pdgId = 0
genLep = {var: getattr(last, var)() for var in lep_varnames}
genLep['motherPdgId'] = mother_pdgId
genLep['grandmotherPdgId'] = grandmother_pdgId
allGenLeps.append(genLep)
if abs(genLep['motherPdgId']) in [11, 13, 15, 23, 24, 25]:
promptGenLeps.append(genLep)
# filter gen leptons
promptGenLeps = list(
filter(lambda l: isGoodGenLepton(l), promptGenLeps))
promptGenLeps.sort(key=lambda p: -p['pt'])
addIndex(promptGenLeps)
## removing photons in dR cone leptons (radiation photons)
for genPhoton in genPhotons_:
genPhoton['minLeptonDR'] = min(
[999] + [deltaR(genPhoton, l) for l in allGenLeps])
genPhotons_ = list(
filter(lambda g: g['minLeptonDR'] > 0.4, genPhotons_))
addIndex(genPhotons_)
# jets
fwlite_genJets = filter(genJetId, fwliteReader.products['genJets'])
genJets = map(
lambda t: {var: getattr(t, var)()
for var in jet_read_varnames},
filter(lambda j: j.pt() > 30, fwlite_genJets))
# filter genJets
genJets = list(filter(lambda j: isGoodGenJet(j), genJets))
# cleaning of jets with isolated photons
genJets = list(
filter(
lambda j: min([999] + [deltaR2(j, p)
for p in genPhotons_]) > 0.4**2,
genJets))
# store minimum DR to jets
for genPhoton in genPhotons_:
genPhoton['minJetDR'] = min(
[999] + [deltaR(genPhoton, j) for j in genJets])
# find b's from tops:
b_partons = [
b for b in filter(
lambda p: abs(p.pdgId()) == 5 and p.numberOfMothers() == 1 and
abs(p.mother(0).pdgId()) == 6, gp)
]
# store if gen-jet is DR matched to a B parton
for genJet in genJets:
genJet['matchBParton'] = (min([999] + [
deltaR2(genJet, {
'eta': b.eta(),
'phi': b.phi()
}) for b in b_partons
]) < 0.2**2)
genJets = filter(
lambda j: (min(
[999] + [deltaR2(j, l) for l in promptGenLeps
if l['pt'] > 10]) > 0.3**2), genJets)
genJets.sort(key=lambda p: -p['pt'])
addIndex(genJets)
# gen b jets
trueBjets = list(filter(lambda j: j['matchBParton'], genJets))
trueNonBjets = list(filter(lambda j: not j['matchBParton'], genJets))
# Mimick b reconstruction ( if the trailing b fails acceptance, we supplement with the leading non-b jet )
genBj0, genBj1 = (trueBjets + trueNonBjets + [None, None])[:2]
if genBj0: fill_vector(event, "genBj0", jet_write_varnames, genBj0)
if genBj1: fill_vector(event, "genBj1", jet_write_varnames, genBj1)
# reco-bjet/leading lepton association
if len(promptGenLeps) > 0 and genBj0 and genBj1:
if vecSumPt(genBj0, promptGenLeps[0], genMet) > vecSumPt(
genBj1, promptGenLeps[0], genMet):
event.genBjLeadlep_index, event.genBjLeadhad_index = genBj0[
'index'], genBj1['index']
else:
event.genBjLeadlep_index, event.genBjLeadhad_index = genBj1[
'index'], genBj0['index']
# find Z in genLep
(event.genLepZ_mass, genLepZ_l1_index,
genLepZ_l2_index) = closestOSDLMassToMZ(promptGenLeps)
genLepNonZ_indices = [
i for i in range(len(promptGenLeps))
if i not in [genLepZ_l1_index, genLepZ_l2_index]
]
event.genLepZ_l1_index = promptGenLeps[genLepZ_l1_index][
'index'] if genLepZ_l1_index >= 0 else -1
event.genLepZ_l2_index = promptGenLeps[genLepZ_l2_index][
'index'] if genLepZ_l2_index >= 0 else -1
event.genLepNonZ_l1_index = promptGenLeps[genLepNonZ_indices[0]][
'index'] if len(genLepNonZ_indices) > 0 else -1
event.genLepNonZ_l2_index = promptGenLeps[genLepNonZ_indices[1]][
'index'] if len(genLepNonZ_indices) > 1 else -1
# store genLepZ stuff
if event.genLepZ_mass > 0:
genLepZ_l1 = ROOT.TLorentzVector()
genLepZ_l1.SetPtEtaPhiM(
promptGenLeps[event.genLepZ_l1_index]['pt'],
promptGenLeps[event.genLepZ_l1_index]['eta'],
promptGenLeps[event.genLepZ_l1_index]['phi'], 0)
genLepZ_l2 = ROOT.TLorentzVector()
genLepZ_l2.SetPtEtaPhiM(
promptGenLeps[event.genLepZ_l2_index]['pt'],
promptGenLeps[event.genLepZ_l2_index]['eta'],
promptGenLeps[event.genLepZ_l2_index]['phi'], 0)
genLepZ = genLepZ_l1 + genLepZ_l2
event.genLepZ_pt = genLepZ.Pt()
event.genLepZ_eta = genLepZ.Eta()
event.genLepZ_phi = genLepZ.Phi()
event.genLepZ_lldPhi = deltaPhi(
promptGenLeps[event.genLepZ_l1_index]['phi'],
promptGenLeps[event.genLepZ_l2_index]['phi'])
event.genLepZ_lldR = deltaR(promptGenLeps[event.genLepZ_l1_index],
promptGenLeps[event.genLepZ_l2_index])
genLepMinus_index = event.genLepZ_l1_index if promptGenLeps[
event.
genLepZ_l1_index]['pdgId'] > 0 else event.genLepZ_l2_index
event.genLepZ_cosThetaStar = cosThetaStar(
event.genLepZ_mass, event.genLepZ_pt, event.genLepZ_eta,
event.genLepZ_phi, promptGenLeps[genLepMinus_index]['pt'],
promptGenLeps[genLepMinus_index]['eta'],
promptGenLeps[genLepMinus_index]['phi'])
# reco-bjet/nonZ lepton association
if event.genLepNonZ_l1_index >= 0 and genBj0 and genBj1:
if vecSumPt(genBj0, promptGenLeps[event.genLepNonZ_l1_index],
genMet) > vecSumPt(
genBj1, promptGenLeps[event.genLepNonZ_l1_index],
genMet):
event.genBjNonZlep_index, event.genBjNonZhad_index = genBj0[
'index'], genBj1['index']
else:
event.genBjNonZlep_index, event.genBjNonZhad_index = genBj1[
'index'], genBj0['index']
#for jet in genJets:
# print jet['isMuon'], jet['isElectron'], jet['isPhoton'], min([999]+[deltaR2(jet, l) for l in promptGenLeps if l['pt']>10]), jet
# jet/lepton disambiguation -> remove jets, because gen-jets cluster all leptons
#if args.logLevel == 'DEBUG':
# for jet in filter( lambda j: not (min([999]+[deltaR2(j, l) for l in promptGenLeps if l['pt']>10]) > 0.3**2 ), genJets ):
# logger.debug( "Filtered gen %f jet %r lep %r", sqrt((min([999]+[deltaR2(jet, l) for l in promptGenLeps if l['pt']>10]))), jet, [ (l['eta'], jet['pt']/l['pt']) for l in promptGenLeps] )
# assert False, ""
fill_vector_collection(event, "genPhoton", gen_photon_varnames,
genPhotons_)
fill_vector_collection(event, "genLep", lep_all_varnames,
promptGenLeps)
fill_vector_collection(event, "genJet", jet_write_varnames, genJets)
# Reco quantities
if args.delphes or args.HEPMC:
#delphesReader.event.GetEntry(fwliteReader.position-1 ) # do this differently now ...
# add JEC info
allRecoJets = delphesReader.jets()
# add btag info
for i_btagWP, btagWP in enumerate(btagWPs):
count = 0
for jet in allRecoJets:
btag = (jet["bTag"] & (2**i_btagWP) > 0) # Read b-tag bitmap
jet["bTag_" + btagWP] = btag
# read jets
recoJets = filter(isGoodRecoJet, allRecoJets)
recoJets.sort(key=lambda p: -p['pt'])
addIndex(recoJets)
# count b-tag multiplicities
for i_btagWP, btagWP in enumerate(btagWPs):
count = 0
for jet in recoJets:
if jet["bTag_" + btagWP]: count += 1
setattr(event, "nBTag_" + btagWP, count)
if btagWP == default_btagWP:
setattr(event, "nBTag", count)
# upgrade JEC are flavor dependent
for jet in allRecoJets:
btag_ = jet["bTag_" + default_btagWP]
upgradeJECUncertainty.applyJECInfo(jet, flavor=5 if btag else 0)
# count JEC varied jet multiplicities
event.nrecoJets_JEC_up = len(
filter(lambda j: isGoodRecoJet(j, pt_var='pt_JEC_up'),
allRecoJets))
event.nrecoJets_JEC_down = len(
filter(lambda j: isGoodRecoJet(j, pt_var='pt_JEC_down'),
allRecoJets))
event.nBTag_JEC_up = len(
filter(
lambda j: j["bTag_" + default_btagWP] and isGoodRecoJet(
j, pt_var='pt_JEC_up'), allRecoJets))
event.nBTag_JEC_down = len(
filter(
lambda j: j["bTag_" + default_btagWP] and isGoodRecoJet(
j, pt_var='pt_JEC_down'), allRecoJets))
# read jets
recoJets = filter(isGoodRecoJet, allRecoJets)
recoJets.sort(key=lambda p: -p['pt'])
addIndex(recoJets)
# make reco b jets
recoBJets = filter(lambda j: j['bTag_' + default_btagWP], recoJets)
recoNonBJets = filter(lambda j: not j['bTag_' + default_btagWP],
recoJets)
recoBj0, recoBj1 = (recoBJets + recoNonBJets + [None, None])[:2]
if recoBj0: fill_vector(event, "recoBj0", recoJet_varnames, recoBj0)
if recoBj1: fill_vector(event, "recoBj1", recoJet_varnames, recoBj1)
# add b-tag reweights
event.reweight_BTag_B = getBTagSF_1a(default_btagWP, 'B', recoBJets,
recoNonBJets)
event.reweight_BTag_L = getBTagSF_1a(default_btagWP, 'L', recoBJets,
recoNonBJets)
# read leptons
allRecoLeps = delphesReader.muons() + delphesReader.electrons()
allRecoLeps.sort(key=lambda p: -p['pt'])
recoLeps = filter(isGoodRecoLepton, allRecoLeps)
# Photons
recoPhotons = filter(isGoodRecoPhoton, delphesReader.photons())
# Remove radiated photons in dR cone
for recoPhoton in recoPhotons:
recoPhoton['minLeptonDR'] = 999
recoPhoton['minLeptonPt'] = -1.
dr_values = [deltaR(recoPhoton, l) for l in allRecoLeps]
recoPhoton['minLeptonDR'] = min([999] + dr_values)
if len(dr_values) > 0:
closest_lepton = dr_values.index(min(dr_values))
recoPhoton['minLeptonPt'] = allRecoLeps[closest_lepton]['pt']
recoPhotons = list(
filter(lambda g: g['minLeptonDR'] > 0.4, recoPhotons))
for recoPhoton in recoPhotons:
recoPhoton['minJetDR'] = min(
[999] + [deltaR(recoPhoton, j) for j in recoJets])
recoPhotons = list(filter(lambda g: g['minJetDR'] > 0.4, recoPhotons))
# cross-cleaning of reco-objects
recoLeps = filter(
lambda l:
(min([999] + [deltaR2(l, j) for j in recoJets
if j['pt'] > 30]) > 0.3**2), recoLeps)
# give index to leptons
addIndex(recoLeps)
# lepton uncertainties
event.reweight_id_mu = 1.
event.reweight_id_ele = 1.
for l in recoLeps:
if abs(l['pdgId']) == 11:
event.reweight_id_ele *= 1.005
elif abs(l['pdgId']) == 13:
event.reweight_id_mu *= 1.005
# MET
recoMet = delphesReader.met()[0]
# reco-bjet/leading lepton association
if len(recoLeps) > 0 and recoBj0 and recoBj1:
if vecSumPt(recoBj0, recoLeps[0], recoMet) > vecSumPt(
recoBj1, recoLeps[0], recoMet):
event.recoBjLeadlep_index, event.recoBjLeadhad_index = recoBj0[
'index'], recoBj1['index']
else:
event.recoBjLeadlep_index, event.recoBjLeadhad_index = recoBj1[
'index'], recoBj0['index']
# Photons
for recoPhoton in recoPhotons:
recoPhoton['genIndex'] = -1
minDR = 999
if not args.HEPMC:
for index, genPhoton in enumerate(genPhotons_):
dr = deltaR(recoPhoton, genPhoton)
if dr < 0.4 and dr < minDR:
minDR = dr
recoPhoton['genIndex'] = index
# Store
fill_vector_collection(event, "recoLep", recoLep_varnames, recoLeps)
fill_vector_collection(event, "recoJet", recoJet_varnames, recoJets)
fill_vector_collection(event, "recoPhoton", recoPhoton_varnames,
recoPhotons)
event.recoMet_pt = recoMet['pt']
event.recoMet_phi = recoMet['phi']
# search for reco Z in reco leptons
(event.recoZ_mass, recoZ_l1_index,
recoZ_l2_index) = closestOSDLMassToMZ(recoLeps)
recoNonZ_indices = [
i for i in range(len(recoLeps))
if i not in [recoZ_l1_index, recoZ_l2_index]
]
event.recoZ_l1_index = recoLeps[recoZ_l1_index][
'index'] if recoZ_l1_index >= 0 else -1
event.recoZ_l2_index = recoLeps[recoZ_l2_index][
'index'] if recoZ_l2_index >= 0 else -1
event.recoNonZ_l1_index = recoLeps[
recoNonZ_indices[0]]['index'] if len(recoNonZ_indices) > 0 else -1
event.recoNonZ_l2_index = recoLeps[
recoNonZ_indices[1]]['index'] if len(recoNonZ_indices) > 1 else -1
# Store Z information
if event.recoZ_mass >= 0:
if recoLeps[event.recoZ_l1_index]['pdgId'] * recoLeps[
event.recoZ_l2_index]['pdgId'] > 0 or abs(
recoLeps[event.recoZ_l1_index]['pdgId']) != abs(
recoLeps[event.recoZ_l2_index]['pdgId']):
raise RuntimeError("not a Z! Should not happen")
Z_l1 = ROOT.TLorentzVector()
Z_l1.SetPtEtaPhiM(recoLeps[event.recoZ_l1_index]['pt'],
recoLeps[event.recoZ_l1_index]['eta'],
recoLeps[event.recoZ_l1_index]['phi'], 0)
Z_l2 = ROOT.TLorentzVector()
Z_l2.SetPtEtaPhiM(recoLeps[event.recoZ_l2_index]['pt'],
recoLeps[event.recoZ_l2_index]['eta'],
recoLeps[event.recoZ_l2_index]['phi'], 0)
Z = Z_l1 + Z_l2
event.recoZ_pt = Z.Pt()
event.recoZ_eta = Z.Eta()
event.recoZ_phi = Z.Phi()
event.recoZ_lldPhi = deltaPhi(
recoLeps[event.recoZ_l1_index]['phi'],
recoLeps[event.recoZ_l2_index]['phi'])
event.recoZ_lldR = deltaR(recoLeps[event.recoZ_l1_index],
recoLeps[event.recoZ_l2_index])
lm_index = event.recoZ_l1_index if recoLeps[
event.recoZ_l1_index]['pdgId'] > 0 else event.recoZ_l2_index
event.recoZ_cosThetaStar = cosThetaStar(
event.recoZ_mass, event.recoZ_pt, event.recoZ_eta,
event.recoZ_phi, recoLeps[lm_index]['pt'],
recoLeps[lm_index]['eta'], recoLeps[lm_index]['phi'])
# reco-bjet/lepton association
if event.recoNonZ_l1_index >= 0 and recoBj0 and recoBj1:
if vecSumPt(recoBj0, recoLeps[event.recoNonZ_l1_index],
recoMet) > vecSumPt(
recoBj1, recoLeps[event.recoNonZ_l1_index],
recoMet):
event.recoBjNonZlep_index, event.recoBjNonZhad_index = recoBj0[
'index'], recoBj1['index']
else:
event.recoBjNonZlep_index, event.recoBjNonZhad_index = recoBj1[
'index'], recoBj0['index']
def cleanLeptons(event, sample):
recoLep = getCollection(
event, 'recoLep',
["pt", "eta", "phi", "pdgId", "sumPt", "isolationVar"], 'nrecoLep')
recoLep = list(filter(lambda l: isGoodRecoLepton(l), recoLep))
# recoLep = list( filter( lambda l: (l["sumPt"]-l["pt"])/l["pt"] < 0.2, recoLep ) )
recoLep = list(filter(lambda l: l["isolationVar"] < 0.2, recoLep))
# recoLep.sort( key=lambda l: -l["pt"] )
# goodLeps = []
# for i_l, l1 in enumerate(recoLep):
# clean = True
# for j_l, l2 in enumerate(recoLep[:i_l]):
# if deltaR2(l1, l2)<0.4**2:
# clean = False
# break
# if clean: goodLeps.append(l1)
goodLeps = recoLep
event.recoLep = goodLeps
event.nrecoLep = len(goodLeps)
# event.recoLep_pt = []
# event.recoLep_pt.append(goodLeps[0]["pt"])
# event.recoLep_pt.append(goodLeps[1]["pt"])
# event.recoLep_eta = []
# event.recoLep_eta.append(goodLeps[0]["eta"])
# event.recoLep_eta.append(goodLeps[1]["eta"])
# event.recoLep_phi = []
# event.recoLep_phi.append(goodLeps[0]["phi"])
# event.recoLep_phi.append(goodLeps[1]["phi"])
event.recoZ_mass = -999 #float("nan")
event.recoZ_pt = -999 #float("nan")
event.recoZ_phi = -999 #float("nan")
event.recoZ_eta = -999 #float("nan")
event.recoZ_lldPhi = -999 #float("nan")
event.recoZ_lldR = -999 #float("nan")
if event.nrecoLep != 1:
event.lumiweight1fb = 0
return
if event.nrecoLep > 1:
event.recoZ_mass, event.recoZ_l1_index, event.recoZ_l2_index = closestOSDLMassToMZ(
goodLeps)
l1 = goodLeps[event.recoZ_l1_index]
l2 = goodLeps[event.recoZ_l2_index]
# print deltaR(l1,l2), l1["pt"], l2["pt"], event.recoZ_l1_index, event.recoZ_l2_index, event.recoZ_mass
if event.recoZ_mass:
Z_l1 = ROOT.TLorentzVector()
Z_l1.SetPtEtaPhiM(goodLeps[event.recoZ_l1_index]['pt'],
goodLeps[event.recoZ_l1_index]['eta'],
goodLeps[event.recoZ_l1_index]['phi'], 0)
Z_l2 = ROOT.TLorentzVector()
Z_l2.SetPtEtaPhiM(goodLeps[event.recoZ_l2_index]['pt'],
goodLeps[event.recoZ_l2_index]['eta'],
goodLeps[event.recoZ_l2_index]['phi'], 0)
Z = Z_l1 + Z_l2
event.recoZ_pt = Z.Pt()
event.recoZ_eta = Z.Eta()
event.recoZ_phi = Z.Phi()
event.recoZ_lldPhi = deltaPhi(
goodLeps[event.recoZ_l1_index]['phi'],
goodLeps[event.recoZ_l2_index]['phi'])
event.recoZ_lldR = deltaR(goodLeps[event.recoZ_l1_index],
goodLeps[event.recoZ_l2_index])
lm_index = event.recoZ_l1_index if goodLeps[
event.recoZ_l1_index]['pdgId'] > 0 else event.recoZ_l2_index
event.recoZ_cosThetaStar = cosThetaStar(
event.recoZ_mass, event.recoZ_pt, event.recoZ_eta,
event.recoZ_phi, goodLeps[lm_index]['pt'],
goodLeps[lm_index]['eta'], goodLeps[lm_index]['phi'])
if event.recoZ_lldPhi < 0.1 or event.recoZ_lldR < 0.1:
event.lumiweight1fb = 0
return
event.recoJet = getCollection(
event, 'recoJet',
["pt", "eta", "phi", "nCharged", "nNeutrals", "bTag"], 'nrecoJet')
event.recoJet = list(filter(lambda l: isGoodRecoJet(l), event.recoJet))
event.recoJet.sort(key=lambda l: -l["pt"])
event.recoJet = list(
filter(
lambda j: min([999] + [deltaR2(j, p)
for p in event.recoLep]) > 0.4**2,
event.recoJet))
event.nrecoJet = len(event.recoJet)
event.nBTag = len(filter(lambda j: j["bTag"], event.recoJet))
