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()