xtrack 0.92.0__tar.gz → 0.93.1__tar.gz

{xtrack-0.92.0/xtrack.egg-info → xtrack-0.93.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.92.0
+Version: 0.93.1
 Summary: Tracking library for particle accelerators
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xtrack

xtrack-0.93.1/tests/test_boris_spatial.py

@@ -0,0 +1,162 @@
+import numpy as np
+from scipy.constants import c as clight
+from scipy.constants import e as qe
+
+import xobjects as xo
+import xtrack as xt
+from xtrack._temp.boris_and_solenoid_map.solenoid_field import SolenoidField
+
+
+def test_boris_spatial_solenoid_map():
+    delta=np.array([0, 4])
+    p0 = xt.Particles(mass0=xt.ELECTRON_MASS_EV, q0=1,
+                    energy0=45.6e9/1000,
+                    x=[-1e-3, -1e-3],
+                    px=-1e-3*(1+delta),
+                    y=1e-3,
+                    delta=delta)
+
+    p = p0.copy()
+
+    sf = SolenoidField(L=4, a=0.3, B0=1.5, z0=20)
+
+    integrator = xt.BorisSpatialIntegrator(fieldmap_callable=sf.get_field,
+                                            s_start=0,
+                                            s_end=30,
+                                            n_steps=15000)
+    p_boris = p.copy()
+    integrator.track(p_boris)
+
+
+    x_log = np.array(integrator.x_log)
+    y_log = np.array(integrator.y_log)
+    z_log = np.array(integrator.z_log)
+
+    b_seen = sf.get_field(x_log, y_log, z_log)
+
+
+    z_axis = np.linspace(0, 30, 1001)
+    Bz_axis = sf.get_field(0 * z_axis, 0 * z_axis, z_axis)[2]
+
+    P0_J = p.p0c[0] * qe / clight
+    brho = P0_J / qe / p.q0
+
+    # ks = 0.5 * (Bz_axis[:-1] + Bz_axis[1:]) / brho
+    ks = Bz_axis / brho
+    ks_entry = ks[:-1]
+    ks_exit = ks_entry*0
+    ks_exit = ks[1:]
+
+    dz = z_axis[1]-z_axis[0]
+
+    line = xt.Line(elements=[xt.VariableSolenoid(length=dz,
+                                        ks_profile=[ks_entry[ii], ks_exit[ii]])
+                                for ii in range(len(z_axis)-1)])
+    line.build_tracker()
+
+    p_xt = p0.copy()
+    line.track(p_xt, turn_by_turn_monitor='ONE_TURN_EBE')
+    mon = line.record_last_track
+
+    p_xt = p0.copy()
+    line.configure_radiation(model=None)
+    line.track(p_xt, turn_by_turn_monitor='ONE_TURN_EBE')
+    mon_no_rad = line.record_last_track
+
+    Bz_mid = 0.5 * (Bz_axis[:-1] + Bz_axis[1:])
+    Bz_mon = 0 * Bz_axis
+    Bz_mon[1:] = Bz_mid
+
+    # Wolsky Eq. 3.114
+    Ax = -0.5 * Bz_mon * mon.y
+    Ay =  0.5 * Bz_mon * mon.x
+
+    # Wolsky Eq. 2.74
+    ax_ref = Ax * p0.q0 * qe / P0_J
+    ay_ref = Ay * p0.q0 * qe / P0_J
+
+    px_mech = mon.px - ax_ref
+    py_mech = mon.py - ay_ref
+    pz_mech = np.sqrt((1 + mon.delta)**2 - px_mech**2 - py_mech**2)
+
+    xp = px_mech / pz_mech
+    yp = py_mech / pz_mech
+
+    dx_ds = np.diff(mon.x, axis=1) / np.diff(mon.s, axis=1)
+    dy_ds = np.diff(mon.y, axis=1) / np.diff(mon.s, axis=1)
+
+    z_check = sf.z0 + sf.L * np.linspace(-2, 2, 1001)
+
+    for i_part in range(z_log.shape[1]):
+
+        this_s_boris = 0.5 * (z_log[:-1, i_part] + z_log[1:, i_part])
+        dx_ds_boris = np.diff(x_log[:, i_part]) / np.diff(z_log[:, i_part])
+        dy_ds_boris = np.diff(y_log[:, i_part]) / np.diff(z_log[:, i_part])
+
+        s_xsuite = 0.5 * (mon.s[i_part, :-1] + mon.s[i_part, 1:])
+        dx_ds_xsuite = np.diff(mon.x[i_part, :]) / np.diff(mon.s[i_part, :])
+        dy_ds_xsuite = np.diff(mon.y[i_part, :]) / np.diff(mon.s[i_part, :])
+
+        dx_ds_xsuite_check = np.interp(z_check, s_xsuite, dx_ds_xsuite)
+        dy_ds_xsuite_check = np.interp(z_check, s_xsuite, dy_ds_xsuite)
+
+        dx_ds_boris_check = np.interp(z_check, this_s_boris, dx_ds_boris)
+        dy_ds_boris_check = np.interp(z_check, this_s_boris, dy_ds_boris)
+
+        this_dx_ds = dx_ds[i_part, :]
+        this_dy_ds = dy_ds[i_part, :]
+
+        xo.assert_allclose(dx_ds_xsuite_check, dx_ds_boris_check, rtol=0,
+                atol=2.8e-2 * (np.max(dx_ds_boris_check) - np.min(dx_ds_boris_check)))
+        xo.assert_allclose(dy_ds_xsuite_check, dy_ds_boris_check, rtol=0,
+                atol=2.8e-2 * (np.max(dy_ds_boris_check) - np.min(dy_ds_boris_check)))
+
+        xo.assert_allclose(ax_ref[i_part, :], mon.ax[i_part, :],
+                        rtol=0, atol=np.max(np.abs(ax_ref)*3e-2))
+        xo.assert_allclose(ay_ref[i_part, :], mon.ay[i_part, :],
+                        rtol=0, atol=np.max(np.abs(ay_ref)*3e-2))
+
+def test_boris_spatial_drift():
+    def zero_field(x, y, z):
+        return (0*x, 0*y, 0*z)
+
+    integrator = xt.BorisSpatialIntegrator(fieldmap_callable=zero_field,
+                                            s_start=10,
+                                            s_end=20,
+                                            n_steps=15000)
+
+    drift = xt.Drift(length=10, model='exact')
+
+    p0 = xt.Particles('proton',
+            x=[1e-2, -1e-2], px=[15e-3, 0], delta=[0, 2], p0c=1e9, zeta=1)
+
+    p_integ = p0.copy()
+    integrator.track(p_integ)
+
+    p_drift = p0.copy()
+    drift.track(p_drift)
+
+    xo.assert_allclose(p_integ.x, p_drift.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.px, p_drift.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.y, p_drift.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.py, p_drift.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.s, p_drift.s, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.delta, p_drift.delta, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.zeta, p_drift.zeta, rtol=0, atol=1e-10)
+
+    # Check behavior with lost particles
+    p0 = xt.Particles('proton',
+            x=[1e-2, -1e-2], px=[15e-3, 0], delta=[0, 2], p0c=1e9, zeta=1,
+            state=[1, -1])
+
+    p_integ = p0.copy()
+    integrator.track(p_integ)
+    p_drift = p0.copy()
+    drift.track(p_drift)
+
+    xo.assert_allclose(p_integ.x, p_drift.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.px, p_drift.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.y, p_drift.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.py, p_drift.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.s, p_drift.s, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.delta, p_drift.delta, rtol=0, atol=1e-10)

{xtrack-0.92.0 → xtrack-0.93.1}/tests/test_madnginterface.py

@@ -163,4 +163,142 @@ def test_madng_conversion_drift_slice():
     tw_ng = line.madng_twiss(normal_form=False)
 
     xo.assert_allclose(tw_ng.beta11_ng, tw.betx, rtol=1e-8)
-    xo.assert_allclose(tw_ng.beta22_ng, tw.bety, rtol=1e-8)
+    xo.assert_allclose(tw_ng.beta22_ng, tw.bety, rtol=1e-8)
+
+def test_madng_interface_with_slicing():
+    line = xt.load(test_data_folder /
+                            'hllhc15_thick/lhc_thick_with_knobs.json')
+
+    # Cut line at every 1 up to s = 1000
+    line.cut_at_s(np.arange(1000))
+
+    tw_xs = line.twiss4d()
+    tw = line.madng_twiss()
+
+    assert len(tw) == len(tw_xs)
+
+    xo.assert_allclose(tw.x, 0, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.y, 0, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.betx2, 0, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.bety1, 0, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.x, tw.x_ng, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw.y, tw.y_ng, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.betx2, tw.beta12_ng, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.bety1, tw.beta21_ng, atol=1e-19, rtol=0)
+    xo.assert_allclose(tw.wx_chrom, tw.wx_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.wy_chrom, tw.wy_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.ax_chrom, tw.ax_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.ay_chrom, tw.ay_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.bx_chrom, tw.bx_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.by_chrom, tw.by_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)
+
+def test_madng_twiss_with_initial_conditions():
+    line = xt.load(test_data_folder /
+                            'hllhc15_thick/lhc_thick_with_knobs.json')
+    #pytest.set_trace()
+    tw_xs = line.twiss(betx=120, bety=150)
+    tw = line.madng_twiss(beta11=120, beta22=150)
+
+    assert len(tw) == len(tw_xs)
+    assert len(tw.betx) == len(tw.beta11_ng)
+
+    xo.assert_allclose(tw.betx, tw.beta11_ng, rtol=1e-7, atol=1e-6)
+    xo.assert_allclose(tw.bety, tw.beta22_ng, rtol=1e-7, atol=1e-6)
+    xo.assert_allclose(tw.alfx, tw.alfa11_ng, rtol=1e-7, atol=1e-6)
+    xo.assert_allclose(tw.alfy, tw.alfa22_ng, rtol=1e-7, atol=1e-6)
+    xo.assert_allclose(tw.dx, tw.dx_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw.dy, tw.dy_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw.dpx, tw.dpx_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw.dpy, tw.dpy_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw.x, tw.x_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw.y, tw.y_ng, rtol=1e-8, atol=1e-6)
+
+    tw2_xs = line.twiss(start='s.ds.l8.b1', end='ip1', betx=100, bety=34)
+    tw2_xsng = line.madng_twiss(start='s.ds.l8.b1', end='ip1', beta11=100, beta22=34, xsuite_tw=False)
+
+    assert len(tw2_xs.betx) == len(tw2_xsng.beta11_ng)
+    xo.assert_allclose(tw2_xs.betx, tw2_xsng.beta11_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw2_xs.bety, tw2_xsng.beta22_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw2_xs.alfx, tw2_xsng.alfa11_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw2_xs.alfy, tw2_xsng.alfa22_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw2_xs.dx, tw2_xsng.dx_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw2_xs.dy, tw2_xsng.dy_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw2_xs.dpx, tw2_xsng.dpx_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw2_xs.dpy, tw2_xsng.dpy_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw2_xs.x, tw2_xsng.x_ng, rtol=1e-8, atol=1e-8)
+    xo.assert_allclose(tw2_xs.y, tw2_xsng.y_ng, rtol=1e-8, atol=1e-8)
+
+    tw3_xs = line.twiss(start='ip8', end='ip2', betx=1.5, bety=1.5)
+    tw3_xsng = line.madng_twiss(start='ip8', end='ip2', beta11=1.5, beta22=1.5, xsuite_tw=True)
+
+    assert len(tw3_xs.betx) == len(tw3_xsng.beta11_ng)
+    xo.assert_allclose(tw3_xs.betx, tw3_xsng.beta11_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xs.bety, tw3_xsng.beta22_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xs.alfx, tw3_xsng.alfa11_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xs.alfy, tw3_xsng.alfa22_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xs.dx, tw3_xsng.dx_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xs.dy, tw3_xsng.dy_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xs.dpx, tw3_xsng.dpx_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xs.dpy, tw3_xsng.dpy_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xs.x, tw3_xsng.x_ng, rtol=1e-8, atol=1e-8)
+    xo.assert_allclose(tw3_xs.y, tw3_xsng.y_ng, rtol=1e-8, atol=1e-8)
+
+    xo.assert_allclose(tw3_xsng.betx, tw3_xsng.beta11_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xsng.bety, tw3_xsng.beta22_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xsng.alfx, tw3_xsng.alfa11_ng, rtol=1e-8, atol=1e-6)
+    xo.assert_allclose(tw3_xsng.alfy, tw3_xsng.alfa22_ng, rtol=1e-8, atol=1e-6)
+
+def test_madng_slices():
+    line = xt.load(test_data_folder /
+                            'hllhc15_thick/lhc_thick_with_knobs.json')
+    tw = line.twiss4d()
+
+    twng = line.madng_twiss()
+
+    line.cut_at_s(np.linspace(0, line.get_length(), 5000))
+    tw_sliced = line.twiss4d()
+    twng_sliced = line.madng_twiss()
+    tt_sliced = line.get_table()
+
+    assert np.all(np.array(sorted(list(set(tt_sliced.element_type)))) ==
+        ['',
+        'Cavity',
+        'Drift',
+        'DriftSlice',
+        'Marker',
+        'Multipole',
+        'Octupole',
+        'Quadrupole',
+        'RBend',
+        'Sextupole',
+        'ThickSliceBend',
+        'ThickSliceCavity',
+        'ThickSliceMultipole',
+        'ThickSliceOctupole',
+        'ThickSliceQuadrupole',
+        'ThickSliceRBend',
+        'ThickSliceSextupole',
+        'ThickSliceUniformSolenoid',
+        'ThinSliceBendEntry',
+        'ThinSliceBendExit',
+        'ThinSliceOctupoleEntry',
+        'ThinSliceOctupoleExit',
+        'ThinSliceQuadrupoleEntry',
+        'ThinSliceQuadrupoleExit',
+        'ThinSliceRBendEntry',
+        'ThinSliceRBendExit',
+        'ThinSliceSextupoleEntry',
+        'ThinSliceSextupoleExit',
+        'ThinSliceUniformSolenoidEntry',
+        'ThinSliceUniformSolenoidExit',
+        'UniformSolenoid'])
+
+    twng_ip = twng.rows['ip.*']
+    twng_ip_sliced = twng_sliced.rows['ip.*']
+    xo.assert_allclose(twng_ip.s, twng_ip_sliced.s, rtol=1e-8)
+    xo.assert_allclose(twng_ip.beta11_ng, twng_ip_sliced.beta11_ng, rtol=1e-3)
+    xo.assert_allclose(twng_ip.beta22_ng, twng_ip_sliced.beta22_ng, rtol=1e-3)
+    xo.assert_allclose(twng_ip.wx_ng, twng_ip_sliced.wx_ng, rtol=1e-3)
+    xo.assert_allclose(twng_ip.wy_ng, twng_ip_sliced.wy_ng, rtol=1e-3)
+    xo.assert_allclose(twng_ip.dx_ng, twng_ip_sliced.dx_ng, atol=1e-6)
+    xo.assert_allclose(twng_ip.dy_ng, twng_ip_sliced.dy_ng, atol=1e-6)

{xtrack-0.92.0 → xtrack-0.93.1}/xtrack/__init__.py

@@ -47,6 +47,7 @@ from .trajectory_correction import TrajectoryCorrection
 from .mad_parser.loader import load_madx_lattice
 from . import json
 from .load import load
+from .boris import BorisSpatialIntegrator
 
 from .multiline import Multiline
 

xtrack-0.93.1/xtrack/_version.py

@@ -0,0 +1 @@
+__version__ = '0.93.1'

xtrack-0.93.1/xtrack/boris.py

@@ -0,0 +1,173 @@
+import numpy as np
+
+from scipy.constants import c as clight
+from scipy.constants import e as qe
+
+class BorisSpatialIntegrator:
+
+    isthick = True
+
+    def __init__(self, fieldmap_callable, s_start, s_end, n_steps, verbose=False):
+        self.fieldmap_callable = fieldmap_callable
+        self.s_start = s_start
+        self.s_end = s_end
+        self.ds = (s_end - s_start) / n_steps
+        self.n_steps = n_steps
+        self.verbose = verbose
+        self.length = s_end - s_start
+
+    def track(self, p):
+
+        mask_alive = p.state > 0
+
+        x_log = []
+        y_log = []
+        z_log = []
+        s_in = p.s[mask_alive].copy()
+        p.s[mask_alive] = self.s_start
+
+        for ii in range(self.n_steps):
+
+            if self.verbose:
+                print(f's_in = {s_in[0]:.3f} s_in_map = {p.s[0]:.3f}', end='\r', flush=True)
+
+            x = p.x[mask_alive].copy()
+            y = p.y[mask_alive].copy()
+            z = p.s[mask_alive].copy()
+            px = p.px[mask_alive].copy()
+            py = p.py[mask_alive].copy()
+            delta = p.delta[mask_alive].copy()
+            energy = p.energy[mask_alive].copy()
+            p0c = p.p0c[mask_alive].copy()
+            beta0 = p.beta0[mask_alive].copy()
+            charge = p.charge[mask_alive].copy()
+            mass = p.mass[mask_alive].copy()
+
+            charge_coulomb = charge * qe
+            mass_kg = mass * qe / clight**2
+            gamma = energy / mass
+
+            P0 = p0c * qe / clight # in kg m/s
+            P = P0 * (1 + delta)
+
+            Px = px * P0
+            Py = py * P0
+
+            w = np.zeros((Px.shape[0], 3), dtype=Px.dtype)
+            w[:, 0] = Px
+            w[:, 1] = Py
+            w[:, 2] = P
+
+            x_new, y_new, z_new, w_new, dt = step_spatial_boris_B(x, y, z, w,
+                charge_coulomb, self.ds,
+                field_fn=self.fieldmap_callable, m_kg=mass_kg, gamma=gamma)
+            p.x[mask_alive] = x_new
+            p.y[mask_alive] = y_new
+            p.s[mask_alive] = z_new
+            p.px[mask_alive] = w_new[:, 0] / P0
+            p.py[mask_alive] = w_new[:, 1] / P0
+            p.zeta[mask_alive] += (self.ds - dt * clight * beta0)
+
+            x_log.append(p.x.copy())
+            y_log.append(p.y.copy())
+            z_log.append(p.s.copy())
+        p.s[mask_alive] = s_in + self.length
+        self.x_log = np.array(x_log)
+        self.y_log = np.array(y_log)
+        self.z_log = np.array(z_log)
+
+
+import numpy as np
+c = 299_792_458.0  # m/s
+
+def step_spatial_boris_B(x, y, z, w, q, dz, field_fn, m_kg, gamma):
+    """
+    Spatial Boris step for magnetic fields only (E = 0),
+    using constant total momentum magnitude P = w[:,2].
+
+    Parameters
+    ----------
+    x, y, z : (N,) arrays
+        Particle positions [m].
+    w : (N, 3) array
+        Momentum-like state: (px, py, P), where
+        P = |p| = sqrt(px^2 + py^2 + pz^2) is constant.
+    q : float
+        Particle charge [C].
+    dz : float
+        Spatial step along z [m].
+    field_fn : callable(x, y, z) -> (Bx, By, Bz)
+        Function returning magnetic-field components [T].
+
+    Returns
+    -------
+    x1, y1, z1 : (N,) arrays
+        Updated positions [m].
+    w1 : (N, 3) array
+        Updated momentum state (px, py, P).
+    """
+
+    dt = 0.
+
+    # --- Unpack and ensure arrays
+    x = np.asarray(x)
+    y = np.asarray(y)
+    z = np.asarray(z)
+    w = np.asarray(w)
+    px, py, P = w[:, 0], w[:, 1], w[:, 2]
+
+    # --- Compute longitudinal momentum from constant magnitude
+    pz = np.sqrt(np.maximum(P**2 - px**2 - py**2, 0.0))
+
+    # --- Half drift in (x, y)
+    xh = x + (px / pz) * (dz * 0.5)
+    yh = y + (py / pz) * (dz * 0.5)
+    zh = z + dz * 0.5
+    dt += (dz * 0.5) / pz * gamma * m_kg #  s
+
+    # --- Evaluate magnetic field at mid-step
+    Bx, By, Bz = field_fn(xh, yh, zh)
+
+    # ============================================
+    # (1) FIRST HALF-KICK from (Bx, By)
+    # ============================================
+    pxm = px - 0.5 * q * dz * By
+    pym = py + 0.5 * q * dz * Bx
+
+    # --- Recompute pz to maintain |p| = P
+    pz = np.sqrt(np.maximum(P**2 - pxm**2 - pym**2, 0.0))
+
+    # ============================================
+    # (2) ROTATION due to Bz
+    # ============================================
+    t = 0.5 * q * Bz * dz / pz
+    t2 = t * t
+    s = 2.0 * t / (1.0 + t2)
+    c0 = (1.0 - t2) / (1.0 + t2)
+
+    # pxp = c0 * pxm - s * pym
+    # pyp = s * pxm + c0 * pym
+    pxp = c0 * pxm + s * pym
+    pyp = -s * pxm + c0 * pym
+
+    # ============================================
+    # (3) SECOND HALF-KICK from (Bx, By)
+    # ============================================
+    px1 = pxp - 0.5 * q * dz * By
+    py1 = pyp + 0.5 * q * dz * Bx
+
+    # --- Recompute pz after full step
+    pz1 = np.sqrt(np.maximum(P**2 - px1**2 - py1**2, 0.0))
+
+    # ============================================
+    # (4) SECOND HALF-DRIFT (x, y)
+    # ============================================
+    x1 = xh + (px1 / pz1) * (dz * 0.5)
+    y1 = yh + (py1 / pz1) * (dz * 0.5)
+    z1 = z + dz
+    dt += (dz * 0.5) / pz1 * gamma * m_kg #  s
+
+    # --- Pack updated (px, py, P)
+    w1 = np.stack([px1, py1, P], axis=1)
+
+    return x1, y1, z1, w1, dt

{xtrack-0.92.0 → xtrack-0.93.1}/xtrack/line.py

@@ -1044,6 +1044,8 @@ class Line:
 
     @particle_ref.setter
     def particle_ref(self, particle_ref):
+        if isinstance(particle_ref, LineParticleRef):
+            particle_ref = particle_ref.line._particle_ref
         self._particle_ref = particle_ref
         # This looks a bit dangerous, when working with coasting beams in environments.
         # If the particle is shared with other lines, t_sim might be wrong.
@@ -2514,7 +2516,7 @@ class Line:
         s_cuts = list(tab_insertions['s_start']) + list(tab_insertions['s_end'])
         s_cuts = list(set(s_cuts))
 
-        self.cut_at_s(s_cuts, s_tol=1e-06, return_slices=True)
+        self.cut_at_s(s_cuts, s_tol=s_tol, return_slices=True)
 
         tt_after_cut = self.get_table()
         tt_after_cut['length'] = np.diff(tt_after_cut.s, append=tt_after_cut.s[-1])