def find_jet_pair(tree):
# Find a pair of two tau jets
jets = tree.jets
tau_tags = tree.tauTags
pair = None
n_jets = len(jets)
for i in range(n_jets - 1):
if tau_tags[i].tag < 0.5:
continue
vector1 = utils.get_lorentz_vector(jets[i])
if not check_deltaR(vector1, tree):
continue
if not utils.check_pt(vector1, 15):
continue
for j in range(i + 1, n_jets):
if tau_tags[j].tag < 0.5:
continue
vector2 = utils.get_lorentz_vector(jets[j])
if not check_deltaR(vector2, tree):
continue
if not utils.check_pt(vector2, 15):
continue
pair = {
jets[i]: vector1,
jets[j]: vector2
}
return pair
def match_neutrino(self, neutrino):
# Match a tau neutrino to a generator level tau particle
if self.gen_tau.core.pdgId * neutrino.core.pdgId > 0:
self.gen_neutrino = neutrino
self.gen_vector = utils.get_lorentz_vector(self.gen_tau) - utils.get_lorentz_vector(neutrino)
return True
return False
def get_tau_collection(tree):
# get data from tree
jets = tree.jets
tau_tags = tree.tauTags
gen_particles = tree.skimmedGenParticles
tau_collection = []
# loop through reconstructed jets
for i in range(len(jets)):
curr_set = {}
# select only tau-tagged jets
if tau_tags[i].tag < 0.5:
continue
# get lorentz vector of selected jet
vector = utils.get_lorentz_vector(jets[i])
# find a matching generator tau particle for reconstructed jet
for particle in gen_particles:
# select only taus
pdg = particle.core.pdgId
if abs(pdg) == 15:
# find delta R of tau jet w.r.t generated tau
deltaR = vector.DeltaR(utils.get_lorentz_vector(particle))
# select generated tau with small delta R
if deltaR < 0.05:
curr_set = {
'gen': particle,
'rec': jets[i],
'rec_vector': vector
}
break
# find corresponding neutrino for gen tau
if curr_set:
for particle in gen_particles:
# select only tau neutrinos
pdg = particle.core.pdgId
if abs(pdg) == 16:
# check if charges match
if pdg * curr_set['gen'].core.pdgId > 0:
curr_set.update({'gen_neutrino': particle})
# add found set into collection
tau_collection.append(curr_set)
else:
print(
'Reconstructed tau jet found with no matching generator tau particle'
)
return tau_collection
def find_muon_pair_nofilter(tree):
# Find a pair of two oppositely charged muons (legacy TLorentzVector)
muons = tree.muons
pair = None
n_mu = len(muons)
for i in range(n_mu - 1):
vector1 = utils.get_lorentz_vector(muons[i])
ch1 = muons[i].core.charge
for j in range(i + 1, n_mu):
vector2 = utils.get_lorentz_vector(muons[j])
ch2 = muons[j].core.charge
if ch1 * ch2 < 0:
pair = {muons[i]: vector1, muons[j]: vector2}
return pair
def get_particle_cone(tree, lorentz_vector, cone_size):
gen_particles = tree.genParticles
cone_particles = {}
# loop through all generator particles
for gen_particle in gen_particles:
gen_vector = utils.get_lorentz_vector(gen_particle)
# pdg = gen_particle.core.pdgId
status = gen_particle.core.status
# check if particle is stable
if status != 1:
continue
# find delta R w.r.t given lorentz vector
deltaR = lorentz_vector.DeltaR(gen_vector)
# if pdg in [11, 12, -11, -12]:
# print('Found ', pdg, ' with delta R ', deltaR, ' and energy ', gen_vector.E())
# compare delta R to given cone size
if deltaR < cone_size:
cone_particles.update({gen_particle: gen_vector})
return cone_particles
def check_deltaR(vector, tree):
# compares delta R w.r.t. MC taus
mc_particles = tree.skimmedGenParticles
for particle in mc_particles:
pdg = particle.core.pdgId
if abs(pdg) == 15:
deltaR = vector.DeltaR(utils.get_lorentz_vector(particle))
if deltaR < 0.05:
return True
return False
def get_jetparts(tree, jet):
vectors = []
jetparts = tree.jetParts
begin = jet.particles_begin
end = jet.particles_end
for jetpart in jetparts[begin:end]:
vectors.append(utils.get_lorentz_vector(jetpart))
return vectors
def match_reconstruction(self, jet):
# Match a reconstructed tau jet to a generator level tau
if self.rec_taujet:
return False
vector = utils.get_lorentz_vector(jet)
deltaR = self.gen_vector.DeltaR(vector)
if deltaR < 0.05:
self.rec_taujet = jet
self.rec_vector = vector
return True
return False
def missing_energy(tree):
# finds neutrinos from MC particles
mc_particles = tree.skimmedGenParticles
neutrinos = {}
for particle in mc_particles:
pdg = particle.core.pdgId
if abs(pdg) in [12, 14, 16]:
# print(pdg, end=':')
# print(particle.core.status, end=' ')
neutrinos.update({particle: utils.get_lorentz_vector(particle)})
# print('\n', end='')
return neutrinos
def find_muon_pair(tree):
# Find a pair of two oppositely charged muons
muons = tree.muons
pair = None
n_mu = len(muons)
for i in range(n_mu - 1):
vector1 = utils.get_lorentz_vector(muons[i])
if not utils.check_pt(vector1, 15):
continue
if not check_isolation(tree, i):
continue
ch1 = muons[i].core.charge
for j in range(i + 1, n_mu):
vector2 = utils.get_lorentz_vector(muons[j])
if not utils.check_pt(vector2, 15):
continue
if not check_isolation(tree, j):
continue
ch2 = muons[j].core.charge
if ch1 * ch2 < 0:
pair = {muons[i]: vector1, muons[j]: vector2}
return pair
def get_gen_taus(tree):
gen_particles = tree.genParticles
taus = []
# loop through generator particles
for particle in gen_particles:
pdg = particle.core.pdgId
status = particle.core.status
# find taus
if abs(pdg) == 15 and status == 2:
vector = utils.get_lorentz_vector(particle)
taus.append(vector)
# print('Found tau: ', pdg, ' with energy ', vector.E())
return taus
n_tot = tree.GetEntries()
for event in range(n_tot):
tree.GetEntry(event)
# get tau tagged jets
tau_jets = []
jets = tree.jets
tags = tree.tauTags
n_jets = len(jets)
for i in range(n_jets):
if tags[i].tag > 0:
tau_jets.append(jets[i])
# get MC taus
mc_taus = []
mc_particles = tree.skimmedGenParticles
for particle in mc_particles:
pdg = particle.core.pdgId
if abs(pdg) == 15:
mc_taus.append(particle)
# compare tau tagged jets to MC taus
for tau_jet in tau_jets:
jet_vector = utils.get_lorentz_vector(tau_jet)
for mc_tau in mc_taus:
mc_vector = utils.get_lorentz_vector(mc_tau)
histogram.Fill(jet_vector.DeltaR(mc_vector))
# write to file
outf.Write()
def get_gen_tau_mass(tau_set):
tau_vector = utils.get_lorentz_vector(tau_set['gen'])
neutrino_vector = utils.get_lorentz_vector(tau_set['gen_neutrino'])
jet_vector = tau_vector - neutrino_vector
mass = jet_vector.M()
return mass
def get_gen_tau_energy(tau_set):
tau_vector = utils.get_lorentz_vector(tau_set['gen'])
neutrino_vector = utils.get_lorentz_vector(tau_set['gen_neutrino'])
jet_vector = tau_vector - neutrino_vector
energy = jet_vector.E()
return energy
def visible_pt(self):
# Return the visible pT of a generator tau
if not self.gen_tau:
return None
vector = utils.get_lorentz_vector(self.gen_tau)
return utils.get_pt(vector)
def create_rec_tau(self, taujet):
# Create a reconstructed tau jet
self.rec_taujet = taujet
self.rec_vector = utils.get_lorentz_vector(taujet)
def create_gen_tau(self, tau):
# Create a generator level tau
self.gen_tau = tau
self.gen_vector = utils.get_lorentz_vector(tau)