def fill_jet_histograms(self, jet, jet_groomed_lund, jetR, obs_setting, grooming_setting,
obs_label, jet_pt_ungroomed, suffix):
# Recluster with WTA (with larger jet R)
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2*jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
if self.debug_level > 2:
print('WTA jet definition is:', jet_def_wta)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_wta = reclusterer_wta.result(jet)
name = 'h_{}_JetPt_R{}_{}{}'.format(self.observable, jetR, obs_label, suffix)
if 'Standard_SD' in obs_setting:
if grooming_setting in self.obs_grooming_settings[self.observable]:
jet_groomed = jet_groomed_lund.pair()
deltaR = jet.delta_R(jet_groomed)
if jet_groomed_lund.Delta() < 0: # untagged jet (i.e. failed SD)
deltaR = -1.
#getattr(self, 'h_{}_JetPt_R{}_{}'.format(self.observable, jetR, obs_label)).Fill(jet.pt(), deltaR)
getattr(self, name).Fill(jet.pt(), deltaR)
if obs_setting == 'Standard_WTA':
deltaR = jet.delta_R(jet_wta)
#getattr(self, 'h_{}_JetPt_R{}_{}'.format(self.observable, jetR, obs_label)).Fill(jet.pt(), deltaR)
getattr(self, name).Fill(jet.pt(), deltaR)
if 'WTA_SD' in obs_setting:
if grooming_setting in self.obs_grooming_settings[self.observable]:
jet_groomed = jet_groomed_lund.pair()
deltaR = jet_groomed.delta_R(jet_wta)
if jet_groomed_lund.Delta() < 0: # untagged jet (i.e. failed SD)
deltaR = -1.
#getattr(self, 'h_{}_JetPt_R{}_{}'.format(self.observable, jetR, obs_label)).Fill(jet.pt(), deltaR)
getattr(self, name).Fill(jet.pt(), deltaR)
def fill_observable_histograms(self, hname, jet, jet_groomed_lund, jetR,
obs_setting, grooming_setting, obs_label,
jet_pt_ungroomed):
# Recluster with WTA (with larger jet R)
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2 * jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
if self.debug_level > 3:
print('WTA jet definition is:', jet_def_wta)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_wta = reclusterer_wta.result(jet)
# Compute jet axis differences
if 'Standard_SD' in obs_setting:
jet_groomed = jet_groomed_lund.pair()
deltaR = jet.delta_R(jet_groomed)
if jet_groomed_lund.Delta() < 0: # untagged jet (i.e. failed SD)
deltaR = -1.
elif obs_setting == 'Standard_WTA':
deltaR = jet.delta_R(jet_wta)
elif 'WTA_SD' in obs_setting:
jet_groomed = jet_groomed_lund.pair()
deltaR = jet_groomed.delta_R(jet_wta)
if jet_groomed_lund.Delta() < 0: # untagged jet (i.e. failed SD)
deltaR = -1.
if grooming_setting:
grooming_label = self.utils.grooming_label(grooming_setting)
grooming_label = '_' + grooming_label
else:
grooming_label = ''
getattr(
self, 'h_{}_JetPt_Truth_R{}_{}{}'.format(
self.observable, jetR, obs_setting,
grooming_label)).Fill(jet_pt_ungroomed, deltaR)
def fill_matched_jet_histograms(self, jet_det, jet_det_groomed_lund, jet_truth,
jet_truth_groomed_lund, jet_pp_det, jetR,
obs_setting, grooming_setting, obs_label,
jet_pt_det_ungroomed, jet_pt_truth_ungroomed, R_max, suffix):
# Recluster with WTA (with larger jet R)
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2*jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
if self.debug_level > 3:
print('WTA jet definition is:', jet_def_wta)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_det_wta = reclusterer_wta.result(jet_det)
jet_truth_wta = reclusterer_wta.result(jet_truth)
# Compute jet axis differences
jet_det_groomed = jet_det_groomed_lund.pair()
jet_truth_groomed = jet_truth_groomed_lund.pair()
if obs_setting == 'Standard_SD':
deltaR_det = jet_det.delta_R(jet_det_groomed)
deltaR_truth = jet_truth.delta_R(jet_truth_groomed)
elif obs_setting == 'Standard_WTA':
deltaR_det = jet_det.delta_R(jet_det_wta)
deltaR_truth = jet_truth.delta_R(jet_truth_wta)
elif obs_setting == 'WTA_SD':
deltaR_det = jet_det_groomed.delta_R(jet_det_wta)
deltaR_truth = jet_truth_groomed.delta_R(jet_truth_wta)
# Fill response
self.fill_response(self.observable, jetR, jet_pt_det_ungroomed, jet_pt_truth_ungroomed,
deltaR_det, deltaR_truth, obs_label, R_max, prong_match = False)
def main():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly', prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
# print the banner first
fj.ClusterSequence.print_banner()
print()
# set up our jet definition and a jet selector
jet_R0 = 0.4
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
jet_selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsEtaMax(2)
print(jet_def)
all_jets = []
# mycfg = ['PhaseSpace:pThatMin = 100']
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if args.nev < 100:
args.nev = 100
for i in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
parts = pythiafjext.vectorize(pythia, True, -1, 1, False)
jets = jet_selector(jet_def(parts))
all_jets.extend(jets)
pythia.stat()
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
lund_gen = fjcontrib.LundGenerator(jet_def_lund)
print('making lund diagram for all jets...')
lunds = [lund_gen.result(j) for j in all_jets]
print('listing lund plane points... Delta, kt - for {} selected jets'.format(len(all_jets)))
for l in lunds:
print ('- jet pT={0:5.2f} eta={1:5.2f}'.format(l[0].pair().perp(), l[0].pair().eta()))
print (' Deltas={}'.format([s.Delta() for s in l]))
print (' kts={}'.format([s.Delta() for s in l]))
print ( )
print('[i] reclustering and using soft drop...')
jet_def_rc = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
print('Reclustering:', jet_def_rc)
rc = fjcontrib.Recluster(jet_def_rc, True)
sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
for i,j in enumerate(all_jets):
j_rc = rc.result(j)
print()
print('- [{0:3d}] orig pT={1:10.3f} reclustered pT={2:10.3f}'.format(i, j.perp(), j_rc.perp()))
j_sd = sd.result(j)
print(' |-> after soft drop pT={0:10.3f} delta={1:10.3f}'.format(j_sd.perp(), j_sd.perp() - j.perp()))
sd_info = fjcontrib.get_SD_jet_info(j_sd)
print(" |-> SD jet params z={0:10.3f} dR={1:10.3f} mu={2:10.3f}".format(sd_info.z, sd_info.dR, sd_info.mu))
def get_wta_jet(self, jet, jetR):
# Recluster with WTA (with larger jet R)
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2 * jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
if self.debug_level > 3:
print('WTA jet definition is:', jet_def_wta)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
return reclusterer_wta.result(jet)
def main():
# get the banner out of the way early on
fj.ClusterSequence.print_banner()
print()
# set up our jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, 0.4)
selector = fj.SelectorPtMin(15.0) & fj.SelectorAbsRapMax(4.5)
print("jet definition is:", jet_def)
print("jet selector is:", selector, "\n")
filename = './Pythia-dijet-ptmin100-lhc-pileup-1ev.dat'
f = open(filename, 'r')
#filename = '/Users/gsalam/work/fastjet/data/Pythia-PtMin50-LHC-10kev.dat.gz'
#f = gzip.GzipFile(filename,'rb')
# get the event
iev = 0
while True:
event = read_event(f)
iev += 1
if (len(event) == 0): break
# cluster it
jets = selector(jet_def(event))
# print some info
npileup = 0
for p in event:
if (p.python_info().subevent_index > 0): npileup += 1
print("Event {0} has {1} particles (of which {2} from pileup)".format(
iev, len(event), npileup))
print_jets(jets)
jet_def_rc = fj.JetDefinition(fj.antikt_algorithm, 0.1)
rc = fjcontrib.Recluster(jet_def_rc, True)
sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
for i, j in enumerate(jets):
j_rc = rc.result(j)
print(
'- [{0:3d}] orig pT={1:10.3f} reclustered pT={2:10.3f}'.format(
i, j.perp(), j_rc.perp()))
j_sd = sd.result(j)
# j_sd.structure_of<fj.contrib.SoftDrop>().delta_R()
# print(j_sd.python_info())
print(' |-> after soft drop pT={0:10.3f} delta={1:10.3f}'.format(
j_sd.perp(),
j_sd.perp() - j.perp()))
sd_info = fjcontrib.get_SD_jet_info(j_sd)
print(" |-> SD jet params z={0:10.3f} dR={1:10.3f} mu={2:10.3f}".
format(sd_info.z, sd_info.dR, sd_info.mu))
def fill_jet_histograms(self, jet, jet_groomed_lund, jetR, obs_setting, grooming_setting,
obs_label, jet_pt_ungroomed, suffix):
# Recluster with WTA (with larger jet R)
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2*jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
if self.debug_level > 2:
print('WTA jet definition is:', jet_def_wta)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_wta = reclusterer_wta.result(jet)
jet_groomed = jet_groomed_lund.pair()
self.fill_jet_axis_histogram(jet, jet_groomed, jet_wta, jetR, obs_setting,
grooming_setting, obs_label)
def fill_jet_matches(self, jet_det, jetR, beta):
sd = fjcontrib.SoftDrop(self.sd_beta, self.sd_zcut, jetR)
jet_def_recluster = fj.JetDefinition(fj.cambridge_algorithm, jetR)
reclusterer = fjcontrib.Recluster(jet_def_recluster)
sd.set_reclustering(True, reclusterer)
if self.debug_level > 2:
print('SoftDrop groomer is: {}'.format(sd.description()))
# Check additional acceptance criteria
# skip event if not satisfied -- since first jet in event is highest pt
if not self.utils.is_det_jet_accepted(jet_det):
return
if jet_det.has_user_info():
jet_truth = jet_det.python_info().match
if jet_truth:
self.fill_response_histograms(jet_det, jet_truth, sd, jetR,
beta)
def fill_observable_histograms(self, hname, jet, jet_groomed_lund, jetR, obs_setting,
grooming_setting, obs_label, jet_pt_ungroomed):
# Recluster with WTA (with larger jet R)
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2*jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
if self.debug_level > 3:
print('WTA jet definition is:', jet_def_wta)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_wta = reclusterer_wta.result(jet)
# Compute jet axis differences
jet_groomed = jet_groomed_lund.pair()
if obs_setting == 'Standard_SD':
deltaR = jet.delta_R(jet_groomed)
elif obs_setting == 'Standard_WTA':
deltaR = jet.delta_R(jet_wta)
elif obs_setting == 'WTA_SD':
deltaR = jet_groomed.delta_R(jet_wta)
getattr(self, hname.format(self.observable, jetR, obs_label)).Fill(jet_pt_ungroomed, deltaR)
def angle_between_jet_axes(self, jetR, jet, obs_setting, grooming_setting):
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2*jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_wta = reclusterer_wta.result(jet)
if 'Standard_SD' in obs_setting:
gshop = fjcontrib.GroomerShop(jet, jetR, self.reclustering_algorithm)
jet_sd_lund = self.utils.groom(gshop, grooming_setting, jetR)
jet_sd = jet_sd_lund.pair()
deltaR = jet.delta_R(jet_sd)
if jet_sd_lund.Delta() < 0: # untagged jet (i.e. failed SD)
deltaR = -1
elif obs_setting == 'Standard_WTA':
deltaR = jet.delta_R(jet_wta)
elif 'WTA_SD' in obs_setting:
gshop = fjcontrib.GroomerShop(jet, jetR, self.reclustering_algorithm)
jet_sd_lund = self.utils.groom(gshop, grooming_setting, jetR)
jet_sd = jet_sd_lund.pair()
deltaR = jet_wta.delta_R(jet_sd)
if jet_sd_lund.Delta() < 0: # untagged jet (i.e. failed SD)
deltaR = -1
return deltaR
def analysis(self, df):
#print(df)
m_array = np.full((self.df_tracks['ParticlePt'].values.size), 0.1396)
djmm = fjtools.DJetMatchMaker()
djmm.set_ch_pt_eta_phi_m(self.df_tracks['ParticlePt'].values,
self.df_tracks['ParticleEta'].values,
self.df_tracks['ParticlePhi'].values, m_array)
djmm.set_Ds_pt_eta_phi_m(df['pt_cand'].values, df['eta_cand'].values,
df['phi_cand'].values, df['inv_mass'].values)
djmm.set_daughters0_pt_eta_phi(df['pt_prong0'].values,
df['eta_prong0'].values,
df['phi_prong0'].values)
djmm.set_daughters1_pt_eta_phi(df['pt_prong1'].values,
df['eta_prong1'].values,
df['phi_prong1'].values)
#run for each D candidate to build jet
for id0, d0 in enumerate(djmm.Ds):
#daughter tracks matching
_parts_and_ds = djmm.match(0.005, id0)
#replacing daughter tracks with matched D0 candidate
#including D0
_parts_and_ds.push_back(d0)
#jet reconstruction with D0 and charged particle
jetR = 0.4
ja = jet_analysis.JetAnalysis(jet_R=jetR,
jet_RecombinationScheme=fj.E_scheme,
particle_eta_max=0.9,
jet_pt_min=5.0)
ja.analyze_event(_parts_and_ds)
if len(ja.jets) < 1:
continue
jets = ja.jets_as_psj_vector()
#filtering D0 jets
djets = djmm.filter_D0_jets(jets)
if len(djets) > 0:
j = djets[0]
dcand = djmm.get_Dcand_in_jet(j)
#number of constitutents > 1
#if len(j.constituents())<=1:
# continue
#jets with the winner take all axis################################
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm,
2 * jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
#print('WTA jet definition is:', jet_def_wta)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_wta = reclusterer_wta.result(j)
################################
D_cosp = df['cos_p'].values
D_cosTStar = df['cos_t_star'].values
D_NormalisedDecayLength = df['norm_dl_xy'].values
D_ImpactParameterProduct = df['imp_par_prod'].values
D_cand_type = df['cand_type'].values
self.twjc.fill_branches(
jet=j,
jetWta=jet_wta,
dR=j.delta_R(dcand[0]),
dRWTA=jet_wta.delta_R(dcand[0]),
D=dcand[0],
cos_p=float(D_cosp[id0]),
D_cos_t_star=float(D_cosTStar[id0]),
D_norm_dlxy=float(D_NormalisedDecayLength[id0]),
D_imp_par_prod=float(D_ImpactParameterProduct[id0]),
Dmeson_cand_type=float(D_cand_type[id0]))
self.twjc.fill_tree()
if len(djets) > 1:
perror("more than one jet per D candidate?")
return True
def fill_charged_jet_histograms(self, jet, gshop, holes_in_jet, jet_pt, jetR, constituent_threshold):
# Grooming jet
jet_groomed_lund = gshop.soft_drop(self.inclusive_chjet_observables['soft_drop_beta'], self.inclusive_chjet_observables['soft_drop_zcut'], jetR)
# g
if 40 < jet_pt < 60 and abs(jet.eta()) < (self.inclusive_chjet_observables['eta_cut_alice_R'] - jetR):
g = 0
for constituent in jet.constituents():
g += constituent.pt() / jet_pt * constituent.delta_R(jet)
for hadron in holes_in_jet:
g -= hadron.pt() / jet_pt * hadron.delta_R(jet)
getattr(self, f'h_chjet_g_alice_R{jetR}_pt{constituent_threshold}').Fill(g)
# Angularity (5.02 definition)
if 60 < jet_pt < 80 and abs(jet.eta()) < (self.inclusive_chjet_observables['eta_cut_alice_R'] - jetR):
for alpha in self.inclusive_chjet_observables['angularity_alice']['alpha']:
kappa=1
lambda_alpha = fjext.lambda_beta_kappa(jet, alpha, kappa, jetR)
for hadron in holes_in_jet:
lambda_alpha -= hadron.pt() / jet_pt * np.power(hadron.delta_R(jet), alpha)
getattr(self, f'h_chjet_angularity_ungroomed_alice_R{jetR}_alpha{alpha}_pt{constituent_threshold}').Fill(lambda_alpha)
if jet_groomed_lund:
lambda_alpha_g = fjext.lambda_beta_kappa(jet_groomed_lund.pair(), alpha, kappa, jetR)
for hadron in holes_in_jet:
lambda_alpha_g -= hadron.pt() / jet_pt * np.power(hadron.delta_R(jet), alpha)
getattr(self, f'h_chjet_angularity_groomed_alice_R{jetR}_alpha{alpha}_pt{constituent_threshold}').Fill(lambda_alpha_g)
# Jet mass
if 60 < jet_pt < 80 and abs(jet.eta()) < (self.inclusive_chjet_observables['eta_cut_alice_R'] - jetR):
jet_mass = jet.m()
# Add holes together as four vectors, and then calculate their mass, removing it from the jet mass.
if holes_in_jet:
# Avoid modifying the original hole.
hole_four_vector = fj.PseudoJet()
for hadron in holes_in_jet:
hole_four_vector += hadron
# Remove mass from holes
jet_mass -= hole_four_vector.m()
getattr(self, f'h_chjet_mass_alice_R{jetR}_pt{constituent_threshold}').Fill(jet_mass)
# Soft Drop
if 60 < jet_pt < 80 and abs(jet.eta()) < (self.inclusive_chjet_observables['eta_cut_alice_R'] - jetR):
if jet_groomed_lund:
theta_g = jet_groomed_lund.Delta() / jetR
zg = jet_groomed_lund.z()
# Note: untagged jets will return negative value
getattr(self, f'h_chjet_zg_alice_R{jetR}_pt{constituent_threshold}').Fill(zg)
getattr(self, f'h_chjet_tg_alice_R{jetR}_pt{constituent_threshold}').Fill(theta_g)
# Subjet z
if 80 < jet_pt < 120 and abs(jet.eta()) < (self.inclusive_chjet_observables['eta_cut_alice_R'] - jetR):
for r in self.inclusive_chjet_observables['subjetz_alice']['r']:
cs_subjet = fj.ClusterSequence(jet.constituents(), fj.JetDefinition(fj.antikt_algorithm, r))
subjets = fj.sorted_by_pt(cs_subjet.inclusive_jets())
# Get leading subjet (accounts for holes)
leading_subjet, leading_subjet_pt = self.leading_jet(subjets, holes_in_jet, r)
z_leading = leading_subjet_pt / jet_pt
# If z=1, it will be default be placed in overflow bin -- prevent this
if np.isclose(z_leading, 1.):
z_leading = 0.999
# Fill histogram
getattr(self, f'h_chjet_subjetz_alice_R{jetR}_r{r}_pt{constituent_threshold}').Fill(z_leading)
# Jet axis
if 60 < jet_pt < 80 and abs(jet.eta()) < (self.inclusive_chjet_observables['eta_cut_alice_R'] - jetR):
# Recluster with WTA (with larger jet R)
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2*jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_wta = reclusterer_wta.result(jet)
# Standard-WTA
deltaR = jet.delta_R(jet_wta)
getattr(self, f'h_chjet_axis_Standard_WTA_alice_R{jetR}_pt{constituent_threshold}').Fill(deltaR)
# Standard-SD
if jet_groomed_lund:
deltaR = jet.delta_R(jet_groomed_lund.pair())
getattr(self, f'h_chjet_axis_Standard_SD_alice_R{jetR}_pt{constituent_threshold}').Fill(deltaR)
# SD-WTA
if jet_groomed_lund:
deltaR = jet_wta.delta_R(jet_groomed_lund.pair())
getattr(self, f'h_chjet_axis_SD_WTA_alice_R{jetR}_pt{constituent_threshold}').Fill(deltaR)
# Hardest kt
if 60 < jet_pt < 80 and abs(jet.eta()) < (self.inclusive_chjet_observables["eta_cut_alice_R"] - jetR):
for a in self.inclusive_chjet_observables["hardest_kt_alice"]["dynamical_grooming_a"]:
groomed = gshop.dynamical(a)
ktg = groomed.kt()
# Note: untagged will return kt = 0
getattr(self, f"h_chjet_ktg_dyg_a_{round(a*10):03}_alice_R{round(jetR*10):02}_pt{constituent_threshold}").Fill(ktg)
ktg = jet_groomed_lund.kt()
# Note: untagged jets will return kt = 0
getattr(self, f"h_chjet_ktg_soft_drop_z_cut_02_alice_R{round(jetR*10):02}_pt{constituent_threshold}").Fill(ktg)
pythia.stat()
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
lund_gen = fjcontrib.LundGenerator(jet_def_lund)
print('making lund diagram for all jets...')
lunds = [lund_gen.result(j) for j in all_jets]
print('listing lund plane points... Delta, kt - for {} selected jets'.format(len(all_jets)))
for l in lunds:
print ('- jet pT={0:5.2f} eta={1:5.2f}'.format(l[0].pair().perp(), l[0].pair().eta()))
print (' Deltas={}'.format([s.Delta() for s in l]))
print (' kts={}'.format([s.Delta() for s in l]))
print ( )
print('[i] reclustering and using soft drop...')
jet_def_rc = fj.JetDefinition(fj.cambridge_algorithm, 0.1)
print('Reclustering:', jet_def_rc)
rc = fjcontrib.Recluster(jet_def_rc, True)
sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
for i,j in enumerate(all_jets):
j_rc = rc.result(j)
print()
print('- [{0:3d}] orig pT={1:10.3f} reclustered pT={2:10.3f}'.format(i, j.perp(), j_rc.perp()))
j_sd = sd.result(j)
print(' |-> after soft drop pT={0:10.3f} delta={1:10.3f}'.format(j_sd.perp(), j_sd.perp() - j.perp()))
sd_info = fjcontrib.get_SD_jet_info(j_sd)
print(" |-> SD jet params z={0:10.3f} dR={1:10.3f} mu={2:10.3f}".format(sd_info.z, sd_info.dR, sd_info.mu))
def main():
parser = argparse.ArgumentParser(description='pythia8 in python', prog=os.path.basename(__file__))
parser.add_argument('-i', '--input', help='input file', default='low', type=str, required=True)
parser.add_argument('--nev', help='number of events', default=-1, type=int)
parser.add_argument('--jetptcut', help='jet pt cut', default=10., type=float)
args = parser.parse_args()
files = find_files(args.input, "*.txt")
print(files)
print('[i] number of files found {}'.format(len(files)))
# jet finder
# print the banner first
fj.ClusterSequence.print_banner()
print()
jet_R0 = 0.4
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
jet_selector = fj.SelectorPtMin(10.0) & fj.SelectorAbsEtaMax(3)
if args.nev < 0:
args.nev = len(files)
if args.nev > len(files):
args.nev = len(files)
print("[i] running on {}".format(files[:args.nev]))
all_jets = []
for fin in tqdm.tqdm(files[:args.nev]):
input_hepmc = hepmc3ext.YuukaRead(fin)
if input_hepmc.failed():
print ("[error] unable to read from {}".format(fin))
sys.exit(1)
if input_hepmc.nextEvent():
jets = find_jets_hepmc(jet_def, jet_selector, input_hepmc, accept_status=[62])
all_jets.extend(jets)
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
lund_gen = fjcontrib.LundGenerator(jet_def_lund)
print('[i] making lund diagram for all jets...')
lunds = [lund_gen.result(j) for j in all_jets]
print('[i] reclustering and using soft drop...')
jet_def_rc = fj.JetDefinition(fj.cambridge_algorithm, 0.1)
print('[i] Reclustering:', jet_def_rc)
all_jets_sd = []
rc = fjcontrib.Recluster(jet_def_rc, True)
sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
fout = ROOT.TFile('hepmc_jetreco.root', 'recreate')
lbins = logbins(1., 500, 50)
hJetPt04 = ROOT.TH1D("hJetPt04", "hJetPt04", 50, lbins)
hJetPt04sd = ROOT.TH1D("hJetPt04sd", "hJetPt04sd", 50, lbins)
[hJetPt04.Fill(j.perp()) for j in all_jets]
[hJetPt04sd.Fill(j.perp()) for j in all_jets_sd]
hLund = ROOT.TH2D("hLund", "hLund", 60, 0, 6, 100, -4, 5)
lunds = [lund_gen.result(j) for j in all_jets if j.perp() > args.jetptcut]
jsel = [j for j in all_jets if j.perp() > args.jetptcut]
print('[i] {} jets above {} GeV/c'.format(len(jsel), args.jetptcut))
for l in lunds:
for s in l:
hLund.Fill(math.log(1./s.Delta()), math.log(s.kt()))
if len(jsel) > 0:
hLund.Scale(1./len(jsel))
fout.Write()
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('--ignore-mycfg',
help="ignore some settings hardcoded here",
default=False,
action='store_true')
args = parser.parse_args()
# print the banner first
fj.ClusterSequence.print_banner()
print()
# set up our jet definition and a jet selector
jet_R0 = 0.4
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
jet_selector = fj.SelectorPtMin(100.0) & fj.SelectorAbsEtaMax(1)
print(jet_def)
all_jets = []
mycfg = ['PhaseSpace:pThatMin = 100']
if args.ignore_mycfg:
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
print("[e] pythia initialization failed.")
return
if args.nev < 100:
args.nev = 100
for i in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
parts = pythiafjext.vectorize(pythia, True, -1, 1, False)
jets = jet_selector(jet_def(parts))
all_jets.extend(jets)
pythia.stat()
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
lund_gen = fjcontrib.LundGenerator(jet_def_lund)
print('making lund diagram for all jets...', lund_gen.description())
lunds = [lund_gen.result(j) for j in all_jets]
print(
'listing lund plane points... Delta, kt - for {} selected jets'.format(
len(all_jets)))
for l in lunds:
print('- jet pT={0:5.2f} eta={1:5.2f}'.format(l[0].pair().perp(),
l[0].pair().eta()))
print(' Deltas={}'.format([s.Delta() for s in l]))
print(' kts={}'.format([s.kt() for s in l]))
print()
dy_groomer = fjcontrib.DynamicalGroomer(jet_def_lund)
print(dy_groomer.description())
dy_groomed = [dy_groomer.result(j, 2) for j in all_jets]
print('listing results from dynamical grooming...')
for l in dy_groomed:
print(l, ' kt={}'.format(l.kt()))
for j in all_jets:
rdyng2 = dy_groomer.result(j, 2)
rdyng1 = dy_groomer.result(j, 1)
print('jet', j)
print('- all splits kts:',
sorted([s.kt() for s in dy_groomer.lund_splits()], reverse=True))
print('- dynG kt a=1:', rdyng1.kt(), 'a=2:', rdyng2.kt())
print()
return
print('[i] reclustering and using soft drop...')
jet_def_rc = fj.JetDefinition(fj.cambridge_algorithm, 0.1)
print('Reclustering:', jet_def_rc)
rc = fjcontrib.Recluster(jet_def_rc, True)
sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
for i, j in enumerate(all_jets):
j_rc = rc.result(j)
print()
print('- [{0:3d}] orig pT={1:10.3f} reclustered pT={2:10.3f}'.format(
i, j.perp(), j_rc.perp()))
j_sd = sd.result(j)
print(' |-> after soft drop pT={0:10.3f} delta={1:10.3f}'.format(
j_sd.perp(),
j_sd.perp() - j.perp()))
sd_info = fjcontrib.get_SD_jet_info(j_sd)
print(
" |-> SD jet params z={0:10.3f} dR={1:10.3f} mu={2:10.3f}".format(
sd_info.z, sd_info.dR, sd_info.mu))
def main():
parser = argparse.ArgumentParser(description='pythia8 in python',
prog=os.path.basename(__file__))
parser.add_argument('-i',
'--input',
help='input file',
default='low',
type=str,
required=True)
parser.add_argument('--hepmc',
help='what format 2 or 3',
default=2,
type=int)
parser.add_argument('--nev', help='number of events', default=10, type=int)
args = parser.parse_args()
###
# now lets read the HEPMC file and do some jet finding
if args.hepmc == 3:
input_hepmc = pyhepmc_ng.ReaderAscii(args.input)
if args.hepmc == 2:
input_hepmc = pyhepmc_ng.ReaderAsciiHepMC2(args.input)
if input_hepmc.failed():
print("[error] unable to read from {}".format(args.input))
sys.exit(1)
# jet finder
# print the banner first
fj.ClusterSequence.print_banner()
print()
jet_R0 = 0.4
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
jet_selector = fj.SelectorPtMin(10.0) & fj.SelectorPtMax(
500.0) & fj.SelectorAbsEtaMax(3)
all_jets = []
event_hepmc = pyhepmc_ng.GenEvent()
pbar = tqdm.tqdm(range(args.nev))
while not input_hepmc.failed():
ev = input_hepmc.read_event(event_hepmc)
if input_hepmc.failed():
break
jets_hepmc = find_jets_hepmc(jet_def, jet_selector, event_hepmc)
all_jets.extend(jets_hepmc)
pbar.update()
if pbar.n >= args.nev:
break
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
lund_gen = fjcontrib.LundGenerator(jet_def_lund)
print('[i] making lund diagram for all jets...')
lunds = [lund_gen.result(j) for j in all_jets]
print('[i] listing lund plane points... Delta, kt - for {} selected jets'.
format(len(all_jets)))
for l in lunds:
if len(l) < 1:
continue
print('- jet pT={0:5.2f} eta={1:5.2f}'.format(l[0].pair().perp(),
l[0].pair().eta()))
print(' Deltas={}'.format([s.Delta() for s in l]))
print(' kts={}'.format([s.kt() for s in l]))
print()
print('[i] reclustering and using soft drop...')
jet_def_rc = fj.JetDefinition(fj.cambridge_algorithm, 0.1)
print('[i] Reclustering:', jet_def_rc)
all_jets_sd = []
rc = fjcontrib.Recluster(jet_def_rc, True)
sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
for i, j in enumerate(all_jets):
j_rc = rc.result(j)
print()
print('- [{0:3d}] orig pT={1:10.3f} reclustered pT={2:10.3f}'.format(
i, j.perp(), j_rc.perp()))
j_sd = sd.result(j)
print(' |-> after soft drop pT={0:10.3f} delta={1:10.3f}'.format(
j_sd.perp(),
j_sd.perp() - j.perp()))
all_jets_sd.append(j_sd)
sd_info = fjcontrib.get_SD_jet_info(j_sd)
print(
" |-> SD jet params z={0:10.3f} dR={1:10.3f} mu={2:10.3f}".format(
sd_info.z, sd_info.dR, sd_info.mu))
fout = ROOT.TFile('hepmc_jetreco.root', 'recreate')
lbins = logbins(1., 500, 50)
hJetPt04 = ROOT.TH1D("hJetPt04", "hJetPt04", 50, lbins)
hJetPt04sd = ROOT.TH1D("hJetPt04sd", "hJetPt04sd", 50, lbins)
[hJetPt04.Fill(j.perp()) for j in all_jets]
[hJetPt04sd.Fill(j.perp()) for j in all_jets_sd]
hLund = ROOT.TH2D("hLund", "hLund", 60, 0, 6, 100, -4, 5)
lunds = [lund_gen.result(j) for j in all_jets if j.perp() > 100]
j100 = [j for j in all_jets if j.perp() > 100]
print('{} jets above 100 GeV/c'.format(len(j100)))
for l in lunds:
for s in l:
hLund.Fill(math.log(1. / s.Delta()), math.log(s.kt()))
fout.Write()
def analyze_groomed_jet(self, grooming_setting, jet, jetR, R_max):
# Check additional acceptance criteria
if not self.utils.is_det_jet_accepted(jet):
return
jet_pt_ungroomed = jet.pt()
grooming_label = self.utils.grooming_label(grooming_setting)
# Construct SD groomer, and groom jet
if 'sd' in grooming_setting:
zcut = grooming_setting['sd'][0]
beta = grooming_setting['sd'][1]
sd = fjcontrib.SoftDrop(beta, zcut, jetR)
jet_def_recluster = fj.JetDefinition(fj.cambridge_algorithm, jetR)
reclusterer = fjcontrib.Recluster(jet_def_recluster)
sd.set_reclustering(True, reclusterer)
if self.debug_level > 2:
print('SoftDrop groomer is: {}'.format(sd.description()))
jet_sd = sd.result(jet)
# Construct Dynamical groomer, and groom jet
if 'dg' in grooming_setting:
a = grooming_setting['dg'][0]
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 2 * jetR)
dy_groomer = fjcontrib.DynamicalGroomer(jet_def_lund)
if self.debug_level > 2:
print('Dynamical groomer is: {}'.format(
dy_groomer.description()))
jet_dg_lund = dy_groomer.result(jet, a)
jet_dg = jet_dg_lund.pair()
# Compute groomed observables
if 'sd' in grooming_setting:
# If both SD and DG are specified, first apply DG, then SD
if 'dg' in grooming_setting:
if jet_dg.has_constituents():
jet_groomed = sd.result(jet_dg)
else:
return
else:
jet_groomed = jet_sd
sd_info = fjcontrib.get_SD_jet_info(jet_groomed)
theta_g = sd_info.dR / jetR
zg = sd_info.z
elif 'dg' in grooming_setting:
jet_groomed = jet_dg
# (https://phab.hepforge.org/source/fastjetsvn/browse/contrib/contribs/LundPlane/tags/1.0.3/LundGenerator.hh)
dR = jet_dg_lund.Delta()
theta_g = dR / jetR
zg = jet_dg_lund.z()
# Fill histograms
if R_max:
suffix = '_Rmax{}'.format(R_max)
else:
suffix = ''
if grooming_setting in self.obs_grooming_settings['theta_g']:
getattr(
self, 'h_theta_g_JetPt_R{}_{}{}'.format(
jetR, grooming_label,
suffix)).Fill(jet_pt_ungroomed, theta_g)
if grooming_setting in self.obs_grooming_settings['zg']:
getattr(self, 'h_zg_JetPt_R{}_{}{}'.format(
jetR, grooming_label, suffix)).Fill(jet_pt_ungroomed, zg)
# Fill jet axis difference
if 'jet_axis' in self.observable_list:
# Recluster with WTA (with larger jet R)
jet_def_wta = fj.JetDefinition(fj.cambridge_algorithm, 2 * jetR)
jet_def_wta.set_recombination_scheme(fj.WTA_pt_scheme)
if self.debug_level > 2:
print('WTA jet definition is:', jet_def_wta)
reclusterer_wta = fjcontrib.Recluster(jet_def_wta)
jet_wta = reclusterer_wta.result(jet)
self.fill_jet_axis_histograms(jet, jet_groomed, jet_wta, jetR,
grooming_setting, grooming_label)
