def _one_turn_map(p, particle_on_madx_co, tracker):
xl_part = particle_on_madx_co.copy()
xl_part.x = p[0]
xl_part.px = p[1]
xl_part.y = p[2]
xl_part.py = p[3]
xl_part.zeta = p[4]
xl_part.delta = p[5]
part = xt.Particles(**xl_part.to_dict())
tracker.track(part)
p_res = np.array([
part.x[0], part.px[0], part.y[0], part.py[0], part.zeta[0],
part.delta[0]
])
return p_res
def track_particle_xtrack(
line, 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,
_context=None):
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)
import xtrack as xt
tracker = xt.Tracker(_context=_context, sequence=line)
particles = xt.Particles(_context=_context,
p0c = partCO.p0c,
x = partCO.x + Dx_wrt_CO_m,
px = partCO.px + Dpx_wrt_CO_rad,
y = partCO.y + Dy_wrt_CO_m,
py = partCO.py + Dpy_wrt_CO_rad,
zeta = partCO.zeta + Dsigma_wrt_CO_m,
delta = partCO.delta + Ddelta_wrt_CO)
print('Start track')
tracker.track(particles, num_turns=n_turns, turn_by_turn_monitor=True)
print('Done track')
#print(res.particles[0])
x_tbt = tracker.record_last_track.x.copy().T
px_tbt = tracker.record_last_track.px.copy().T
y_tbt = tracker.record_last_track.y.copy().T
py_tbt = tracker.record_last_track.py.copy().T
sigma_tbt = tracker.record_last_track.zeta.copy().T
delta_tbt = tracker.record_last_track.delta.copy().T
print('Done loading!')
extra = {'particles': particles, 'tracker': tracker}
return x_tbt, px_tbt, y_tbt, py_tbt, sigma_tbt, delta_tbt, extra
sigma_y = 2e-3
sigma_z = 30e-2
p0c = 25.92e9
mass = Particles.pmass
theta_probes = 30 * np.pi / 180
r_max_probes = 2e-2
z_probes = 1.2 * sigma_z
n_probes = 1000
from xfields.test_support.temp_makepart import generate_particles_object
(particles_pyst, r_probes, x_probes, y_probes,
z_probes) = generate_particles_object(n_macroparticles, bunch_intensity,
sigma_x, sigma_y, sigma_z, p0c, mass,
n_probes, r_max_probes, z_probes,
theta_probes)
particles = xt.Particles(_context=context, **particles_pyst.to_dict())
######################
# Space charge (PIC) #
######################
x_lim = 5. * sigma_x
y_lim = 5. * sigma_y
z_lim = 5. * sigma_z
from xfields import SpaceCharge3D
spcharge_parent = SpaceCharge3D(_context=context,
length=1,
update_on_track=True,
apply_z_kick=False,
Dx_wrt_CO_m=np.array(displace_x),
Dpx_wrt_CO_rad=0,
Dy_wrt_CO_m=np.array(displace_y),
Dpy_wrt_CO_rad=0.,
Dsigma_wrt_CO_m=0.,
Ddelta_wrt_CO=0.,
n_turns=num_turns,
input_folder='../')
tracker = xt.Tracker(sequence=line)
part_track = partCO.copy()
part_track.x += np.array(displace_x)
part_track.y += np.array(displace_y)
particles = xt.Particles(**part_track.to_dict())
particles.particle_id = np.arange(particles.num_particles)
tracker.track(particles, turn_by_turn_monitor=True, num_turns=num_turns)
print('Xtrack')
print(tracker.record_last_track.x)
print('Sixtrack')
print(x_tbt_sixtrack.T)
assert np.allclose(tracker.record_last_track.x[0, :],
x_tbt_sixtrack[:, 0],
rtol=1e-15,
atol=9e-11)
assert np.allclose(tracker.record_last_track.y[0, :],
y_tbt_sixtrack[:, 0],
def _set_orbit_dependent_parameters_for_bb(line, tracker, particle_on_co):
temp_particles = xt.Particles(**particle_on_co.to_dict())
for ii, ee in enumerate(tracker.line.elements):
if ee.__class__.__name__ == 'BeamBeamBiGaussian2D':
px_0 = temp_particles.px[0]
py_0 = temp_particles.py[0]
ee.q0 = ee._temp_q0
# Separation of 4D is so far set w.r.t. the closes orbit
# (to be able to compare against sixtrack)
# Here we set the righe quantities (coordinates of the strong beam)
ee.mean_x += temp_particles.x[0]
ee.mean_y += temp_particles.y[0]
line.elements[ii].x_bb = ee.mean_x
line.elements[ii].y_bb = ee.mean_y
ee.track(temp_particles)
ee.d_px = temp_particles.px - px_0
ee.d_py = temp_particles.py - py_0
line.elements[ii].d_px = ee.d_px
line.elements[ii].d_py = ee.d_py
temp_particles.px -= ee.d_px
temp_particles.py -= ee.d_py
elif ee.__class__.__name__ == 'BeamBeamBiGaussian3D':
ee.q0 = ee._temp_q0
ee.x_CO = temp_particles.x[0]
ee.px_CO = temp_particles.px[0]
ee.y_CO = temp_particles.y[0]
ee.py_CO = temp_particles.py[0]
ee.sigma_CO = temp_particles.zeta[0]
ee.delta_CO = temp_particles.delta[0]
ee.track(temp_particles)
ee.Dx_sub = temp_particles.x[0] - ee.x_CO
ee.Dpx_sub = temp_particles.px[0] - ee.px_CO
ee.Dy_sub = temp_particles.y[0] - ee.y_CO
ee.Dpy_sub = temp_particles.py[0] - ee.py_CO
ee.Dsigma_sub = temp_particles.zeta[0] - ee.sigma_CO
ee.Ddelta_sub = temp_particles.delta[0] - ee.delta_CO
temp_particles.x[0] = ee.x_CO
temp_particles.px[0] = ee.px_CO
temp_particles.y[0] = ee.y_CO
temp_particles.py[0] = ee.py_CO
temp_particles.zeta[0] = ee.sigma_CO
temp_particles.delta[0] = ee.delta_CO
line.elements[ii].x_co = ee.x_CO
line.elements[ii].px_co = ee.px_CO
line.elements[ii].y_co = ee.y_CO
line.elements[ii].py_co = ee.py_CO
line.elements[ii].zeta_co = ee.sigma_CO
line.elements[ii].delta_co = ee.delta_CO
line.elements[ii].d_x = ee.Dx_sub
line.elements[ii].d_px = ee.Dpx_sub
line.elements[ii].d_y = ee.Dy_sub
line.elements[ii].d_py = ee.Dpy_sub
line.elements[ii].d_zeta = ee.Dsigma_sub
line.elements[ii].d_delta = ee.Ddelta_sub
else:
ee.track(temp_particles)
import json
import numpy as np
import xline as xl
import xtrack as xt
with open('../xlines/line_bb_for_tracking.json', 'r') as fid:
line_dict = json.load(fid)
line = xl.Line.from_dict(line_dict)
partCO = xl.Particles.from_dict(line_dict['particle_on_tracker_co'])
tracker = xt.Tracker(sequence=line)
particles = xt.Particles(**partCO.to_dict())
for _ in range(10):
print(particles.at_turn[0], particles.x[0], particles.y[0],
particles.zeta[0])
tracker.track(particles)
WW = np.array(line_dict['WW_finite_diffs'])
WWinv = np.array(line_dict['WWInv_finite_diffs'])
assert np.max(np.abs(np.dot(WW, WWinv) - np.eye(6))) < 1e-10
ampl_sigmas = 1.
norm_emit_x = 2.5e-6
geom_emit_x = norm_emit_x / particles.beta0 / particles.gamma0