def fill_emb_3(self, iev, jm):
# pdebug('@fill: jm[0]', jm[0], 'jm[1]', jm[1], 'jm[2]', jm[2])
self.twh.fill_branch('iev', iev)
self.twh.fill_branch('det', jm[0])
self.twh.fill_branch('part', jm[1])
self.twh.fill_branch('hybr', jm[2])
self.twh.fill_branch('dpt_pp', jm[0].pt() - jm[1].pt())
self.twh.fill_branch('dpt_emb', jm[2].pt() - jm[0].pt())
self.twh.fill_branch('dR_pp', jm[0].delta_R(jm[1]))
self.twh.fill_branch('dR_emb', jm[0].delta_R(jm[2]))
sd0 = self.sd.result(jm[0])
self.twh.fill_branch('sd_det', sd0)
sd0_pe1 = fj.PseudoJet()
sd0_pe2 = fj.PseudoJet()
sd0_has_parents = sd0.has_parents(sd0_pe1, sd0_pe2)
self.twh.fill_branch('sd_det_p1', sd0_pe1)
self.twh.fill_branch('sd_det_p2', sd0_pe2)
sdi0 = fjcontrib.get_SD_jet_info(sd0)
self.twh.fill_branch('sd_det_zg', sdi0.z)
self.twh.fill_branch('sd_det_Rg', sdi0.dR)
sd1 = self.sd.result(jm[1])
self.twh.fill_branch('sd_part', sd1)
sd1_pe1 = fj.PseudoJet()
sd1_pe2 = fj.PseudoJet()
sd1_has_parents = sd1.has_parents(sd1_pe1, sd1_pe2)
self.twh.fill_branch('sd_part_p1', sd1_pe1)
self.twh.fill_branch('sd_part_p2', sd1_pe2)
sdi1 = fjcontrib.get_SD_jet_info(sd1)
self.twh.fill_branch('sd_part_zg', sdi1.z)
self.twh.fill_branch('sd_part_Rg', sdi1.dR)
sd2 = self.sd.result(jm[2])
self.twh.fill_branch('sd_emb', sd2)
sd2_pe1 = fj.PseudoJet()
sd2_pe2 = fj.PseudoJet()
sd2_has_parents = sd2.has_parents(sd2_pe1, sd2_pe2)
self.twh.fill_branch('sd_emb_p1', sd2_pe1)
self.twh.fill_branch('sd_emb_p2', sd2_pe2)
sdi2 = fjcontrib.get_SD_jet_info(sd2)
self.twh.fill_branch('sd_emb_zg', sdi2.z)
self.twh.fill_branch('sd_emb_Rg', sdi2.dR)
m02_1 = -1
m02_2 = -1
if sd0_has_parents and sd2_has_parents:
m02_1 = fjtools.matched_pt(sd2_pe1, sd0_pe1)
m02_2 = fjtools.matched_pt(sd2_pe2, sd0_pe2)
self.twh.fill_branch('sd_det_emb_mpt1', m02_1)
self.twh.fill_branch('sd_det_emb_mpt2', m02_2)
self.twh.fill_branch('sd_det_split', sd0_has_parents)
self.twh.fill_branch('sd_part_split', sd1_has_parents)
self.twh.fill_branch('sd_emb_split', sd2_has_parents)
self.twh.fill_tree()
def fill_groomers_matched(self, tw, grd_pp, grd_emb, sdescr):
tw.fill_branch(sdescr + '_pp', grd_pp)
tw.fill_branch(sdescr + '_emb', grd_emb)
tw.fill_branch(sdescr + '_dRppemb',
grd_emb.pair().delta_R(grd_pp.pair()))
harder_pt_match = -1
softer_pt_match = -1
if grd_pp.pair().perp() > 0 and grd_emb.pair().perp() > 0:
harder_pt_match = fjtools.matched_pt(grd_emb.harder(),
grd_pp.harder())
softer_pt_match = fjtools.matched_pt(grd_emb.softer(),
grd_pp.softer())
tw.fill_branch(sdescr + '_mpt1', harder_pt_match)
tw.fill_branch(sdescr + '_mpt2', softer_pt_match)
def matched(j1, j2):
# j2i = fjtools.matched_Ry(j1, j2)
mpt = fjtools.matched_pt(j1, j2)
if mpt > 0.5:
return True, j1, j2, fjext.lambda_beta_kappa(
j1, 1.0, 1.0, 1.0), fjext.lambda_beta_kappa(j2, 1.0, 1.0, 1.0)
return False
def fill_subjet_matched_pt_histograms(self, observable, subjet_det, subjet_truth,
z_det, z_truth, jet_pt_truth, jetR, subjetR, R_max):
# Get pp det-level subjet
# Inclusive case: This is matched to the combined subjet (and its pp truth-level subjet)
# Leading case: This is matched only to the pp truth-level leading subjet
subjet_pp_det = None
if subjet_truth.has_user_info():
subjet_pp_det = subjet_truth.python_info().match
if not subjet_pp_det:
return
matched_pt = fjtools.matched_pt(subjet_det, subjet_pp_det)
name = 'h_{}_matched_pt_JetPt_R{}_{}_Rmax{}'.format(observable, jetR, subjetR, R_max)
getattr(self, name).Fill(jet_pt_truth, z_det, matched_pt)
# Plot dz between det and truth subjets
deltaZ = z_det - z_truth
name = 'h_{}_matched_pt_deltaZ_JetPt_R{}_{}_Rmax{}'.format(observable, jetR, subjetR, R_max)
getattr(self, name).Fill(jet_pt_truth, matched_pt, deltaZ)
# Plot dR between det and truth subjets
deltaR = subjet_det.delta_R(subjet_truth)
name = 'h_{}_matched_pt_deltaR_JetPt_R{}_{}_Rmax{}'.format(observable, jetR, subjetR, R_max)
getattr(self, name).Fill(jet_pt_truth, matched_pt, deltaR)
match = (matched_pt > 0.5)
return match
def fill_matched(j1s, j2s, tj_no_pup, tj_pup, tj_delta, jet_R0):
for j1 in j1s:
tj_no_pup.Fill(j1.perp(), j1.eta(), j1.phi(),
fjext.lambda_beta_kappa(j1, 1.0, 1.0, jet_R0),
fjext.lambda_beta_kappa(j1, 2.0, 1.0, jet_R0),
fjext.lambda_beta_kappa(j1, 3.0, 1.0, jet_R0))
for j2 in j2s:
mpt = fjtools.matched_pt(j1, j2)
tj_delta.Fill(j1.perp(), j1.eta(), j1.phi(),
fjext.lambda_beta_kappa(j1, 1.0, 1.0, jet_R0),
fjext.lambda_beta_kappa(j1, 2.0, 1.0, jet_R0),
fjext.lambda_beta_kappa(j1, 3.0, 1.0, jet_R0),
j2.perp(), j2.eta(), j2.phi(),
fjext.lambda_beta_kappa(j2, 1.0, 1.0, jet_R0),
fjext.lambda_beta_kappa(j2, 2.0, 1.0, jet_R0),
fjext.lambda_beta_kappa(j2, 3.0, 1.0, jet_R0), mpt)
for j1 in j2s:
tj_pup.Fill(j1.perp(), j1.eta(), j1.phi(),
fjext.lambda_beta_kappa(j1, 1.0, 1.0, jet_R0),
fjext.lambda_beta_kappa(j1, 2.0, 1.0, jet_R0),
fjext.lambda_beta_kappa(j1, 3.0, 1.0, jet_R0))
def fill_branches_prong_matching(self, j_pp, j_emb, **kwargs):
if fjtools.matched_pt(j_emb, j_pp) < 0.5:
return
tw = self.tembwp
tw.fill_branch('j_pp', j_pp)
self.gshop.recluster(j_pp)
self.gshop_emb.recluster(j_emb)
for a in self.alphas:
self.fill_groomers_matched(tw, self.gshop.dynamical(a),
self.gshop.dynamical(a),
'dg_{:.1f}'.format(a))
self.fill_groomers_matched(tw, self.gshop.max_pt_softer(),
self.gshop_emb.max_pt_softer(),
'max_ptsoft')
self.fill_groomers_matched(tw, self.gshop.max_z(),
self.gshop_emb.max_z(), 'max_z')
self.fill_groomers_matched(tw, self.gshop.max_kt(),
self.gshop_emb.max_kt(), 'max_kt')
self.fill_groomers_matched(tw, self.gshop.max_kappa(),
self.gshop_emb.max_kappa(), 'max_kappa')
self.fill_groomers_matched(tw, self.gshop.max_tf(),
self.gshop_emb.max_tf(), 'max_tf')
self.fill_groomers_matched(tw, self.gshop.min_tf(),
self.gshop_emb.min_tf(), 'min_tf')
for zcut in enumerate(self.sd_zcuts):
self.fill_groomers_matched(tw, self.gshop.soft_drop(0.0, zcut),
self.gshop_emb.soft_drop(0.0, zcut),
'sd{}'.format(zcut))
gsd = self.gshop.soft_drop(0., zcut)
tw.fill_branch('sd_{}_pp'.format(zcut), gsd.pair())
gsd = self.gshop_emb.soft_drop(0., zcut)
tw.fill_branch('sd_{}_emb'.format(zcut), gsd.pair())
for s in kwargs:
tw.fill_branch(s, kwargs[s])
tw.fill_tree()
def fill_prong_matching_histograms(self, jet_truth, jet_det,
jet_det_groomed_lund,
jet_pt_truth_ungroomed, jetR,
grooming_setting, grooming_label,
R_max):
# Do grooming on pp-det jet, and get prongs
jet_pp_det = jet_truth.python_info().match
gshop = fjcontrib.GroomerShop(jet_pp_det, jetR, fj.cambridge_algorithm)
jet_pp_det_groomed_lund = self.utils.groom(gshop, grooming_setting,
jetR)
if not jet_pp_det_groomed_lund:
return
# Groomer shop returns a fjcontrib::LundGenerator
# The prongs can be retrieved directly from this object.
# If the object exists, then it has passed grooming
jet_pp_det_prong1 = jet_pp_det_groomed_lund.harder()
jet_pp_det_prong2 = jet_pp_det_groomed_lund.softer()
# Get prongs of combined jet
jet_combined_prong1 = jet_det_groomed_lund.harder()
jet_combined_prong2 = jet_det_groomed_lund.softer()
# Get the fastjet::PseudoJets from the fjcontrib::LundGenerators
jet_pp_det_groomed = jet_pp_det_groomed_lund.pair()
jet_det_groomed = jet_det_groomed_lund.pair()
if self.debug_level > 1:
if jet_pt_truth_ungroomed > 80.:
print(
'=======================================================')
print('jet_pt_truth_ungroomed: {}'.format(
jet_pt_truth_ungroomed))
print('jet_pt_pp_det_ungroomed: {}'.format(jet_pp_det.pt()))
print('jet_pt_pp_det_groomed: {}'.format(
jet_pp_det_groomed.pt()))
print('jet_pt_combined_groomed: {}'.format(
jet_det_groomed.pt()))
print('')
print('jet_pp_det tracks: {}'.format([
track.user_index() for track in jet_pp_det.constituents()
]))
print(' track pt: {}'.format([
np.around(track.pt(), 2)
for track in jet_pp_det.constituents()
]))
if jet_pp_det_groomed.has_constituents():
print('jet_pp_det_groomed tracks: {}'.format([
track.user_index()
for track in jet_pp_det_groomed.constituents()
]))
print(' track pt: {}'.format([
np.around(track.pt(), 2)
for track in jet_pp_det_groomed.constituents()
]))
if jet_det_groomed.has_constituents():
print('jet_combined groomed tracks: {}'.format([
track.user_index()
for track in jet_det_groomed.constituents()
]))
print(' track pt: {}'.format([
np.around(track.pt(), 2)
for track in jet_det_groomed.constituents()
]))
print('jet_combined ungroomed tracks: {}'.format(
[track.user_index() for track in jet_det.constituents()]))
print(' track pt: {}'.format([
np.around(track.pt(), 2)
for track in jet_det.constituents()
]))
# Compute fraction of pt of the pp-det prong tracks that is contained in the combined-jet prong,
# in order to have a measure of whether the combined-jet prong is the "same" prong as the pp-det prong
deltaR_prong1 = -1.
deltaR_prong2 = -1.
deltaZ = -1.
if jet_pp_det_groomed.has_constituents(
) and jet_det_groomed.has_constituents():
# Subleading jet pt-matching
# --------------------------
# (1) Fraction of pt matched: subleading pp-det in subleading combined
matched_pt_subleading_subleading = fjtools.matched_pt(
jet_combined_prong2, jet_pp_det_prong2)
# (2) Fraction of pt matched: subleading pp-det in leading combined
matched_pt_subleading_leading = fjtools.matched_pt(
jet_combined_prong1, jet_pp_det_prong2)
# (3) Fraction of pt matched: subleading pp-det in ungroomed combined jet
matched_pt_subleading_groomed = fjtools.matched_pt(
jet_det_groomed, jet_pp_det_prong2)
matched_pt_subleading_ungroomed = fjtools.matched_pt(
jet_det, jet_pp_det_prong2)
matched_pt_subleading_ungroomed_notgroomed = matched_pt_subleading_ungroomed - matched_pt_subleading_groomed
# (4) Fraction of pt matched: subleading pp-det not in ungroomed combined jet
matched_pt_subleading_outside = 1 - matched_pt_subleading_ungroomed
# Leading jet pt-matching
# --------------------------
# (1) Fraction of pt matched: leading pp-det in subleading combined
matched_pt_leading_subleading = fjtools.matched_pt(
jet_combined_prong2, jet_pp_det_prong1)
# (2) Fraction of pt matched: leading pp-det in leading combined
matched_pt_leading_leading = fjtools.matched_pt(
jet_combined_prong1, jet_pp_det_prong1)
# (3) Fraction of pt matched: leading pp-det in ungroomed combined jet
matched_pt_leading_groomed = fjtools.matched_pt(
jet_det_groomed, jet_pp_det_prong1)
matched_pt_leading_ungroomed = fjtools.matched_pt(
jet_det, jet_pp_det_prong1)
matched_pt_leading_ungroomed_notgroomed = matched_pt_leading_ungroomed - matched_pt_leading_groomed
# (4) Fraction of pt matched: leading pp-det not in ungroomed combined jet
matched_pt_leading_outside = 1 - matched_pt_leading_ungroomed
# Compute delta-R between pp-det prong and combined prong
# --------------------------
deltaR_prong1 = jet_combined_prong1.delta_R(jet_pp_det_prong1)
deltaR_prong2 = jet_combined_prong2.delta_R(jet_pp_det_prong2)
deltaZ = jet_det_groomed_lund.z() - jet_pp_det_groomed_lund.z()
if self.debug_level > 1:
if jet_pt_truth_ungroomed > 80.:
print('subleading prong tracks -- combined: {}'.format([
track.user_index()
for track in jet_combined_prong2.constituents()
]))
print('subleading prong tracks -- pp-det: {}'.format([
track.user_index()
for track in jet_pp_det_prong2.constituents()
]))
print('leading prong tracks -- combined: {}'.format([
track.user_index()
for track in jet_combined_prong1.constituents()
]))
print('leading prong tracks -- pp-det: {}'.format([
track.user_index()
for track in jet_pp_det_prong1.constituents()
]))
print('')
print('leading_prong_pt: {}'.format(
jet_combined_prong1.pt()))
print('matched_pt_leading_subleading fraction: {}'.format(
matched_pt_leading_subleading))
print('matched_pt_leading_leading fraction: {}'.format(
matched_pt_leading_leading))
print(
'matched_pt_leading_ungroomed_notgroomed fraction: {}'.
format(matched_pt_leading_ungroomed_notgroomed))
print('matched_pt_leading_outside fraction: {}'.format(
matched_pt_leading_outside))
print('')
print('subleading_prong_pt: {}'.format(
jet_combined_prong2.pt()))
print(
'matched_pt_subleading_subleading fraction: {}'.format(
matched_pt_subleading_subleading))
print('matched_pt_subleading_leading fraction: {}'.format(
matched_pt_subleading_leading))
print(
'matched_pt_subleading_ungroomed_notgroomed fraction: {}'
.format(matched_pt_subleading_ungroomed_notgroomed))
print('matched_pt_subleading_outside fraction: {}'.format(
matched_pt_subleading_outside))
print('')
print('deltaR_prong1: {}'.format(deltaR_prong1))
print('deltaR_prong2: {}'.format(deltaR_prong2))
elif jet_pp_det_groomed.has_constituents(
): # pp-det passed grooming, but combined jet failed grooming
matched_pt_leading_leading = matched_pt_leading_subleading = matched_pt_leading_ungroomed_notgroomed = matched_pt_leading_outside = matched_pt_subleading_leading = matched_pt_subleading_subleading = matched_pt_subleading_ungroomed_notgroomed = matched_pt_subleading_outside = -0.1
elif jet_det_groomed.has_constituents(
): # combined jet passed grooming, but pp-det failed grooming
matched_pt_leading_leading = matched_pt_leading_subleading = matched_pt_leading_ungroomed_notgroomed = matched_pt_leading_outside = matched_pt_subleading_leading = matched_pt_subleading_subleading = matched_pt_subleading_ungroomed_notgroomed = matched_pt_subleading_outside = -0.2
else: # both pp-det and combined jet failed SoftDrop
matched_pt_leading_leading = matched_pt_leading_subleading = matched_pt_leading_ungroomed_notgroomed = matched_pt_leading_outside = matched_pt_subleading_leading = matched_pt_subleading_subleading = matched_pt_subleading_ungroomed_notgroomed = matched_pt_subleading_outside = -0.3
# Leading prong
getattr(
self, 'hProngMatching_leading_leading_JetPt_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_leading_leading, deltaR_prong1)
getattr(
self,
'hProngMatching_leading_subleading_JetPt_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_leading_subleading, deltaR_prong1)
getattr(
self,
'hProngMatching_leading_ungroomed_JetPt_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_leading_ungroomed_notgroomed,
deltaR_prong1)
getattr(
self, 'hProngMatching_leading_outside_JetPt_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_leading_outside, deltaR_prong1)
getattr(
self,
'hProngMatching_leading_leading_JetPtDet_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(), matched_pt_leading_leading,
deltaR_prong1)
getattr(
self,
'hProngMatching_leading_subleading_JetPtDet_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(), matched_pt_leading_subleading,
deltaR_prong1)
getattr(
self,
'hProngMatching_leading_ungroomed_JetPtDet_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(),
matched_pt_leading_ungroomed_notgroomed,
deltaR_prong1)
getattr(
self,
'hProngMatching_leading_outside_JetPtDet_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(), matched_pt_leading_outside,
deltaR_prong1)
getattr(
self, 'hProngMatching_leading_leading_JetPtZ_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_leading_leading, deltaZ)
getattr(
self,
'hProngMatching_leading_subleading_JetPtZ_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_leading_subleading, deltaZ)
getattr(
self,
'hProngMatching_leading_ungroomed_JetPtZ_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_leading_ungroomed_notgroomed, deltaZ)
getattr(
self, 'hProngMatching_leading_outside_JetPtZ_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_leading_outside, deltaZ)
# Subleading prong
getattr(
self,
'hProngMatching_subleading_leading_JetPt_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_subleading_leading, deltaR_prong2)
getattr(
self,
'hProngMatching_subleading_subleading_JetPt_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_subleading_subleading, deltaR_prong2)
getattr(
self,
'hProngMatching_subleading_ungroomed_JetPt_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_subleading_ungroomed_notgroomed,
deltaR_prong2)
getattr(
self,
'hProngMatching_subleading_outside_JetPt_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_subleading_outside, deltaR_prong2)
getattr(
self,
'hProngMatching_subleading_leading_JetPtDet_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(), matched_pt_subleading_leading,
deltaR_prong2)
getattr(
self,
'hProngMatching_subleading_subleading_JetPtDet_R{}_{}_Rmax{}'.
format(jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(),
matched_pt_subleading_subleading,
deltaR_prong2)
getattr(
self, 'hProngMatching_subleading_ungroomed_JetPtDet_R{}_{}_Rmax{}'.
format(jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(),
matched_pt_subleading_ungroomed_notgroomed,
deltaR_prong2)
getattr(
self,
'hProngMatching_subleading_outside_JetPtDet_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(), matched_pt_subleading_outside,
deltaR_prong2)
getattr(
self,
'hProngMatching_subleading_leading_JetPtZ_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_subleading_leading, deltaZ)
getattr(
self,
'hProngMatching_subleading_subleading_JetPtZ_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_subleading_subleading, deltaZ)
getattr(
self,
'hProngMatching_subleading_ungroomed_JetPtZ_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_subleading_ungroomed_notgroomed,
deltaZ)
getattr(
self,
'hProngMatching_subleading_outside_JetPtZ_R{}_{}_Rmax{}'.format(
jetR, grooming_label,
R_max)).Fill(jet_pt_truth_ungroomed,
matched_pt_subleading_outside, deltaZ)
# Plot correlation of matched pt fraction for leading-subleading and subleading-leading
getattr(
self,
'hProngMatching_subleading-leading_correlation_JetPtDet_R{}_{}_Rmax{}'
.format(jetR, grooming_label,
R_max)).Fill(jet_pp_det.pt(),
matched_pt_leading_subleading,
matched_pt_subleading_leading)
subleading_match = (matched_pt_subleading_subleading > 0.5)
leading_match = (matched_pt_leading_leading > 0.5)
prong_match = subleading_match and leading_match
return prong_match
def fill_tree_matched(signal_jet,
emb_jet,
tw,
sd,
rho,
iev=None,
weight=None,
sigma=None):
tw.clear()
mpt = fjtools.matched_pt(emb_jet, signal_jet)
if mpt <= 0.5:
return None
tw.fill_branch('j_mpt', mpt)
if iev:
tw.fill_branch('ev_id', iev)
if weight:
tw.fill_branch('weight', weight)
if sigma:
tw.fill_branch('sigma', sigma)
sd_signal_jet = sd.result(signal_jet)
sd_info_signal_jet = fjcontrib.get_SD_jet_info(sd_signal_jet)
sd_emb_jet = sd.result(emb_jet)
sd_info_emb_jet = fjcontrib.get_SD_jet_info(sd_emb_jet)
tw.fill_branch('rho', rho)
tw.fill_branch('j', signal_jet)
tw.fill_branch('sd_j', sd_signal_jet)
tw.fill_branch('sd_j_z', sd_info_signal_jet.z)
tw.fill_branch('sd_j_dR', sd_info_signal_jet.dR)
tw.fill_branch('j_nc', len(signal_jet.constituents()))
tw.fill_branch('ej', emb_jet)
tw.fill_branch('ej_ptc', emb_jet.pt() - emb_jet.area() * rho)
tw.fill_branch('sd_ej', sd_emb_jet)
tw.fill_branch('sd_ej_cpt', sd_emb_jet.pt() - sd_emb_jet.area() * rho)
tw.fill_branch('sd_ej_z', sd_info_emb_jet.z)
tw.fill_branch('sd_ej_dR', sd_info_emb_jet.dR)
p1 = fj.PseudoJet()
p2 = fj.PseudoJet()
has_parents_signal = sd_signal_jet.has_parents(p1, p2)
# print('signal_jet:', has_parents, len(p1.constituents()), len(p2.constituents()))
tw.fill_branch('j_p1', p1)
tw.fill_branch('j_p2', p2)
pe1 = fj.PseudoJet()
pe2 = fj.PseudoJet()
has_parents_emb = sd_emb_jet.has_parents(pe1, pe2)
tw.fill_branch('ej_p1', pe1)
tw.fill_branch('ej_p2', pe2)
if has_parents_emb:
tw.fill_branch('ej_p1_ptc', pe1.pt() - pe1.area() * rho)
tw.fill_branch('ej_p2_ptc', pe2.pt() - pe2.area() * rho)
else:
tw.fill_branch('ej_p1_ptc', -1000)
tw.fill_branch('ej_p2_ptc', -1000)
mpt1 = -1.0 # not passed SD
mpt2 = -1.0 # not passed SD
if has_parents_signal and has_parents_emb:
mpt1 = fjtools.matched_pt(pe1, p1)
mpt2 = fjtools.matched_pt(pe2, p2)
tw.fill_branch('mpt1', mpt1)
tw.fill_branch('mpt2', mpt2)
# print('signal_jet:', has_parents, len(pe1.constituents()), len(pe2.constituents()))
# print('emb_jets', has_parents, len(pe1.constituents()), len(pe2.constituents()))
# for c in pe2.constituents():
# cp1 = fj.PseudoJet()
# cp2 = fj.PseudoJet()
# print(' - ', c.has_parents(cp1, cp2))
#tw.fill_branch('jsd', sd_j)
#tw.fill_branch('jm', ej)
tw.fill_tree()
return emb_jet
def main():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
parser.add_argument('--embed',
help='run embedding from a file list',
default='',
type=str)
args = parser.parse_args()
if args.nev < 1:
args.nev = 1
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
part_selection = [pythiafjext.kFinal, pythiafjext.kCharged]
max_eta = 1.
be = None
embd = None
if len(args.embed) > 0:
embd = DataBackgroundIO(file_list=args.embed)
print(embd)
else:
be = BoltzmannEvent(mean_pt=0.6,
multiplicity=2000 * max_eta * 2,
max_eta=max_eta,
max_pt=100)
print(be)
# print the banner first
fj.ClusterSequence.print_banner()
print()
# set up our jet definition and a jet selector
jet_R0 = 0.6
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
jet_def_emb = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
jet_selector = fj.SelectorPtMin(10.0) & fj.SelectorAbsEtaMax(1)
fout = ROOT.TFile('pythia_8jet.root', 'recreate')
fout.cd()
hfraction = ROOT.TProfile('hfraction', 'hfraction', 10, 0, 100)
hdpt = ROOT.TProfile('hdpt', 'hdpt', 10, 0, 100)
hfraction2D = ROOT.TH2F('hfraction2D', 'hfraction', 10, 0, 100, 20, 0, 1)
hdpt2D = ROOT.TH2F('hdpt2D', 'hdpt', 10, 0, 100, 20, -1, 0)
hfraction_emb = ROOT.TProfile('hfraction_emb', 'hfraction', 10, 0, 100)
hdpt_emb = ROOT.TProfile('hdpt_emb', 'hdpt', 10, 0, 100)
hfraction2D_emb = ROOT.TH2F('hfraction2D_emb', 'hfraction', 10, 0, 100, 20,
0, 1)
hdpt2D_emb = ROOT.TH2F('hdpt2D_emb', 'hdpt', 10, 0, 100, 20, -1, 0)
for iev in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
parts = []
parts = pythiafjext.vectorize_select(pythia, part_selection, 0, False)
jets = fj.sorted_by_pt(jet_selector(jet_def(parts)))
if embd:
bg_parts = embd.load_event(offset=10000)
else:
bg_parts = be.generate(offset=10000)
for j in jets:
_sum_all, _sum_top_n, _fraction_pt = calc_n_lead(j, 8)
hfraction.Fill(j.pt(), _fraction_pt)
hdpt.Fill(j.pt(), (_sum_top_n - _sum_all) / _sum_all)
hfraction2D.Fill(j.pt(), _fraction_pt)
hdpt2D.Fill(j.pt(), (_sum_top_n - _sum_all) / _sum_all)
full_event = fj.vectorPJ()
tmp = [full_event.push_back(psj) for psj in bg_parts]
tmp = [full_event.push_back(psj) for psj in j.constituents()]
embd_jets = fj.sorted_by_pt(jet_selector(jet_def_emb(full_event)))
for jemb in embd_jets:
mpt = fjtools.matched_pt(jemb, j)
if mpt < 0.5:
continue
_sum_all_emb, _sum_top_n_emb, _fraction_pt_emb = calc_n_lead(
jemb, 8)
_fraction_pt_emb = _sum_top_n_emb / _sum_all
hfraction_emb.Fill(jemb.pt(), _fraction_pt)
hdpt_emb.Fill(jemb.pt(),
(_sum_top_n_emb - _sum_all) / _sum_all)
hfraction2D_emb.Fill(jemb.pt(), _fraction_pt)
hdpt2D_emb.Fill(jemb.pt(),
(_sum_top_n_emb - _sum_all) / _sum_all)
fg = ROOT.TF1('fg', 'gaus', 0, 1)
fg.SetParameter(0, 1)
fg.SetParameter(1, 0.8)
fg.SetParameter(2, 0.1)
hfraction2D.FitSlicesY(fg)
hfraction2D_emb.FitSlicesY(fg)
fgdpt = ROOT.TF1('fgdpt', 'gaus', -1, 0)
fgdpt.SetParameter(0, 1)
fgdpt.SetParameter(1, -0.2)
fgdpt.SetParameter(2, 0.1)
hdpt2D.FitSlicesY(fgdpt)
hdpt2D_emb.FitSlicesY(fgdpt)
fout.Write()
fout.Close()
def delta_pt_matched(j, refjets, rho): for refj in refjets: mpt = fjtools.matched_pt(j, refj) if mpt > 0.5: return j.perp() - refj.perp() - rho * j.area() return -1000.
def matched_jet(j, refjets): for rj in refjets: mpt = fjtools.matched_pt(j, rj) if mpt > 0.5: return rj return None
