def main():
parser = argparse.ArgumentParser(description='pythia8 in python',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
hepmc2output = "pythia_gen_test_hepmc2.dat"
pyhepmc2writer = pythiaext.Pythia8HepMC2Wrapper(hepmc2output)
# experimental and not functioning as of now - switching off
# hepmc3output = "pyhia_gen_test_hepmc3.dat"
# pyhepmc3writer = pythiahepmc3.Pythia8HepMC3Wrapper(hepmc3output)
mycfg = ['PhaseSpace:pThatMin = 100']
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if args.nev < 10:
args.nev = 10
for i in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
pyhepmc2writer.fillEvent(pythia)
# pyhepmc3writer.fillEvent(pythia)
pythia.stat()
print("[i] file written: {}".format(hepmc2output))
def generate():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly', prog=os.path.basename(__file__))
parser.add_argument('-o', '--output', help='output file name', default='hjet.root', type=str)
parser.add_argument('-t', '--trigger', help='trigger pt', default=6., type=float)
pyconf.add_standard_pythia_args(parser)
parser.add_argument('--charged', default=False, action='store_true')
args = parser.parse_args()
# print the banner first
fj.ClusterSequence.print_banner()
print()
# mycfg = ['PhaseSpace:pThatMin = 6']
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if args.nev < 1:
args.nev = 1
# jet_particle_eta_max = 0.9
hjet = HJetAnalysis(jet_particle_eta_max=0.9, output=args.output)
for iev in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal, pythiafjext.kCharged])
if len(parts) < 1:
continue
hjet.analyze_event(iev, parts, pythia)
hjet.finalize()
pythia.stat()
def PythiaPartonHadron(self, args):
# Create ROOT TTree file for storing raw PYTHIA particle information
outf_path = os.path.join(self.output_dir, args.tree_output_fname)
outf = ROOT.TFile(outf_path, 'recreate')
outf.cd()
pinfo('user seed for pythia', self.user_seed)
# mycfg = ['PhaseSpace:pThatMin = 100']
mycfg = ['Random:setSeed=on', 'Random:seed={}'.format(self.user_seed)]
mycfg.append('HadronLevel:all=off')
####################################################################
# PYTHIA instance with MPI off
setattr(args, "py_noMPI", True)
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
self.calculate_events(pythia)
pythia.stat()
print()
####################################################################
# PYTHIA instance with MPI on
setattr(args, "py_noMPI", False)
pythia_MPI = pyconf.create_and_init_pythia_from_args(args, mycfg)
self.calculate_events(pythia_MPI, MPIon=True)
pythia_MPI.stat()
print()
####################################################################
# Print out some final statistics
print("N total final MPI-off events:", int(self.N_events_MPIoff), "with",
int(pythia.info.nAccepted() - self.N_events_MPIoff),
"events rejected at hadronization step",
"\nN total final MPI-on events:", int(self.N_events_MPIon), "with",
int(pythia_MPI.info.nAccepted() - self.N_events_MPIon),
"events rejected at hadronization step")
####################################################################
# Save output trees in ROOT file
self.fill_write_trees()
self.save_xsec_N(pythia.info.sigmaGen(), self.N_events_MPIoff,
pythia_MPI.info.sigmaGen(), self.N_events_MPIon)
outf.Write()
outf.Close()
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 pythia_parton_hadron(self, args):
# Create ROOT TTree file for storing raw PYTHIA particle information
outf_path = os.path.join(self.output_dir, args.tree_output_fname)
outf = ROOT.TFile(outf_path, 'recreate')
outf.cd()
# Initialize response histograms
self.initialize_hist()
pinfo('user seed for pythia', self.user_seed)
mycfg = ['Random:setSeed=on', 'Random:seed={}'.format(self.user_seed)]
mycfg.append('HadronLevel:all=off')
# print the banner first
fj.ClusterSequence.print_banner()
print()
# -------------------------------
# PYTHIA instance with MPI off and ISR on
setattr(args, "py_noMPI", True)
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
self.init_jet_tools()
self.calculate_events(pythia)
pythia.stat()
print()
# -------------------------------
# PYTHIA instance with MPI on and ISR on
setattr(args, "py_noMPI", False)
pythia_MPI = pyconf.create_and_init_pythia_from_args(args, mycfg)
self.calculate_events(pythia_MPI, MPIon=True)
print()
self.scale_print_final_info(pythia, pythia_MPI)
outf.Write()
outf.Close()
self.save_output_objects()
def __init__(self, **kwargs):
self.configure_from_args(pthatmin=100,
eta_max=1,
jet_pt_min=10,
jet_R0=0.4)
super(PythiaJetty, self).__init__(**kwargs)
parser = argparse.ArgumentParser(
description='pythia8 fastjet on the fly', prog=None)
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args('')
args.py_pthatmin = self.pthatmin
mycfg = []
self.pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not self.pythia:
print("[e] pythia initialization failed.")
self.parts_pythia = None
def main():
parser = argparse.ArgumentParser(description='pythia8 in python', prog=os.path.basename(__file__))
parser.add_argument('-o', '--output', help='output file name', default='pythia_hepmc.dat', type=str)
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
hepmc2output = args.output
pyhepmc2writer = pythiaext.Pythia8HepMC2Wrapper(hepmc2output)
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if args.nev < 10:
args.nev = 10
for i in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
pyhepmc2writer.fillEvent(pythia)
pythia.stat()
print("[i] file written: {}".format(hepmc2output))
def main():
parser = argparse.ArgumentParser(description='pythia8 in python',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
max_eta_hadron = 3
jet_R0 = 0.4
jet_selector = fj.SelectorPtMin(100.0) & fj.SelectorPtMax(
125.0) & fj.SelectorAbsEtaMax(max_eta_hadron - 1.05 * jet_R0)
parts_selector_h = fj.SelectorAbsEtaMax(max_eta_hadron)
fj.ClusterSequence.print_banner()
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
pbar = tqdm.tqdm(range(args.nev))
for i in pbar:
if not pythia.next():
pbar.update(-1)
continue
parts_pythia_h = pythiafjext.vectorize_select(pythia,
[pythiafjext.kFinal], 0,
False)
parts_pythia_h_selected = parts_selector_h(parts_pythia_h)
jets_h = fj.sorted_by_pt(jet_selector(
jet_def(parts_pythia_h_selected)))
if len(jets_h) < 1:
continue
# do your things with jets here...
pythia.stat()
pythia.settings.writeFile(args.py_cmnd_out)
def main():
parser = argparse.ArgumentParser(description='pythia8 in python',
prog=os.path.basename(__file__))
parser.add_argument('-o',
'--output_dir',
help='output file location',
default='.',
type=str,
required=True)
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
if not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
output_file = os.path.join(args.output_dir, 'pythia8.hepmc')
pyhepmc2writer = pythiaext.Pythia8HepMC2Wrapper(output_file)
# pyhepmc3writer = pythiahepmc3.Pythia8HepMC3Wrapper(output_file)
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if args.nev < 10:
args.nev = 10
for i in range(args.nev):
if not pythia.next():
continue
if i % 100 == 0:
print(f'event {i}/{args.nev}')
pyhepmc2writer.fillEvent(pythia)
# pyhepmc3writer.fillEvent(pythia)
pythia.stat()
pythia.settings.writeFile(
os.path.join(args.output_dir, 'modified_settings.hepmc'))
print(f"[i] file written: {output_file}")
def generate():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly',
prog=os.path.basename(__file__))
parser.add_argument(
'-d',
'--output-dir',
help='output directory name - use with default file name',
default='.',
type=str)
parser.add_argument('-o',
'--output',
help='output file name',
default='',
type=str)
parser.add_argument('--overwrite', default=False, action='store_true')
parser.add_argument('--t-min',
help='trigger pt min',
default=6.,
type=float)
parser.add_argument('--t-max',
help='trigger pt max',
default=7.,
type=float)
parser.add_argument('--jet-R',
help='jet finder R',
default=0.4,
type=float)
parser.add_argument('--charged', default=False, action='store_true')
parser.add_argument('--runid', default=0, type=int)
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
# mycfg = ['PhaseSpace:pThatMin = 6']
mycfg = []
if '.root' not in args.output:
rs = '0{}'.format(int(args.jet_R * 10))
if args.jet_R >= 1:
rs = '{}'.format(int(args.jet_R))
args.output = '{}/h_jet_R{}_t{}_{}'.format(args.output_dir, rs,
args.t_min, args.t_max)
if args.charged:
args.output = '{}/h_jet_ch_R{}_t{}_{}'.format(
args.output_dir, rs, int(args.t_min), int(args.t_max))
if args.py_pthatmin > 0:
args.output += '_pthatmin{}'.format(int(args.py_pthatmin))
if args.py_noMPI:
args.output += '_noMPI'
if args.py_noISR:
args.output += '_noISR'
if args.py_noHadron:
args.output += '_noHadr'
if args.py_minbias > 0:
args.output += '_minbias'
if args.runid > 0:
args.output += '_runid_{}'.format(args.runid)
args.py_seed = 1000 + args.runid
args.output += '.root'
if os.path.exists(args.output):
if not args.overwrite:
print('[w] output file', args.output, 'exists - skipping.')
return
# print the banner first
fj.ClusterSequence.print_banner()
print()
mycfg.append("SoftQCD:inelastic = on") # Andreas' recommendation
#and in the code i do not allow decay of the following particles:
mycfg.append("310:mayDecay = off") # //K0s
mycfg.append("3122:mayDecay = off") # //labda0
mycfg.append("3112:mayDecay = off") # //sigma-
mycfg.append("3212:mayDecay = off") # //sigma0
mycfg.append("3222:mayDecay = off") # //sigma+
mycfg.append("3312:mayDecay = off") # //xi-
mycfg.append("3322:mayDecay = off") # //xi+
mycfg.append("3334:mayDecay = off") # //omega-
print('[i] additional settings', mycfg)
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
return
if args.nev < 1:
args.nev = 1
jet_particle_eta_max = 0.9
jet_particle_selector = fj.SelectorAbsEtaMax(jet_particle_eta_max)
fout = r.TFile(args.output, 'RECREATE')
fout.cd()
hmV0M = r.TH1F('hmV0M', 'hmV0M', 1000, 0, 1000)
hmV0A = r.TH1F('hmV0A', 'hmV0A', 1000, 0, 1000)
hmV0C = r.TH1F('hmV0C', 'hmV0C', 1000, 0, 1000)
event_output = RTreeWriter(tree_name='evT', fout=fout)
jet_output = RTreeWriter(tree_name='jetT', fout=fout)
hjet_output = RTreeWriter(tree_name='hjetT', fout=fout)
v0det = V0Detector()
j_ana = JetAnalysis(jet_R=args.jet_R,
particle_eta_max=jet_particle_eta_max)
hjet = HJet(trigger_range=[args.t_min, args.t_max])
for ev_id in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
if args.charged:
parts = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged])
else:
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal])
event_output.clear()
jet_output.clear()
hjet_output.clear()
jet_parts = jet_particle_selector(parts)
ev_w = pythia.info.sigmaGen()
ev_code = pythia.info.code()
pthard = pythia.info.pTHat()
mTot = len(parts)
mCB = len(jet_parts)
v0det.analyze_event(parts)
event_output.fill_branch('ev_id', ev_id)
event_output.fill_branch('weight', ev_w)
event_output.fill_branch('code', ev_code)
event_output.fill_branch('pthard', pthard)
event_output.fill_branch('mTot', mTot)
event_output.fill_branch('mCB', mCB)
v0det.fill_branches(event_output)
event_output.fill_tree()
hmV0M.Fill(v0det.V0_mult)
hmV0A.Fill(v0det.V0A_mult)
hmV0C.Fill(v0det.V0C_mult)
if len(parts) < 1:
continue
hjet.analyze_event(jet_parts)
if hjet.trigger_particle:
j_ana.analyze_event(jet_parts)
jet_output.fill_branch('ev_id', ev_id)
jet_output.fill_branch('weight', ev_w)
jet_output.fill_branch('code', ev_code)
jet_output.fill_branch('pthard', pthard)
jet_output.fill_branch('mTot', mTot)
jet_output.fill_branch('mCB', mCB)
j_ana.fill_branches(jet_output)
jet_output.fill_tree()
hjet_output.fill_branch('ev_id', ev_id)
hjet_output.fill_branch('weight', ev_w)
hjet_output.fill_branch('code', ev_code)
hjet_output.fill_branch('pthard', pthard)
hjet_output.fill_branch('mTot', mTot)
hjet_output.fill_branch('mCB', mCB)
hjet.fill_branches(hjet_output, j_ana.jets)
v0det.fill_branches(hjet_output)
j_ana.fill_branches(hjet_output)
hjet_output.fill_tree()
pythia.stat()
fout.Write()
fout.Close()
print('[i] written', fout.GetName())
def main():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
# could use --py-seed
parser.add_argument('--user-seed',
help='pythia seed',
default=1111,
type=int)
parser.add_argument('--output', default="output.root", type=str)
parser.add_argument('--beta', help='sd beta', default=0, type=float)
parser.add_argument('--jetR', help='jet radius', default=0.4, type=float)
args = parser.parse_args()
if args.user_seed < 0:
args.user_seed = 1111
pinfo('user seed for pythia', args.user_seed)
# mycfg = ['PhaseSpace:pThatMin = 100']
mycfg = ['Random:setSeed=on', 'Random:seed={}'.format(args.user_seed)]
mycfg.append('HadronLevel:all=off')
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if args.nev < 100:
args.nev = 100
# print the banner first
fj.ClusterSequence.print_banner()
print()
# set up our jet definition and a jet selector
jet_R0 = args.jetR
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
print(jet_def)
# hadron level - ALICE
max_eta_hadron = 0.9
pwarning('max eta for particles after hadronization set to',
max_eta_hadron)
parts_selector_h = fj.SelectorAbsEtaMax(max_eta_hadron)
jet_selector = fj.SelectorPtMin(20.0) & fj.SelectorPtMax(
100.0) & fj.SelectorAbsEtaMax(max_eta_hadron - 1.05 * jet_R0)
max_eta_parton = max_eta_hadron + 2. * jet_R0
pwarning('max eta for partons set to', max_eta_parton)
parts_selector_p = fj.SelectorAbsEtaMax(max_eta_parton)
outf = ROOT.TFile(
args.output.replace('.root', '_beta{}.root'.format(args.beta)),
'recreate')
outf.cd()
t = ROOT.TTree('t', 't')
tw = RTreeWriter(tree=t)
# event loop
for iev in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
parts_pythia_p = pythiafjext.vectorize_select(pythia,
[pythiafjext.kFinal], 0,
True)
parts_pythia_p_selected = parts_selector_p(parts_pythia_p)
hstatus = pythia.forceHadronLevel()
if not hstatus:
pwarning('forceHadronLevel false event', iev)
continue
# parts_pythia_h = pythiafjext.vectorize_select(pythia, [pythiafjext.kHadron, pythiafjext.kCharged])
parts_pythia_h = pythiafjext.vectorize_select(pythia,
[pythiafjext.kFinal], 0,
True)
parts_pythia_h_selected = parts_selector_h(parts_pythia_h)
parts_pythia_hch = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged], 0, True)
parts_pythia_hch_selected = parts_selector_h(parts_pythia_hch)
# pinfo('debug partons...')
# for p in parts_pythia_p_selected:
# pyp = pythiafjext.getPythia8Particle(p)
# print(pyp.name())
# pinfo('debug hadrons...')
# for p in parts_pythia_h_selected:
# pyp = pythiafjext.getPythia8Particle(p)
# print(pyp.name())
# pinfo('debug ch. hadrons...')
# for p in parts_pythia_hch_selected:
# pyp = pythiafjext.getPythia8Particle(p)
# print(pyp.name())
# parts = pythiafjext.vectorize(pythia, True, -1, 1, False)
jets_p = fj.sorted_by_pt(jet_def(parts_pythia_p))
jets_h = fj.sorted_by_pt(jet_def(parts_pythia_h))
jets_ch_h = fj.sorted_by_pt(jet_selector(jet_def(parts_pythia_hch)))
sd = fjcontrib.SoftDrop(args.beta, 0.1, jet_R0)
for i, jchh in enumerate(jets_ch_h):
# match hadron (full) jet
for j, jh in enumerate(jets_h):
drhh = jchh.delta_R(jh)
if drhh < jet_R0 / 2.:
# match parton level jet
for k, jp in enumerate(jets_p):
dr = jh.delta_R(jp)
if dr < jet_R0 / 2.:
jchh_sd = sd.result(jchh)
jchh_sd_info = fjcontrib.get_SD_jet_info(jchh_sd)
jh_sd = sd.result(jh)
jh_sd_info = fjcontrib.get_SD_jet_info(jh_sd)
jp_sd = sd.result(jp)
jp_sd_info = fjcontrib.get_SD_jet_info(jp_sd)
# pwarning('event', iev)
# pinfo('matched jets: ch.h:', jchh.pt(), 'h:', jh.pt(), 'p:', jp.pt(), 'dr:', dr)
tw.fill_branch('iev', iev)
tw.fill_branch('ch', jchh)
tw.fill_branch('h', jh)
tw.fill_branch('p', jp)
tw.fill_branch('p_zg', jp_sd_info.z)
tw.fill_branch('p_Rg', jp_sd_info.dR)
tw.fill_branch('p_thg', jp_sd_info.dR / jet_R0)
tw.fill_branch('p_mug', jp_sd_info.mu)
tw.fill_branch('h_zg', jh_sd_info.z)
tw.fill_branch('h_Rg', jh_sd_info.dR)
tw.fill_branch('h_thg', jh_sd_info.dR / jet_R0)
tw.fill_branch('h_mug', jh_sd_info.mu)
tw.fill_branch('ch_zg', jchh_sd_info.z)
tw.fill_branch('ch_Rg', jchh_sd_info.dR)
tw.fill_branch('ch_thg', jchh_sd_info.dR / jet_R0)
tw.fill_branch('ch_mug', jchh_sd_info.mu)
tw.fill_tree()
#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))
pythia.stat()
outf.Write()
outf.Close()
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(80.0) & fj.SelectorPtMax(
100.0) & fj.SelectorAbsEtaMax(1)
# jet_selector = fj.SelectorPtMin(40.0) & fj.SelectorPtMax(200.0) &fj.SelectorAbsEtaMax(1)
print(jet_def)
all_jets = []
mycfg = ['PhaseSpace:pThatMin = 80']
# mycfg = ['PhaseSpace:pThatMin = 40']
if args.ignore_mycfg:
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
perror("pythia initialization failed.")
return
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
lund_gen = fjcontrib.LundGenerator(jet_def_lund)
print(lund_gen.description())
dy_groomer = fjcontrib.DynamicalGroomer(jet_def_lund)
print(dy_groomer.description())
# sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
sd = fjcontrib.SoftDrop(0, 0.2, 1.0)
print(sd)
# jet_def_rc01 = fj.JetDefinition(fj.cambridge_algorithm, 0.1)
# jet_def_rc02 = fj.JetDefinition(fj.cambridge_algorithm, 0.2)
# print (jet_def_rc01)
# print (jet_def_rc02)
# rc = fjcontrib.Recluster(jet_def_rc, True)
jet_def_rc01 = fj.JetDefinition(fj.antikt_algorithm, 0.1)
jet_def_rc02 = fj.JetDefinition(fj.antikt_algorithm, 0.2)
print(jet_def_rc01)
print(jet_def_rc02)
#rc = fjcontrib.Recluster(jet_def_rc, True)
# tw = treewriter.RTreeWriter(name = 'lsjvsx', file_name = 'leadsj_vs_x.root')
tw = treewriter.RTreeWriter(name='lsjvsx',
file_name='leadsj_vs_x_bias80.root')
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)
partons = pythiafjext.vectorize_select(pythia, [pythiafjext.kParton],
0, True)
parts = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged], 0, False)
# parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, False)
jets = jet_selector(jet_def(parts))
# for j in tqdm.tqdm(jets):
for j in jets:
j_type = match_dR(j, partons, jet_R0 / 2.)
j_sd = sd.result(j)
sd_info = fjcontrib.get_SD_jet_info(j_sd)
rc_sjets01 = fj.sorted_by_pt(jet_def_rc01(j.constituents()))
rc_sjets02 = fj.sorted_by_pt(jet_def_rc02(j.constituents()))
tw.fill_branches(
j=j,
lund=[ls for ls in lund_gen.result(j)],
dyg1=dy_groomer.result(j, 1),
sd=j_sd,
sd_z=sd_info.z,
sd_mu=sd_info.mu,
sd_Delta=sd_info.dR,
lsjet01=rc_sjets01[0],
nsjet01=len(rc_sjets01),
sjet01=rc_sjets01,
lsjet02=rc_sjets02[0],
nsjet02=len(rc_sjets02),
sjet02=rc_sjets02,
ppid=j_type[0],
pquark=j_type[1],
pglue=j_type[2] # this is redundancy
)
tw.fill_tree()
pythia.stat()
tw.write_and_close()
def generate():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly',
prog=os.path.basename(__file__))
parser.add_argument(
'-d',
'--output-dir',
help='output directory name - use with default file name',
default='.',
type=str)
parser.add_argument('-o',
'--output',
help='output file name',
default='',
type=str)
parser.add_argument('--overwrite', default=False, action='store_true')
parser.add_argument('--jet-R',
help='jet finder R',
default=0.4,
type=float)
parser.add_argument('--charged', default=False, action='store_true')
parser.add_argument('--runid', default=0, type=int)
parser.add_argument('--tranges',
default='6-7',
help='hadron trigger ranges min-max,min1-max1,...',
type=str)
group = parser.add_mutually_exclusive_group()
group.add_argument('--inel', default=False, action='store_true')
group.add_argument('--hard', default=False, action='store_true')
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
# mycfg = ['PhaseSpace:pThatMin = 6']
mycfg = []
if '.root' not in args.output:
rs = '0{}'.format(int(args.jet_R * 10))
if args.jet_R >= 1:
rs = '{}'.format(int(args.jet_R))
args.output = '{}/h_jet_R{}'.format(args.output_dir, rs)
if args.charged:
args.output = '{}/h_jet_ch_R{}'.format(args.output_dir, rs)
if args.tranges:
args.output += '_tranges_{}'.format(args.tranges.replace(',', "_"))
if args.runid >= 0:
args.output += '_runid_{}'.format(args.runid)
args.py_seed = 1000 + args.runid
if args.py_noMPI:
args.output += '_noMPI'
if args.py_noISR:
args.output += '_noISR'
if args.py_noHadron:
args.output += '_noHadr'
if args.py_minbias > 0:
args.output += '_minbias'
if args.py_pthatmin > 0:
args.output += '_pthatmin_{}'.format(args.py_pthatmin)
if args.inel:
args.output += '_inel'
mycfg.append("SoftQCD:inelastic = on")
mycfg.append("HardQCD:all = off")
else:
if args.hard:
args.output += '_biasref_{}'.format(args.py_biasref)
args.output += '_hard'
mycfg.append("HardQCD:all = on")
else:
mycfg.append("HardQCD:all = on")
args.output += '_hard'
args.output += '.root'
print(args)
if os.path.exists(args.output):
if not args.overwrite:
print('[w] output file', args.output, 'exists - skipping.')
return
print('[i] output file', args.output)
# print the banner first
fj.ClusterSequence.print_banner()
print()
#and in the code i do not allow decay of the following particles:
mycfg.append("310:mayDecay = off") # //K0s
mycfg.append("3122:mayDecay = off") # //labda0
mycfg.append("3112:mayDecay = off") # //sigma-
mycfg.append("3212:mayDecay = off") # //sigma0
mycfg.append("3222:mayDecay = off") # //sigma+
mycfg.append("3312:mayDecay = off") # //xi-
mycfg.append("3322:mayDecay = off") # //xi+
mycfg.append("3334:mayDecay = off") # //omega-
print('[i] additional settings', mycfg)
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
return
if args.nev < 1:
args.nev = 1
tpairs = []
st = args.tranges.split(',')
try:
for _s in st:
t0 = float(_s.split('-')[0])
t1 = float(_s.split('-')[1])
tpairs.append([t0, t1])
except:
print(
'[e] something is not quite right with trigger ranges... stop here.'
)
jet_particle_eta_max = 0.9
jet_particle_selector = fj.SelectorAbsEtaMax(jet_particle_eta_max)
v0det = V0Detector()
j_ana = JetAnalysis(jet_R=args.jet_R,
particle_eta_max=jet_particle_eta_max)
fout = r.TFile(args.output, 'RECREATE')
fout.cd()
hmV0M = r.TH1F('hmV0M', 'hmV0M', 1000, 0, 1000)
hmV0A = r.TH1F('hmV0A', 'hmV0A', 1000, 0, 1000)
hmV0C = r.TH1F('hmV0C', 'hmV0C', 1000, 0, 1000)
event_output = RTreeWriter(tree_name='evT', fout=fout)
jet_output = RTreeWriter(tree_name='jetT', fout=fout)
hjet_sets = []
for t in tpairs:
hjet_output = RTreeWriter(tree_name='hjetT_{}_{}'.format(
int(t[0]), int(t[1])),
fout=fout)
hjet = HJet(trigger_range=[t[0], t[1]])
print(hjet)
hjset = HJetSet(hjet, hjet_output)
hjet_sets.append(hjset)
for ev_id in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
if args.charged:
parts = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged])
else:
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal])
event_output.clear()
jet_output.clear()
_tmp = [s.hjet_output.clear() for s in hjet_sets]
jet_parts = jet_particle_selector(parts)
ev_s = pythia.info.sigmaGen()
ev_w = pythia.info.weight()
ev_code = pythia.info.code()
pthard = pythia.info.pTHat()
mTot = len(parts)
mCB = len(jet_parts)
v0det.analyze_event(parts)
event_output.fill_branch('ev_id', ev_id)
event_output.fill_branch('weight', ev_w)
event_output.fill_branch('sigma', ev_s)
event_output.fill_branch('code', ev_code)
event_output.fill_branch('pthard', pthard)
event_output.fill_branch('mTot', mTot)
event_output.fill_branch('mCB', mCB)
v0det.fill_branches(event_output)
event_output.fill_tree()
hmV0M.Fill(v0det.V0_mult)
hmV0A.Fill(v0det.V0A_mult)
hmV0C.Fill(v0det.V0C_mult)
if len(parts) < 1:
continue
if True in [s.analyze_event(jet_parts) for s in hjet_sets]:
j_ana.analyze_event(jet_parts)
jet_output.fill_branch('ev_id', ev_id)
jet_output.fill_branch('weight', ev_w)
jet_output.fill_branch('sigma', ev_s)
jet_output.fill_branch('code', ev_code)
jet_output.fill_branch('pthard', pthard)
jet_output.fill_branch('mTot', mTot)
jet_output.fill_branch('mCB', mCB)
j_ana.fill_branches(jet_output)
jet_output.fill_tree()
for s in hjet_sets:
if s.hjet.trigger_particle:
s.hjet_output.fill_branch('ev_id', ev_id)
s.hjet_output.fill_branch('weight', ev_w)
s.hjet_output.fill_branch('sigma', ev_s)
s.hjet_output.fill_branch('code', ev_code)
s.hjet_output.fill_branch('pthard', pthard)
s.hjet_output.fill_branch('mTot', mTot)
s.hjet_output.fill_branch('mCB', mCB)
s.hjet.fill_branches(s.hjet_output, j_ana.jets)
v0det.fill_branches(s.hjet_output)
j_ana.fill_branches(s.hjet_output)
s.hjet_output.fill_tree()
pythia.stat()
fout.Write()
fout.Close()
print('[i] written', fout.GetName())
def main():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
_default_output_filename = os.path.basename(__file__).replace(
".py", "") + "_output.root"
parser.add_argument('--output', default=_default_output_filename, type=str)
parser.add_argument('--debug', default=0, type=int)
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.6
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
jet_selector = fj.SelectorPtMin(2.0) & fj.SelectorAbsEtaMax(2)
print(jet_def)
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, jet_R0)
lund_gen = fjcontrib.LundGenerator(jet_def_lund)
print(jet_def_lund)
print(lund_gen)
outf = ROOT.TFile(args.output, 'recreate')
outf.cd()
t = ROOT.TTree('t', 't')
tw = RTreeWriter(tree=t)
# 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
if args.debug:
pwarning('-- event', i)
# parts = pythiafjext.vectorize(pythia, True, -1, 1, False)
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0,
True)
if args.debug > 5:
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kHadron],
0, True)
if args.debug > 10:
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kAny], 0,
True)
if args.debug > 0:
for p in parts:
pypart = pythiafjext.getPythia8Particle(p)
if pypart.name()[:2] == 'D0':
pinfo(pypart.name(), pypart.id(), pypart.status(),
'final =?', pypart.isFinal())
jets = jet_selector(jet_def(parts))
for j in jets:
isD0_lead = False
lead_part = fj.sorted_by_E(j.constituents())[0]
pypart = pythiafjext.getPythia8Particle(lead_part)
if args.debug:
pinfo('leading id is', pypart.id(), pypart.name(), 'jet', j)
if abs(pypart.id()) == 421:
# pinfo('leading D0')
isD0_lead = True
l = lund_gen.result(j)
if len(l) > 0:
tw.fill_branch('Epair', [s.pair().e() for s in l])
tw.fill_branch('z', [s.z() for s in l])
tw.fill_branch('kt', [s.kt() for s in l])
tw.fill_branch('delta', [s.Delta() for s in l])
tw.fill_branch('D0lead', isD0_lead)
tw.fill_branch('lead_id', pypart.id())
tw.fill_tree()
else:
if args.debug:
pwarning("len of a lund is less than 1?", len(l), l)
pythia.stat()
outf.Write()
outf.Close()
print('[i] written', outf.GetName())
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('--nw', help="no warn", default=False, action='store_true')
parser.add_argument('--ignore-mycfg', help="ignore some settings hardcoded here", default=False, action='store_true')
parser.add_argument('--enable-background', help="enable background calc", default=False, action='store_true')
parser.add_argument('--output', help="output file name", default='leadsj_vs_x_output.root', type=str)
# for background
parser.add_argument('--cent-bin', help="centraility bin 0 is the 0-5 percent most central bin", type=int, default=0)
parser.add_argument('--seed', help="pr gen seed", type=int, default=1111)
parser.add_argument('--harmonics', help="set harmonics flag (0 : v1 - v5) , (1 : v2 - v5) , (2: v3 - v5) , (3: v1 - v4) , (4: v1 - v3) , (5: uniform dN/dphi no harmonics) , (6 : v1 - v2 , v4 - v5) , (7 : v1 - v3 , v5) , (8 : v1 , v3 - v5) , (9 : v1 only) , (10 : v2 only) , (11 : v3 only) , (12 : v4 only) , (13 : v5 only)",
type=int, default=5)
parser.add_argument('--eta', help="set eta range must be uniform (e.g. abs(eta) < 0.9, which is ALICE TPC fiducial acceptance)",
type=float, default=0.9)
parser.add_argument('--qa', help="PrintOutQAHistos", default=False, action='store_true')
parser.add_argument('--dRmax', default=0.25, type=float)
parser.add_argument('--alpha', default=0, type=float)
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(args.py_pthatmin) & fj.SelectorPtMax(1000.0) & fj.SelectorAbsEtaMax(args.eta - jet_R0)
# jet_selector = fj.SelectorPtMin(40.0) & fj.SelectorPtMax(200.0) &fj.SelectorAbsEtaMax(1)
print(jet_def)
all_jets = []
# mycfg = ['PhaseSpace:pThatMin = 80']
# mycfg = ['PhaseSpace:pThatMin = 40']
mycfg = ['']
if args.ignore_mycfg:
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
perror("pythia initialization failed.")
return
jet_def_lund = fj.JetDefinition(fj.cambridge_algorithm, 1.0)
lund_gen = fjcontrib.LundGenerator(jet_def_lund)
print (lund_gen.description())
dy_groomer = fjcontrib.DynamicalGroomer(jet_def_lund)
print (dy_groomer.description())
# sd = fjcontrib.SoftDrop(0, 0.1, 1.0)
sd01 = fjcontrib.SoftDrop(0, 0.1, 1.0)
print (sd01)
sd02 = fjcontrib.SoftDrop(0, 0.2, 1.0)
print (sd02)
# jet_def_rc01 = fj.JetDefinition(fj.cambridge_algorithm, 0.1)
# jet_def_rc02 = fj.JetDefinition(fj.cambridge_algorithm, 0.2)
# print (jet_def_rc01)
# print (jet_def_rc02)
# rc = fjcontrib.Recluster(jet_def_rc, True)
jet_def_rc01 = fj.JetDefinition(fj.antikt_algorithm, 0.1)
jet_def_rc02 = fj.JetDefinition(fj.antikt_algorithm, 0.2)
print (jet_def_rc01)
print (jet_def_rc02)
#rc = fjcontrib.Recluster(jet_def_rc, True)
# tw = treewriter.RTreeWriter(name = 'lsjvsx', file_name = 'leadsj_vs_x.root')
tw = treewriter.RTreeWriter(name = 'lsjvsx', file_name = args.output)
tgbkg = None
be = None
if args.enable_background:
# ROOT.gSystem.Load("libpyjetty_TennGen.dylib")
# tgbkg = ROOT.TennGen() # //constructor
# tgbkg.SetCentralityBin(args.cent_bin) # //centraility bin 0 is the 0-5 % most central bin
# tgbkg.SetRandomSeed(args.seed) # //setting the seed
# tgbkg.SetHarmonics(args.harmonics) # // set harmonics flag (0 : v1 - v5) , (1 : v2 - v5) , (2: v3 - v5) , (3: v1 - v4) , (4: v1 - v3) , (5: uniform dN/dphi no harmonics) , (6 : v1 - v2 , v4 - v5) , (7 : v1 - v3 , v5) , (8 : v1 , v3 - v5) , (9 : v1 only) , (10 : v2 only) , (11 : v3 only) , (12 : v4 only) , (13 : v5 only)
# tgbkg.SetEtaRange(args.eta) # //set eta range must be uniform (e.g. |eta| < 0.9, which is ALICE TPC fiducial acceptance)
# tgbkg.PrintOutQAHistos(args.qa) #
# tgbkg.InitializeBackground() #
from pyjetty.mputils import BoltzmannEvent
be = BoltzmannEvent(mean_pt=0.7, multiplicity=2000 * args.eta * 2, max_eta=max_eta, max_pt=100)
print(be)
from pyjetty.mputils import CEventSubtractor, CSubtractorJetByJet
cs = CEventSubtractor(alpha=args.alpha, max_distance=args.dRmax, max_eta=args.eta, bge_rho_grid_size=0.25, max_pt_correct=100)
print(cs)
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)
partons = pythiafjext.vectorize_select(pythia, [pythiafjext.kParton], 0, True)
parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal, pythiafjext.kCharged], 0, False)
# parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, False)
jets = jet_selector(jet_def(parts))
# for j in tqdm.tqdm(jets):
for j in jets:
j_type = match_dR(j, partons, jet_R0 / 2.)
if j_type[0] is None:
if args.nw:
continue
pwarning('Jet with no parton label')
continue
j_sd02 = sd02.result(j)
sd02_info = fjcontrib.get_SD_jet_info(j_sd02)
j_sd01 = sd01.result(j)
sd01_info = fjcontrib.get_SD_jet_info(j_sd01)
rc_sjets01 = fj.sorted_by_pt(jet_def_rc01(j.constituents()))
rc_sjets02 = fj.sorted_by_pt(jet_def_rc02(j.constituents()))
tw.fill_branches( j = j,
lund = [ls for ls in lund_gen.result(j)],
dyg1 = dy_groomer.result(j, 1),
sd01 = j_sd01,
sd01_z = sd01_info.z,
sd01_mu = sd01_info.mu,
sd01_Delta = sd01_info.dR,
sd02 = j_sd02,
sd02_z = sd02_info.z,
sd02_mu = sd02_info.mu,
sd02_Delta = sd02_info.dR,
# breaking compatibility
# sd = j_sd,
# sd_z = sd_info.z,
# sd_mu = sd_info.mu,
# sd_Delta = sd_info.dR,
lsjet01 = rc_sjets01[0],
nsjet01 = len(rc_sjets01),
sjet01 = rc_sjets01,
lsjet02 = rc_sjets02[0],
nsjet02 = len(rc_sjets02),
sjet02 = rc_sjets02,
ppid = j_type[0],
pquark = j_type[1],
pglue = j_type[2], # this is redundancy
pycode = pythia.info.code(),
pysigmagen = pythia.info.sigmaGen(),
pysigmaerr = pythia.info.sigmaErr(),
pyid1 = pythia.info.id1pdf(),
pyid2 = pythia.info.id1pdf(),
pyx1 = pythia.info.x1pdf(),
pyx2 = pythia.info.x2pdf(),
pypdf1 = pythia.info.pdf1(),
pyQfac = pythia.info.QFac(),
pyalphaS = pythia.info.alphaS(),
pypthat = pythia.info.pTHat(),
pymhat = pythia.info.mHat()
)
if be:
bg_parts = be.generate(offset=10000)
full_event = bg_parts
tmp = [full_event.push_back(psj) for psj in j.constituents()]
if cs:
cs_parts = cs.process_event(full_event)
rho = cs.bge_rho.rho()
bg_jets = fj.sorted_by_pt(jet_def(cs_parts))
for bj in bg_jets:
if fjtools.matched_pt(bj, j) > 0.5:
pass
tw.fill_tree()
pythia.stat()
tw.write_and_close()
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('--nw',
help="no warn",
default=True,
action='store_true')
parser.add_argument('--ignore-mycfg',
help="ignore some settings hardcoded here",
default=False,
action='store_true')
parser.add_argument('--enable-background',
help="enable background calc",
default=False,
action='store_true')
parser.add_argument('--output',
help="output file name",
default='leadsj_vs_zloss.root',
type=str)
parser.add_argument('--jetptmin',
help="jet pt minimum",
default=-1,
type=float)
parser.add_argument('--jetptmax',
help="jet pt maximum",
default=1e6,
type=float)
parser.add_argument('--eta', help="jet eta max", default=2.4, type=float)
parser.add_argument(
'--kt',
help="use kT algorithm instead of anti-kT for the subjets",
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(args.py_pthatmin) & fj.SelectorPtMax(
1000.0) & fj.SelectorAbsEtaMax(args.eta - jet_R0)
mycfg = []
if args.jetptmin > 0:
mycfg = ['PhaseSpace:pThatMin = {}'.format(args.jetptmin)]
jet_selector = fj.SelectorPtMin(args.jetptmin) & fj.SelectorPtMax(
args.jetptmax) & fj.SelectorAbsEtaMax(args.eta - jet_R0)
print(jet_def)
if args.ignore_mycfg:
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
perror("pythia initialization failed.")
return
nbins = 20
# sjrs = [0.001 + x * 0.04 for x in range(0, nbins)]
sjrs = logbins(0.001, jet_R0, nbins)
print(sjrs)
print('log(1/r) :', [ROOT.TMath.Log(1 / r) for r in sjrs])
sjdefs = dict()
for sjr in sjrs:
if args.kt:
_jet_def = fj.JetDefinition(fj.kt_algorithm, sjr)
else:
_jet_def = fj.JetDefinition(fj.antikt_algorithm, sjr)
sjdefs[sjr] = _jet_def
# tw = treewriter.RTreeWriter(name = 'lsjvsx', file_name = 'leadsj_vs_x.root')
tw = treewriter.RTreeWriter(name='lsjvszloss', file_name=args.output)
tw.fout.cd()
h_zloss_r_q = dict()
h_zloss_r_g = dict()
for sjr in sjrs:
sname = 'h_zloss_glue_{}'.format(sjr)
_h_zloss_r_g = ROOT.TH1F(sname, sname, len(sjrs), 0., 1.)
h_zloss_r_g[sjr] = _h_zloss_r_g
sname = 'h_zloss_quark_{}'.format(sjr)
_h_zloss_r_q = ROOT.TH1F(sname, sname, len(sjrs), 0., 1.)
h_zloss_r_q[sjr] = _h_zloss_r_q
lbins = logbins(ROOT.TMath.Log(1. / jet_R0), ROOT.TMath.Log(1. / sjrs[0]),
nbins)
print('lbins:', lbins)
sname = 'prof_zloss_vs_r_any'
prof_a = ROOT.TProfile(sname, sname, nbins, 0, jet_R0)
prof_a_log = ROOT.TProfile(sname + '_log', sname + '_log', nbins, lbins)
sname = 'prof_zloss_vs_r_glue'
prof_g = ROOT.TProfile(sname, sname, nbins, 0, jet_R0)
prof_g_log = ROOT.TProfile(sname + '_log', sname + '_log', nbins, lbins)
sname = 'prof_zloss_vs_r_quark'
prof_q = ROOT.TProfile(sname, sname, nbins, 0, jet_R0)
prof_q_log = ROOT.TProfile(sname + '_log', sname + '_log', nbins, lbins)
# prof_q_log = ROOT.TProfile(sname+'_log', sname+'_log', nbins, ROOT.TMath.Log(1./jet_R0), ROOT.TMath.Log(1./sjrs[0]))
sname = 'h2_zloss_vs_r_glue'
h2_zloss_r_g = ROOT.TH2F(sname, sname, nbins, 0., jet_R0, len(sjrs), 0.,
1.)
sname = 'h2_zloss_vs_r_quark'
h2_zloss_r_q = ROOT.TH2F(sname, sname, nbins, 0., jet_R0, len(sjrs), 0.,
1.)
# loop
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)
partons = pythiafjext.vectorize_select(pythia, [pythiafjext.kParton],
0, True)
parts = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged], 0, False)
# parts = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, False)
jets = jet_selector(jet_def(parts))
# for j in tqdm.tqdm(jets):
for j in jets:
j_type = match_dR(j, partons, jet_R0 / 2.)
if j_type[0] is None:
if args.nw:
continue
pwarning('Jet with no parton label')
continue
tw.fill_branch("j", j)
for sjr in sjrs:
rc_jets = fj.sorted_by_pt(sjdefs[sjr](j.constituents()))
tw.fill_branch("sjr{}".format(sjr), rc_jets[0])
zloss = 1. - rc_jets[0].perp() / j.perp()
tw.fill_branch("sjr{}_zloss".format(sjr), zloss)
tw.fill_branch("ppid", j_type[0])
tw.fill_branch("pquark", j_type[1])
tw.fill_branch("pglue", j_type[2])
prof_a.Fill(sjr, zloss)
prof_a_log.Fill(ROOT.TMath.Log(1. / sjr), zloss)
if j_type[1]:
h_zloss_r_q[sjr].Fill(zloss)
h2_zloss_r_q.Fill(sjr, zloss)
prof_q.Fill(sjr, zloss)
prof_q_log.Fill(ROOT.TMath.Log(1. / sjr), zloss)
if j_type[2]:
h_zloss_r_g[sjr].Fill(zloss)
h2_zloss_r_g.Fill(sjr, zloss)
prof_g.Fill(sjr, zloss)
prof_g_log.Fill(ROOT.TMath.Log(1. / sjr), zloss)
tw.fill_tree()
pythia.stat()
tw.write_and_close()
def main():
parser = argparse.ArgumentParser(description='pythia8 in python', prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
max_eta_hadron=3
jet_R0 = 0.4
# jet_selector = fj.SelectorPtMin(100.0) & fj.SelectorPtMax(125.0) & fj.SelectorAbsEtaMax(max_eta_hadron - 1.05 * jet_R0)
jet_selector = fj.SelectorPtMin(10.0) & fj.SelectorAbsEtaMax(max_eta_hadron - 1.05 * jet_R0)
parts_selector_h = fj.SelectorAbsEtaMax(max_eta_hadron)
fj.ClusterSequence.print_banner()
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
qweights = [0.05, 0.1, 0.2, 0.3]
qweights.insert(0, 0)
rout = ROOT.TFile('gen_quench_out.root', 'recreate')
hpt = []
thf = []
for i, w in enumerate(qweights):
hname = 'hpt_{}'.format(i)
htitle = 'hpt w={}'.format(w)
rout.cd()
h = ROOT.TH1F(hname, htitle, 10, mputils.logbins(10, 500, 10))
hpt.append(h)
if w <= 0:
w = 1e-3
hname = 'th_{}'.format(i)
htitle = 'thf w={}'.format(w)
rout.cd()
th = ROOT.TF1(hname, 'gaus', -5 * w , 5 * w)
th.SetParameter(0, 1)
th.SetParameter(1, 0)
th.SetParameter(2, w)
thf.append(th)
pbar = tqdm.tqdm(range(args.nev))
for i in pbar:
if not pythia.next():
pbar.update(-1)
continue
parts_pythia_h = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, False)
parts_pythia_h_selected = parts_selector_h(parts_pythia_h)
jets_hv = fj.sorted_by_pt(jet_selector(jet_def(parts_pythia_h_selected)))
if len(jets_hv) < 1:
continue
jets_h = None
# do your things with jets here...
for i, w in enumerate(qweights):
if w > 0:
_pthermal = []
for p in parts_pythia_h_selected:
_pth0 = fj.PseudoJet()
_pth0.reset_PtYPhiM(p.perp() * (1.-w), p.rap(), p.phi(), p.m())
_pthermal.append(_pth0)
_pth1 = fj.PseudoJet()
_pth1.reset_PtYPhiM(p.perp() * (0.+w), p.rap() + thf[i].GetRandom(-3 * w , 3 * w), p.phi() + thf[i].GetRandom(-3 * w , 3 * w), p.m())
_pthermal.append(_pth1)
jets_h = fj.sorted_by_pt(jet_selector(jet_def(_pthermal)))
else:
jets_h = jets_hv
for j in jets_h:
hpt[i].Fill(j.perp())
rout.cd()
for _f in thf:
_f.Write()
rout.Write()
rout.Close()
pythia.stat()
pythia.settings.writeFile(args.py_cmnd_out)
def main(agrs):
fj.ClusterSequence.print_banner()
print()
ja = JetAnalysis(jet_R=args.jet_R,
jet_algorithm=fj.antikt_algorithm,
particle_eta_max=args.max_eta)
grfj = GridFastJet(grid_size=0.01,
jet_R=args.jet_R,
jet_algorithm=fj.antikt_algorithm,
particle_eta_max=args.max_eta)
print(grfj)
grfjR = GridFastJetROOT(grid_size=0.01,
jet_R=args.jet_R,
jet_algorithm=fj.antikt_algorithm,
particle_eta_max=args.max_eta)
print(grfjR)
pythia = None
if args.pythia:
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()
ts = RTreeWriter(tree_name='ts', fout=fout)
tg = RTreeWriter(tree_name='tg', fout=fout)
tgR = RTreeWriter(tree_name='tgR', fout=fout)
for iev in tqdm.tqdm(range(args.nev)):
if pythia:
if not pythia.next():
continue
parts_pythia = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged])
ja.analyze_event(parts=parts_pythia)
if len(ja.jets) < 1:
continue
if ja.jets[0].pt() < 10:
continue
ts.fill_branch('j', ja.jets)
ts.fill_branch('p', ja.particles)
ts.fill_tree()
if args.grid:
grfj.analyze_event(parts=parts_pythia)
tg.fill_branch('j', grfj.jets)
tg.fill_branch('p', grfj.particles)
tg.fill_tree()
if args.gridR:
grfjR.analyze_event(parts=parts_pythia)
tgR.fill_branch('j', grfjR.jets)
tgR.fill_branch('p', grfjR.particles)
tgR.fill_tree()
ts.write_and_close()
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('--output', default="output.root", type=str)
parser.add_argument('--overwrite', help="overwrite output", default=False, action='store_true')
args = parser.parse_args()
if args.output == 'output.root':
args.output = 'output_alice_efficiency.root'
if os.path.isfile(args.output):
if not args.overwrite:
print('[i] output', args.output, 'exists - use --overwrite to do just that...')
return
print(args)
if args.py_seed >= 0:
mycfg.append('Random:setSeed=on')
mycfg.append('Random:seed={}'.format(args.py_seed))
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
print("[e] pythia initialization failed.")
return
max_eta = 1
parts_selector = fj.SelectorAbsEtaMax(max_eta)
if args.nev < 1:
args.nev = 1
outf = ROOT.TFile(args.output, 'recreate')
outf.cd()
hpart_gen = ROOT.TH1F('hpart_gen', 'hpart gen;p_{T};counts', 20, logbins(0.01, 100, 20))
heffi_pp = ROOT.TH1F('heffi_pp', 'heffi pp;p_{T};efficiency', 20, logbins(0.01, 100, 20))
heffi_PbPb = ROOT.TH1F('heffi_PbPb', 'heffi PbPb;p_{T};efficiency', 20, logbins(0.01, 100, 20))
effi_pp = AliceChargedParticleEfficiency(csystem='pp')
effi_PbPb = AliceChargedParticleEfficiency(csystem='PbPb')
for iev in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
parts_pythia = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal, pythiafjext.kCharged])
parts = parts_selector(parts_pythia)
_tmp = [hpart_gen.Fill(p.pt()) for p in parts]
_tmp = [heffi_pp.Fill(p.pt()) for p in effi_pp.apply_efficiency(parts)]
_tmp = [heffi_PbPb.Fill(p.pt()) for p in effi_PbPb.apply_efficiency(parts)]
continue
pythia.stat()
heffi_pp.Sumw2()
heffi_pp.Divide(hpart_gen)
heffi_PbPb.Sumw2()
heffi_PbPb.Divide(hpart_gen)
outf.Write()
outf.Close()
print('[i] written', outf.GetName())
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('--charged', default=False, action='store_true')
parser.add_argument('--neutral', default=False, action='store_true')
parser.add_argument('--partons', default=False, action='store_true')
parser.add_argument('--quarks', default=False, action='store_true')
parser.add_argument('--diquarks', default=False, action='store_true')
parser.add_argument('--gluons', default=False, action='store_true')
parser.add_argument('--leptons', default=False, action='store_true')
parser.add_argument('--Ncharged', default=False, action='store_true')
parser.add_argument('--Nneutral', default=False, action='store_true')
parser.add_argument('--Npartons', default=False, action='store_true')
parser.add_argument('--Nquarks', default=False, action='store_true')
parser.add_argument('--Ndiquarks', default=False, action='store_true')
parser.add_argument('--Ngluons', default=False, action='store_true')
parser.add_argument('--Nleptons', default=False, action='store_true')
args = parser.parse_args()
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if args.nev < 1:
args.nev = 1
part_selection = [pythiafjext.kFinal]
if args.charged:
part_selection.append(pythiafjext.kCharged)
if args.neutral:
part_selection.append(pythiafjext.kNeutral)
if args.partons:
part_selection.append(pythiafjext.kParton)
if args.quarks:
part_selection.append(pythiafjext.kQuark)
if args.diquarks:
part_selection.append(pythiafjext.kDiquark)
if args.gluons:
part_selection.append(pythiafjext.kGluon)
if args.leptons:
part_selection.append(pythiafjext.kLepton)
if args.Ncharged:
part_selection.append(-pythiafjext.kCharged)
if args.Nneutral:
part_selection.append(-pythiafjext.kNeutral)
if args.Npartons:
part_selection.append(-pythiafjext.kParton)
if args.Nquarks:
part_selection.append(-pythiafjext.kQuark)
if args.Ndiquarks:
part_selection.append(-pythiafjext.kDiquark)
if args.Ngluons:
part_selection.append(-pythiafjext.kGluon)
if args.Nleptons:
part_selection.append(-pythiafjext.kLepton)
for iev in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
parts = []
parts = pythiafjext.vectorize_select(pythia, part_selection, 0, True)
print('[i] number of particles selected:', len(parts))
for p in parts:
pypart = pythiafjext.getPythia8Particle(p)
print_pythia_particle(pypart)
def main():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
# could use --py-seed
parser.add_argument('--fj-R', help='jet finder R', default=0.8, type=float)
parser.add_argument('--user-seed',
help='pythia seed',
default=-1,
type=int)
parser.add_argument('--output',
default='{}.root'.format(os.path.basename(__file__)),
type=str)
parser.add_argument('--min-jet-pt',
help='jet pt selection',
default=50.,
type=float)
parser.add_argument('--max-jet-pt',
help='jet pt selection',
default=1000.,
type=float)
parser.add_argument('--npart-min',
help='minimum npart in Argantyr',
default=2,
type=int)
parser.add_argument('--as-data',
help='write as data - tree naming convention',
action='store_true',
default=False)
parser.add_argument('--run-number',
help='set run number',
default=1,
type=int)
parser.add_argument('--part-min-pt',
help='minimum pt of a particle',
default=0.15,
type=float)
args = parser.parse_args()
if args.user_seed < 0:
args.user_seed = -1
mycfg = []
else:
pinfo('user seed for pythia', args.user_seed)
# mycfg = ['PhaseSpace:pThatMin = 100']
mycfg = ['Random:setSeed=on', 'Random:seed={}'.format(args.user_seed)]
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if args.nev < 100:
args.nev = 100
# print the banner first
fj.ClusterSequence.print_banner()
print()
# set up our jet definition and a jet selector
jet_R0 = args.fj_R
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
print(jet_def)
# hadron level - ALICE
max_eta_hadron = 3.
pwarning('max eta for particles after hadronization set to',
max_eta_hadron)
parts_selector_h = fj.SelectorAbsEtaMax(max_eta_hadron) & fj.SelectorPtMin(
args.part_min_pt)
parts_selector_cent = fj.SelectorAbsEtaMax(5.) & fj.SelectorAbsEtaMin(3.)
outf = ROOT.TFile(args.output, 'recreate')
outf.cd()
# t = ROOT.TTree('t', 't')
# tw = RTreeWriter(tree=t)
# tch = ROOT.TTree('tch', 'tch')
# twch = RTreeWriter(tree=tch)
te = ROOT.TTree('te', 'te')
twe = RTreeWriter(tree=te)
tdf = ROOT.TDirectoryFile('PWGHF_TreeCreator', 'PWGHF_TreeCreator')
tdf.cd()
if args.as_data:
t_p = ROOT.TNtuple(
'tree_Particle', 'tree_Particle',
'run_number:ev_id:ParticlePt:ParticleEta:ParticlePhi:ParticlePID')
else:
t_p = ROOT.TNtuple(
'tree_Particle_gen', 'tree_Particle_gen',
'run_number:ev_id:ParticlePt:ParticleEta:ParticlePhi:ParticlePID')
t_e = ROOT.TNtuple(
'tree_event_char', 'tree_event_char',
'run_number:ev_id:z_vtx_reco:is_ev_rej:weight:sigma:npart:nch:nchfwd:nchselect'
)
run_number = args.run_number
ev_id = 0
# event loop
for iev in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
twe.clear()
# tw.clear()
# twch.clear()
weight = pythia.info.weight()
if args.py_PbPb:
# from main113.cc
# Also fill the number of (absorptively and diffractively)
# wounded nucleaons.
nw = pythia.info.hiinfo.nAbsTarg() + pythia.info.hiinfo.nDiffTarg(
) + pythia.info.hiinfo.nAbsProj() + pythia.info.hiinfo.nDiffProj()
fill_ncoll_branches(pythia, twe)
else:
nw = 2
twe.fill_branch('nw', nw)
twe.fill_branch('w', weight)
sigma = pythia.info.sigmaGen()
twe.fill_branch('sigma', sigma)
# parts_pythia_h = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, False)
# parts_pythia_h_selected = parts_selector_h(parts_pythia_h)
parts_pythia_ch = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged], 0, True)
parts_pythia_ch_selected = parts_selector_h(parts_pythia_ch)
nch_total = len(parts_pythia_ch)
twe.fill_branch('nch', nch_total)
ncharged_fwd = len(parts_selector_cent(parts_pythia_ch))
twe.fill_branch('nchfwd', ncharged_fwd)
ncharged_selected = len(parts_pythia_ch_selected)
twe.fill_branch('nchselect', ncharged_selected)
twe.fill_branch('iev', iev)
ev_id = ev_id + 1
if args.py_PbPb and args.npart_min > nw:
twe.fill_tree()
continue
for p in parts_pythia_ch_selected:
pyp = pythiafjext.getPythia8Particle(p)
t_p.Fill(float(run_number), float(ev_id), p.perp(), p.eta(),
p.phi(), pyp.id())
t_e.Fill(float(run_number), float(ev_id), 0, 0, weight, sigma, nw,
nch_total, ncharged_fwd, ncharged_selected)
twe.fill_tree()
pythia.stat()
outf.Write()
outf.Close()
def main():
parser = argparse.ArgumentParser(description='pythia8 in python',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
args = parser.parse_args()
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
max_eta_hadron = 3
jet_R0 = 0.4
jet_selector = fj.SelectorPtMin(100.0) & fj.SelectorPtMax(
125.0) & fj.SelectorAbsEtaMax(max_eta_hadron - 1.05 * jet_R0)
# jet_selector = fj.SelectorPtMin(10.0) & fj.SelectorAbsEtaMax(max_eta_hadron - 1.05 * jet_R0)
parts_selector_h = fj.SelectorAbsEtaMax(max_eta_hadron)
fj.ClusterSequence.print_banner()
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
qweights = [0, 2, 4, 6, 10] # n-parts quenched
output = MyOutput('gen_quench_out.root', qweights)
if output.new_files():
print('[i] new files with', output.list_files())
else:
return
thm = []
for i, w in enumerate(qweights):
_t = ROOT.RUtil.Thermalizer(0.7, w, 1.0, max_eta_hadron)
thm.append(_t)
run_number = 0
event_number = 0
pbar = tqdm.tqdm(range(args.nev))
while (pbar.n < args.nev):
if not pythia.next():
continue
parts_pythia_h = pythiafjext.vectorize_select(pythia,
[pythiafjext.kFinal], 0,
False)
parts_pythia_h_selected = parts_selector_h(parts_pythia_h)
jets_hv = fj.sorted_by_pt(
jet_selector(jet_def(parts_pythia_h_selected)))
if len(jets_hv) < 1:
continue
if event_number > 0 and event_number % 1000 == 0:
if output.new_files():
print('[i] new files:', output.list_files())
else:
print('[e] no new file. stop here.')
break
event_number = event_number + 1
pbar.update(1)
jets_h = None
# do your things with jets/events here...
for i, w in enumerate(qweights):
if w > 0:
_pthermal = []
for p in parts_pythia_h_selected:
parts = thm[i].thermalize(p.perp(), p.eta(), p.phi(),
p.m())
__ = [
_pthermal.append(
fj.PseudoJet(_p.px(), _p.py(), _p.pz(), _p.e()))
for _p in parts
]
# print(i, 'len', len(_pthermal), 'from', len(parts_pythia_h_selected))
jets_h = fj.sorted_by_pt(jet_selector(jet_def(_pthermal)))
for _p in _pthermal:
output.files[w].tn.Fill(run_number, event_number,
_p.perp(), _p.eta(), _p.phi(), 111)
else:
jets_h = jets_hv
for _p in parts_pythia_h_selected:
output.files[w].tn.Fill(run_number, event_number,
_p.perp(), _p.eta(), _p.phi(), 111)
for j in jets_h:
output.files[w].hpt.Fill(j.perp())
if j.perp() > 100 and j.perp() < 125:
for c in j.constituents():
output.files[w].hz.Fill(c.perp() / j.perp())
pbar.close()
output.close()
pythia.stat()
pythia.settings.writeFile(args.py_cmnd_out)
def pythia_init_from_string(ssettings, mycfg=[]):
# example: ssettings = "--py-ecm 5000 --user-seed=100000 --nev 1000"
mycfg = []
args = get_args_from_settings(ssettings)
pythia8 = pyconf.create_and_init_pythia_from_args(args, mycfg)
return pythia8
def main():
mycfg = []
ssettings = "--py-ecm 5000 --py-minbias --user-seed=100000"
args = get_args_from_settings(ssettings)
pythia_mb = pyconf.create_and_init_pythia_from_args(args, mycfg)
mycfg = []
ssettings = "--py-ecm 5000 --user-seed=100000 --nev 100000"
args = get_args_from_settings(ssettings)
pythia_hard = pyconf.create_and_init_pythia_from_args(args, mycfg)
max_eta_hadron = 1
parts_selector_h = fj.SelectorAbsEtaMax(max_eta_hadron)
jet_R0 = 0.4
jet_selector = fj.SelectorPtMin(20.0) & fj.SelectorPtMax(
200.0) & fj.SelectorAbsEtaMax(max_eta_hadron - 1.05 * jet_R0)
n_pileup = 1 #5
# 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)
print(jet_def)
fout = ROOT.TFile(args.output, 'recreate')
fout.cd()
tj_delta = ROOT.TNtuple(
"tj_delta", "tj_delta",
"pt:eta:phi:L11:L21:L31:ptm:etam:phim:L11m:L21m:L31m:mpt")
tj_no_pup = ROOT.TNtuple("tj_no_pup", "tj_no_pup",
"pt:eta:phi:L11:L21:L31")
tj_pup = ROOT.TNtuple("tj_pup", "tj_pup", "pt:eta:phi:L11:L21:L31")
hmult_hard = ROOT.TH1F("hmult_hard", "hmult_hard", 300, 0, 300)
hmult_pup = ROOT.TH1F("hmult_pup", "hmult_pup", 300, 0, 300)
hpt_acc_hard = ROOT.TProfile2D("hpt_acc_hard", "hpt_acc_hard;#eta;#varphi",
50, -1, 1, 50, 0,
ROOT.TMath.Pi() * 2.)
hpt_acc_pup = ROOT.TProfile2D("hpt_acc_pup", "hpt_acc_pup;#eta;#varphi",
50, -1, 1, 50, 0,
ROOT.TMath.Pi() * 2.)
for n in tqdm(range(args.nev)):
if not pythia_hard.next():
continue
parts_pythia_h = pythiafjext.vectorize_select(
pythia_hard, [pythiafjext.kFinal, pythiafjext.kCharged], 0, False)
parts_pythia_h_selected = parts_selector_h(parts_pythia_h)
parts_pileup = None
for ipile in range(n_pileup):
while not pythia_mb.next():
continue
parts_pythia_h_ue = pythiafjext.vectorize_select(
pythia_mb, [pythiafjext.kFinal, pythiafjext.kCharged], 10000,
False)
parts_pythia_h_selected_ue = parts_selector_h(parts_pythia_h_ue)
if parts_pileup is None:
parts_pileup = parts_pythia_h_selected_ue
else:
parts_pileup += parts_pythia_h_selected_ue
mult_hard = len(parts_pythia_h_selected)
mult_ue = len(parts_pileup)
jets_h = fj.sorted_by_pt(jet_selector(
jet_def(parts_pythia_h_selected)))
jets_h_w_ue = fj.sorted_by_pt(
jet_selector(jet_def(parts_pileup + parts_pythia_h_selected)))
if len(jets_h) < 1:
continue
fill_matched(jets_h, jets_h_w_ue, tj_no_pup, tj_pup, tj_delta, jet_R0)
hmult_hard.Fill(mult_hard)
hmult_pup.Fill(mult_ue)
_tmp = [
hpt_acc_hard.Fill(p.eta(), p.phi(), p.perp())
for p in parts_pythia_h_selected
]
_tmp = [
hpt_acc_pup.Fill(p.eta(), p.phi(), p.perp()) for p in parts_pileup
]
pythia_hard.stat()
pythia_mb.stat()
fout.Write()
fout.Close()
print('[i] written ', fout.GetName())
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 fastjet on the fly',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
# Could use --py-seed
parser.add_argument('--user-seed', help='PYTHIA starting seed', default=1111, type=int)
parser.add_argument('--output', default="output.root", type=str)
parser.add_argument('--sd_beta', help='SoftDrop beta', default=None, type=float)
parser.add_argument('--jetR', help='Jet radius/resolution parameter', default=0.4, type=float)
parser.add_argument('--no-match-level', help="Save simulation for only one level with " + \
"no matching. Options: 'p', 'h', 'ch'", default=None, type=str)
parser.add_argument('--p-ch-MPI', help="Match between parton level (no MPI) and charged " + \
"hadron level (with MPI) for ALICE response characterization",
action='store_true', default=False)
args = parser.parse_args()
level = args.no_match_level
if args.p_ch_MPI:
if level:
print("ERROR: --no-match-level and --p-ch-MPI cannot be set simultaneously.")
exit(1)
if level not in [None, 'p', 'h', 'ch']:
print("ERROR: Unrecognized type %s. Please use 'p', 'h', or 'ch'" % args.type_only)
exit(1)
# Angularity beta values
betas = [1, 1.5, 2, 3]
if args.user_seed < 0:
args.user_seed = 1111
pinfo('user seed for pythia', args.user_seed)
# mycfg = ['PhaseSpace:pThatMin = 100']
mycfg = ['Random:setSeed=on', 'Random:seed={}'.format(args.user_seed)]
mycfg.append('HadronLevel:all=off')
# Have at least 1 event
if args.nev < 1:
args.nev = 1
if args.p_ch_MPI:
d = vars(args)
d['py_noMPI'] = True
pythia_noMPI = pyconf.create_and_init_pythia_from_args(args, mycfg)
args_MPI = copy.deepcopy(args)
d = vars(args_MPI)
d['py_noMPI'] = False
pythia = pyconf.create_and_init_pythia_from_args(args_MPI, mycfg)
else:
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
# print the banner first
fj.ClusterSequence.print_banner()
print()
# set up our jet definition and a jet selector
jet_R0 = args.jetR
jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
print(jet_def)
# hadron level - ALICE
max_eta_hadron = 0.9
pwarning('max eta for particles after hadronization set to', max_eta_hadron)
parts_selector_h = fj.SelectorAbsEtaMax(max_eta_hadron)
jet_selector = fj.SelectorPtMin(5.0) #& fj.SelectorAbsEtaMax(max_eta_hadron - jet_R0)
max_eta_parton = max_eta_hadron + 2. * jet_R0
pwarning('max eta for partons set to', max_eta_parton)
parts_selector_p = fj.SelectorAbsEtaMax(max_eta_parton)
if not args.sd_beta is None:
args.output = args.output.replace('.root', '_sdbeta{}.root'.format(args.sd_beta))
outf = ROOT.TFile(args.output, 'recreate')
outf.cd()
t = ROOT.TTree('t', 't')
tw = RTreeWriter(tree=t)
count1 = 0
count2 = 0
# event loop
for iev in range(args.nev): #tqdm.tqdm(range(args.nev)):
if not pythia.next():
if args.p_ch_MPI:
pythia_noMPI.next()
continue
if args.p_ch_MPI and not pythia_noMPI.next():
continue
parts_pythia_p = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, True)
parts_pythia_p_selected = parts_selector_p(parts_pythia_p)
if args.p_ch_MPI:
parts_pythia_p = pythiafjext.vectorize_select(pythia_noMPI, [pythiafjext.kFinal], 0, True)
parts_pythia_p_selected = parts_selector_p(parts_pythia_p)
hstatus = pythia.forceHadronLevel()
if not hstatus:
#pwarning('forceHadronLevel false event', iev)
continue
# parts_pythia_h = pythiafjext.vectorize_select(
# pythia, [pythiafjext.kHadron, pythiafjext.kCharged])
parts_pythia_h = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, True)
parts_pythia_h_selected = parts_selector_h(parts_pythia_h)
parts_pythia_hch = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged], 0, True)
parts_pythia_hch_selected = parts_selector_h(parts_pythia_hch)
# pinfo('debug partons...')
# for p in parts_pythia_p_selected:
# pyp = pythiafjext.getPythia8Particle(p)
# print(pyp.name())
# pinfo('debug hadrons...')
# for p in parts_pythia_h_selected:
# pyp = pythiafjext.getPythia8Particle(p)
# print(pyp.name())
# pinfo('debug ch. hadrons...')
# for p in parts_pythia_hch_selected:
# pyp = pythiafjext.getPythia8Particle(p)
# print(pyp.name())
# parts = pythiafjext.vectorize(pythia, True, -1, 1, False)
jets_p = fj.sorted_by_pt(jet_selector(jet_def(parts_pythia_p)))
jets_h = fj.sorted_by_pt(jet_selector(jet_def(parts_pythia_h)))
jets_ch = fj.sorted_by_pt(jet_selector(jet_def(parts_pythia_hch)))
if level: # Only save info at one level w/o matching
jets = locals()["jets_%s" % level]
for jet in jets:
tw.fill_branch('iev', iev)
tw.fill_branch(level, jet)
kappa = 1
for beta in betas:
label = str(beta).replace('.', '')
tw.fill_branch('l_%s_%s' % (level, label),
lambda_beta_kappa(jet, jet_R0, beta, kappa))
continue
if not args.sd_beta is None:
sd = fjcontrib.SoftDrop(args.sd_beta, 0.1, jet_R0)
for i,jchh in enumerate(jets_ch):
# match hadron (full) jet
drhh_list = []
for j, jh in enumerate(jets_h):
drhh = jchh.delta_R(jh)
if drhh < jet_R0 / 2.:
drhh_list.append((j,jh))
if len(drhh_list) != 1:
count1 += 1
else: # Require unique match
j, jh = drhh_list[0]
# match parton level jet
dr_list = []
for k, jp in enumerate(jets_p):
dr = jh.delta_R(jp)
if dr < jet_R0 / 2.:
dr_list.append((k, jp))
if len(dr_list) != 1:
count2 += 1
else:
k, jp = dr_list[0]
# pwarning('event', iev)
# pinfo('matched jets: ch.h:', jchh.pt(), 'h:', jh.pt(),
# 'p:', jp.pt(), 'dr:', dr)
tw.fill_branch('iev', iev)
tw.fill_branch('ch', jchh)
tw.fill_branch('h', jh)
tw.fill_branch('p', jp)
kappa = 1
for beta in betas:
label = str(beta).replace('.', '')
tw.fill_branch("l_ch_%s" % label,
lambda_beta_kappa(jchh, jet_R0, beta, kappa))
tw.fill_branch("l_h_%s" % label,
lambda_beta_kappa(jh, jet_R0, beta, kappa))
tw.fill_branch("l_p_%s" % label,
lambda_beta_kappa(jp, jet_R0, beta, kappa))
if not args.sd_beta is None:
jchh_sd = sd.result(jchh)
jchh_sd_info = fjcontrib.get_SD_jet_info(jchh_sd)
jh_sd = sd.result(jh)
jh_sd_info = fjcontrib.get_SD_jet_info(jh_sd)
jp_sd = sd.result(jp)
jp_sd_info = fjcontrib.get_SD_jet_info(jp_sd)
tw.fill_branch('p_zg', jp_sd_info.z)
tw.fill_branch('p_Rg', jp_sd_info.dR)
tw.fill_branch('p_thg', jp_sd_info.dR/jet_R0)
tw.fill_branch('p_mug', jp_sd_info.mu)
tw.fill_branch('h_zg', jh_sd_info.z)
tw.fill_branch('h_Rg', jh_sd_info.dR)
tw.fill_branch('h_thg', jh_sd_info.dR/jet_R0)
tw.fill_branch('h_mug', jh_sd_info.mu)
tw.fill_branch('ch_zg', jchh_sd_info.z)
tw.fill_branch('ch_Rg', jchh_sd_info.dR)
tw.fill_branch('ch_thg', jchh_sd_info.dR/jet_R0)
tw.fill_branch('ch_mug', jchh_sd_info.mu)
#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))
tw.fill_tree()
if args.p_ch_MPI:
pythia_noMPI.stat()
pythia.stat()
print("%i jets cut at first match criteria; %i jets cut at second match criteria." %
(count1, count2))
outf.Write()
outf.Close()
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')
parser.add_argument('--output', default="output.root", type=str)
parser.add_argument('--alpha', default=0, type=float)
parser.add_argument('--dRmax', default=0.0, type=float)
parser.add_argument('--zcut', default=0.1, type=float)
parser.add_argument('--overwrite',
help="overwrite output",
default=False,
action='store_true')
parser.add_argument('--embed',
help='run embedding from a file list',
default='',
type=str)
parser.add_argument('--SDsignal',
help='embed only SD signal prongs',
default=False,
action='store_true')
parser.add_argument('--SDsignal-single',
help='embed only SD signal - only leading prong!',
default=False,
action='store_true')
parser.add_argument('--efficiency',
help='apply charged particle efficiency',
default=False,
action='store_true')
parser.add_argument('--benchmark',
help='benchmark pthat setting - 80 GeV',
default=False,
action='store_true')
parser.add_argument('--csjet',
help='constituent subtration jet-by-jet',
default=False,
action='store_true')
args = parser.parse_args()
if args.output == 'output.root':
args.output = 'output_alpha_{}_dRmax_{}_SDzcut_{}.root'.format(
args.alpha, args.dRmax, args.zcut)
if args.py_seed >= 0:
args.output = 'output_alpha_{}_dRmax_{}_SDzcut_{}_seed_{}.root'.format(
args.alpha, args.dRmax, args.zcut, args.py_seed)
if args.embed:
args.output = args.output.replace('.root', '_emb.root')
if args.efficiency:
args.output = args.output.replace('.root', '_effi.root')
if args.SDsignal:
args.output = args.output.replace('.root', '_SDsignal.root')
if args.SDsignal_single:
args.output = args.output.replace('.root', '_SDsignal_single.root')
if args.csjet:
args.output = args.output.replace('.root', '_csjet.root')
if os.path.isfile(args.output):
if not args.overwrite:
print('[i] output', args.output,
'exists - use --overwrite to do just that...')
return
print(args)
# alice specific
max_eta = 0.9
# 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)
print(jet_def)
mycfg = []
if args.benchmark:
mycfg = ['PhaseSpace:pThatMin = 80', 'PhaseSpace:pThatMax = -1']
jet_selector = fj.SelectorPtMin(80.0) & fj.SelectorPtMax(
100.0) & fj.SelectorAbsEtaMax(max_eta - 1.05 * jet_R0)
# jet_selector_cs = fj.SelectorPtMin(50.0) & fj.SelectorAbsEtaMax(max_eta - 1.05 * jet_R0)
else:
args.py_biaspow = 4
args.py_biasref = 10
jet_selector = fj.SelectorPtMin(20) & fj.SelectorAbsEtaMax(
max_eta - 1.05 * jet_R0)
# jet_selector_cs = fj.SelectorPtMin(50.0) & fj.SelectorAbsEtaMax(max_eta - 1.05 * jet_R0)
if args.ignore_mycfg:
mycfg = []
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
print("[e] pythia initialization failed.")
return
sd_zcut = args.zcut
sd = fjcontrib.SoftDrop(0, sd_zcut, jet_R0)
jarho = JetAnalysisWithRho(jet_R=jet_R0,
jet_algorithm=fj.antikt_algorithm,
particle_eta_max=max_eta)
ja = JetAnalysis(jet_R=jet_R0,
jet_algorithm=fj.antikt_algorithm,
particle_eta_max=max_eta)
be = None
embd = None
if len(args.embed) > 0:
embd = DataBackgroundIO(file_list=args.embed)
print(embd)
else:
be = BoltzmannEvent(mean_pt=0.6,
multiplicity=2000 * max_eta * 2,
max_eta=max_eta,
max_pt=100)
print(be)
cs = None
if args.dRmax > 0:
cs = CEventSubtractor(alpha=args.alpha,
max_distance=args.dRmax,
max_eta=max_eta,
bge_rho_grid_size=0.25,
max_pt_correct=100)
print(cs)
csjet = None
if args.csjet:
csjet = CSubtractorJetByJet(max_eta=max_eta, bge_rho_grid_size=0.25)
print(csjet)
parts_selector = fj.SelectorAbsEtaMax(max_eta)
if args.nev < 1:
args.nev = 1
outf = ROOT.TFile(args.output, 'recreate')
outf.cd()
t = ROOT.TTree('t', 't')
tw = RTreeWriter(tree=t)
te = ROOT.TTree('te', 'te')
twe = RTreeWriter(tree=te)
# effi_pp = AliceChargedParticleEfficiency(csystem='pp')
effi_PbPb = None
if args.efficiency:
effi_PbPb = AliceChargedParticleEfficiency(csystem='PbPb')
print(effi_PbPb)
### EVENT LOOP STARTS HERE
for iev in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
parts_pythia = pythiafjext.vectorize_select(
pythia, [pythiafjext.kFinal, pythiafjext.kCharged])
parts_gen = parts_selector(parts_pythia)
if effi_PbPb:
parts = effi_PbPb.apply_efficiency(parts_gen)
else:
parts = parts_gen
signal_jets = fj.sorted_by_pt(jet_selector(jet_def(parts)))
if len(signal_jets) < 1:
continue
for sjet in signal_jets:
if args.SDsignal or args.SDsignal_single:
sd_sjet = sd.result(sjet)
pe1 = fj.PseudoJet()
pe2 = fj.PseudoJet()
has_parents = sd_sjet.has_parents(pe1, pe2)
if has_parents:
jparts = fj.vectorPJ()
pe1.set_user_index(0)
pe2.set_user_index(1)
if args.SDsignal_single:
if pe1.pt() > pe2.pt():
jparts.push_back(pe1)
else:
jparts.push_back(pe2)
else:
jparts.push_back(pe1)
jparts.push_back(pe2)
sjets = fj.sorted_by_pt(jet_selector(jet_def(jparts)))
if len(sjets) == 1:
sjet = sjets[0]
else:
continue
else:
continue
if embd:
bg_parts = embd.load_event(offset=10000)
# for p in bg_parts:
# print(p.user_index())
else:
bg_parts = be.generate(offset=10000)
# for p in bg_parts:
# print(p.user_index())
full_event = bg_parts
tmp = [full_event.push_back(psj) for psj in sjet.constituents()]
if cs:
cs_parts = cs.process_event(full_event)
rho = cs.bge_rho.rho()
jarho.analyze_event(cs_parts)
tmp = [
fill_tree_data(ej, twe, sd, rho, iev, pythia.info.weight(),
pythia.info.sigmaGen()) for ej in jarho.jets
]
tmp = [
fill_tree_matched(sjet, ej, tw, sd, rho, iev,
pythia.info.weight(),
pythia.info.sigmaGen())
for ej in jarho.jets
]
else:
jarho.analyze_event(full_event)
rho = jarho.rho
if csjet:
#_csjet = fjcontrib.ConstituentSubtractor(jarho.bg_estimator)
# subtr_jets = [_csjet.result(ej) for ej in jarho.jets]
csjet.set_event_particles(full_event)
#subtr_jets = [csjet.process_jet(ej) for ej in jarho.jets]
#print ('jbyj cs', len(subtr_jets), 'from', len(jarho.jets))
#subtr_jets_wconstits = [_j for _j in subtr_jets if _j.has_constituents()]
#for _j in subtr_jets_wconstits:
# print(len(_j.constituents()))
subtr_jets_wconstits = csjet.process_jets(jarho.jets)
japerjet = JetAnalysisPerJet(
jet_R=jet_R0,
jet_algorithm=fj.antikt_algorithm,
particle_eta_max=max_eta,
input_jets=subtr_jets_wconstits)
# for _j in japerjet.jets:
# for _c in _j.constituents():
# if _c.user_index() >= 0:
# print('user index kept?', _c.user_index())
# # else:
# # print('user index kept?', _c.user_index(), _c.pt())
# _sd_j = sd.result(_j)
# https://phab.hepforge.org/source/fastjetsvn/browse/contrib/contribs/RecursiveTools/trunk/Recluster.cc L 270
# tmp = [fill_tree_matched(sjet, ej, tw, sd, rho, iev, pythia.info.sigmaGen()) for ej in subtr_jets_wcs]
tmp = [
fill_tree_data(ej, twe, sd, rho, iev,
pythia.info.weight(),
pythia.info.sigmaGen())
for ej in japerjet.jets
]
tmp = [
fill_tree_matched(sjet, ej, tw, sd, rho, iev,
pythia.info.weight(),
pythia.info.sigmaGen())
for ej in japerjet.jets
]
else:
tmp = [
fill_tree_data(ej, twe, sd, rho, iev,
pythia.info.weight(),
pythia.info.sigmaGen())
for ej in jarho.jets
]
tmp = [
fill_tree_matched(sjet, ej, tw, sd, rho, iev,
pythia.info.weight(),
pythia.info.sigmaGen())
for ej in jarho.jets
]
pythia.stat()
outf.Write()
outf.Close()
print('[i] written', outf.GetName())
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 main():
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
_default_output_filename = os.path.basename(__file__).replace(
".py", "") + "_output.root"
parser.add_argument('--output', default=_default_output_filename, type=str)
parser.add_argument('--user-seed',
help='pythia seed',
default=1111,
type=int)
parser.add_argument('--debug', default=0, type=int)
args = parser.parse_args()
# jets
# print the banner first
# fj.ClusterSequence.print_banner()
# print()
# # set up our jet definition and a jet selector
jet_R0 = 1.0
# jet_def = fj.JetDefinition(fj.antikt_algorithm, jet_R0)
# print(jet_def)
# acceptance
# hadron level acceptamce
max_eta_hadron = 10.
from pyjetty.mputils import pwarning
pwarning('max eta for particles after hadronization set to',
max_eta_hadron)
parts_selector_h = fj.SelectorAbsEtaMax(max_eta_hadron)
jet_selector = fj.SelectorPtMin(1.0) & fj.SelectorPtMax(
100.0) & fj.SelectorAbsEtaMax(max_eta_hadron - 1.05 * jet_R0)
# parton level acceptamce
max_eta_parton = max_eta_hadron + 3. * jet_R0
pwarning('max eta for partons set to', max_eta_parton)
parts_selector_p = fj.SelectorAbsEtaMax(max_eta_parton)
# initialize pythia
# mZ = pythia8.Pythia().particleData.m0(23)
mZ = 91.188
beams_eCM = "Beams:eCM={}".format(mZ)
mycfg = [
"PDF:lepton = off", # Allow no substructure in e+- beams: normal for corrected LEP data.
"WeakSingleBoson:ffbar2gmZ = on", # Process selection.
"23:onMode = off", # Switch off all Z0 decays and then switch back on those to quarks.
"23:onIfAny = 1 2 3 4 5",
"Beams:idA = 11",
"Beams:idB = -11",
beams_eCM, # LEP1 initialization at Z0 mass.
"HadronLevel:all=off", # parton level first
"PhaseSpace:bias2Selection=off"
] # this is ON by default in pyconf - not OK for these settings
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
if not pythia:
return
# initialize ROOT output
outf = ROOT.TFile(args.output, 'recreate')
outf.cd()
tdf = ROOT.TDirectoryFile('PWGHF_TreeCreator', 'PWGHF_TreeCreator')
tdf.cd()
t_p = ROOT.TNtuple(
'tree_Particle_P', 'tree_Particle_P',
'run_number:ev_id:ParticlePt:ParticleEta:ParticlePhi:ParticleID:ParticleIDabs:ParticleCharge:isGluon:isQuark'
)
# t_p = ROOT.TNtuple('tree_Particle_gen', 'tree_Particle_gen', 'run_number:ev_id:ParticlePt:ParticleEta:ParticlePhi:ParticleID:ParticleIDabs:ParticleCharge')
t_h = ROOT.TNtuple(
'tree_Particle_H', 'tree_Particle_H',
'run_number:ev_id:ParticlePt:ParticleEta:ParticlePhi:ParticleID:ParticleIDabs:ParticleCharge:isHadron:isLepton:isVisible'
)
t_e = ROOT.TNtuple('tree_event_char', 'tree_event_char',
'run_number:ev_id:z_vtx_reco:is_ev_rej')
if args.nev < 100:
args.nev = 100
run_number = args.user_seed
# main loop
for i in tqdm.tqdm(range(args.nev)):
if not pythia.next():
continue
if args.debug:
pwarning('-- event', i)
#select particles
parts_pythia_p = pythiafjext.vectorize_select(pythia,
[pythiafjext.kFinal], 0,
True)
parts_pythia_p_selected = parts_selector_p(parts_pythia_p)
# hadronize
hstatus = pythia.forceHadronLevel()
if not hstatus:
pwarning('forceHadronLevel false event', iev)
continue
parts_pythia_h = pythiafjext.vectorize_select(pythia,
[pythiafjext.kFinal], 0,
True)
parts_pythia_h_selected = parts_selector_h(parts_pythia_h)
# charged hadrons/particles only
# parts_pythia_h = pythiafjext.vectorize_select(pythia, [pythiafjext.kHadron, pythiafjext.kCharged])
# parts_pythia_hch = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal, pythiafjext.kCharged], 0, True)
# parts_pythia_hch_selected = parts_selector_h(parts_pythia_hch)
# stream to trees
ev_id = i
t_e.Fill(run_number, ev_id, 0, 0)
_tmp = [
t_p.Fill(
run_number,
ev_id,
p.perp(),
p.eta(),
p.phi(),
pythiafjext.getPythia8Particle(p).id(),
pythiafjext.getPythia8Particle(p).idAbs(),
pythiafjext.getPythia8Particle(p).charge(),
pythiafjext.getPythia8Particle(p).isGluon(),
pythiafjext.getPythia8Particle(p).isQuark(),
) for p in parts_pythia_p
]
_tmp = [
t_h.Fill(run_number, ev_id, p.perp(), p.eta(), p.phi(),
pythiafjext.getPythia8Particle(p).id(),
pythiafjext.getPythia8Particle(p).idAbs(),
pythiafjext.getPythia8Particle(p).charge(),
pythiafjext.getPythia8Particle(p).isHadron(),
pythiafjext.getPythia8Particle(p).isLepton(),
pythiafjext.getPythia8Particle(p).isVisible())
for p in parts_pythia_h
]
pythia.stat()
outf.Write()
outf.Close()
