def fromSixDump101(cls, input_folder, st_dump_file, **kwargs):
import sixtracktools
import pysixtrack
six = sixtracktools.SixInput(input_folder)
line, rest, iconv = six.expand_struct(convert=pysixtrack.element_types)
sixdump = sixtracktools.SixDump101(st_dump_file)
num_iconv = int(len(iconv))
num_belem = int(len(line))
num_dumps = int(len(sixdump.particles))
assert num_iconv > 0
assert num_belem > iconv[num_iconv - 1]
assert num_dumps >= num_iconv
assert (num_dumps % num_iconv) == 0
num_particles = int(num_dumps / num_iconv)
self = cls(**kwargs)
for ii in range(num_iconv):
elem_id = iconv[ii]
assert elem_id < num_belem
p = self.Particles(num_particles=num_particles)
assert p.num_particles == num_particles
assert len(p.q0) == num_particles
for jj in range(num_particles):
kk = num_particles * ii + jj
assert kk < num_dumps
p.from_pysixtrack(
pysixtrack.Particles(**sixdump[kk].get_minimal_beam()), jj)
p.state[jj] = 1
p.at_element[jj] = elem_id
return self
def track_particle_sixtrack(
partCO, Dx_wrt_CO_m, Dpx_wrt_CO_rad,
Dy_wrt_CO_m, Dpy_wrt_CO_rad,
Dsigma_wrt_CO_m, Ddelta_wrt_CO, n_turns
):
Dx_wrt_CO_m, Dpx_wrt_CO_rad,\
Dy_wrt_CO_m, Dpy_wrt_CO_rad,\
Dsigma_wrt_CO_m, Ddelta_wrt_CO = vectorize_all_coords(
Dx_wrt_CO_m, Dpx_wrt_CO_rad,
Dy_wrt_CO_m, Dpy_wrt_CO_rad,
Dsigma_wrt_CO_m, Ddelta_wrt_CO)
n_part = len(Dx_wrt_CO_m)
wfold = 'temp_trackfun'
if not os.path.exists(wfold):
os.mkdir(wfold)
os.system('cp fort.* %s' % wfold)
with open('fort.3', 'r') as fid:
lines_f3 = fid.readlines()
# Set initial coordinates
i_start_ini = None
for ii, ll in enumerate(lines_f3):
if ll.startswith('INITIAL COO'):
i_start_ini = ii
break
lines_f3[i_start_ini + 2] = ' 0.\n'
lines_f3[i_start_ini + 3] = ' 0.\n'
lines_f3[i_start_ini + 4] = ' 0.\n'
lines_f3[i_start_ini + 5] = ' 0.\n'
lines_f3[i_start_ini + 6] = ' 0.\n'
lines_f3[i_start_ini + 7] = ' 0.\n'
lines_f3[i_start_ini + 2 + 6] = ' 0.\n'
lines_f3[i_start_ini + 3 + 6] = ' 0.\n'
lines_f3[i_start_ini + 4 + 6] = ' 0.\n'
lines_f3[i_start_ini + 5 + 6] = ' 0.\n'
lines_f3[i_start_ini + 6 + 6] = ' 0.\n'
lines_f3[i_start_ini + 7 + 6] = ' 0.\n'
lines_f13 = []
for i_part in range(n_part):
temp_part = pysixtrack.Particles(**partCO)
temp_part.x += Dx_wrt_CO_m[i_part]
temp_part.px += Dpx_wrt_CO_rad[i_part]
temp_part.y += Dy_wrt_CO_m[i_part]
temp_part.py += Dpy_wrt_CO_rad[i_part]
temp_part.sigma += Dsigma_wrt_CO_m[i_part]
temp_part.delta += Ddelta_wrt_CO[i_part]
lines_f13.append('%.10e\n' % ((temp_part.x) * 1e3))
lines_f13.append('%.10e\n' % ((temp_part.px) * temp_part.rpp * 1e3))
lines_f13.append('%.10e\n' % ((temp_part.y) * 1e3))
lines_f13.append('%.10e\n' % ((temp_part.py) * temp_part.rpp * 1e3))
lines_f13.append('%.10e\n' % ((temp_part.sigma) * 1e3))
lines_f13.append('%.10e\n' % ((temp_part.delta)))
if i_part % 2 == 1:
lines_f13.append('%.10e\n' % (temp_part.energy0 * 1e-6))
lines_f13.append('%.10e\n' % (prev_part.energy * 1e-6))
lines_f13.append('%.10e\n' % (temp_part.energy * 1e-6))
prev_part = temp_part
with open(wfold + '/fort.13', 'w') as fid:
fid.writelines(lines_f13)
if np.mod(n_part, 2) != 0:
raise ValueError('SixTrack does not like this!')
i_start_tk = None
for ii, ll in enumerate(lines_f3):
if ll.startswith('TRACKING PAR'):
i_start_tk = ii
break
# Set number of turns and number of particles
temp_list = lines_f3[i_start_tk + 1].split(' ')
temp_list[0] = '%d' % n_turns
temp_list[2] = '%d' % (n_part / 2)
lines_f3[i_start_tk + 1] = ' '.join(temp_list)
# Set number of idfor = 2
temp_list = lines_f3[i_start_tk + 2].split(' ')
temp_list[2] = '2'
lines_f3[i_start_tk + 2] = ' '.join(temp_list)
# Setup turn-by-turn dump
i_start_dp = None
for ii, ll in enumerate(lines_f3):
if ll.startswith('DUMP'):
i_start_dp = ii
break
lines_f3[i_start_dp + 1] = 'StartDUMP 1 664 101 dumtemp.dat\n'
with open(wfold + '/fort.3', 'w') as fid:
fid.writelines(lines_f3)
os.system('./runsix_trackfun')
# Load sixtrack tracking data
sixdump_all = sixtracktools.SixDump101('%s/dumtemp.dat' % wfold)
x_tbt = np.zeros((n_turns, n_part))
px_tbt = np.zeros((n_turns, n_part))
y_tbt = np.zeros((n_turns, n_part))
py_tbt = np.zeros((n_turns, n_part))
sigma_tbt = np.zeros((n_turns, n_part))
delta_tbt = np.zeros((n_turns, n_part))
for i_part in range(n_part):
sixdump_part = sixdump_all[i_part::n_part]
x_tbt[:, i_part] = sixdump_part.x
px_tbt[:, i_part] = sixdump_part.px
y_tbt[:, i_part] = sixdump_part.y
py_tbt[:, i_part] = sixdump_part.py
sigma_tbt[:, i_part] = sixdump_part.sigma
delta_tbt[:, i_part] = sixdump_part.delta
return x_tbt, px_tbt, y_tbt, py_tbt, sigma_tbt, delta_tbt
p0c_eV = sixinput.initialconditions[-3] * 1e6
# Build pysixtrack line from sixtrack input
line = pysixtrack.Line.from_sixinput(sixinput)
other_data = line.other_info
# Info on sixtrack->pyblep conversion
iconv = other_data['iconv']
########################################################
# Search closed orbit #
# (for comparison purposes we the orbit from sixtrack) #
########################################################
# Load sixtrack tracking data
sixdump_all = sixtracktools.SixDump101('sixtrack/res/dump3.dat')
# Assume first particle to be on the closed orbit
Nele_st = len(iconv)
sixdump_CO = sixdump_all[::2][:Nele_st]
# Disable BB elements
line.disable_beambeam()
# Find closed orbit
guess_from_sixtrack = [
getattr(sixdump_CO, att)[0] for att in 'x px y py sigma delta'.split()
]
part_on_CO = line.find_closed_orbit(guess=guess_from_sixtrack,
method='get_guess',
p0c=p0c_eV)
#Setup turn-by-turn dump
i_start_dp = None
for ii, ll in enumerate(lines_f3):
if ll.startswith('DUMP'):
i_start_dp = ii
break
lines_f3[i_start_dp + 1] = 'StartDUMP 1 664 101 dumtemp.dat\n'
with open(wfold + '/fort.3', 'w') as fid:
fid.writelines(lines_f3)
os.system('./runsix_trackfun')
# Load sixtrack tracking data
sixdump_all = sixtracktools.SixDump101('%s/dumtemp.dat' % wfold)
sixdump_CO = sixdump_all[::2] # Particle on CO
sixdump_part = sixdump_all[1::2] #
x_tbt = sixdump_part.x
px_tbt = sixdump_part.px
y_tbt = sixdump_part.y
py_tbt = sixdump_part.py
sigma_tbt = sixdump_part.sigma
delta_tbt = sixdump_part.delta
plt.close('all')
fig1 = plt.figure(1)
axx = fig1.add_subplot(2, 1, 1)
axy = fig1.add_subplot(2, 1, 2, sharex=axx)
sixinput = sixtracktools.SixInput(".")
p0c_eV = sixinput.initialconditions[-3] * 1e6
# Build pysixtrack line from sixtrack input
line = pysixtrack.Line.from_sixinput(sixinput)
# Info on sixtrack->pyblep conversion
iconv = line.other_info["iconv"]
########################################################
# Search closed orbit #
# (for comparison purposes we the orbit from sixtrack) #
########################################################
# Load sixtrack tracking data
sixdump_all = sixtracktools.SixDump101("res/dump3.dat")
# Assume first particle to be on the closed orbit
Nele_st = len(iconv)
sixdump_CO = sixdump_all[::2][:Nele_st]
# Disable BB elements
line.disable_beambeam()
# Find closed orbit
guess_from_sixtrack = [
getattr(sixdump_CO, att)[0] for att in "x px y py sigma delta".split()
]
part_on_CO = line.find_closed_orbit(guess=guess_from_sixtrack,
method="get_guess",
p0c=p0c_eV)
import sixtracktools
import pysixtrack
six = sixtracktools.SixInput('.')
line, other = pysixtrack.Line.from_sixinput(six)
iconv = other['iconv']
sixdump = sixtracktools.SixDump101('res/dump3.dat')[1::2]
def compare(prun,pbench):
out=[]
for att in 'x px y py delta sigma'.split():
vrun=getattr(prun,att)
vbench=getattr(pbench,att)
diff=vrun-vbench
out.append(abs(diff))
print(f"{att:<5} {vrun:22.13e} {vbench:22.13e} {diff:22.13g}")
print(f"max {max(out):21.12e}")
return max(out)
print("")
for ii in range(1,len(iconv)):
jja=iconv[ii-1]
jjb=iconv[ii]
prun=pysixtrack.Particles(**sixdump[ii-1].get_minimal_beam())
print(f"\n-----sixtrack={ii} sixtracklib={jja} --------------")
#print(f"pysixtr {jja}, x={prun.x}, px={prun.px}")
for jj in range(jja+1, jjb+1):
label,elem=line.element_names[jj], line.elements[jj]
elem.track(prun)
print(f"{jj} {label},{str(elem)[:50]}")
import sixtracktools
import pysixtrack
six = sixtracktools.SixInput('sixtrack')
line, rest, iconv = six.expand_struct(convert=pysixtrack.element_types)
sixdump = sixtracktools.SixDump101('sixtrack/dump3.dat')[::2]
def compare(prun, pbench):
out = []
for att in 'x px y py delta sigma'.split():
vrun = getattr(prun, att)
vbench = getattr(pbench, att)
diff = vrun - vbench
out.append(abs(diff))
print(f"{att:<5} {vrun:22.13e} {vbench:22.13e} {diff:22.13g}")
print(f"max {max(out):21.12e}")
return max(out)
print("")
for ii in range(1, len(iconv)):
jja = iconv[ii - 1]
jjb = iconv[ii]
prun = pysixtrack.Particles(**sixdump[ii - 1].get_minimal_beam())
print(f"\n-----sixtrack={ii} sixtracklib={jja} --------------")
#print(f"pysixtr {jja}, x={prun.x}, px={prun.px}")
for jj in range(jja + 1, jjb + 1):
label, elem_type, elem = line[jj]
elem.track(prun)
print(f"{jj} {label},{str(elem)[:50]}")
import sixtracktools
import pysixtrack
six = sixtracktools.SixInput(".")
line, other = pysixtrack.Line.from_sixinput(six)
iconv = other["iconv"]
sixdump = sixtracktools.SixDump101("res/dump.dat")[1::2]
def compare(prun, pbench):
out = []
for att in "x px y py delta sigma".split():
vrun = getattr(prun, att)
vbench = getattr(pbench, att)
diff = vrun - vbench
out.append(abs(diff))
print(f"{att:<5} {vrun:22.13e} {vbench:22.13e} {diff:22.13g}")
print(f"max {max(out):21.12e}")
return max(out)
print("")
for ii in range(1, len(iconv)):
jja = iconv[ii - 1]
jjb = iconv[ii]
prun = pysixtrack.Particles(**sixdump[ii - 1].get_minimal_beam())
print(f"\n-----sixtrack={ii} sixtracklib={jja} --------------")
# print(f"pysixtr {jja}, x={prun.x}, px={prun.px}")
for jj in range(jja + 1, jjb + 1):
label, elem = line.element_names[jj], line.elements[jj]
def generate_particle_data(input_path, output_path, conf=dict()):
print("**** Generating Particles Data From SixTrack Input:")
path_to_dump_file = os.path.join(input_path, "dump3.dat")
print("**** -> Reading sixtrack input data from:\r\n" +
f"**** {path_to_dump_file}")
six = sixtracktools.SixInput(input_path)
#line, rest, iconv = six.expand_struct( convert=pysixtrack.elements )
line = pysix.Line.from_sixinput(six)
iconv = line.other_info["iconv"]
sixdump = sixtracktools.SixDump101(path_to_dump_file)
num_iconv = int(len(iconv))
num_belem = int(len(line))
num_dumps = int(len(sixdump.particles))
assert num_iconv > 0
assert num_belem > iconv[num_iconv - 1]
assert num_dumps >= num_iconv
assert (num_dumps % num_iconv) == 0
num_particles = num_dumps // num_iconv
print(f"**** Info :: num sixtrack sequences : {num_iconv}")
print(f"**** Info :: num beam elements : {num_belem}")
print(f"**** Info :: num particles : {num_particles}")
assert num_particles > 0
assert num_belem > 0
assert num_iconv > 0
# =========================================================================
# Get initial particle distribution:
# Generate the initial particle disitribution buffers
print("**** -> Generating initial particle distributions ...")
generate_particle_data_initial(output_path, iconv, sixdump, conf=conf)
# =========================================================================
# Make sixtrack sequency-by-sequence data:
if conf.get("make_sixtrack_sequ_by_sequ", False):
print("**** -> Generating SixTrack sequ-by-sequ particle data ...")
generate_particle_data_sequ_by_sequ(output_path,
line,
iconv,
sixdump,
conf=conf)
# =========================================================================
# Make elem-by-elem data using pysixtrack:
if conf.get("make_elem_by_elem_data", False):
print(
"**** -> Generating elem-by-elem particle data using pysixtrack ..."
)
generate_particle_data_elem_by_elem(output_path,
line,
iconv,
sixdump,
conf=conf)
# =========================================================================
# Make until turn data using pysixtrack:
if conf.get( "make_until_num_turn_data", False ) and \
conf.get( "until_num_turns", 1 ) > 0:
print(
"**** -> Generating until_turn tracked data using pysixtrack ...")
until_turn = conf.get("until_num_turns", 1)
generate_particle_data_until_turn(output_path,
line,
iconv,
sixdump,
until_turn,
conf=conf)
import sixtracktools
import pysixtrack
six = sixtracktools.SixInput("sixtrack")
line, rest, iconv = six.expand_struct(convert=pysixtrack.element_types)
sixdump = sixtracktools.SixDump101("sixtrack/dump3.dat")[::2]
def compare(prun, pbench):
out = []
for att in "x px y py delta sigma".split():
vrun = getattr(prun, att)
vbench = getattr(pbench, att)
diff = vrun - vbench
out.append(abs(diff))
print(f"{att:<5} {vrun:22.13e} {vbench:22.13e} {diff:22.13g}")
print(f"max {max(out):21.12e}")
return max(out)
print("")
for ii in range(1, len(iconv)):
jja = iconv[ii - 1]
jjb = iconv[ii]
prun = pysixtrack.Particles(**sixdump[ii - 1].get_minimal_beam())
print(f"\n-----sixtrack={ii} sixtracklib={jja} --------------")
# print(f"pysixtr {jja}, x={prun.x}, px={prun.px}")
for jj in range(jja + 1, jjb + 1):
label, elem_type, elem = line[jj]
elem.track(prun)
print(f"{jj} {label},{str(elem)[:50]}")
def track_particle_sixtrack(
partCO,
Dx_wrt_CO_m,
Dpx_wrt_CO_rad,
Dy_wrt_CO_m,
Dpy_wrt_CO_rad,
Dsigma_wrt_CO_m,
Ddelta_wrt_CO,
n_turns,
):
(
Dx_wrt_CO_m,
Dpx_wrt_CO_rad,
Dy_wrt_CO_m,
Dpy_wrt_CO_rad,
Dsigma_wrt_CO_m,
Ddelta_wrt_CO,
) = vectorize_all_coords(
Dx_wrt_CO_m,
Dpx_wrt_CO_rad,
Dy_wrt_CO_m,
Dpy_wrt_CO_rad,
Dsigma_wrt_CO_m,
Ddelta_wrt_CO,
)
n_part = len(Dx_wrt_CO_m)
wfold = "temp_trackfun"
if not os.path.exists(wfold):
os.mkdir(wfold)
os.system("cp fort.* %s" % wfold)
with open("fort.3", "r") as fid:
lines_f3 = fid.readlines()
# Set initial coordinates
i_start_ini = None
for ii, ll in enumerate(lines_f3):
if ll.startswith("INITIAL COO"):
i_start_ini = ii
break
lines_f3[i_start_ini + 2] = " 0.\n"
lines_f3[i_start_ini + 3] = " 0.\n"
lines_f3[i_start_ini + 4] = " 0.\n"
lines_f3[i_start_ini + 5] = " 0.\n"
lines_f3[i_start_ini + 6] = " 0.\n"
lines_f3[i_start_ini + 7] = " 0.\n"
lines_f3[i_start_ini + 2 + 6] = " 0.\n"
lines_f3[i_start_ini + 3 + 6] = " 0.\n"
lines_f3[i_start_ini + 4 + 6] = " 0.\n"
lines_f3[i_start_ini + 5 + 6] = " 0.\n"
lines_f3[i_start_ini + 6 + 6] = " 0.\n"
lines_f3[i_start_ini + 7 + 6] = " 0.\n"
lines_f13 = []
prev_part = None
for i_part in range(n_part):
temp_part = pysixtrack.Particles(**partCO)
temp_part.x += Dx_wrt_CO_m[i_part]
temp_part.px += Dpx_wrt_CO_rad[i_part]
temp_part.y += Dy_wrt_CO_m[i_part]
temp_part.py += Dpy_wrt_CO_rad[i_part]
temp_part.sigma += Dsigma_wrt_CO_m[i_part]
temp_part.delta += Ddelta_wrt_CO[i_part]
lines_f13.append("%.10e\n" % ((temp_part.x) * 1e3))
lines_f13.append("%.10e\n" % ((temp_part.px) * temp_part.rpp * 1e3))
lines_f13.append("%.10e\n" % ((temp_part.y) * 1e3))
lines_f13.append("%.10e\n" % ((temp_part.py) * temp_part.rpp * 1e3))
lines_f13.append("%.10e\n" % ((temp_part.sigma) * 1e3))
lines_f13.append("%.10e\n" % ((temp_part.delta)))
if i_part % 2 == 1:
lines_f13.append("%.10e\n" % (temp_part.energy0 * 1e-6))
lines_f13.append("%.10e\n" % (prev_part.energy * 1e-6))
lines_f13.append("%.10e\n" % (temp_part.energy * 1e-6))
prev_part = temp_part
with open(wfold + "/fort.13", "w") as fid:
fid.writelines(lines_f13)
if np.mod(n_part, 2) != 0:
raise ValueError("SixTrack does not like this!")
i_start_tk = None
for ii, ll in enumerate(lines_f3):
if ll.startswith("TRACKING PAR"):
i_start_tk = ii
break
# Set number of turns and number of particles
temp_list = lines_f3[i_start_tk + 1].split(" ")
temp_list[0] = "%d" % n_turns
temp_list[2] = "%d" % (n_part / 2)
lines_f3[i_start_tk + 1] = " ".join(temp_list)
# Set number of idfor = 2
temp_list = lines_f3[i_start_tk + 2].split(" ")
temp_list[2] = "2"
lines_f3[i_start_tk + 2] = " ".join(temp_list)
# Setup turn-by-turn dump
i_start_dp = None
for ii, ll in enumerate(lines_f3):
if ll.startswith("DUMP"):
i_start_dp = ii
break
lines_f3[i_start_dp + 1] = "StartDUMP 1 664 101 dumtemp.dat\n"
with open(wfold + "/fort.3", "w") as fid:
fid.writelines(lines_f3)
os.system("./runsix_trackfun")
# Load sixtrack tracking data
sixdump_all = sixtracktools.SixDump101("%s/dumtemp.dat" % wfold)
x_tbt = np.zeros((n_turns, n_part))
px_tbt = np.zeros((n_turns, n_part))
y_tbt = np.zeros((n_turns, n_part))
py_tbt = np.zeros((n_turns, n_part))
sigma_tbt = np.zeros((n_turns, n_part))
delta_tbt = np.zeros((n_turns, n_part))
for i_part in range(n_part):
sixdump_part = sixdump_all[i_part::n_part]
x_tbt[:, i_part] = sixdump_part.x
px_tbt[:, i_part] = sixdump_part.px
y_tbt[:, i_part] = sixdump_part.y
py_tbt[:, i_part] = sixdump_part.py
sigma_tbt[:, i_part] = sixdump_part.sigma
delta_tbt[:, i_part] = sixdump_part.delta
return x_tbt, px_tbt, y_tbt, py_tbt, sigma_tbt, delta_tbt
