def analyzeEvents(self):
# Fill det track histograms
for fj_particles_det in self.df_fjparticles['fj_particles_det']:
self.fillTrackHistograms(fj_particles_det)
fj.ClusterSequence.print_banner()
print()
for jetR in self.jetR_list:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector_det = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(self.eta_max - jetR)
jet_selector_truth_matched = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(self.eta_max - jetR)
print('jet definition is:', jet_def)
print('jet selector for det-level is:', jet_selector_det)
print('jet selector for truth-level matches is:', jet_selector_truth_matched,'\n')
# Iterate over the groupby and do jet-finding simultaneously for
# fj_1 and fj_2 per event, so that I can match jets -- and fill histograms
for fj_particles_det, fj_particles_truth in \
zip(self.df_fjparticles['fj_particles_det'],
self.df_fjparticles['fj_particles_truth']):
self.analyze_jets(fj_particles_det, fj_particles_truth, jet_def,
jet_selector_det, jet_selector_truth_matched)
def __init__(self, **kwargs):
self.configure_constants(
particle_eta_max=0.9,
particle_pt_max=
100, # reject jets with constituent with pT > max_particle_pt
jet_R=0.4,
jet_algorithm=fj.antikt_algorithm,
jet_pt_min=-200,
bge_rho_grid_size=-1, # no background subtraction for -1
sd_z_cuts=[0.1],
sd_betas=[0, 2],
show_progress=False,
name="MPJetAnalysis",
output_prefix='./')
self.jet_eta_max = self.particle_eta_max - self.jet_R * 1.05
self.jet_def = fj.JetDefinition(self.jet_algorithm, self.jet_R)
self.jet_selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(
self.jet_eta_max)
self.particle_selector = fj.SelectorPtMin(0.15) & fj.SelectorAbsRapMax(
self.particle_eta_max)
self.jet_area_def = fj.AreaDefinition(
fj.active_area_explicit_ghosts,
fj.GhostedAreaSpec(self.particle_eta_max))
self.bg_estimator = None
self.constit_subtractor = None
self.jet_output = None
self.event_output = None
self.fout = None
super(MPJetAnalysis, self).__init__(**kwargs)
self.filename_output = '{}{}.root'.format(self.output_prefix,
self.name)
if self.fout is None:
self.fout = ROOT.TFile(self.filename_output, 'recreate')
if self.jet_output is None:
self.jet_output = treewriter.RTreeWriter(tree_name='tjet',
fout=self.fout)
if self.event_output is None:
self.event_output = treewriter.RTreeWriter(tree_name='tev',
fout=self.fout)
fj.ClusterSequence.print_banner()
print()
print(self)
print(' . particle selector', self.particle_selector)
print(' . jet selector', self.jet_selector)
print(' . jet definition:', self.jet_def)
# define softdrops
self.sds = []
for beta in self.sd_betas:
for zcut in self.sd_z_cuts:
_sd = fjcontrib.SoftDrop(beta, zcut, self.jet_R)
self.sds.append(_sd)
for _sd in self.sds:
print(' . sd:', _sd.description())
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 = '../data/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)
def analyzeEvents(self):
# Fill det track histograms
[
self.fillTrackHistograms(fj_particles_det)
for fj_particles_det in self.df_fjparticles['fj_particles_det']
]
fj.ClusterSequence.print_banner()
print()
for jetR in self.jetR_list:
for beta in self.beta_list:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector_det = fj.SelectorPtMin(
5.0) & fj.SelectorAbsRapMax(0.9 - jetR)
jet_selector_truth_matched = fj.SelectorPtMin(5.0)
print('jet definition is:', jet_def)
print('jet selector for det-level is:', jet_selector_det, '\n')
print('jet selector for truth-level matches is:',
jet_selector_truth_matched, '\n')
# Then can use list comprehension to iterate over the groupby and do jet-finding
# simultaneously for fj_1 and fj_2 per event, so that I can match jets -- and fill histograms
result = [
self.analyzeJets(fj_particles_det, fj_particles_truth,
jet_def, jet_selector_det,
jet_selector_truth_matched, beta)
for fj_particles_det, fj_particles_truth in zip(
self.df_fjparticles['fj_particles_det'],
self.df_fjparticles['fj_particles_truth'])
]
def analyze_event(self, event):
# Get list of hadrons from the event, and fill some histograms
hadrons = event.hadrons(min_track_pt=self.min_track_pt)
self.fill_hadron_histograms(hadrons)
# Get list of final-state partons from the event, and fill some histograms
partons = event.final_partons()
self.fill_parton_histograms(partons)
# Create list of fastjet::PseudoJets
fj_hadrons = []
fj_hadrons = self.fill_fastjet_constituents(hadrons)
# Loop through specified jet R
for jetR in self.jetR_list:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(
self.min_jet_pt) & fj.SelectorAbsRapMax(5.)
if self.debug_level > 0:
print('jet definition is:', jet_def)
print('jet selector is:', jet_selector, '\n')
# Do jet finding
jets = []
jets_selected = []
cs = fj.ClusterSequence(fj_hadrons, jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
# Fill some jet histograms
self.fill_jet_histograms(jets_selected, jetR)
def analyzeEvents(self):
fj.ClusterSequence.print_banner()
print()
for jetR in self.jetR_list:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(0.9 -
jetR)
print('jet definition is:', jet_def)
print('jet selector is:', jet_selector, '\n')
# Define SoftDrop settings
sd = fjcontrib.SoftDrop(self.sd_beta, self.sd_zcut, jetR)
print('SoftDrop groomer is: {}'.format(sd.description()))
for beta in self.beta_list:
# Use list comprehension to do jet-finding and fill histograms
result = [
self.analyzeJets(fj_particles, jet_def, jet_selector, beta,
sd)
for fj_particles in self.df_fjparticles
]
def main():
# set up our jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, 0.6)
selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(4.5)
filename = '../data/single-event.dat'
# get the event
event = read_event(filename)
# cluster it
jets = selector(jet_def(event))
# print out some information about the event and clustering
print("Event has {0} particles".format(len(event)))
print("jet definition is:", jet_def)
print("jet selector is:", selector, "\n")
# print the jets
print_jets(jets)
# get internal information about one of the jets
if (len(jets) > 0):
print("Number of constituents of jets[0] is {0}".format(
len(jets[0].constituents())))
def analyze_event(self, event):
# Create list of fastjet::PseudoJets (separately for jet shower particles and holes)
fj_hadrons_positive = self.fill_fastjet_constituents(event,
select_status='+')
fj_hadrons_negative = self.fill_fastjet_constituents(event,
select_status='-')
# Fill hadron histograms for jet shower particles
self.fill_hadron_histograms(fj_hadrons_positive, status='+')
self.fill_hadron_histograms(fj_hadrons_negative, status='-')
# Loop through specified jet R
for jetR in self.jetR_list:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(
self.min_jet_pt) & fj.SelectorAbsRapMax(5.)
if self.debug_level > 0:
print('jet definition is:', jet_def)
print('jet selector is:', jet_selector, '\n')
# Do jet finding
cs = fj.ClusterSequence(fj_hadrons_positive, jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
# Fill some jet histograms
self.fill_jet_histograms(jets_selected, fj_hadrons_negative, jetR)
def analyze_file_list(file_inputs=[],
output_prefix='rg',
tree_name='tree_Particle'):
anl = []
bg_rho_range = fj.SelectorAbsRapMax(0.9)
bg_jet_def = fj.JetDefinition(fj.kt_algorithm, 0.4)
bg_area_def = fj.AreaDefinition(fj.active_area_explicit_ghosts,
fj.GhostedAreaSpec(0.9))
bg_estimator = fj.JetMedianBackgroundEstimator(bg_rho_range, bg_jet_def,
bg_area_def)
print('[i]', bg_estimator.description())
an_std = MPJetAnalysis(output_prefix=output_prefix,
name='std',
bg_estimator=bg_estimator)
anl.append(an_std)
g_bg_estimator = fj.GridMedianBackgroundEstimator(0.9, 0.4)
print('[i]', g_bg_estimator.description())
an_gbg = MPJetAnalysis(output_prefix=output_prefix,
name='bgb',
bg_estimator=g_bg_estimator)
anl.append(an_gbg)
cs004 = csubtractor.CEventSubtractor(alpha=0,
max_distance=0.4,
max_eta=0.9,
bge_rho_grid_size=0.25,
max_pt_correct=100)
an_cs_004 = MPJetAnalysis(output_prefix=output_prefix,
name='cs004',
bg_estimator=cs004.bge_rho,
constit_subtractor=cs004)
anl.append(an_cs_004)
cs404 = csubtractor.CEventSubtractor(alpha=4,
max_distance=0.4,
max_eta=0.9,
bge_rho_grid_size=0.25,
max_pt_correct=100)
an_cs_404 = MPJetAnalysis(output_prefix=output_prefix,
name='cs404',
bg_estimator=cs404.bge_rho,
constit_subtractor=cs404)
anl.append(an_cs_404)
ad = MPAnalysisDriver(file_list=file_inputs,
analyses_list=anl,
tree_name=tree_name)
ad.run()
print()
print(' ---')
print()
print(ad)
print('[i] done.')
def analyze_event(self, event):
# Initialize empty list for each output observable
self.initialize_output_lists()
# Create list of fastjet::PseudoJets (separately for jet shower particles and holes)
fj_hadrons_positive = self.fill_fastjet_constituents(event, select_status='+')
fj_hadrons_negative = self.fill_fastjet_constituents(event, select_status='-')
# Create list of charged particles
fj_hadrons_positive_charged = self.fill_fastjet_constituents(event, select_status='+',
select_charged=True)
fj_hadrons_negative_charged = self.fill_fastjet_constituents(event, select_status='-',
select_charged=True)
# Fill hadron histograms for jet shower particles
self.fill_hadron_histograms(fj_hadrons_positive, status='+')
self.fill_hadron_histograms(fj_hadrons_negative, status='-')
# Loop through specified jet R
for jetR in self.jet_R:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(self.min_jet_pt) & fj.SelectorAbsRapMax(self.max_jet_y)
# Full jets
# -----------------
cs = fj.ClusterSequence(fj_hadrons_positive, jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
# Fill inclusive full jet histograms
[self.analyze_inclusive_jet(jet, fj_hadrons_positive, fj_hadrons_negative, jetR, full_jet=True) for jet in jets_selected]
# Charged jets
# -----------------
cs_charged = fj.ClusterSequence(fj_hadrons_positive_charged, jet_def)
jets_charged = fj.sorted_by_pt(cs_charged.inclusive_jets())
jets_selected_charged = jet_selector(jets_charged)
# Fill inclusive charged jet histograms
[self.analyze_inclusive_jet(jet, fj_hadrons_positive_charged, fj_hadrons_negative_charged, jetR, full_jet=False) for jet in jets_selected_charged]
# Fill semi-inclusive jet correlations
if self.semi_inclusive_chjet_observables:
if self.sqrts == 2760:
jetR_list = self.semi_inclusive_chjet_observables['IAA_alice']['jet_R']+self.semi_inclusive_chjet_observables['nsubjettiness_alice']['jet_R']
elif self.sqrts == 200:
jetR_list = self.semi_inclusive_chjet_observables['IAA_star']['jet_R']
if jetR in jetR_list:
self.fill_semi_inclusive_chjet_histograms(jets_selected_charged, fj_hadrons_positive_charged, fj_hadrons_negative_charged, jetR)
# Fill dijet histograms
if self.dijet_observables:
self.fill_dijet_histograms(jets_selected, fj_hadrons_negative, jetR)
def analyze_event(self, event):
# Create list of fastjet::PseudoJets (separately for jet shower particles and holes)
fj_hadrons_positive_all = self.fill_fastjet_constituents(event, select_status='+')
fj_hadrons_negative_all = self.fill_fastjet_constituents(event, select_status='-')
# Create list of charged particles
fj_hadrons_positive_charged_all = self.fill_fastjet_constituents(event, select_status='+',
select_charged=True)
fj_hadrons_negative_charged_all = self.fill_fastjet_constituents(event, select_status='-',
select_charged=True)
# Fill hadron histograms for jet shower particles
self.fill_hadron_histograms(fj_hadrons_positive_all, status='+')
self.fill_hadron_histograms(fj_hadrons_negative_all, status='-')
# Loop through several different constituent thresholds
for constituent_threshold in self.constituent_threshold:
# Set constituent threshold
fj_hadrons_positive = [hadron for hadron in fj_hadrons_positive_all if hadron.pt() > constituent_threshold]
fj_hadrons_negative = [hadron for hadron in fj_hadrons_negative_all if hadron.pt() > constituent_threshold]
fj_hadrons_positive_charged = [hadron for hadron in fj_hadrons_positive_charged_all if hadron.pt() > constituent_threshold]
fj_hadrons_negative_charged = [hadron for hadron in fj_hadrons_negative_charged_all if hadron.pt() > constituent_threshold]
# Loop through specified jet R
for jetR in self.jet_R:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(self.min_jet_pt) & fj.SelectorAbsRapMax(self.max_jet_y)
if self.debug_level > 0:
print('jet definition is:', jet_def)
print('jet selector is:', jet_selector, '\n')
# Full jets
# -----------------
cs = fj.ClusterSequence(fj_hadrons_positive, jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
# Fill inclusive full jet histograms
[self.analyze_inclusive_jet(jet, fj_hadrons_positive, fj_hadrons_negative, jetR, constituent_threshold, charged=False) for jet in jets_selected]
# Charged jets
# -----------------
cs_charged = fj.ClusterSequence(fj_hadrons_positive_charged, jet_def)
jets_charged = fj.sorted_by_pt(cs_charged.inclusive_jets())
jets_selected_charged = jet_selector(jets_charged)
# Fill inclusive charged jet histograms
[self.analyze_inclusive_jet(jet, fj_hadrons_positive_charged, fj_hadrons_negative_charged, jetR, constituent_threshold, charged=True) for jet in jets_selected_charged]
# Fill jet correlations
self.fill_semi_inclusive_chjet_histograms(jets_selected_charged, fj_hadrons_positive_charged, fj_hadrons_negative_charged, jetR, constituent_threshold)
def analyze_event(self, fj_particles):
# Perform constituent subtraction for each R_max (do this once, for all jetR)
if not self.is_pp:
fj_particles_subtracted = [
self.constituent_subtractor[i].process_event(fj_particles)
for i, R_max in enumerate(self.max_distance)
]
# Loop through jetR, and process event for each R
for jetR in self.jetR_list:
# Keep track of whether to fill R-independent histograms
self.fill_R_indep_hists = (jetR == self.jetR_list[0])
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(0.9 -
jetR)
if self.debug_level > 2:
print('jet definition is:', jet_def)
print('jet selector is:', jet_selector, '\n')
# Analyze
if self.is_pp:
# Do jet finding
cs = fj.ClusterSequence(fj_particles, jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
self.analyze_jets(jets_selected, jetR)
else:
for i, R_max in enumerate(self.max_distance):
if self.debug_level > 1:
print('R_max: {}'.format(R_max))
# Keep track of whether to fill R_max-independent histograms
self.fill_Rmax_indep_hists = (i == 0)
# Perform constituent subtraction
rho = self.constituent_subtractor[i].bge_rho.rho()
if self.fill_R_indep_hists and self.fill_Rmax_indep_hists:
getattr(self, 'hRho').Fill(rho)
# Do jet finding (re-do each time, to make sure matching info gets reset)
cs = fj.ClusterSequence(fj_particles_subtracted[i],
jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
self.analyze_jets(jets_selected, jetR, R_max=R_max)
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 = rt.Recluster(jet_def_rc, True)
sd = rt.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 = rt.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 analyzeEvents(self):
fj.ClusterSequence.print_banner()
print()
for jetR in self.jetR_list:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(self.eta_max - jetR)
print('jet definition is:', jet_def)
print('jet selector is:', jet_selector,'\n')
for alpha in self.alpha_list:
for fj_particles in self.df_fjparticles:
# do jet-finding and fill histograms
self.analyzeJets(fj_particles, jet_def, jet_selector, alpha)
def analyze_event(self, fj_particles_hard, fj_particles_combined_beforeCS):
# Check that the entries exist appropriately
if type(fj_particles_hard) != fj.vectorPJ or type(
fj_particles_combined_beforeCS) != fj.vectorPJ:
print('fj_particles type mismatch -- skipping event')
return
# Perform constituent subtraction for each R_max
fj_particles_combined = []
for i, R_max in enumerate(self.max_distance):
if R_max == 0:
fj_particles_combined.append(fj_particles_combined_beforeCS)
else:
fj_particles_combined.append(
self.constituent_subtractor[i].process_event(
fj_particles_combined_beforeCS))
# Loop through jetR, and process event for each R
for jetR in self.jetR_list:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(
self.min_jet_pt) & fj.SelectorAbsRapMax(self.eta_max - jetR)
for i, R_max in enumerate(self.max_distance):
#print()
#print(R_max)
#print('Total number of combined particles: {}'.format(len([p.pt() for p in fj_particles_combined_beforeCS])))
#print('After constituent subtraction {}: {}'.format(i, len([p.pt() for p in fj_particles_combined[i]])))
# Do jet finding (re-do each time, to make sure matching info gets reset)
cs_combined = fj.ClusterSequence(fj_particles_combined[i],
jet_def)
jets_combined = fj.sorted_by_pt(cs_combined.inclusive_jets())
jets_combined_selected = jet_selector(jets_combined)
cs_hard = fj.ClusterSequence(fj_particles_hard, jet_def)
jets_hard = fj.sorted_by_pt(cs_hard.inclusive_jets())
jets_hard_selected = jet_selector(jets_hard)
self.analyze_jets(jets_combined_selected,
jets_hard_selected,
jetR,
R_max=R_max)
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")
# create a user-defined recombiner which checks for photons and
# sums user-indices (see below for details)
recombiner = UserRecombiner()
jet_def_user_recomb = fj.JetDefinition(fj.antikt_algorithm, 0.4)
jet_def_user_recomb.set_python_recombiner(recombiner)
print("jet definition with user recombiner is:", jet_def_user_recomb)
filename = '../data/Pythia-dijet-ptmin100-lhc-pileup-1ev.dat'
f = open(filename, 'r')
# get the event
iev = 0
while True:
event = read_event(f)
iev += 1
if (len(event) == 0): break
# cluster it with the default recombiner and print some info
jets = selector(jet_def(event))
print("Event {0} has {1} particles".format(iev, len(event)))
print_jets(jets)
print("")
# now re-cluster with our user-defined recombiner
jets = selector(jet_def_user_recomb(event))
print("")
print("CHECK: below, the user index (built through the recombiner)")
print(" should correspond to the number of photons")
print("")
print_jets(jets)
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 = '../data/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))
# Create a FastJet selector based on a Python function (which
# takes a PseudoJet and returns True if the PseudoJet passes the
# selection condition). The resulting selector can be used in the
# same way as any normal FastJet selector.
#
# See print_jets below for other examples of python-defined
# Selectors (built either from a class or from a function)
sel_pileup = fj.SelectorPython(is_pileup)
n_pileup_particles = sel_pileup.count(event)
# print some info
print("Event {0} has {1} particles (of which {2} from pileup)".format(
iev, len(event), n_pileup_particles))
print_jets(jets)
def do_cs_jet_by_jet(full_event, ptmin=100.):
# clustering with ghosts and get the jets
jet_def = fj.JetDefinition(fj.antikt_algorithm, 0.4)
ghost_RapMax = 3.
ghost_spec = fj.GhostedAreaSpec(ghost_RapMax, 1, ghost_area)
area_def = fj.AreaDefinition(fj.active_area_explicit_ghosts, ghost_spec)
clust_seq_full = fj.ClusterSequenceArea(full_event, jet_def, area_def)
full_jets = clust_seq_full.inclusive_jets(ptmin)
# background estimation
jet_def_bge = fj.JetDefinition(fj.kt_algorithm, 0.4)
area_def_bge = fj.AreaDefinition(fj.active_area_explicit_ghosts,
ghost_spec)
bge_range = fj.SelectorAbsRapMax(3.0)
bge = fj.JetMedianBackgroundEstimator(bge_range, jet_def_bge, area_def_bge)
bge.set_particles(full_event)
# subtractor
subtractor = cs.ConstituentSubtractor()
subtractor.set_distance_type(0)
subtractor.set_max_distance(max_distance)
subtractor.set_alpha(alpha)
subtractor.set_max_eta(3.0)
subtractor.set_background_estimator(bge)
subtractor.set_common_bge_for_rho_and_rhom()
#sel_max_pt = fj.SelectorPtMax(10)
#subtractor.set_particle_selector(sel_max_pt)
# do subtraction
corrected_jets = cs.PseudoJetVec()
for jet in full_jets:
subtracted_jet = subtractor.result(jet)
corrected_jets.push_back(subtracted_jet)
# pt cut
selector = fj.SelectorPtMin(ptmin)
return selector(corrected_jets), clust_seq_full
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(5.0) & fj.SelectorAbsRapMax(4.5)
print("jet definition is:", jet_def)
print("jet selector is:", selector, "\n")
#filename = '../data/single-event.dat'
filename = '../data/Pythia-PtMin1000-LHC-10ev.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
jets = selector(jet_def(event))
print("Event {0} has {1} particles".format(iev, len(event)))
# cluster it
for ijet in range(len(jets)):
print("jet {0} pt and rap: {1} {2}".format(ijet, jets[ijet].pt(),
jets[ijet].rap()))
# make sure jet-related information is correctly held
if (len(jets) > 0):
print("Number of constituents of jets[0] is {0}".format(
len(jets[0].constituents())))
def analyze_event(self, fj_particles, gridsize=None, diagnostic=False):
self.event_bck_df = None
self.event_bck_df = self.bck_df[self.bck_df['ev_id'] == self.ev_idx[
self.event_number]]
#print(self.event_number)
self.event_number += 1
if self.event_number > self.nEvents:
return
if len(fj_particles) > 1:
if np.abs(fj_particles[0].eta() - fj_particles[1].eta()) < 1e-10:
if fj_particles[0].pt() < 1e-5:
print(
'WARNING: Duplicate DUMMY particles may be present in event',
self.event_number)
else:
print(
'WARNING: Duplicate JET particles may be present in event',
self.event_number)
#[print(p.eta(),p.pt()) for p in fj_particles]
# If constituent subtraction is enabled, perform subtraction on the event
if self.constituent_subtractor:
# Convert df of pt/eta/phi of thermal particles to list of fastjet particles, for convenience
thermal_particles = []
if len(self.event_bck_df) != 0:
thermal_particles = self.get_fjparticles(self.event_bck_df)
# Drop specified fraction of thermal particles -- loop manually since the wrapped functions are a bit funky
thermal_particles_selected = []
for i, p in enumerate(thermal_particles):
if np.random.uniform() >= self.thermal_rejection_fraction:
thermal_particles_selected.append(p)
#print(f'n_thermals before: {len(thermal_particles)}')
#print(f'n_thermals after: {len(thermal_particles_selected)}')
# Determine rho from thermal particles
self.constituent_subtractor.bge_rho.set_particles(
thermal_particles_selected)
# Perform subtraction over full event (jet+recoil)
fj_particles = self.constituent_subtractor.subtractor.subtract_event(
fj_particles)
#rho = self.constituent_subtractor.bge_rho.rho()
#print(f'rho: {rho}')
#print()
# Loop through jetR, and process event for each R
for jetR in self.jetR_list:
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(0.9 -
jetR)
# Do jet finding
jets_selected = None
cs = fj.ClusterSequence(fj_particles, jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
# If no jets were selected, move on to next event
if len(jets_selected) == 0:
continue
#----------------------------------------------
fj_subtracted_constituents = None
subtracted_jets = []
if not self.thermal_subtraction_method:
subtracted_jets = jets_selected
elif '4momsub' in self.thermal_subtraction_method.lower():
'''
------------------------------------------------
Thermal subtraction using 4MomSub method
------------------------------------------------
1. Cluster the initial jet collection from the final state particles (including dummies).
2. Compile a list of the thermal momenta (particles in the HepMC event record with status code 3).
For each jet, get the list of thermal momenta that have DeltaR < 1x10-5 with one of the jet constituents, i.e a dummy particle.
4. Sum up the four-momenta of the matched thermal momenta. This constitutes the background.
5. For each jet subtract the background four-momentum from the jet's four momentum, this provides the corrected jet collection.
6. Calculate jet observables from corrected jet four-momenta.
'''
for jet in jets_selected:
fj_subtracted_constituents = None
fj_subtracted_constituents = self.subtract_thermal_4momsub(
jet, jetR)
jet_def_largerR = fj.JetDefinition(fj.antikt_algorithm,
2. * jetR)
cs_largerR = fj.ClusterSequence(fj_subtracted_constituents,
jet_def_largerR)
subtracted_jets = fj.sorted_by_pt(
cs_largerR.inclusive_jets())
if len(subtracted_jets) > 1:
print(
'WARNING: Got more than one subtracted jet out of one input jet'
)
elif 'gridsub' in self.thermal_subtraction_method.lower():
'''
------------------------------------------------
Thermal subtraction using GridSub1 method
------------------------------------------------
1. Cluster the initial jet collection from the final state particles.
2. Compile a list of the thermal momenta (particles in the HepMC event record with status code 3).
3. Define the grid resolution and place grid over jets.
4. Inside each cell sum the jet constituents' four-momenta and subtract the thermal
four-momenta that fall into the cell (note: no matching is required, thermal four momenta
with distance DeltaR < R from the jet axis are considered), providing a single four momentum for each cell.
5. In case a cell contains more thermal momentum than jet constituents, the cells is set
to have zero four-momentum. This is deemed to be the case when the (scalar) pT of
the thermal component is larger than the pT of the particle component.
6. Re-cluster the jets with the cell four-momenta as input to get the final, subtracted jets.
7. Calculate jet observables from re-clustered jets.
'''
fj_subtracted_constituents = self.subtract_thermal_gridsub1(
jets_selected, jetR, gridsize, diagnostic)
if not fj_subtracted_constituents:
continue
cs = fj.ClusterSequence(fj_subtracted_constituents, jet_def)
subtracted_jets = fj.sorted_by_pt(cs.inclusive_jets())
#----------------------------------------------
result = [
self.analyze_accepted_jet(jet, jetR, gridsize, diagnostic)
for jet in subtracted_jets
]
def analyze_event(self,
fj_particles_det,
fj_particles_truth,
fj_particles_det_holes=None,
fj_particles_truth_holes=None):
self.event_number += 1
if self.event_number > self.event_number_max:
return
if self.debug_level > 1:
print('-------------------------------------------------')
print('event {}'.format(self.event_number))
# Check that the entries exist appropriately
# (need to check how this can happen -- but it is only a tiny fraction of events)
if type(fj_particles_det) != fj.vectorPJ or type(
fj_particles_truth) != fj.vectorPJ:
print('fj_particles type mismatch -- skipping event')
return
if self.jetscape:
if type(fj_particles_det_holes) != fj.vectorPJ or type(
fj_particles_truth_holes) != fj.vectorPJ:
print('fj_particles_holes type mismatch -- skipping event')
return
if len(fj_particles_truth) > 1:
if np.abs(fj_particles_truth[0].pt() -
fj_particles_truth[1].pt()) < 1e-10:
print('WARNING: Duplicate particles may be present')
print([p.user_index() for p in fj_particles_truth])
print([p.pt() for p in fj_particles_truth])
# If Pb-Pb, construct embedded event (do this once, for all jetR)
if not self.is_pp:
# If thermal model, generate a thermal event and add it to the det-level particle list
if self.thermal_model:
fj_particles_combined_beforeCS = self.thermal_generator.load_event(
)
# Form the combined det-level event
# The pp-det tracks are each stored with a unique user_index >= 0
# (same index in fj_particles_combined and fj_particles_det -- which will be used in prong-matching)
# The thermal tracks are each stored with a unique user_index < 0
[
fj_particles_combined_beforeCS.push_back(p)
for p in fj_particles_det
]
# Main case: Get Pb-Pb event and embed it into the det-level particle list
else:
fj_particles_combined_beforeCS = self.process_io_emb.load_event(
)
# Form the combined det-level event
# The pp-det tracks are each stored with a unique user_index >= 0
# (same index in fj_particles_combined and fj_particles_det -- which will be used in prong-matching)
# The Pb-Pb tracks are each stored with a unique user_index < 0
[
fj_particles_combined_beforeCS.push_back(p)
for p in fj_particles_det
]
# Perform constituent subtraction for each R_max
fj_particles_combined = [
self.constituent_subtractor[i].process_event(
fj_particles_combined_beforeCS)
for i, R_max in enumerate(self.max_distance)
]
if self.debug_level > 3:
print([p.user_index() for p in fj_particles_truth])
print([p.pt() for p in fj_particles_truth])
print([p.user_index() for p in fj_particles_det])
print([p.pt() for p in fj_particles_det])
print([p.user_index() for p in fj_particles_combined_beforeCS])
print([p.pt() for p in fj_particles_combined_beforeCS])
if self.dry_run:
return
# Loop through jetR, and process event for each R
for jetR in self.jetR_list:
# Keep track of whether to fill R-independent histograms
self.fill_R_indep_hists = (jetR == self.jetR_list[0])
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector_det = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(
0.9 - jetR)
jet_selector_truth_matched = fj.SelectorPtMin(
5.0) & fj.SelectorAbsRapMax(0.9)
if self.debug_level > 2:
print('')
print('jet definition is:', jet_def)
print('jet selector for det-level is:', jet_selector_det)
print('jet selector for truth-level matches is:',
jet_selector_truth_matched)
# Analyze
if self.is_pp:
# Find pp det and truth jets
cs_det = fj.ClusterSequence(fj_particles_det, jet_def)
jets_det_pp = fj.sorted_by_pt(cs_det.inclusive_jets())
jets_det_pp_selected = jet_selector_det(jets_det_pp)
cs_truth = fj.ClusterSequence(fj_particles_truth, jet_def)
jets_truth = fj.sorted_by_pt(cs_truth.inclusive_jets())
jets_truth_selected = jet_selector_det(jets_truth)
jets_truth_selected_matched = jet_selector_truth_matched(
jets_truth)
self.analyze_jets(jets_det_pp_selected, jets_truth_selected,
jets_truth_selected_matched, jetR)
else:
for i, R_max in enumerate(self.max_distance):
if self.debug_level > 1:
print('')
print('R_max: {}'.format(R_max))
print('Total number of combined particles: {}'.format(
len([
p.pt() for p in fj_particles_combined_beforeCS
])))
print('After constituent subtraction {}: {}'.format(
i,
len([p.pt() for p in fj_particles_combined[i]])))
# Keep track of whether to fill R_max-independent histograms
self.fill_Rmax_indep_hists = (i == 0)
# Perform constituent subtraction on det-level, if applicable
self.fill_background_histograms(
fj_particles_combined_beforeCS,
fj_particles_combined[i], jetR, i)
# Do jet finding (re-do each time, to make sure matching info gets reset)
cs_det = fj.ClusterSequence(fj_particles_det, jet_def)
jets_det_pp = fj.sorted_by_pt(cs_det.inclusive_jets())
jets_det_pp_selected = jet_selector_det(jets_det_pp)
cs_truth = fj.ClusterSequence(fj_particles_truth, jet_def)
jets_truth = fj.sorted_by_pt(cs_truth.inclusive_jets())
jets_truth_selected = jet_selector_det(jets_truth)
jets_truth_selected_matched = jet_selector_truth_matched(
jets_truth)
cs_combined = fj.ClusterSequence(fj_particles_combined[i],
jet_def)
jets_combined = fj.sorted_by_pt(
cs_combined.inclusive_jets())
jets_combined_selected = jet_selector_det(jets_combined)
self.analyze_jets(
jets_combined_selected,
jets_truth_selected,
jets_truth_selected_matched,
jetR,
jets_det_pp_selected=jets_det_pp_selected,
R_max=R_max,
fj_particles_det_holes=fj_particles_det_holes,
fj_particles_truth_holes=fj_particles_truth_holes)
def analyze_event(self, fj_particles):
self.event_number += 1
if self.event_number > self.event_number_max:
return
if self.debug_level > 1:
print('-------------------------------------------------')
print('event {}'.format(self.event_number))
if len(fj_particles) > 1:
if np.abs(fj_particles[0].pt() - fj_particles[1].pt()) < 1e-10:
print('WARNING: Duplicate particles may be present')
print([p.user_index() for p in fj_particles])
print([p.pt() for p in fj_particles])
# Perform constituent subtraction for each R_max (do this once, for all jetR)
if not self.is_pp:
fj_particles_subtracted = { R_max : cs.process_event(fj_particles) for \
R_max, cs in self.constituent_subtractor.items() }
# Loop through jetR, and process event for each R
for jetR in self.jetR_list:
# Keep track of whether to fill R-independent histograms
self.fill_R_indep_hists = (jetR == self.jetR_list[0])
# Set jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
jet_selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsRapMax(0.9 - jetR)
if self.debug_level > 2:
print('jet definition is:', jet_def)
print('jet selector is:', jet_selector,'\n')
# Analyze
if self.is_pp or self.include_no_subtraction:
# Do jet finding
cs = fj.ClusterSequence(fj_particles, jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
self.analyze_jets(jets_selected, jetR)
if not self.is_pp:
max_distance = self.max_distance if isinstance(self.max_distance, list) else \
self.max_distance[jetR]
for R_max in max_distance:
if self.debug_level > 1:
print('R_max: {}'.format(R_max))
# Keep track of whether to fill R_max-independent histograms
self.fill_Rmax_indep_hists = (R_max == max_distance[0])
# Perform constituent subtraction
rho = self.constituent_subtractor[R_max].bge_rho.rho()
if self.fill_R_indep_hists and self.fill_Rmax_indep_hists:
getattr(self, 'hRho').Fill(rho)
# Do jet finding (re-do each time, to make sure matching info gets reset)
cs = fj.ClusterSequence(fj_particles_subtracted[R_max], jet_def)
jets = fj.sorted_by_pt(cs.inclusive_jets())
jets_selected = jet_selector(jets)
self.analyze_jets(jets_selected, jetR, R_max = R_max)
def run(data, n_events = 1000000):
out = []
njets = []
met = []
rho = []
jets_corr = []
area = []
# run jet clustering with AntiKt, R=1.0
R = 1.0
jet_def = fj.JetDefinition(fj.antikt_algorithm, R)
# Area Definition
ghost_maxrap = 4.7
area_def = fj.AreaDefinition(fj.active_area, fj.GhostedAreaSpec(ghost_maxrap))
# Background estimator
select_rapidity = fj.SelectorAbsRapMax(ghost_maxrap)
bge = fj.JetMedianBackgroundEstimator(select_rapidity, jet_def, area_def)
# Loop over events
for ievt in range(n_events):
# Build a list of all particles and MET Information
pjs = []
pjmet = fj.PseudoJet()
pjmets = fj.PseudoJet()
for i in range(int(data.shape[1]/3)):
pj = fj.PseudoJet()
pj.reset_PtYPhiM(data.at[ievt, 3*i+0], data.at[ievt, 3*i+1], data.at[ievt, 3*i+2], 0)
if pj.pt() > 1.0:
pjs.append(pj)
pjmet.reset_momentum(-pj.px(), -pj.py(), 0, pj.E())
pjmets = pjmets + pjmet
met.append(pjmets)
# Cluster sequence
clust_seq = fj.ClusterSequenceArea(pjs, jet_def, area_def)
jets = fj.sorted_by_pt(clust_seq.inclusive_jets())
jets = [j for j in jets if j.pt() > 30. and j.eta() < 4.7]
area.append([jets[0].area(), jets[1].area()])
# Save the two leading jets and njets
jets_sel = (fj.SelectorNHardest(2))(jets)
out.append(jets_sel)
njets.append(len(jets))
# Background estimator
bge.set_particles(pjs)
rho.append(bge.rho())
# Correct Jets
sub = fj.Subtractor(bge)
sub_jets = sub(jets_sel)
jets_corr.append(sub_jets)
return out, area, met, njets, rho, jets_corr
