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