def __init__(self, outputname, enable_aa_trees=False):
self.outf = ROOT.TFile(outputname, 'recreate')
self.outf.cd()
self.t = ROOT.TTree('t', 't')
self.tw = RTreeWriter(tree=self.t)
self.taaw = None
self.tembw = None
self.tembwp = None
if enable_aa_trees:
self.taa = ROOT.TTree('taa', 'taa')
self.taaw = RTreeWriter(tree=self.taa)
self.temb = ROOT.TTree('temb', 'temb')
self.tembw = RTreeWriter(tree=self.temb)
self.tembp = ROOT.TTree('tembp', 'tembp')
self.tembwp = RTreeWriter(tree=self.tembp)
self.jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
self.dy_groomer_alphas = [0.1, 1.0, 2.0]
self.sd_zcuts = [0.1, 0.2, 0.3, 0.4]
self.gshop = fjcontrib.GroomerShop(self.jet_def_lund)
self.gshop_emb = fjcontrib.GroomerShop(self.jet_def_lund)
print(self.gshop.description())
self.sds = []
sd01 = fjcontrib.SoftDrop(0, 0.1, 1.0)
sd02 = fjcontrib.SoftDrop(0, 0.2, 1.0)
self.sds.append(sd01)
self.sds.append(sd02)
def fill_response_histograms(self, jet_det, jet_tru, jetR, alpha):
# Ungroomed jet pT
jet_pt_det = jet_det.pt()
jet_pt_tru = jet_tru.pt()
# just use kappa = 1 for now
kappa = 1
l_det = fjext.lambda_beta_kappa(jet_det, alpha, kappa, jetR)
l_tru = fjext.lambda_beta_kappa(jet_tru, alpha, kappa, jetR)
label = "R%s_%s" % (str(jetR), str(alpha))
''' Histograms per pT bin (currently unnecessary and cause clutter)
(pTmin, pTmax) = pT_bin(jet_det.pt(), self.pTbins)
if pTmin > -1e-3: # pTmin will be -1 if not a valid bin
getattr(self, ("hLambda_pT%i-%i_%s_mcdet" % (pTmin, pTmax, label)).replace('.', '')).Fill(l_det)
(pTmin, pTmax) = pT_bin(jet_sd_det.pt(), self.pTbins)
if pTmin > -1e-3: # pTmin will be -1 if not a valid bin
getattr(self, ("hLambda_pT%i-%i_%s_mcdet_SD" % (pTmin, pTmax, label)).replace('.', '')).Fill(l_sd_det)
'''
if l_tru != 0:
lambda_resolution = (l_det - l_tru) / l_tru
getattr(self, 'hAngResidual_JetPt_%s' % label).Fill(jet_pt_tru, lambda_resolution)
# Observable plots
getattr(self, 'hAng_JetPt_det_%s' % label).Fill(jet_pt_det, l_det)
getattr(self, 'hAng_JetPt_tru_%s' % label).Fill(jet_pt_tru, l_tru)
getattr(self, 'hResponse_ang_%s' % label).Fill(l_det, l_tru)
x = ([jet_pt_det, jet_pt_tru, l_det, l_tru])
x_array = array('d', x)
getattr(self, 'hResponse_JetPt_ang_%s' % label).Fill(x_array)
for i, gs in enumerate(self.grooming_settings):
gl = self.grooming_labels[i]
# soft drop jet
gshop_det = fjcontrib.GroomerShop(jet_det, jetR, self.reclustering_algorithm)
jet_sd_det = self.utils.groom(gshop_det, gs, jetR).pair()
gshop_tru = fjcontrib.GroomerShop(jet_tru, jetR, self.reclustering_algorithm)
jet_sd_tru = self.utils.groom(gshop_tru, gs, jetR).pair()
# lambda for soft drop jet
l_sd_det = fjext.lambda_beta_kappa(jet_det, jet_sd_det, alpha, kappa, jetR)
l_sd_tru = fjext.lambda_beta_kappa(jet_tru, jet_sd_tru, alpha, kappa, jetR)
# Should fill histograms using the ungroomed jet pT
getattr(self, 'hAng_JetPt_det_%s_%s' % (label, gl)).Fill(jet_pt_det, l_sd_det)
getattr(self, 'hAng_JetPt_tru_%s_%s' % (label, gl)).Fill(jet_pt_tru, l_sd_tru)
getattr(self, 'hResponse_ang_%s_%s' % (label, gl)).Fill(l_sd_det, l_sd_tru)
x = ([jet_pt_det, jet_pt_tru, l_sd_det, l_sd_tru])
x_array = array('d', x)
getattr(self, 'hResponse_JetPt_ang_%s_%s' % (label, gl)).Fill(x_array)
def fill_matched_jet_tree(self, tw, jetR, iev, jp, jh, jchh):
tw.fill_branch('iev', iev)
tw.fill_branch('ch', jchh)
tw.fill_branch('h', jh)
tw.fill_branch('p', jp)
for i, gs in enumerate(self.grooming_settings):
gl = self.grooming_labels[i]
# Groomed jets
gshop_chh = fjcontrib.GroomerShop(jchh, jetR,
self.reclustering_algorithm)
jet_ch_groomed_lund = self.utils.groom(gshop_chh, gs, jetR)
if not jet_ch_groomed_lund:
continue
gshop_h = fjcontrib.GroomerShop(jh, jetR,
self.reclustering_algorithm)
jet_h_groomed_lund = self.utils.groom(gshop_h, gs, jetR)
if not jet_h_groomed_lund:
continue
gshop_p = fjcontrib.GroomerShop(jp, jetR,
self.reclustering_algorithm)
jet_p_groomed_lund = self.utils.groom(gshop_p, gs, jetR)
if not jet_p_groomed_lund:
continue
obs_dict = None
for obs in self.observables:
if obs == "theta_g":
obs_dict = {
"p": jet_p_groomed_lund.Delta() / jetR,
"h": jet_h_groomed_lund.Delta() / jetR,
"ch": jet_ch_groomed_lund.Delta() / jetR
}
elif obs == "zg":
if self.skip_zg:
continue
obs_dict = {
"p": jet_p_groomed_lund.z(),
"h": jet_h_groomed_lund.z(),
"ch": jet_ch_groomed_lund.z()
}
else:
raise ValueError("Unrecognized observable " + obs)
for level in ["p", "h", "ch"]:
tw.fill_branch("%s_%s_%s" % (obs, level, gl),
obs_dict[level])
def fill_jet_histograms_MPI(self, jetR, jp, jh, jch):
for i, gs in enumerate(self.grooming_settings):
gl = self.grooming_labels[i]
# Groomed jets
gshop_chh = fjcontrib.GroomerShop(jch, jetR,
self.reclustering_algorithm)
jet_ch_groomed_lund = self.utils.groom(gshop_chh, gs, jetR)
if not jet_ch_groomed_lund:
continue
gshop_h = fjcontrib.GroomerShop(jh, jetR,
self.reclustering_algorithm)
jet_h_groomed_lund = self.utils.groom(gshop_h, gs, jetR)
if not jet_h_groomed_lund:
continue
gshop_p = fjcontrib.GroomerShop(jp, jetR,
self.reclustering_algorithm)
jet_p_groomed_lund = self.utils.groom(gshop_p, gs, jetR)
if not jet_p_groomed_lund:
continue
label = "R%s_%s" % (jetR, gl)
obs_dict = None
for obs in self.observables:
if obs == "theta_g":
obs_dict = {
"p": jet_p_groomed_lund.Delta() / jetR,
"h": jet_h_groomed_lund.Delta() / jetR,
"ch": jet_ch_groomed_lund.Delta() / jetR
}
elif obs == "zg":
if self.skip_zg:
continue
obs_dict = {
"p": jet_p_groomed_lund.z(),
"h": jet_h_groomed_lund.z(),
"ch": jet_ch_groomed_lund.z()
}
else:
raise ValueError("Unrecognized observable " + obs)
# 4D response matrices for "forward folding" from h to ch level
x = ([jch.pt(), jh.pt(), obs_dict['ch'], obs_dict['h']])
x_array = array('d', x)
getattr(
self, 'hResponse_JetPt_%s_h_ch_MPIon_%sScaled' %
(obs, label)).Fill(x_array)
def analyze_inclusive_jet(self, jet, fj_hadrons_positive, fj_hadrons_negative, jetR, constituent_threshold, charged=False):
# Get the corrected jet pt by subtracting the negative recoils within R
holes_in_jet = []
negative_pt = 0.
for hadron in fj_hadrons_negative:
if jet.delta_R(hadron) < jetR:
negative_pt += hadron.pt()
holes_in_jet.append(hadron)
jet_pt_uncorrected = jet.pt() # uncorrected pt: shower+recoil
jet_pt = jet_pt_uncorrected - negative_pt # corrected pt: shower+recoil-holes
if charged:
getattr(self, f'h_chjet_pt_recoils_R{jetR}_pt{constituent_threshold}').Fill(jet_pt, negative_pt)
else:
getattr(self, f'h_jet_pt_recoils_R{jetR}_pt{constituent_threshold}').Fill(jet_pt, negative_pt)
# Construct groomed jet
gshop = fjcontrib.GroomerShop(jet, jetR, fj.cambridge_algorithm)
# Fill histograms
if charged:
self.fill_charged_jet_histograms(jet, gshop, holes_in_jet, jet_pt, jetR, constituent_threshold)
else:
self.fill_full_jet_histograms(jet, jet_pt, jetR, constituent_threshold)
def fill_unmatched_jet_histograms(self, jet, jetR, hname):
# Loop through each jet subconfiguration (i.e. subobservable / grooming setting)
observable = self.observable_list[0]
for i in range(len(self.obs_settings[observable])):
obs_setting = self.obs_settings[observable][i]
grooming_setting = self.obs_grooming_settings[observable][i]
obs_label = self.utils.obs_label(obs_setting, grooming_setting)
# Groom jet, if applicable
if grooming_setting:
gshop = fjcontrib.GroomerShop(jet, jetR,
self.reclustering_algorithm)
jet_groomed_lund = self.utils.groom(gshop, grooming_setting,
jetR)
if not jet_groomed_lund:
continue
else:
jet_groomed_lund = None
# Call user function to fill histograms
self.fill_observable_histograms(hname, jet, jet_groomed_lund, jetR,
obs_setting, grooming_setting,
obs_label, jet.pt())
def fill_MPI_histograms(self, jetR, jet):
for i, gs in enumerate(self.grooming_settings):
gl = self.grooming_labels[i]
label = "R" + str(jetR) + '_' + gl
# Groomed jet
gshop = fjcontrib.GroomerShop(jet, jetR,
self.reclustering_algorithm)
jet_groomed_lund = self.utils.groom(gshop, gs, jetR)
if not jet_groomed_lund:
continue
obs_val = None
for obs in self.observables:
if obs == "theta_g":
obs_val = jet_groomed_lund.Delta() / jetR
elif obs == "zg":
if self.skip_zg:
continue
obs_val = jet_groomed_lund.z()
else:
raise ValueError("Unrecognized observable " + obs)
getattr(self,
'h_JetPt_%s_ch_MPIon_%sScaled' % (obs, label)).Fill(
jet.pt(), obs_val)
def analyze_accepted_jet(self, jet, jetR, suffix):
# Check additional acceptance criteria
if not self.utils.is_det_jet_accepted(jet):
return
# Fill base histograms
jet_pt_ungroomed = jet.pt()
if self.is_pp or (len(suffix) and self.fill_Rmax_indep_hists):
hZ = getattr(self, 'hZ_R{}'.format(jetR))
for constituent in jet.constituents():
z = constituent.pt() / jet_pt_ungroomed
hZ.Fill(jet_pt_ungroomed, z)
# Loop through each jet subconfiguration (i.e. subobservable / grooming setting)
for observable in self.observable_list:
for i in range(len(self.obs_settings[observable])):
obs_setting = self.obs_settings[observable][i]
grooming_setting = self.obs_grooming_settings[observable][i]
obs_label = self.utils.obs_label(obs_setting, grooming_setting)
# Groom jet, if applicable
if grooming_setting:
gshop = fjcontrib.GroomerShop(jet, jetR, self.reclustering_algorithm)
jet_groomed_lund = self.utils.groom(gshop, grooming_setting, jetR)
if not jet_groomed_lund:
continue
else:
jet_groomed_lund = None
# Call user function to fill histograms
self.fill_jet_histograms(observable, jet, jet_groomed_lund, jetR, obs_setting,
grooming_setting, obs_label, jet_pt_ungroomed, suffix)
def fill_full_jet_groomed_histograms(self, grooming_setting, jet, holes_in_jet, jet_pt, jetR):
# Construct groomed jet
gshop = fjcontrib.GroomerShop(jet, jetR, fj.cambridge_algorithm)
zcut = grooming_setting['zcut']
beta = grooming_setting['beta']
jet_groomed_lund = gshop.soft_drop(beta, zcut, jetR)
if not jet_groomed_lund:
return
if self.sqrts == 5020:
# CMS m_g
if grooming_setting in self.inclusive_jet_observables['mg_cms']['SoftDrop']:
pt_min = self.inclusive_jet_observables['mg_cms']['pt'][0]
pt_max = self.inclusive_jet_observables['mg_cms']['pt'][1]
if jetR in self.inclusive_jet_observables['mg_cms']['jet_R']:
if abs(jet.eta()) < (self.inclusive_jet_observables['mg_cms']['eta_cut']):
if jet_pt > pt_min and jet_pt < pt_max:
if jet_groomed_lund.Delta() > self.inclusive_jet_observables['mg_cms']['dR']:
mg = jet_groomed_lund.pair().m()
# Note: untagged jets will return negative value
self.observable_dict_event[f'inclusive_jet_mg_cms_R{jetR}_zcut{zcut}_beta{beta}'].append([jet_pt, mg])
# CMS z_g
if grooming_setting in self.inclusive_jet_observables['zg_cms']['SoftDrop']:
pt_min = self.inclusive_jet_observables['zg_cms']['pt'][0]
pt_max = self.inclusive_jet_observables['zg_cms']['pt'][1]
if jetR in self.inclusive_jet_observables['zg_cms']['jet_R']:
if abs(jet.eta()) < (self.inclusive_jet_observables['zg_cms']['eta_cut']):
if jet_pt > pt_min and jet_pt < pt_max:
if jet_groomed_lund.Delta() > self.inclusive_jet_observables['zg_cms']['dR']:
zg = jet_groomed_lund.z()
# Note: untagged jets will return negative value
self.observable_dict_event[f'inclusive_jet_zg_cms_R{jetR}_zcut{zcut}_beta{beta}'].append([jet_pt, zg])
def analyze_accepted_jet(self, jet, jetR, gridsize, diagnostic=False):
# Fill base histograms
jet_pt_ungroomed = jet.pt()
# Loop through each jet subconfiguration (i.e. subobservable / grooming setting)
# Note that the subconfigurations are defined by the first observable, if multiple are defined
observable = self.observable_list[0]
for i in range(len(self.obs_settings[observable])):
obs_setting = self.obs_settings[observable][i]
grooming_setting = self.obs_grooming_settings[observable][i]
obs_label = self.utils.obs_label(obs_setting, grooming_setting)
# Groom jet, if applicable
if grooming_setting:
gshop = fjcontrib.GroomerShop(jet, jetR,
self.reclustering_algorithm)
jet_groomed_lund = self.utils.groom(gshop, grooming_setting,
jetR)
if not jet_groomed_lund:
continue
else:
jet_groomed_lund = None
# Call user function to fill histograms
if not diagnostic:
self.fill_jet_histograms(jet, jet_groomed_lund, jetR,
obs_setting, grooming_setting,
obs_label, jet_pt_ungroomed, gridsize)
else:
self.fill_jet_histograms(jet, jet_groomed_lund, jetR,
obs_setting, grooming_setting,
obs_label, jet_pt_ungroomed, gridsize,
'_diagnostics')
def fill_unmatched_jet_tree(self, tw, jetR, iev, jet):
tw.fill_branch('iev', iev)
tw.fill_branch(self.level, jet)
for i, gs in enumerate(self.grooming_settings):
gl = self.grooming_labels[i]
# Groomed jet
gshop = fjcontrib.GroomerShop(jet, jetR,
self.reclustering_algorithm)
jet_groomed_lund = self.utils.groom(gshop, gs, jetR)
if not jet_groomed_lund:
continue
obs_val = None
for obs in self.observables:
if obs == "theta_g":
obs_val = jet_p_groomed_lund.Delta() / jetR
elif obs == "zg":
if self.skip_zg:
continue
obs_val = jet_p_groomed_lund.z()
tw.fill_branch("%s_%s_%s" % (obs, self.level, gl), obs_val)
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 fillJetHistograms(self, jet, jetR, alpha):
kappa = 1
l = fjext.lambda_beta_kappa(jet, alpha, kappa, jetR)
# Fill plots
getattr(self, "h_ang_JetPt_R%s_%s" % (jetR, alpha)).Fill(jet.pt(), l)
getattr(self, "h_ang_JetRap_R%s_%s" % (jetR, alpha)).Fill(jet.rap(), l)
getattr(self, "hJetPt_R%s" % str(jetR)).Fill(jet.pt())
#getattr(self, "hM_JetPt_R%s" % str(jetR)).Fill(jet_pt, jet.m())
for i, gs in enumerate(self.grooming_settings):
gl = self.grooming_labels[i]
gshop = fjcontrib.GroomerShop(jet, jetR, self.reclustering_algorithm)
jet_sd = self.utils.groom(gshop, gs, jetR).pair()
l_sd = fjext.lambda_alpha_kappa(jet, jet_sd, alpha, kappa, jetR)
# Should fill histograms using the ungroomed jet pT & rapidity
getattr(self, ("h_ang_JetPt_R%s_%s_%s" % (jetR, alpha, gl))).Fill(jet.pt(), l_sd)
getattr(self, ("h_ang_JetRap_R%s_%s_%s" % (jetR, alpha, gl))).Fill(jet.rap(), l_sd)
def fill_charged_jet_groomed_histograms(self, grooming_setting, jet, holes_in_jet, jet_pt, jetR):
# Construct groomed jet
gshop = fjcontrib.GroomerShop(jet, jetR, fj.cambridge_algorithm)
zcut = grooming_setting['zcut']
beta = grooming_setting['beta']
jet_groomed_lund = gshop.soft_drop(beta, zcut, jetR)
if not jet_groomed_lund:
return
if self.sqrts == 5020:
# Soft Drop
if grooming_setting in self.inclusive_chjet_observables['zg_alice']['SoftDrop']:
pt_min = self.inclusive_chjet_observables['zg_alice']['pt_ch'][0]
pt_max = self.inclusive_chjet_observables['zg_alice']['pt_ch'][1]
if abs(jet.eta()) < (self.inclusive_chjet_observables['zg_alice']['eta_cut_R'] - jetR):
if jetR in self.inclusive_chjet_observables['zg_alice']['jet_R']:
if jet_pt > pt_min and jet_pt < pt_max:
theta_g = jet_groomed_lund.Delta() / jetR
zg = jet_groomed_lund.z()
# Note: untagged jets will return negative value
self.observable_dict_event[f'inclusive_chjet_zg_alice_R{jetR}_zcut{zcut}_beta{beta}'].append(zg)
self.observable_dict_event[f'inclusive_chjet_tg_alice_R{jetR}_zcut{zcut}_beta{beta}'].append(theta_g)
def fill_jet_matches(self, jet_det, jetR, R_max):
# Set suffix for filling histograms
if R_max:
suffix = '_Rmax{}'.format(R_max)
else:
suffix = ''
# Get matched truth jet
if jet_det.has_user_info():
jet_truth = jet_det.python_info().match
if jet_truth:
jet_pt_det_ungroomed = jet_det.pt()
jet_pt_truth_ungroomed = jet_truth.pt()
JES = (jet_pt_det_ungroomed - jet_pt_truth_ungroomed) / jet_pt_truth_ungroomed
getattr(self, 'hJES_R{}{}'.format(jetR, suffix)).Fill(jet_pt_truth_ungroomed, JES)
# If Pb-Pb case, we need to keep jet_det, jet_truth, jet_pp_det
jet_pp_det = None
if not self.is_pp:
# Get pp-det jet
jet_pp_det = jet_truth.python_info().match
# Fill delta-pt histogram
if jet_pp_det:
jet_pp_det_pt = jet_pp_det.pt()
delta_pt = (jet_pt_det_ungroomed - jet_pp_det_pt)
getattr(self, 'hDeltaPt_emb_R{}_Rmax{}'.format(jetR, R_max)).Fill(jet_pt_truth_ungroomed, delta_pt)
# Loop through each jet subconfiguration (i.e. subobservable / grooming setting)
observable = self.observable_list[0]
for i in range(len(self.obs_settings[observable])):
obs_setting = self.obs_settings[observable][i]
grooming_setting = self.obs_grooming_settings[observable][i]
obs_label = self.utils.obs_label(obs_setting, grooming_setting)
if self.debug_level > 3:
print('obs_label: {}'.format(obs_label))
# Groom jets, if applicable
if grooming_setting:
# Groom det jet
gshop_det = fjcontrib.GroomerShop(jet_det, jetR, self.reclustering_algorithm)
jet_det_groomed_lund = self.utils.groom(gshop_det, grooming_setting, jetR)
if not jet_det_groomed_lund:
return
# Groom truth jet
gshop_truth = fjcontrib.GroomerShop(jet_truth, jetR, self.reclustering_algorithm)
jet_truth_groomed_lund = self.utils.groom(gshop_truth, grooming_setting, jetR)
if not jet_truth_groomed_lund:
return
else:
jet_det_groomed_lund = None
jet_truth_groomed_lund = None
# Call user function to fill histos
self.fill_matched_jet_histograms(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)
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 < 10:
args.nev = 10
for i in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
attach_pythia_particle_info = True
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal],
attach_pythia_particle_info)
jets = jet_selector(jet_def(parts))
if len(jets) < 2:
continue
gsetting = {'sd': [0.1, 0]}
g1 = groom(jets[0], 0.4, 0.1, 0)
print(' |-> GroomerShop::soft_drop 1 no copy', g1.as_string())
g2 = groom(jets[1], 0.4, 0.1, 0)
print(' |-> GroomerShop::soft_drop 2 no copy', g2.as_string())
g1_copy = groom_copy(jets[0], 0.4, 0.1, 0)
g2_copy = groom_copy(jets[1], 0.4, 0.1, 0)
print(' |-> GroomerShop::soft_drop 1 w/ copy', g1_copy.as_string())
print(' |-> GroomerShop::soft_drop 1 no copy', g1.as_string(),
' * this can be a hard to debug runtime error *')
print(' |-> GroomerShop::soft_drop 2 w/ copy', g2_copy.as_string())
print(' |-> GroomerShop::soft_drop 2 no copy', g2.as_string())
gshops = [
fjcontrib.GroomerShop(j, 0.4, fj.antikt_algorithm) for j in jets
]
for ij, jj in enumerate(jets):
print('orig jet:', jj, 'from gshop:', gshops[ij].jet(), 'SD:',
gshops[ij].soft_drop(0.0, 0.1, 0.4).as_string())
print(gshops[ij].lund_generator().description(),
'\n number of splits:', len(gshops[ij].lund_splits()))
gshops = [
fjcontrib.GroomerShop(j, 0.4, fj.cambridge_algorithm) for j in jets
]
for ij, jj in enumerate(jets):
print('orig jet:', jj, 'from gshop:', gshops[ij].jet(), 'SD:',
gshops[ij].soft_drop(0.0, 0.1, 0.4).as_string())
print(gshops[ij].lund_generator().description(),
'\n number of splits:', len(gshops[ij].lund_splits()))
# print (' xxx ')
# fjcontrib.setGroomer(jets[0], 0.4)
# fjcontrib.setGroomer(jets[0], 0.4)
# fjcontrib.setGroomer(jets[0], 0.4)
# print (' xxx ', fj.cambridge_algorithm)
# algo = fj.cambridge_algorithm
# this is removed from the library - GroomerShopUI
# [print(' |-> Groomed SD', fjcontrib.groom(j).soft_drop(0.0, 0.1, 0.4).as_string()) for j in jets]
# [print(' |-> Groomed max-tf', fjcontrib.groom(j).max_tf().as_string()) for j in jets]
print('---')
pythia.stat()
def fill_jet_matches(self, jet_det, jetR, R_max, fj_particles_det_holes,
fj_particles_truth_holes):
# Set suffix for filling histograms
if R_max:
suffix = '_Rmax{}'.format(R_max)
else:
suffix = ''
# Get matched truth jet
if jet_det.has_user_info():
jet_truth = jet_det.python_info().match
if jet_truth:
jet_pt_det_ungroomed = jet_det.pt()
jet_pt_truth_ungroomed = jet_truth.pt()
JES = (jet_pt_det_ungroomed -
jet_pt_truth_ungroomed) / jet_pt_truth_ungroomed
getattr(self, 'hJES_R{}{}'.format(jetR, suffix)).Fill(
jet_pt_truth_ungroomed, JES)
# If Pb-Pb case, we need to keep jet_det, jet_truth, jet_pp_det
jet_pp_det = None
if not self.is_pp:
# Get pp-det jet
jet_pp_det = jet_truth.python_info().match
# Fill delta-pt histogram
if jet_pp_det:
jet_pp_det_pt = jet_pp_det.pt()
delta_pt = (jet_pt_det_ungroomed - jet_pp_det_pt)
getattr(self, 'hDeltaPt_emb_R{}_Rmax{}'.format(
jetR, R_max)).Fill(jet_pt_truth_ungroomed,
delta_pt)
# Loop through each jet subconfiguration (i.e. subobservable / grooming setting)
observable = self.observable_list[0]
for i in range(len(self.obs_settings[observable])):
obs_setting = self.obs_settings[observable][i]
grooming_setting = self.obs_grooming_settings[observable][
i]
obs_label = self.utils.obs_label(obs_setting,
grooming_setting)
if self.debug_level > 3:
print('obs_label: {}'.format(obs_label))
# Groom jets, if applicable
if grooming_setting:
# Groom det jet
gshop_det = fjcontrib.GroomerShop(
jet_det, jetR, self.reclustering_algorithm)
jet_det_groomed_lund = self.utils.groom(
gshop_det, grooming_setting, jetR)
if not jet_det_groomed_lund:
continue
# Groom truth jet
gshop_truth = fjcontrib.GroomerShop(
jet_truth, jetR, self.reclustering_algorithm)
jet_truth_groomed_lund = self.utils.groom(
gshop_truth, grooming_setting, jetR)
if not jet_truth_groomed_lund:
continue
else:
jet_det_groomed_lund = None
jet_truth_groomed_lund = None
# If jetscape, pass the list of holes within R of the jet to the user
holes_in_det_jet = None
holes_in_truth_jet = None
if self.jetscape:
holes_in_det_jet = [
hadron for hadron in fj_particles_det_holes
if jet_det.delta_R(hadron) < jetR
]
holes_in_truth_jet = [
hadron for hadron in fj_particles_truth_holes
if jet_truth.delta_R(hadron) < jetR
]
# Get the corrected jet pt by subtracting the negative recoils within R
for hadron in holes_in_det_jet:
jet_pt_det_ungroomed -= hadron.pt()
for hadron in holes_in_truth_jet:
jet_pt_truth_ungroomed -= hadron.pt()
# Call user function to fill histos
self.fill_matched_jet_histograms(
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,
holes_in_det_jet=holes_in_det_jet,
holes_in_truth_jet=holes_in_truth_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('--ignore-mycfg', help="ignore some settings hardcoded here", default=True, action='store_true')
parser.add_argument('--part-info', help="attach particle info to psj", default=False, action='store_true')
parser.add_argument('--output', help="output file name", default='snowmass21_sim.root', type=str)
args = parser.parse_args()
# print the banner first
fj.ClusterSequence.print_banner()
print()
# set up our jet definition and a jet selector
jet_R04 = 0.4
jet_def_R04 = fj.JetDefinition(fj.antikt_algorithm, jet_R04)
jet_R10 = 1.0
jet_def_R10 = fj.JetDefinition(fj.antikt_algorithm, jet_R10)
# select jets
jet_selector = fj.SelectorPtMin(10.0) & fj.SelectorAbsEtaMax(2.)
# pythia init
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
fout = ROOT.TFile(args.output, 'recreate')
fout.cd()
ptbins = logbins(10, 1000, 25)
irbins = linbins(0, 1, 25)
nsbins = linbins(0, 25, 25)
print(ptbins)
print(irbins)
hERptR04 = ROOT.TH2D('hERptR04', 'hERptR04;p_{T}^{jet} (GeV/c); r', 25, ptbins, 25, irbins)
hERptR10 = ROOT.TH2D('hERptR10', 'hERptR10;p_{T}^{jet} (GeV/c); r', 25, ptbins, 25, irbins)
hR04nsd01pt = ROOT.TH2D('hR04nsd01pt', 'hR04nsd01pt', 25, ptbins, 25, nsbins)
hR04nsd02pt = ROOT.TH2D('hR04nsd02pt', 'hR04nsd02pt', 25, ptbins, 25, nsbins)
hR04nlundpt = ROOT.TH2D('hR04nlundpt', 'hR04nlundpt', 25, ptbins, 25, nsbins)
hR04sd02Rg = ROOT.TH2D('hR04sd02Rg', 'hR04sd02Rg', 25, ptbins, 25, irbins)
hR04sd02Rg_n = ROOT.TH2D('hR04sd02Rg_n', 'hR04sd02Rg_n', 25, ptbins, 25, irbins)
hR10nsd01pt = ROOT.TH2D('hR10nsd01pt', 'hR10nsd01pt', 25, ptbins, 25, nsbins)
hR10nsd02pt = ROOT.TH2D('hR10nsd02pt', 'hR10nsd02pt', 25, ptbins, 25, nsbins)
hR10nlundpt = ROOT.TH2D('hR10nlundpt', 'hR10nlundpt', 25, ptbins, 25, nsbins)
hR10sd02Rg = ROOT.TH2D('hR10sd02Rg', 'hR10sd02Rg', 25, ptbins, 25, irbins)
hR10sd02Rg_n = ROOT.TH2D('hR10sd02Rg_n', 'hR10sd02Rg_n', 25, ptbins, 25, irbins)
# event loop
if args.nev < 10:
args.nev = 100
for i in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
attach_pythia_particle_info = args.part_info
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], attach_pythia_particle_info)
jets_R04 = jet_selector(jet_def_R04(parts))
jets_R10 = jet_selector(jet_def_R10(parts))
gshops = [fjcontrib.GroomerShop(j, 0.4, fj.cambridge_algorithm) for j in jets_R04]
for ij, jj in enumerate(jets_R04):
for c in jj.constituents():
hERptR04.Fill(jj.perp(), c.delta_R(jj), c.perp())
lund_splits = gshops[ij].lund_splits()
n_SD_01 = len([s.z() for s in lund_splits if s.z() > 0.1])
hR04nsd01pt.Fill(jj.perp(), n_SD_01)
n_SD_02 = len([s.z() for s in lund_splits if s.z() > 0.2])
hR04nsd02pt.Fill(jj.perp(), n_SD_02)
n_splits = len(lund_splits)
hR04nlundpt.Fill(jj.perp(), n_splits)
sd02 = gshops[ij].soft_drop(0.0, 0.2, 1.)
hR04sd02Rg.Fill(jj.perp(), sd02.Delta())
[hR04sd02Rg_n.Fill(jj.perp(), s.Delta()) for s in lund_splits if s.z() > 0.2]
gshops = [fjcontrib.GroomerShop(j, 1.0, fj.cambridge_algorithm) for j in jets_R10]
for ij, jj in enumerate(jets_R10):
for c in jj.constituents():
hERptR10.Fill(jj.perp(), c.delta_R(jj), c.perp())
lund_splits = gshops[ij].lund_splits()
n_SD_01 = len([s.z() for s in lund_splits if s.z() > 0.1])
hR10nsd01pt.Fill(jj.perp(), n_SD_01)
n_SD_02 = len([s.z() for s in lund_splits if s.z() > 0.2])
hR10nsd02pt.Fill(jj.perp(), n_SD_02)
n_splits = len(lund_splits)
hR10nlundpt.Fill(jj.perp(), n_splits)
sd02 = gshops[ij].soft_drop(0.0, 0.2, 1.)
hR10sd02Rg.Fill(jj.perp(), sd02.Delta())
[hR10sd02Rg_n.Fill(jj.perp(), s.Delta()) for s in lund_splits if s.z() > 0.2]
pythia.stat()
fout.cd()
for h in [hERptR04, hERptR10]:
hi = part_int_h2(h)
hi.Write()
for h in [hERptR04, hR04nsd01pt, hR04nsd02pt, hR04nlundpt, hR04sd02Rg, hR04sd02Rg_n]:
tp = h.ProfileX(h.GetName() + '_pfx', 1, -1, 's')
tp.Write()
for h in [hERptR10, hR10nsd01pt, hR10nsd02pt, hR10nlundpt, hR10sd02Rg, hR10sd02Rg_n]:
tp = h.ProfileX(h.GetName() + '_pfx', 1, -1, 's')
tp.Write()
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 < 10:
args.nev = 10
for i in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
attach_pythia_particle_info = True
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal],
attach_pythia_particle_info)
jets = jet_selector(jet_def(parts))
for j in jets:
gshop = fjcontrib.GroomerShop(j)
# note these LundDeclustering objects can be streamed to a tree using RTreeStreamer
dg01 = gshop.dynamical(0.1)
idg01 = gshop.index(dg01)
dg20 = gshop.dynamical(2.0)
idg20 = gshop.index(dg20)
max_kt = gshop.max_kt()
imax_kt = gshop.index(max_kt)
max_pt_softer = gshop.max_pt_softer()
# check if the same split selected:
# if dg01.pair() == dg20.pair():
# or use indices
if idg01 == idg20 and idg01 > 0:
print('- interesting jet?:')
print(' dg01 :', dg01.as_string(), 'index dg01:',
idg01)
print(' dg20 :', dg20.as_string(), 'index dg20:',
idg20)
print(' max_kt :', max_kt.as_string(), 'index max_kt:',
imax_kt)
print(' max_pt_softer:', max_pt_softer.as_string())
print(' max_kappa :', gshop.max_kappa().as_string())
print(' max_tf :', gshop.max_tf().as_string())
print(' min_tf :', gshop.min_tf().as_string())
print(' max_z :', gshop.max_z().as_string())
print('softdrop check for jet:', j)
sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
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={} dR={} mu={}".format(
sd_info.z, sd_info.dR, sd_info.mu))
print(' |-> GroomerShop::soft_drop',
gshop.soft_drop(0, 0.1, 1.0).as_string())
# or call with no radius param - will use max allowed
# print(' |-> GroomerShop::soft_drop', gshop.soft_drop(0, 0.1).as_string())
pythia.stat()
def fill_RMs(self, jetR, gs, gl, jp, jh, jch):
# Groomed jets
gshop_chh = fjcontrib.GroomerShop(jch, jetR,
self.reclustering_algorithm)
jet_ch_groomed_lund = self.utils.groom(gshop_chh, gs, jetR)
if not jet_ch_groomed_lund:
return
gshop_h = fjcontrib.GroomerShop(jh, jetR, self.reclustering_algorithm)
jet_h_groomed_lund = self.utils.groom(gshop_h, gs, jetR)
if not jet_h_groomed_lund:
return
gshop_p = fjcontrib.GroomerShop(jp, jetR, self.reclustering_algorithm)
jet_p_groomed_lund = self.utils.groom(gshop_p, gs, jetR)
if not jet_p_groomed_lund:
return
label = "R%s_%s" % (jetR, gl)
obs_dict = None
for obs in self.observables:
if obs == "theta_g":
obs_dict = {
"p": jet_p_groomed_lund.Delta() / jetR,
"h": jet_h_groomed_lund.Delta() / jetR,
"ch": jet_ch_groomed_lund.Delta() / jetR
}
elif obs == "zg":
if self.skip_zg:
continue
obs_dict = {
"p": jet_p_groomed_lund.z(),
"h": jet_h_groomed_lund.z(),
"ch": jet_ch_groomed_lund.z()
}
else:
raise ValueError("Unrecognized observable " + obs)
if self.level in [None, 'ch']:
getattr(self,
'h_JetPt_%s_ch_MPIoff_%sScaled' % (obs, label)).Fill(
jch.pt(), obs_dict['ch'])
if self.level in [None, 'h']:
getattr(self,
'h_JetPt_%s_h_MPIoff_%sScaled' % (obs, label)).Fill(
jh.pt(), obs_dict['h'])
if self.level in [None, 'p']:
getattr(self,
'h_JetPt_%s_p_MPIoff_%sScaled' % (obs, label)).Fill(
jp.pt(), obs_dict['p'])
if self.level == None:
getattr(self, 'hResponse_%s_p_ch_MPIoff_%sScaled' %
(obs, label)).Fill(obs_dict['p'], obs_dict['ch'])
# Residual plots (with and without divisor in y-axis)
getattr(self,
"hDiff_JetPt_%s_MPIoff_%sScaled" % (obs, label)).Fill(
jch.pt(), obs_dict['p'] - obs_dict['ch'])
if obs_dict['p']: # prevent divide by 0
getattr(
self, "hResidual_JetPt_%s_MPIoff_%sScaled" %
(obs, label)).Fill(jp.pt(),
(obs_dict['p'] - obs_dict['ch']) /
obs_dict['p'])
# 4D response matrices for "forward folding" to ch level
x = ([jch.pt(), jp.pt(), obs_dict['ch'], obs_dict['p']])
x_array = array('d', x)
getattr(
self, 'hResponse_JetPt_%s_p_ch_MPIoff_%sScaled' %
(obs, label)).Fill(x_array)
x = ([jh.pt(), jp.pt(), obs_dict['h'], obs_dict['p']])
x_array = array('d', x)
getattr(
self, 'hResponse_JetPt_%s_p_h_MPIoff_%sScaled' %
(obs, label)).Fill(x_array)
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 groom_copy(jet, jetR, zcut, beta):
gshop = fjcontrib.GroomerShop(jet)
return gshop.soft_drop(beta, zcut, jetR).copy()
