def process(self, event):
self.tree.reset()
haas = getattr(event, self.cfg_ana.haas)
hbbs = getattr(event, self.cfg_ana.hbbs)
haas.sort(key=lambda x: abs(x.m() - 125.))
hbbs.sort(key=lambda x: abs(x.m() - 125.))
if len(haas) > 0 and len(hbbs) > 0:
self.tree.fill('weight', event.weight)
# jet multiplicities
self.tree.fill('nbjets', len(event.selected_bs))
self.tree.fill('nljets', len(event.selected_lights))
self.tree.fill('njets',
len(event.selected_lights) + len(event.selected_bs))
self.tree.fill('nlep', len(event.selected_leptons))
# missing Et
fillMet(self.tree, 'met', event.met)
# Reco higgses
photons = []
photons.append(haas[0].leg1())
photons.append(haas[0].leg2())
photons.sort(key=lambda x: x.pt(), reverse=True)
bs = []
bs.append(hbbs[0].leg1())
bs.append(hbbs[0].leg2())
bs.sort(key=lambda x: x.pt(), reverse=True)
hh = Resonance(haas[0], hbbs[0], 25)
fillParticle(self.tree, 'hh', hh)
fillParticle(self.tree, 'haa', haas[0])
fillParticle(self.tree, 'hbb', hbbs[0])
fillParticle(self.tree, 'a1', photons[0])
fillParticle(self.tree, 'a2', photons[1])
fillParticle(self.tree, 'b1', bs[0])
fillParticle(self.tree, 'b2', bs[1])
drbb = deltaR(bs[0], bs[1])
draa = deltaR(photons[0], photons[1])
self.tree.fill('draa', draa)
self.tree.fill('drbb', drbb)
self.tree.tree.Fill()
'''phos = getattr(event, self.cfg_ana.photons)
bs = getattr(event, self.cfg_ana.bs)
phos.sort(key=lambda x: x.pt(), reverse=True)
bs.sort(key=lambda x: x.pt(), reverse=True)'''
#print len(phos), len(bs)
'''if len(phos) > 1 and len(bs) > 1 :
def process(self, event):
'''process event
The event must contain:
- self.cfg_ana.particles: the particles to be matched
- self.cfg_ana.match_particles: the particles in which the match has to be found
Modifies the particles in event.<self.cfg_ana.particles>
'''
particles = getattr(event, self.cfg_ana.particles)
# match_particles = getattr(event, self.cfg_ana.match_particles)
for collname, pdgid in self.match_collections:
match_ptcs = getattr(event, collname)
match_ptcs_filtered = match_ptcs
if pdgid is not None:
match_ptcs_filtered = [ptc for ptc in match_ptcs
if ptc.pdgid()==pdgid]
pairs = matchObjectCollection(particles, match_ptcs_filtered,
self.cfg_ana.delta_r)
for ptc in particles:
matchname = 'match'
if pdgid:
matchname = 'match_{pdgid}'.format(pdgid=pdgid)
match = pairs[ptc]
setattr(ptc, matchname, match)
if match:
drname = 'dr'
if pdgid:
drname = 'dr_{pdgid}'.format(pdgid=pdgid)
dr = deltaR(ptc, match)
setattr(ptc, drname, dr)
def process(self, event):
particles = getattr(event, self.cfg_ana.particles)
# match_particles = getattr(event, self.cfg_ana.match_particles)
for collname, pdgid in self.match_collections:
match_ptcs = getattr(event, collname)
match_ptcs_filtered = match_ptcs
if pdgid is not None:
match_ptcs_filtered = [
ptc for ptc in match_ptcs if ptc.pdgid() == pdgid
]
pairs = matchObjectCollection(particles, match_ptcs_filtered,
0.3**2)
for ptc in particles:
matchname = 'match'
if pdgid:
matchname = 'match_{pdgid}'.format(pdgid=pdgid)
match = pairs[ptc]
setattr(ptc, matchname, match)
if match:
drname = 'dr'
if pdgid:
drname = 'dr_{pdgid}'.format(pdgid=pdgid)
dr = deltaR(ptc.theta(), ptc.phi(), match.theta(),
match.phi())
setattr(ptc, drname, dr)
def process(self, event):
'''process event
The event must contain:
- self.cfg_ana.particles: the particles to be matched
- self.cfg_ana.match_particles: the particles in which the match has to be found
Modifies the particles in event.<self.cfg_ana.particles>
'''
particles = getattr(event, self.cfg_ana.particles)
# match_particles = getattr(event, self.cfg_ana.match_particles)
for collname, pdgid in self.match_collections:
match_ptcs = getattr(event, collname)
match_ptcs_filtered = match_ptcs
if pdgid is not None:
match_ptcs_filtered = [ptc for ptc in match_ptcs
if ptc.pdgid()==pdgid]
pairs = matchObjectCollection(particles, match_ptcs_filtered,
self.cfg_ana.delta_r)
for ptc in particles:
matchname = 'match'
if pdgid:
matchname = 'match_{pdgid}'.format(pdgid=pdgid)
match = pairs[ptc]
setattr(ptc, matchname, match)
if match:
drname = 'dr'
if pdgid:
drname = 'dr_{pdgid}'.format(pdgid=pdgid)
dr = deltaR(ptc.theta(), ptc.phi(),
match.theta(), match.phi())
setattr(ptc, drname, dr)
def hcal_hcal(self, ele1, ele2):
dR = deltaR(ele1.position.Theta(),
ele1.position.Phi(),
ele2.position.Theta(),
ele2.position.Phi())
link_ok = dR < ele1.angular_size() + ele2.angular_size()
return ('hcal_in', 'hcal_in'), link_ok, dR
def is_inside_cluster(self, other):
'''TODO change name to "overlaps" ? '''
#now we have original unmerged clusters so we can compare directly to see if they overlap
dR = deltaR(self.position.Theta(), self.position.Phi(),
other.position.Theta(), other.position.Phi())
link_ok = dR < self.angular_size() + other.angular_size()
return link_ok, dR
def process(self, event):
pivot = getattr(event, self.cfg_ana.pivot)
ptcs = getattr(event, self.cfg_ana.particles)
dR_list = []
if ptcs and pivot:
pivot = pivot[0]
for ptc in ptcs:
dR_list.append(deltaR(pivot, ptc))
setattr(event, 'dR_list', dR_list)
def is_inside_cluster(self, other):
'''TODO change name to "overlaps" ? '''
#now we have original unmerged clusters so we can compare directly to see if they overlap
dR = deltaR(self.position.Theta(),
self.position.Phi(),
other.position.Theta(),
other.position.Phi())
link_ok = dR < self.angular_size() + other.angular_size()
return link_ok, dR
def process(self, event):
jets = getattr(event, self.cfg_ana.jets)
genjets = getattr(event, self.cfg_ana.genjets)
pairs = matchObjectCollection(jets, genjets, 0.3**2)
for jet in jets:
jet.gen = pairs[jet]
if jet.gen:
jet.dR = deltaR(jet.theta(), jet.phi(),
jet.gen.theta(), jet.gen.phi())
def process(self, event):
jets = getattr(event, self.cfg_ana.jets)
genjets = getattr(event, self.cfg_ana.genjets)
pairs = matchObjectCollection(jets, genjets, 0.3**2)
for jet in jets:
jet.gen = pairs[jet]
if jet.gen:
jet.dR = deltaR(jet.theta(), jet.phi(),
jet.gen.theta(), jet.gen.phi())
def process(self, event):
jets = event.rec_jets
genjets = event.gen_jets
pairs = matchObjectCollection(jets, genjets, 0.3**2)
for jet in jets:
jet.gen = pairs[jet]
if jet.gen:
jet.dR = deltaR(jet.theta(), jet.phi(),
jet.gen.theta(), jet.gen.phi())
def process(self, event):
pivot = getattr(event, self.cfg_ana.pivot)
ptcs = getattr(event, self.cfg_ana.particles)
dR_list = []
if ptcs and pivot:
pivot = pivot[0]
for ptc in ptcs:
dR_list.append(deltaR(pivot, ptc))
setattr(event, 'dR_list', dR_list)
def process(self, event):
particles = getattr(event, self.cfg_ana.particles)
match_particles = getattr(event, self.cfg_ana.match_particles)
pairs = matchObjectCollection(particles, match_particles,
self.dr2)
for ptc in particles:
match = pairs[ptc]
if match:
dr = deltaR(ptc.theta(), ptc.phi(),
match.theta(), match.phi())
setattr(ptc, self.instance_label, MatchInfo(match, dr))
def drmin(event):
drmin = 999999.
for i, j in itertools.combinations(range(4), 2):
theta1 = getattr(event, 'jets4_{}_theta'.format(i))
phi1 = getattr(event, 'jets4_{}_phi'.format(i))
theta2 = getattr(event, 'jets4_{}_theta'.format(j))
phi2 = getattr(event, 'jets4_{}_phi'.format(j))
dr = deltaR(theta1, phi1, theta2, phi2)
if dr < drmin:
drmin = dr
return drmin
def process(self, event):
pivot = getattr(event, self.cfg_ana.pivot)[0]
ptcs = getattr(event, self.cfg_ana.particles)
dR = self.cfg_ana.dR
cone_ptcs = inConeCollection(pivot, ptcs, dR, 0.)
for ptc in cone_ptcs:
setattr(ptc, 'dR', deltaR(pivot, ptc))
tlv = TLorentzVector(pivot.p4())
tlv.SetPhi(pivot.p4().Phi() + math.pi)
tlv_theta = math.pi - pivot.p4().Theta()
if tlv_theta >= math.pi:
tlv_theta -= math.pi
tlv.SetTheta(tlv_theta)
control_pivot = Particle(pivot.pdgid(), pivot.charge(), tlv)
control_cone_ptcs = inConeCollection(control_pivot, ptcs, dR, 0.)
setattr(event, self.cfg_ana.output, cone_ptcs)
setattr(event, self.cfg_ana.control_output, control_cone_ptcs)
def is_inside_clusters(self, other):
'''TODO: no need for two versions of this method, see below.
one should have a single overlap method that always works, whether or not there are any
subclusters.
'''
#see if two clusters overlap (allowing for merged clusters which contain subclusters)
#we have a link if any of the subclusters overlap
#the distance is the distance betewen the weighted centres of each (merged) cluster
dist = deltaR(self.position.Theta(), self.position.Phi(),
other.position.Theta(), other.position.Phi())
for c in self.subclusters:
for o in other.subclusters:
is_link, innerdist = c.is_inside_cluster(o)
if is_link:
return True, dist
return False, dist
def process(self, event):
pivot = getattr(event, self.cfg_ana.pivot)[0]
ptcs = getattr(event, self.cfg_ana.particles)
dR = self.cfg_ana.dR
cone_ptcs = inConeCollection(pivot, ptcs, dR, 0.)
for ptc in cone_ptcs:
setattr(ptc, 'dR', deltaR(pivot, ptc))
tlv = TLorentzVector(pivot.p4())
tlv.SetPhi(pivot.p4().Phi()+math.pi)
tlv_theta = math.pi-pivot.p4().Theta()
if tlv_theta >= math.pi:
tlv_theta -= math.pi
tlv.SetTheta(tlv_theta)
control_pivot = Particle(pivot.pdgid(),
pivot.charge(),
tlv)
control_cone_ptcs = inConeCollection(control_pivot, ptcs, dR, 0.)
setattr(event, self.cfg_ana.output, cone_ptcs)
setattr(event, self.cfg_ana.control_output, control_cone_ptcs)
def is_inside_clusters(self, other):
'''TODO: no need for two versions of this method, see below.
one should have a single overlap method that always works, whether or not there are any
subclusters.
'''
#see if two clusters overlap (allowing for merged clusters which contain subclusters)
#we have a link if any of the subclusters overlap
#the distance is the distance betewen the weighted centres of each (merged) cluster
dist = deltaR(self.position.Theta(),
self.position.Phi(),
other.position.Theta(),
other.position.Phi())
for c in self.subclusters:
for o in other.subclusters:
is_link, innerdist = c.is_inside_cluster(o)
if is_link:
return True, dist
return False, dist
def process(self, event):
self.tree.reset()
gen_higgses = getattr(event, self.cfg_ana.gen_higgses)
self.tree.fill('weight', event.weight)
self.tree.fill('nh', len(gen_higgses))
gen_higgses.sort(key=lambda x: x.pt(), reverse=True)
if len(gen_higgses) > 1:
hh = Resonance(gen_higgses[0], gen_higgses[1], 25)
if hh.pt() > 500.:
fillParticle(self.tree, 'h1', gen_higgses[0])
fillParticle(self.tree, 'h2', gen_higgses[1])
fillParticle(self.tree, 'hh', hh)
drhh = deltaR(gen_higgses[0], gen_higgses[1])
self.tree.fill('drhh', drhh)
self.tree.tree.Fill()
def process(self, event):
particles = getattr(event, self.cfg_ana.particles)
# match_particles = getattr(event, self.cfg_ana.match_particles)
for collname, pdgid in self.match_collections:
match_ptcs = getattr(event, collname)
match_ptcs_filtered = match_ptcs
if pdgid is not None:
match_ptcs_filtered = [ptc for ptc in match_ptcs
if ptc.pdgid()==pdgid]
pairs = matchObjectCollection(particles, match_ptcs_filtered,
self.dr2)
for ptc in particles:
matchname = 'match'
if pdgid:
matchname = 'match_{pdgid}'.format(pdgid=pdgid)
match = pairs[ptc]
setattr(ptc, matchname, match)
if match:
drname = 'dr'
if pdgid:
drname = 'dr_{pdgid}'.format(pdgid=pdgid)
dr = deltaR(ptc.theta(), ptc.phi(),
match.theta(), match.phi())
setattr(ptc, drname, dr)
def process(self, event):
assumed_vertex = TVector3(0, 0, 0)
jets = getattr(event, self.cfg_ana.jets)
detector = self.cfg_ana.detector
pt_min = self.cfg_ana.pt_min
dxy_max = self.cfg_ana.dxy_max
dz_max = self.cfg_ana.dz_max
for jet in jets:
IP_b_LL = 0 # value of the log likelihood ratio based on IP initiated at 0
IPs_b_LL = 0 # value of the log likelihood ratio based on IP significance initiated at 0
ipsig_ptcs = [] # list of IP signif and associated ptcs
for id, ptcs in jet.constituents.iteritems():
if abs(id) in [22, 130, 11]:
continue
for ptc in ptcs:
if ptc.q() == 0:
continue
ptc.path.compute_IP(assumed_vertex, jet)
ptc_IP_signif = 0
if hasattr(ptc.path, 'points'
) == True and 'beampipe_in' in ptc.path.points:
phi_in = ptc.path.phi(ptc.path.points['beampipe_in'].X(),\
ptc.path.points['beampipe_in'].Y())
phi_out= ptc.path.phi(ptc.path.points['beampipe_out'].X(),\
ptc.path.points['beampipe_out'].Y())
deltat = ptc.path.time_at_phi(
phi_out) - ptc.path.time_at_phi(phi_in)
x = ptc.path.path_length(deltat)
X_0 = detector.elements['beampipe'].material.x0
ptc.path.compute_theta_0(x, X_0)
ptc.path.compute_IP_signif(
ptc.path.IP, ptc.path.theta_0,
ptc.path.points['beampipe_in'])
else:
ptc.path.compute_IP_signif(ptc.path.IP, None, None)
dx = ptc.path.IP_coord.x() - assumed_vertex.x()
dy = ptc.path.IP_coord.y() - assumed_vertex.y()
dz = ptc.path.IP_coord.z() - assumed_vertex.z()
if ptc.path.p4.Perp() > pt_min and (
dx**2 +
dy**2)**0.5 < dxy_max and dz**2 < dz_max**2:
ipsig_ptcs.append([ptc.path.IP_signif, ptc])
if self.tag_IP_b_LL:
ptc.path.IP_b_LL = self.ll_tag(
self.ratio_IP, ptc.path.IP, IP_b_LL)
if self.tag_IPs_b_LL:
ptc.path.IPs_b_LL = self.ll_tag(
self.ratio_IPs, ptc.path.IP_signif, IPs_b_LL)
ipsig_ptcs.sort(reverse=True)
if len(ipsig_ptcs) < 2:
TCHE = -99
TCHP = -99
TCHE_IP = -99
TCHP_IP = -99
TCHE_x = -99
TCHE_y = -99
TCHE_z = -99
TCHE_pt = -99
TCHE_dr = -99
if len(ipsig_ptcs) > 1:
TCHE = ipsig_ptcs[1][0]
ptc = ipsig_ptcs[1][1]
TCHE_IP = ptc.path.IP
TCHE_x, TCHE_y, TCHE_z = ptc.path.coord_at_time(0)
TCHE_pt = ptc.path.p4.Perp()
TCHE_dr = deltaR(jet.eta(), jet.phi(), ptc.eta(), ptc.phi())
TCHP = -99
TCHP_IP = -99
if len(ipsig_ptcs) > 2:
TCHP = ipsig_ptcs[2][0]
ptc = ipsig_ptcs[2][1]
TCHP_IP = ptc.path.IP
jet.tags['IP_b_LL'] = IP_b_LL if self.tag_IP_b_LL else None
jet.tags['IPs_b_LL'] = IPs_b_LL if self.tag_IPs_b_LL else None
#TODO COLIN : create a BTagInfo class.
jet.tags['TCHE'] = TCHE
jet.tags['TCHP'] = TCHP
jet.tags['TCHE_IP'] = TCHE_IP
jet.tags['TCHP_IP'] = TCHP_IP
jet.tags['TCHE_x'] = TCHE_x
jet.tags['TCHE_y'] = TCHE_y
jet.tags['TCHE_z'] = TCHE_z
jet.tags['TCHE_xy'] = (TCHE_x**2 + TCHE_y**2)**0.5
jet.tags['TCHE_pt'] = TCHE_pt
jet.tags['TCHE_dr'] = TCHE_dr
if hasattr(event, 'K0s') == True:
jet.tags['K0s'] = event.K0s
else:
jet.tags['K0s'] = -99
if hasattr(event, 'Kp') == True:
jet.tags['Kp'] = event.Kp
else:
jet.tags['Kp'] = -99
if hasattr(event, 'L0') == True:
jet.tags['L0'] = event.L0
else:
jet.tags['L0'] = -99
if hasattr(event, 'S0') == True:
jet.tags['S0'] = event.S0
else:
jet.tags['S0'] = -99
if hasattr(event, 'Sp') == True:
jet.tags['Sp'] = event.Sp
else:
jet.tags['Sp'] = -99
if hasattr(event, 'Sm') == True:
jet.tags['Sm'] = event.Sm
else:
jet.tags['Sm'] = -99
if hasattr(event, 'Muons') == True:
jet.tags['Muons'] = event.Muons
else:
jet.tags['Muons'] = -99
def process(self, event):
self.counters['cut_flow'].inc('All events')
mus = getattr(event, self.cfg_ana.muons)
photons = getattr(event, self.cfg_ana.photons)
particles = getattr(event, self.cfg_ana.particles)
lenmu = len(mus)
setattr(event, self.cfg_ana.lenmu, lenmu)
posmus1 = [mu for mu in mus if mu.pdgid() == -13]
negmus1 = [mu for mu in mus if mu.pdgid() == 13]
if len(posmus1) < 1 or len(negmus1) < 1:
return False
self.counters['cut_flow'].inc('Mumu pair')
isomus = [mu for mu in mus if mu.iso.sume / mu.e() < 0.2]
posmus = [mu for mu in isomus if mu.pdgid() == -13]
negmus = [mu for mu in isomus if mu.pdgid() == 13]
if len(posmus) < 1 or len(negmus) < 1:
return False
self.counters['cut_flow'].inc('Relative isolation < 0.2')
bremphotons = []
for i in photons:
for j in isomus:
if deltaR(i, j) < 0.5:
bremphotons.append(i)
# pos_mus and neg_mus may contain repeats of the muons or antimuons but, ordered, they contain a list of pairs that survive the cuts
#photon_combos = sum([map(list, combinations(bremphotons, k)) for k in range(len(bremphotons) + 0)], [])
min_mass_diff = 9999.9
recoilmass = 0
pos_mus = []
neg_mus = []
#below is a method for iterating over all photons, alongside the muons, to choose bremsstrahlung photons such that the system of muons and photons has a recoil mass equal to the Z mass
#chosenphotons = []
#for i in range(len(posmus)):
# mu1 = posmus[i]
# for j in range(len(negmus)):
# mu2 = negmus[j]
# part1 = 240 - mu1.e() - mu2.e()
# part2 = mu1.p3() + mu2.p3()
# for l in range(len(photon_combos)):
# for m in range(len(photon_combos[l])):
# part1 -= photon_combos[l][m].e()
# part2 += photon_combos[l][m].p3()
# recoil_mass_square = part1**2 - numpy.dot(part2, part2)
# if recoil_mass_square<0:
# recoil_mass = 0
# else:
# recoil_mass = math.sqrt(recoil_mass_square)
# mass_diff = abs(recoil_mass - 91.2)
# if mass_diff < min_mass_diff:
# min_mass_diff = mass_diff
# recoilmass = recoil_mass
# for n in range(len(photon_combos[l])):
# chosenphotons.append(photon_combos[l][n])
for i in range(len(posmus)):
mu1 = posmus[i]
for j in range(len(negmus)):
mu2 = negmus[j]
part1 = 240 - mu1.e() - mu2.e()
part2 = mu1.p3() + mu2.p3()
for l in range(len(bremphotons)):
part1 -= bremphotons[l].e()
part2 += bremphotons[l].p3()
recoil_mass_square = part1**2 - numpy.dot(part2, part2)
if recoil_mass_square < 0:
recoil_mass = 0
print 'negative recoil mass squared'
else:
recoil_mass = math.sqrt(recoil_mass_square)
mass_diff = abs(recoil_mass - 91.2)
if mass_diff < min_mass_diff:
min_mass_diff = mass_diff
recoilmass = recoil_mass
if 80 < recoilmass < 110:
pos_mus.append(mu1)
neg_mus.append(mu2)
if len(pos_mus) < 1:
return False
self.counters['cut_flow'].inc('80 < recoil mass < 110')
if len(pos_mus) > 1:
min_mass_diff = 9999.9
id1 = -1
id2 = -1
for i in range(len(pos_mus)):
for j in range(len(neg_mus)):
mass_square = 2 * (pos_mus[i].e() *
neg_mus[j].e()) - 2 * numpy.dot(
pos_mus[i].p3(), neg_mus[j].p3())
if mass_square < 0:
print 'Negative mass squared'
break
else:
mass = math.sqrt(mass_square)
mass_diff = abs(mass - 125.1)
if mass_diff < min_mass_diff:
id1 = i
id2 = j
min_mass_diff = mass_diff
higgscandidates = (pos_mus[id1], neg_mus[id2])
else:
higgscandidates = (pos_mus[0], neg_mus[0])
visible_particle2 = [
ptc for ptc in particles
if ptc.pdgid() not in [12, -12, 14, -14, 16, -16]
]
visible_particle1 = [
ptc for ptc in visible_particle2 if ptc not in bremphotons
]
visible_particle = [
ptc for ptc in visible_particle1 if ptc not in higgscandidates
]
if len(visible_particle) < 2:
return False
self.counters['cut_flow'].inc('Two visible jets')
newparticles = [
ptc for ptc in particles
if ptc not in higgscandidates and ptc not in bremphotons
]
setattr(event, self.cfg_ana.newparticles, newparticles)
setattr(event, self.cfg_ana.higgscandidates, higgscandidates)
def process(self, event):
self.tree.reset()
gen_bs = getattr(event, self.cfg_ana.gen_bs)
gen_higgses = getattr(event, self.cfg_ana.gen_higgses)
gen_higgses.sort(key=lambda x: x.pt(), reverse=True)
gen_tops = getattr(event, self.cfg_ana.gen_tops)
gen_tops.sort(key=lambda x: x.pt(), reverse=True)
fatjets = getattr(event, self.cfg_ana.fatjets)
leptons = getattr(event, self.cfg_ana.selected_leptons)
bjets = event.selected_bs
for_jets = event.jets_nolepton
jets = event.jets_30
#_________________________________________________________________
# compute eflow, tau_ij and bdt variables
R = 1.5
use_DELPHES = False
jet_forTRF = []
jetin_forTRF = []
# fill jet collection to compute TRF -> use all jets
for j in for_jets:
ipdg = 0
if use_DELPHES == True:
ipdg = j.tags['flav']
if ipdg != 4 and ipdg != 5: ipdg = 0
else:
ipdg = j.flavour
jet_forTRF.append([j, ipdg])
for jet in fatjets:
setattr(jet, 'njs', 0)
setattr(jet, 'nbs', 0)
setattr(jet, 'ncs', 0)
setattr(jet, 'nls', 0)
setattr(jet, 'flow', [0] * 5)
setattr(jet, 'p4_js', TLorentzVector())
setattr(jet, 'p4_bs', TLorentzVector())
setattr(jet, 'tau32', -9.)
setattr(jet, 'tau31', -9.)
setattr(jet, 'tau21', -9.)
#setattr(jet, 'bdt_th', -99.)
if (jet.tau1 != 0.0):
jet.tau31 = jet.tau3 / jet.tau1
jet.tau21 = jet.tau2 / jet.tau1
if (jet.tau2 != 0.0):
jet.tau32 = jet.tau3 / jet.tau2
# counting the number of jets inside (R = 1.5 - 0.4 = 1.1) fatjet
for j in for_jets:
# fill different jets matched with fatjet
drjjet = deltaR(j, jet)
if drjjet < 1.1:
jet.njs += 1
jet.p4_js += j.p4()
# get pdgID to compute TRF
ipdg = 0
if use_DELPHES == True:
ipdg = j.tags['flav']
if ipdg != 4 and ipdg != 5: ipdg = 0
else:
ipdg = j.flavour
if ipdg == 5:
jet.nbs += 1
jet.p4_bs += j.p4()
elif ipdg == 4:
jet.ncs += 1
else:
jet.nls += 1
# do eflow with constituents here
constituent_vector = TLorentzVector()
#print jet.pt, jet.flow
for n in range(1, 5 + 1):
#print n
for constituent in jet.jetConstituents[1:]:
#print constituent.pt()
dR = jet.p4().DeltaR(constituent.p4())
if ((dR >= (n - 1) / 5. * R) and (dR < n / 5. * R)):
#print 'in ring', dR
jet.flow[n -
1] += abs(constituent.pt()) / abs(jet.pt())
#print jet.flow
## do what is needed to evaluate bdt here
#self.bdt_tau1 [0] = jet.tau1
#self.bdt_tau2 [0] = jet.tau2
#self.bdt_tau3 [0] = jet.tau3
#self.bdt_tau31 [0] = jet.tau31
#self.bdt_tau21 [0] = jet.tau21
#self.bdt_tau32 [0] = jet.tau32
#self.bdt_flow15 [0] = jet.flow[0]
#self.bdt_flow25 [0] = jet.flow[1]
#self.bdt_flow35 [0] = jet.flow[2]
#self.bdt_flow45 [0] = jet.flow[3]
#self.bdt_flow55 [0] = jet.flow[4]
#self.bdt_jet_m [0] = jet.p4().M()
#self.bdt_softDropped_jet_m [0] = jet.subjetsSoftDrop[0].p4().M()
#self.bdt_jet_nbs [0] = float(jet.nbs)
#
#jet.bdt_th = self.reader.EvaluateMVA("BDT")
# highest bdt score is more higgs like
#fatjets.sort(key=lambda x: x.bdt_th, reverse = True)
# 1/ highest number of jets in fatjet is more top like
fatjets.sort(key=lambda x: x.njs, reverse=True)
# 2/ lowest mass is more higgs like
if len(fatjets) > 1 and fatjets[0].njs == fatjets[1].njs:
fatjets.sort(key=lambda x: x.subjetsSoftDrop[0].p4().M(),
reverse=True)
if len(leptons) > 0 and len(fatjets) > 1:
self.tree.fill('weight', event.weight)
fillLepton(self.tree, 'l', leptons[0])
fillMet(self.tree, 'met', event.met)
self.tree.fill('nbjets', len(bjets))
# compute and fill TRF
self.tree.fill('weight_0tagex', getNbTagEx(0, jet_forTRF, -1))
self.tree.fill('weight_1tagex', getNbTagEx(1, jet_forTRF, -1))
self.tree.fill('weight_2tagex', getNbTagEx(2, jet_forTRF, -1))
self.tree.fill('weight_3tagex', getNbTagEx(3, jet_forTRF, -1))
self.tree.fill('weight_4tagex', getNbTagEx(4, jet_forTRF, -1))
'''higgsjet = fatjets[1]
if higgsjet.nbs > 1:
print higgsjet.p4_bs.M(), higgsjet.subjetsSoftDrop[0].p4().M()'''
for flavour in ['higgs', 'top']:
if flavour == 'higgs':
jet = fatjets[1]
else:
jet = fatjets[0]
fillParticle(self.tree, '{}jet'.format(flavour), jet)
fillParticle(self.tree, 'softDropped_{}jet'.format(flavour),
jet.subjetsSoftDrop[0])
self.tree.fill('{}jet_tau1'.format(flavour), jet.tau1)
self.tree.fill('{}jet_tau2'.format(flavour), jet.tau2)
self.tree.fill('{}jet_tau3'.format(flavour), jet.tau3)
self.tree.fill('{}jet_tau31'.format(flavour), jet.tau31)
self.tree.fill('{}jet_tau32'.format(flavour), jet.tau32)
self.tree.fill('{}jet_tau21'.format(flavour), jet.tau21)
#print 'filling: ',jet.flow[0], jet.flow[1], jet.flow[2], jet.flow[3], jet.flow[4]
self.tree.fill('{}jet_flow15'.format(flavour), jet.flow[0])
self.tree.fill('{}jet_flow25'.format(flavour), jet.flow[1])
self.tree.fill('{}jet_flow35'.format(flavour), jet.flow[2])
self.tree.fill('{}jet_flow45'.format(flavour), jet.flow[3])
self.tree.fill('{}jet_flow55'.format(flavour), jet.flow[4])
self.tree.fill('{}jet_njs'.format(flavour), jet.njs)
self.tree.fill('{}jet_nbs'.format(flavour), jet.nbs)
self.tree.fill('{}jet_ncs'.format(flavour), jet.ncs)
self.tree.fill('{}jet_nls'.format(flavour), jet.nls)
self.tree.fill('{}jet_mjs'.format(flavour), jet.p4_js.M())
self.tree.fill('{}jet_mbs'.format(flavour), jet.p4_bs.M())
##self.tree.fill('{}jet_bdt_th'.format(flavour), jet.bdt_th)
#Hjet = fatjets[1]
#tjet = fatjets[0]
#isHiggsOK = False
# 1/ 18/31 wrong
#if Hjet.nbs > tjet.nbs : isHiggsOK=True
#elif Hjet.nbs == tjet.nbs and Hjet.subjetsSoftDrop[0].p4().M() < tjet.subjetsSoftDrop[0].p4().M() : isHiggsOK=True
# 2/ 18/31 wrong
#if Hjet.nbs > 1 : # 3/ 14/15 wrong
# if Hjet.bdt_th > tjet.bdt_th : isHiggsOK=True
# if isHiggsOK==True : print "good match Higgs"
# else : print "wrong match Higgs"
self.tree.tree.Fill()
def process(self, event):
assumed_vertex = TVector3(0, 0, 0)
jets = getattr(event, self.cfg_ana.jets)
detector = self.cfg_ana.detector
pt_min = self.cfg_ana.pt_min
dxy_max = self.cfg_ana.dxy_max
dz_max = self.cfg_ana.dz_max
for jet in jets:
IP_b_LL = 0 # value of the log likelihood ratio based on IP initiated at 0
IPs_b_LL = 0 # value of the log likelihood ratio based on IP significance initiated at 0
ipsig_ptcs = [] # list of IP signif and associated ptcs
for id, ptcs in jet.constituents.iteritems():
if abs(id) in [22,130,11]:
continue
for ptc in ptcs :
if ptc.q() == 0 :
continue
ptc.path.compute_IP(assumed_vertex,jet)
ptc_IP_signif = 0
if hasattr(ptc.path, 'points') == True and 'beampipe_in' in ptc.path.points:
phi_in = ptc.path.phi(ptc.path.points['beampipe_in'].X(),\
ptc.path.points['beampipe_in'].Y())
phi_out= ptc.path.phi(ptc.path.points['beampipe_out'].X(),\
ptc.path.points['beampipe_out'].Y())
deltat = ptc.path.time_at_phi(phi_out)-ptc.path.time_at_phi(phi_in)
x = ptc.path.path_length(deltat)
X_0 = detector.elements['beampipe'].material.x0
ptc.path.compute_theta_0(x, X_0)
ptc.path.compute_IP_signif(ptc.path.IP,
ptc.path.theta_0,
ptc.path.points['beampipe_in'])
else :
ptc.path.compute_IP_signif(ptc.path.IP, None, None)
dx = ptc.path.IPcoord.x() - assumed_vertex.x()
dy = ptc.path.IPcoord.y() - assumed_vertex.y()
dz = ptc.path.IPcoord.z() - assumed_vertex.z()
if ptc.path.p4.Perp() > pt_min and (dx**2 + dy**2)**0.5 < dxy_max and dz**2 < dz_max**2 :
ipsig_ptcs.append([ptc.path.IP_signif, ptc])
if self.tag_IP_b_LL:
ptc.path.IP_b_LL = self.ll_tag(self.ratio_IP, ptc.path.IP,IP_b_LL )
if self.tag_IPs_b_LL:
ptc.path.IPs_b_LL = self.ll_tag(self.ratio_IPs, ptc.path.IP_signif, IPs_b_LL )
ipsig_ptcs.sort(reverse=True)
if len(ipsig_ptcs) < 2 :
TCHE = -99
TCHP = -99
TCHE_IP = -99
TCHP_IP = -99
TCHE_x = -99
TCHE_y = -99
TCHE_z = -99
TCHE_pt = -99
TCHE_dr = -99
if len(ipsig_ptcs) > 1 :
TCHE = ipsig_ptcs[1][0]
ptc = ipsig_ptcs[1][1]
TCHE_IP = ptc.path.IP
TCHE_x, TCHE_y, TCHE_z = ptc.path.coord_at_time(0)
TCHE_pt = ptc.path.p4.Perp()
TCHE_dr = deltaR(jet.eta(), jet.phi(), ptc.eta(), ptc.phi())
TCHP = -99
TCHP_IP = -99
if len(ipsig_ptcs) > 2 :
TCHP = ipsig_ptcs[2][0]
ptc = ipsig_ptcs[2][1]
TCHP_IP = ptc.path.IP
jet.tags['IP_b_LL'] = IP_b_LL if self.tag_IP_b_LL else None
jet.tags['IPs_b_LL']= IPs_b_LL if self.tag_IPs_b_LL else None
#TODO COLIN : create a BTagInfo class.
jet.tags['TCHE'] = TCHE
jet.tags['TCHP'] = TCHP
jet.tags['TCHE_IP'] = TCHE_IP
jet.tags['TCHP_IP'] = TCHP_IP
jet.tags['TCHE_x'] = TCHE_x
jet.tags['TCHE_y'] = TCHE_y
jet.tags['TCHE_z'] = TCHE_z
jet.tags['TCHE_xy'] = (TCHE_x**2+TCHE_y**2)**0.5
jet.tags['TCHE_pt'] = TCHE_pt
jet.tags['TCHE_dr'] = TCHE_dr
if hasattr(event, 'K0s') == True :
jet.tags['K0s'] = event.K0s
else :
jet.tags['K0s'] = -99
if hasattr(event, 'Kp') == True :
jet.tags['Kp'] = event.Kp
else :
jet.tags['Kp'] = -99
if hasattr(event, 'L0') == True :
jet.tags['L0'] = event.L0
else :
jet.tags['L0'] = -99
if hasattr(event, 'S0') == True :
jet.tags['S0'] = event.S0
else :
jet.tags['S0'] = -99
if hasattr(event, 'Sp') == True :
jet.tags['Sp'] = event.Sp
else :
jet.tags['Sp'] = -99
if hasattr(event, 'Sm') == True :
jet.tags['Sm'] = event.Sm
else :
jet.tags['Sm'] = -99
if hasattr(event, 'Muons') == True :
jet.tags['Muons'] = event.Muons
else :
jet.tags['Muons'] = -99
def process(self, event):
self.tree.reset()
gen_bs = getattr(event, self.cfg_ana.gen_bs)
gen_higgses = getattr(event, self.cfg_ana.gen_higgses)
gen_higgses.sort(key=lambda x: x.pt(), reverse=True)
gen_tops = getattr(event, self.cfg_ana.gen_tops)
gen_tops.sort(key=lambda x: x.pt(), reverse=True)
fatjets = getattr(event, self.cfg_ana.fatjets)
leptons = getattr(event, self.cfg_ana.selected_leptons)
bjets = event.selected_bs
jets = event.jets_30
#_________________________________________________________________
# compute eflow, tau_ij and bdt variables
R = 1.5
for jet in fatjets:
setattr(jet, 'nbs', 0)
setattr(jet, 'flow', [0] * 5)
setattr(jet, 'p4_bs', TLorentzVector())
setattr(jet, 'tau32', -9.)
setattr(jet, 'tau31', -9.)
setattr(jet, 'tau21', -9.)
setattr(jet, 'bdt_th', -99.)
if (jet.tau1 != 0.0):
jet.tau31 = jet.tau3 / jet.tau1
jet.tau21 = jet.tau2 / jet.tau1
if (jet.tau2 != 0.0):
jet.tau32 = jet.tau3 / jet.tau2
# counting the number of bjets inside (R = 1.5 - 0.4 = 1.1) fatjet
for b in bjets:
#print b.flavour
drjb = deltaR(b, jet)
if drjb < 1.1:
jet.nbs += 1
jet.p4_bs += b.p4()
# do eflow with constituents here
constituent_vector = TLorentzVector()
#print jet.pt, jet.flow
for n in range(1, 5 + 1):
#print n
for constituent in jet.jetConstituents[1:]:
#print constituent.pt()
dR = jet.p4().DeltaR(constituent.p4())
if ((dR >= (n - 1) / 5. * R) and (dR < n / 5. * R)):
#print 'in ring', dR
jet.flow[n -
1] += abs(constituent.pt()) / abs(jet.pt())
#print jet.flow
# do what is needed to evaluate bdt here
self.bdt_tau1[0] = jet.tau1
self.bdt_tau2[0] = jet.tau2
self.bdt_tau3[0] = jet.tau3
self.bdt_tau31[0] = jet.tau31
self.bdt_tau21[0] = jet.tau21
self.bdt_tau32[0] = jet.tau32
self.bdt_flow15[0] = jet.flow[0]
self.bdt_flow25[0] = jet.flow[1]
self.bdt_flow35[0] = jet.flow[2]
self.bdt_flow45[0] = jet.flow[3]
self.bdt_flow55[0] = jet.flow[4]
self.bdt_jet_m[0] = jet.p4().M()
self.bdt_softDropped_jet_m[0] = jet.subjetsSoftDrop[0].p4().M()
self.bdt_jet_nbs[0] = float(jet.nbs)
jet.bdt_th = self.reader.EvaluateMVA("BDT")
# highest bdt score is more higgs like
fatjets.sort(key=lambda x: x.bdt_th, reverse=True)
#print '--------------- new event --------------------------------'
if len(leptons) > 0 and len(fatjets) > 1:
self.tree.fill('weight', event.weight)
fillLepton(self.tree, 'l', leptons[0])
fillMet(self.tree, 'met', event.met)
self.tree.fill('nbjets', len(bjets))
'''higgsjet = fatjets[1]
if higgsjet.nbs > 1:
print higgsjet.p4_bs.M(), higgsjet.subjetsSoftDrop[0].p4().M()'''
for flavour in ['higgs', 'top']:
if flavour == 'higgs':
jet = fatjets[1]
else:
jet = fatjets[0]
fillParticle(self.tree, '{}jet'.format(flavour), jet)
fillParticle(self.tree, 'softDropped_{}jet'.format(flavour),
jet.subjetsSoftDrop[0])
self.tree.fill('{}jet_tau1'.format(flavour), jet.tau1)
self.tree.fill('{}jet_tau2'.format(flavour), jet.tau2)
self.tree.fill('{}jet_tau3'.format(flavour), jet.tau3)
self.tree.fill('{}jet_tau31'.format(flavour), jet.tau31)
self.tree.fill('{}jet_tau32'.format(flavour), jet.tau32)
self.tree.fill('{}jet_tau21'.format(flavour), jet.tau21)
#print 'filling: ',jet.flow[0], jet.flow[1], jet.flow[2], jet.flow[3], jet.flow[4]
self.tree.fill('{}jet_flow15'.format(flavour), jet.flow[0])
self.tree.fill('{}jet_flow25'.format(flavour), jet.flow[1])
self.tree.fill('{}jet_flow35'.format(flavour), jet.flow[2])
self.tree.fill('{}jet_flow45'.format(flavour), jet.flow[3])
self.tree.fill('{}jet_flow55'.format(flavour), jet.flow[4])
self.tree.fill('{}jet_nbs'.format(flavour), jet.nbs)
self.tree.fill('{}jet_mbs'.format(flavour), jet.p4_bs.M())
self.tree.fill('{}jet_bdt_th'.format(flavour), jet.bdt_th)
self.tree.tree.Fill()
def ecal_hcal(self, ele1, ele2):
#TODO eta or theta?
dR = deltaR(ele1.position.Theta(), ele1.position.Phi(),
ele2.position.Theta(), ele2.position.Phi())
link_ok = dR < ele1.angular_size() + ele2.angular_size()
return ('ecal_in', 'hcal_in'), link_ok, dR
def process(self, event):
self.treeS.reset()
self.treeB.reset()
gen_bs = getattr(event, self.cfg_ana.gen_bs)
gen_higgses = getattr(event, self.cfg_ana.gen_higgses)
gen_higgses.sort(key=lambda x: x.pt(), reverse = True)
gen_tops = getattr(event, self.cfg_ana.gen_tops)
gen_tops.sort(key=lambda x: x.pt(), reverse = True)
jets = getattr(event, self.cfg_ana.fatjets)
leptons = getattr(event, self.cfg_ana.selected_leptons)
bjets = event.selected_bs
if len(gen_higgses) > 1:
hh_gen = Resonance(gen_higgses[0], gen_higgses[1], 25)
ljets = []
#_________________________________________________________________
# count number of bjets inside jet
for jet in jets:
is_light = True
setattr(jet, 'nbs', 0)
for b in bjets:
drjb = deltaR(b, jet)
if drjb < 1.5:
jet.nbs += 1
#_________________________________________________________________
# compute eflow variables
R = 1.5
for jet in jets:
setattr(jet, 'flow', [0]*5)
constituent_vector = TLorentzVector()
#print jet.pt, jet.flow
for n in range(1,5+1):
#print n
for constituent in jet.jetConstituents[1:]:
#print constituent.pt()
dR = jet.p4().DeltaR(constituent.p4())
if ((dR >= (n-1)/5.*R) and (dR < n/5.*R)):
#print 'in ring', dR
jet.flow[n-1] += abs(constituent.pt())/abs(jet.pt())
#print '--------------- new event --------------------------------'
if len(leptons) > 0 and len(jets) > 1:
#print len(jets), len(leptons)
#print deltaR(jets[0], leptons[0]), deltaR(jets[1], leptons[0])
selected_higgs_jets = []
selected_top_jets = []
# to decide wheather top or higgs jet will be done with MVA
# for now just cheat by checking MC truth
for jet in jets:
drmin_h = 999.
drmin_t = 999.
for higgs in gen_higgses:
drjh = deltaR(higgs, jet)
if drjh < drmin_h:
drmin_h = drjh
for top in gen_tops:
drjt = deltaR(top, jet)
if drjt < drmin_t:
drmin_t = drjt
if drmin_h < drmin_t and drmin_h < 1.0:
selected_higgs_jets.append(jet)
elif drmin_t < drmin_h and drmin_t < 1.0:
selected_top_jets.append(jet)
if len(selected_higgs_jets) > 0 and len(selected_top_jets) > 0 :
for tree in [self.treeS, self.treeB]:
if tree == self.treeS:
jet = selected_higgs_jets[0]
else:
jet = selected_top_jets[0]
fillParticle(tree, 'jet', jet)
fillParticle(tree, 'softDropped_jet', jet.subjetsSoftDrop[0])
tree.fill('jet_tau1' , jet.tau1 )
tree.fill('jet_tau2' , jet.tau2 )
tree.fill('jet_tau3' , jet.tau3 )
jet_tau31 = -9.0
jet_tau21 = -9.0
jet_tau32 = -9.0
if (jet.tau1 != 0.0):
jet_tau31 = jet.tau3/jet.tau1
jet_tau21 = jet.tau2/jet.tau1
if (jet.tau2 != 0.0):
jet_tau32 = jet.tau3/jet.tau2
tree.fill('jet_tau31' , jet_tau31 )
tree.fill('jet_tau32' , jet_tau32 )
tree.fill('jet_tau21' , jet_tau21 )
#print 'filling: ',jet.flow[0], jet.flow[1], jet.flow[2], jet.flow[3], jet.flow[4]
tree.fill('jet_flow15', jet.flow[0])
tree.fill('jet_flow25', jet.flow[1])
tree.fill('jet_flow35', jet.flow[2])
tree.fill('jet_flow45', jet.flow[3])
tree.fill('jet_flow55', jet.flow[4])
tree.fill('jet_nbs', jet.nbs)
tree.tree.Fill()
def process(self, event):
self.tree.reset()
htatas = getattr(event, self.cfg_ana.htatas)
hbbs = getattr(event, self.cfg_ana.hbbs)
met = event.met
htatas.sort(key=lambda x: abs(x.m() - 125.))
hbbs.sort(key=lambda x: abs(x.m() - 125.))
bs = event.selected_bs
taus = event.selected_taus
lights = event.selected_lights
leptons = event.selected_leptons
#print '-------------------'
#print len(htatas), len(hbbs)
#print len(taus), len(bs)
#for tau in taus:
# print tau.charge
#print ROOT.return2()
#f = Foo()
#f.bar() #and you will see "Hello" on the screen
'''
mVisA = 10.; # mass of visible object on side A. Must be >=0.
pxA = 20.; # x momentum of visible object on side A.
pyA = 30.; # y momentum of visible object on side A.
mVisB = 10.; # mass of visible object on side B. Must be >=0.
pxB = -20.; # x momentum of visible object on side B.
pyB = -30.; # y momentum of visible object on side B.
pxMiss = -5.; # x component of missing transverse momentum.
pyMiss = -5.; # y component of missing transverse momentum.
chiA = 4.; # hypothesised mass of invisible on side A. Must be >=0.
chiB = 7.; # hypothesised mass of invisible on side B. Must be >=0.
desiredPrecisionOnMt2 = 0.; # Must be >=0. If 0 alg aims for machine precision. if >0, MT2 computed to supplied absolute precision.
useDeciSectionsInitially=True
asymm_mt2 = asymm_mt2_lester_bisect()
print '-----------------------------------------'
MT2 = asymm_mt2.get_mT2(
mVisA, pxA, pyA,
mVisB, pxB, pyB,
pxMiss, pyMiss,
chiA, chiB,
desiredPrecisionOnMt2,
useDeciSectionsInitially)
print 'MT2', MT2
'''
# fully hadronic selection
if len(taus) > 1 and len(bs) > 1 and len(leptons) == 0:
self.tree.fill('weight', event.weight)
#print event.weight
fillParticle(self.tree, 'ta1', taus[0])
fillParticle(self.tree, 'ta2', taus[1])
fillParticle(self.tree, 'b1', bs[0])
fillParticle(self.tree, 'b2', bs[1])
'''
def mTsq(bT, cT, mB, mC):
eB = math.sqrt(mB*mB+ bT*bT)
eC = math.sqrt(mC*mC+ cT*cT)
return mB*mB+mC*mC+2*(eB*eC - bT*cT)
def smT2(bt1, bt2):
return max(math.sqrt(bt1),math.sqrt(bt2))
mTsq1 = mTsq(taus[0].p4().Vect().XYvector(), bs[0].p4().Vect().XYvector(), taus[0].p4().M(), bs[0].p4().M())
mTsq2 = mTsq(taus[1].p4().Vect().XYvector(), bs[1].p4().Vect().XYvector(), taus[1].p4().M(), bs[1].p4().M())
smTsq = smT2(mTsq1, mTsq2)
#print mTsq1, mTsq2, smTsq
'''
mVisA = bs[0].p4().M()
# mass of visible object on side A. Must be >=0.
pxA = bs[0].p4().Px()
# x momentum of visible object on side A.
pyA = bs[0].p4().Py()
# y momentum of visible object on side A.
mVisB = bs[1].p4().M()
# mass of visible object on side A. Must be >=0.
pxB = bs[1].p4().Px()
# x momentum of visible object on side A.
pyB = bs[1].p4().Py()
# y momentum of visible object on side A.
pxMiss = taus[0].p4().Px() + taus[1].p4().Px() + met.p4().Px(
) # x component of missing transverse momentum.
pyMiss = taus[0].p4().Py() + taus[1].p4().Py() + met.p4().Py(
) # x component of missing transverse momentum.
chiA = taus[0].p4().M()
# hypothesised mass of invisible on side A. Must be >=0.
chiB = taus[1].p4().M()
# hypothesised mass of invisible on side B. Must be >=0.
desiredPrecisionOnMt2 = 0.
# Must be >=0. If 0 alg aims for machine precision. if >0, MT2 computed to supplied absolute precision.
useDeciSectionsInitially = True
asymm_mt2 = asymm_mt2_lester_bisect()
MT2 = asymm_mt2.get_mT2(mVisA, pxA, pyA, mVisB, pxB, pyB, pxMiss,
pyMiss, chiA, chiB, desiredPrecisionOnMt2,
useDeciSectionsInitially)
#print 'MT2', MT2
self.tree.fill('mT2', MT2)
if len(lights) > 0:
fillParticle(self.tree, 'j1', lights[0])
if len(lights) > 1:
fillParticle(self.tree, 'j2', lights[1])
def computeMT(taup4, metp4):
scalar_prod = taup4.Px() * metp4.Px() + taup4.Py() * metp4.Py()
return math.sqrt(2 * (taup4.Pt() * metp4.Pt() - scalar_prod))
mt1 = computeMT(taus[0].p4(), met.p4())
mt2 = computeMT(taus[1].p4(), met.p4())
self.tree.fill('ta1_mt', mt1)
self.tree.fill('ta2_mt', mt2)
st = taus[0].p4().Pt() + taus[1].p4().Pt() + bs[0].p4().Pt(
) + bs[0].p4().Pt() + met.p4().Pt()
self.tree.fill('sT', st)
fillMet(self.tree, 'met', met)
fillParticle(self.tree, 'htata', htatas[0])
fillParticle(self.tree, 'hbb', hbbs[0])
htata_metcorr_p4 = taus[0].p4() + taus[1].p4() + met.p4()
htata_metcorr = Particle(25, 0, htata_metcorr_p4, 1)
fillParticle(self.tree, 'htata_metcorr', htata_metcorr)
hh = Resonance(htatas[0], hbbs[0], 25)
hh_metcorr = Resonance(htata_metcorr, hbbs[0], 25)
fillParticle(self.tree, 'hh', hh)
fillParticle(self.tree, 'hh_metcorr', hh_metcorr)
self.tree.fill('nbjets', len(event.selected_bs))
self.tree.fill('nljets', len(event.selected_lights))
self.tree.fill(
'njets',
len(event.selected_lights) + len(event.selected_bs) +
len(event.selected_taus))
self.tree.fill('nlep', len(event.selected_leptons))
self.tree.fill('ntajets', len(event.selected_taus))
drbb = deltaR(bs[0], bs[1])
drtata = deltaR(taus[0], taus[1])
self.tree.fill('drtata', drtata)
self.tree.fill('drbb', drbb)
# here fill all variables for BDT
self.bdt_ta1_pt[0] = taus[0].p4().Pt()
self.bdt_ta1_eta[0] = taus[0].p4().Eta()
self.bdt_ta1_phi[0] = taus[0].p4().Phi()
self.bdt_ta2_pt[0] = taus[1].p4().Pt()
self.bdt_ta2_eta[0] = taus[1].p4().Eta()
self.bdt_ta2_phi[0] = taus[1].p4().Phi()
self.bdt_b1_pt[0] = bs[0].p4().Pt()
self.bdt_b1_eta[0] = bs[0].p4().Eta()
self.bdt_b1_phi[0] = bs[0].p4().Phi()
self.bdt_b2_pt[0] = bs[1].p4().Pt()
self.bdt_b2_eta[0] = bs[1].p4().Eta()
self.bdt_b2_phi[0] = bs[1].p4().Phi()
self.bdt_met_pt[0] = met.p4().Pt()
self.bdt_met_phi[0] = met.p4().Phi()
self.bdt_met_px[0] = met.p4().Px()
self.bdt_met_py[0] = met.p4().Py()
self.bdt_htata_pt[0] = htatas[0].p4().Pt()
self.bdt_htata_eta[0] = htatas[0].p4().Eta()
self.bdt_htata_phi[0] = htatas[0].p4().Phi()
self.bdt_htata_m[0] = htatas[0].p4().M()
self.bdt_hbb_pt[0] = hbbs[0].p4().Pt()
self.bdt_hbb_eta[0] = hbbs[0].p4().Eta()
self.bdt_hbb_phi[0] = hbbs[0].p4().Phi()
self.bdt_hbb_m[0] = hbbs[0].p4().M()
self.bdt_hh_pt[0] = hh.p4().Pt()
self.bdt_hh_eta[0] = hh.p4().Eta()
self.bdt_hh_phi[0] = hh.p4().Phi()
self.bdt_hh_m[0] = hh.p4().M()
self.bdt_ta1_mt[0] = mt1
self.bdt_ta2_mt[0] = mt2
self.bdt_mT2[0] = MT2
self.bdt_sT[0] = st
self.bdt_njets[0] = len(event.selected_lights) + len(
event.selected_bs) + len(event.selected_taus)
self.bdt_nbjets[0] = len(event.selected_bs)
self.bdt_ntajets[0] = len(event.selected_taus)
#self.bdt_nlep [0] = len(event.selected_leptons)
#print MT2, ",", s ,",", len(event.selected_lights) + len(event.selected_bs) + len(event.selected_taus), ",", len(event.selected_bs) ,",", len(event.selected_taus) ,",", len(event.selected_leptons)t
mva_value = self.reader.EvaluateMVA("BDT")
#print mva_value
self.tree.fill('tmva_bdt', mva_value)
self.tree.tree.Fill()
def process(self, event):
self.tree.reset()
gen_bs = getattr(event, self.cfg_ana.gen_bs)
gen_higgses = getattr(event, self.cfg_ana.gen_higgses)
gen_higgses.sort(key=lambda x: x.pt(), reverse=True)
jets = getattr(event, self.cfg_ana.fatjets)
if len(gen_higgses) > 1:
hh_gen = Resonance(gen_higgses[0], gen_higgses[1], 25)
bjets = []
ljets = []
# do b-tagging on the fly ...
for jet in jets:
is_light = True
for b in gen_bs:
drjb = deltaR(b, jet)
if drjb < 0.8:
is_light = False
if is_light:
ljets.append(jet)
else:
bjets.append(jet)
bjets.sort(key=lambda x: x.pt(), reverse=True)
ljets.sort(key=lambda x: x.pt(), reverse=True)
#if (len(ljets)>0 and len(bjets)>1):
if len(bjets) > 1:
hh = Resonance(bjets[0], bjets[1], 25)
if hh.pt() > 250.:
#self.tree.fill('weight' , event.weight )
weight = (0.70**4) * event.weight
self.tree.fill('weight', weight)
self.tree.fill('nljets', len(ljets))
self.tree.fill('njets', len(jets))
self.tree.fill('nbjets', len(bjets))
fillParticle(self.tree, 'bJet1', bjets[0])
fillParticle(self.tree, 'bJet2', bjets[1])
fillParticle(self.tree, 'softDropped_bJet1',
bjets[0].subjetsSoftDrop[0])
fillParticle(self.tree, 'softDropped_bJet2',
bjets[1].subjetsSoftDrop[0])
fillParticle(self.tree, 'hh', hh)
self.tree.fill('drhh', deltaR(bjets[0], bjets[1]))
self.tree.fill('dPtRel',
abs(bjets[0].pt() - bjets[1].pt()) / hh.pt())
if (bjets[0].tau1 != 0.0):
self.tree.fill('bJet1_tau21',
bjets[0].tau2 / bjets[0].tau1)
else:
self.tree.fill('bJet1_tau21', -99)
if (bjets[1].tau1 != 0.0):
self.tree.fill('bJet2_tau21',
bjets[1].tau2 / bjets[1].tau1)
else:
self.tree.fill('bJet2_tau21', -99)
if len(ljets) > 0:
fillParticle(self.tree, 'lJet1', ljets[0])
fillParticle(self.tree, 'softDropped_lJet1',
ljets[0].subjetsSoftDrop[0])
if (ljets[0].tau1 != 0.0):
self.tree.fill('lJet1_tau21',
ljets[0].tau2 / ljets[0].tau1)
else:
self.tree.fill('lJet1_tau21', -99)
if len(bjets) > 2:
fillParticle(self.tree, 'bJet3', bjets[2])
fillParticle(self.tree, 'softDropped_bJet3',
bjets[2].subjetsSoftDrop[0])
if (bjets[2].tau1 != 0.0):
self.tree.fill('bJet3_tau21',
bjets[2].tau2 / bjets[2].tau1)
else:
self.tree.fill('bJet3_tau21', -99)
if len(ljets) > 1:
fillParticle(self.tree, 'lJet2', ljets[1])
fillParticle(self.tree, 'softDropped_lJet1',
ljets[1].subjetsSoftDrop[0])
if (ljets[1].tau1 != 0.0):
self.tree.fill('lJet2_tau21',
ljets[1].tau2 / ljets[1].tau1)
else:
self.tree.fill('lJet2_tau21', -99)
if len(gen_higgses) > 1:
hh_gen = Resonance(gen_higgses[0], gen_higgses[1], 25)
fillParticle(self.tree, 'hh_gen', hh_gen)
self.tree.tree.Fill()
