xtrack 0.94.1__tar.gz → 0.95.0__tar.gz

{xtrack-0.94.1/xtrack.egg-info → xtrack-0.95.0}/PKG-INFO

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

xtrack-0.95.0/tests/test_atomic_add.py

@@ -0,0 +1,90 @@
+# copyright ############################### #
+# This file is part of the Xtrack Package.  #
+# Copyright (c) CERN, 2025.                 #
+# ######################################### #
+
+import pytest
+import numpy as np
+
+import xtrack as xt
+import xobjects as xo
+from xobjects.test_helpers import for_all_test_contexts
+
+
+@for_all_test_contexts
+@pytest.mark.parametrize("overload", [True, False], ids=['overload', 'no_overload'])
+@pytest.mark.parametrize("ctype", [xo.Int8, xo.Int16, xo.Int32, xo.Int64,
+                                   xo.UInt8, xo.UInt16, xo.UInt32,
+                                   xo.UInt64, xo.Float32, xo.Float64])
+def test_atomic(overload, ctype, test_context):
+    if overload:
+        func_name = 'atomicAdd'
+    else:
+        func_name = f'atomicAdd_{ctype.__name__.lower()[0]}{ctype.__name__.split("t")[1]}'
+    class TestAtomic(xt.BeamElement):
+        _xofields = {f'val':  ctype}
+        allow_track = False
+        _extra_c_sources = [f'''
+        #include <headers/track.h>
+        #include <headers/atomicadd.h>
+
+        GPUKERN
+        void run_atomic_test(TestAtomicData el, GPUGLMEM {ctype._c_type}* increments,
+                             GPUGLMEM {ctype._c_type}* retvals, int length) {{
+            VECTORIZE_OVER(ii, length);
+                GPUGLMEM {ctype._c_type}* val = TestAtomicData_getp_val(el);
+                {ctype._c_type} ret = {func_name}(val, increments[ii]);
+                retvals[ii] = ret;
+            END_VECTORIZE;
+        }}
+        ''']
+
+        _kernels = {
+            'run_atomic_test': xo.Kernel(
+                    c_name='run_atomic_test',
+                    args=[xo.Arg(xo.ThisClass, name='el'),
+                          xo.Arg(ctype, pointer=True, name='increments'),
+                          xo.Arg(ctype, pointer=True, name='retvals'),
+                          xo.Arg(xo.Int32, name='length')],
+                    n_threads='length')
+        }
+
+    atomic = TestAtomic(_context=test_context, val=0)
+    assert atomic.val == 0
+
+    # Test with all increments = 1, so we can check the return values easily.
+    num_steps = 10000
+    if ctype.__name__.startswith('Int') or ctype.__name__.startswith('Uint'):
+        # Less steps to avoid overflow
+        num_steps = min(num_steps, 2**(8*ctype._size - 1) - 1)
+    increments = test_context.zeros(shape=(num_steps,), dtype=ctype._dtype) + 1
+    retvals = test_context.zeros(shape=(num_steps,), dtype=ctype._dtype)
+    atomic.run_atomic_test(increments=increments, retvals=retvals, length=num_steps)
+    assert atomic.val == num_steps
+    retvals = np.sort(test_context.nparray_from_context_array(retvals))
+    assert np.allclose(retvals, np.arange(num_steps, dtype=ctype._dtype), atol=1.e-15, rtol=1.e-15)
+
+    # Test with random increments, where we now only can check the total sum
+    # (retvals can be anything). Watch out: overflow is undefined behaviour,
+    # except for unsigned integers, so we skip this test for signed integers.
+    atomic.val = 0
+    retvals = test_context.zeros(shape=(num_steps,), dtype=ctype._dtype)
+    if ctype.__name__.startswith('Uint'):
+        low = 0
+        high = 2**(8*ctype._size) - 1
+        increments = np.random.randint(low, high+1, size=num_steps, dtype=ctype._dtype)
+        increments = test_context.nparray_to_context_array(increments)
+        atomic.run_atomic_test(increments=increments, retvals=retvals, length=num_steps)
+        increments = test_context.nparray_from_context_array(increments)
+        assert atomic.val == (np.sum(increments).item() % (2**(8*ctype._size)))
+
+    elif ctype.__name__.startswith('Float'):
+        increments  = np.zeros(shape=(num_steps,), dtype=ctype._dtype)
+        increments += np.random.uniform(0, 10, size=num_steps)
+        increments  = test_context.nparray_to_context_array(increments)
+        atomic.run_atomic_test(increments=increments, retvals=retvals, length=num_steps)
+        increments = test_context.nparray_from_context_array(increments)
+        if ctype == xo.Float32:
+            assert np.isclose(atomic.val, np.sum(increments), atol=10., rtol=1.e-4)
+        else:
+            assert np.isclose(atomic.val, np.sum(increments), atol=1.e-6, rtol=1.e-12)

{xtrack-0.94.1 → xtrack-0.95.0}/tests/test_element_internal_record.py

@@ -276,7 +276,6 @@ def test_record_with_twiss(test_context):
     line.particle_ref = xp.Particles(mass0=xp.PROTON_MASS_EV, q0=1, p0c=6.5e12)
     io_buffer = line.tracker.io_buffer
     line.twiss(at_s=np.linspace(0, line.get_length(), 500))
-    
 
 
 @for_all_test_contexts

{xtrack-0.94.1 → xtrack-0.95.0}/tests/test_elements.py

@@ -223,7 +223,7 @@ def test_drift_exact_and_expanded(test_context):
 
     assert line['e2'].model == 'adaptive'
 
-    p0 = xp.Particles(p0c=1e9, px=0.3, _context=test_context)
+    p0 = xp.Particles(p0c=1e9, px=0.3)
     x_prime_expanded = p0.px / (1 + p0.delta)
     x_prime_exact = p0.px / np.sqrt((1 + p0.delta)**2 - p0.px**2)
 
@@ -1288,3 +1288,17 @@ def test_multipole_tilt_90_deg(test_context):
     xo.assert_allclose(pf.ptau, pfy.ptau, rtol=0, atol=1e-14)
 
 
+def test_beam_element_sin_cos_rot_backwards_compatible():
+    rot_s_rad = 0.13
+    sin_rot_s = np.sin(rot_s_rad)
+    cos_rot_s = np.cos(rot_s_rad)
+
+    mb_init = xt.Bend(length=1, _sin_rot_s=sin_rot_s, _cos_rot_s=cos_rot_s)
+    mb_dict = xt.Bend.from_dict({
+        'length': 1,
+        '_sin_rot_s': sin_rot_s,
+        '_cos_rot_s': cos_rot_s,
+    })
+
+    assert rot_s_rad == mb_init.rot_s_rad
+    assert rot_s_rad == mb_dict.rot_s_rad

{xtrack-0.94.1 → xtrack-0.95.0}/tests/test_elements_thick.py

@@ -633,14 +633,11 @@ def test_import_thick_bend_from_madx(use_true_thick_bends, with_knobs, bend_type
     # we assume k0_from_h=False, even if its value evaluates to zero. In MAD-X
     # k0 = h if k0 is zero, but this is not feasible to implement in Xtrack now.
     xo.assert_allclose(elem.k0, 0 if with_knobs else 0.05, atol=1e-14)
+    xo.assert_allclose(elem.k2, 0.4, atol=1e-14)
     xo.assert_allclose(elem.h, 0.05, atol=1e-14)  # h = angle / L
+    xo.assert_allclose(elem.knl, 0.0, atol=1e-14)
     xo.assert_allclose(elem.ksl, 0.0, atol=1e-14)
 
-    xo.assert_allclose(
-        elem.knl,
-        np.array([0, 0, 0.8, 0, 0, 0]),  # knl = [0, 0, k2 * L, 0, 0]
-        atol=1e-14,
-    )
 
     # Edges:
     xo.assert_allclose(elem.edge_entry_fint, 0.5, atol=1e-14)
@@ -667,14 +664,10 @@ def test_import_thick_bend_from_madx(use_true_thick_bends, with_knobs, bend_type
     # Element:
     xo.assert_allclose(elem.length, 3.0, atol=1e-14)
     xo.assert_allclose(elem.k0, 0.4, atol=1e-14)
+    xo.assert_allclose(elem.k2, 0.8, atol=1e-14)
     xo.assert_allclose(elem.h, 0.2 / 3.0, atol=1e-14)  # h = angle / length
     xo.assert_allclose(elem.ksl, 0.0, atol=1e-14)
-
-    xo.assert_allclose(
-        elem.knl,
-        np.array([0, 0, 2.4, 0, 0, 0]),  # knl = [0, 0, k2 * L, 0, 0]
-        atol=1e-14,
-    )
+    xo.assert_allclose(elem.ksl, 0.0, atol=1e-14)
 
     # Edges:
     xo.assert_allclose(elem.edge_entry_fint, 1.0, atol=1e-14)
@@ -779,7 +772,8 @@ def test_import_thick_bend_from_madx_and_slice(
         xo.assert_allclose(elem.weight, 0.5, atol=1e-14)
         xo.assert_allclose(elem._parent.length, 2.0, atol=1e-14)
         xo.assert_allclose(elem._parent.k0, 0.2, atol=1e-14)
-        xo.assert_allclose(elem._parent.knl, [0., 0, 0.8, 0, 0, 0], atol=1e-14)
+        xo.assert_allclose(elem._parent.k2, 0.4, atol=1e-14)
+        xo.assert_allclose(elem._parent.knl, 0, atol=1e-14)
         xo.assert_allclose(elem._parent.ksl, 0, atol=1e-14)
         xo.assert_allclose(elem._parent.h, 0.05, atol=1e-14)
 
@@ -803,14 +797,16 @@ def test_import_thick_bend_from_madx_and_slice(
         xo.assert_allclose(elem.weight, 0.5, atol=1e-14)
         xo.assert_allclose(elem._parent.length, 3.0, atol=1e-14)
         xo.assert_allclose(elem._parent.k0, 0.4, atol=1e-14)
-        xo.assert_allclose(elem._parent.knl, [0., 0, 2.4, 0, 0, 0], atol=1e-14)
+        xo.assert_allclose(elem._parent.k2, 0.8, atol=1e-14)
+        xo.assert_allclose(elem._parent.knl, 0, atol=1e-14)
         xo.assert_allclose(elem._parent.ksl, 0, atol=1e-14)
         xo.assert_allclose(elem._parent.h, 0.2/3, atol=1e-14)
 
         xo.assert_allclose(elem._xobject.weight, 0.5, atol=1e-14)
         xo.assert_allclose(elem._xobject._parent.length, 3.0, atol=1e-14)
         xo.assert_allclose(elem._xobject._parent.k0, 0.4, atol=1e-14)
-        xo.assert_allclose(elem._xobject._parent.knl, [0., 0, 2.4, 0, 0, 0], atol=1e-14)
+        xo.assert_allclose(elem._xobject._parent.k2, 0.8, atol=1e-14)
+        xo.assert_allclose(elem._xobject._parent.knl, 0, atol=1e-14)
         xo.assert_allclose(elem._xobject._parent.ksl, 0, atol=1e-14)
         xo.assert_allclose(elem._xobject._parent.h, 0.2/3, atol=1e-14)
 
@@ -1572,14 +1568,14 @@ def test_solenoid_multipole_shifts(shift_x, shift_y, test_element_name):
     test_sol.mult_shift_y = shift_y
 
     tw = line.twiss(
-        _continue_if_lost=True,
+        #_continue_if_lost=True,
         start=xt.START,
         end=xt.END,
         betx=BETX,
         bety=BETY,
         px=PX0)
     tw_sol = sol_line.twiss(
-        _continue_if_lost=True,
+        #_continue_if_lost=True,
         start=xt.START,
         end=xt.END,
         betx=BETX,

{xtrack-0.94.1 → xtrack-0.95.0}/tests/test_madnginterface.py

@@ -196,16 +196,16 @@ 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)
+    tw_xs = line.twiss(betx=120, bety=150, alfx=5, alfy=5, dx=1e-4)
+    tw = line.madng_twiss(beta11=120, beta22=150, alfa11=5, alfa22=5, dx=1e-4)
 
     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.betx, tw.beta11_ng, rtol=1e-6, atol=1e-6)
+    xo.assert_allclose(tw.bety, tw.beta22_ng, rtol=1e-6, atol=1e-6)
+    xo.assert_allclose(tw.alfx, tw.alfa11_ng, rtol=1e-6, atol=1e-6)
+    xo.assert_allclose(tw.alfy, tw.alfa22_ng, rtol=1e-6, 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)
@@ -213,8 +213,8 @@ def test_madng_twiss_with_initial_conditions():
     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)
+    tw2_xs = line.twiss(start='s.ds.l8.b1', end='ip1', betx=100, bety=34, dx=1e-5)
+    tw2_xsng = line.madng_twiss(start='s.ds.l8.b1', end='ip1', beta11=100, beta22=34, dx=1e-5, 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)
@@ -248,6 +248,24 @@ def test_madng_twiss_with_initial_conditions():
     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)
 
+    tw4_xs = line.twiss(start='ip3', end='ip4', betx=121.5668, bety=218.58374, alfx=2.295, alfy=-2.6429, dx=-0.51)
+    tw4_xsng = line.madng_twiss(start='ip3', end='ip4', beta11=121.5668, beta22=218.58374, alfa11=2.295,
+                                alfa22=-2.6429, dx=-0.51, xsuite_tw=False)
+
+    assert len(tw4_xs.betx) == len(tw4_xsng.beta11_ng)
+    xo.assert_allclose(tw4_xs.betx, tw4_xsng.beta11_ng, rtol=1e-6, atol=1e-5)
+    xo.assert_allclose(tw4_xs.bety, tw4_xsng.beta22_ng, rtol=1e-6, atol=1e-5)
+    xo.assert_allclose(tw4_xs.alfx, tw4_xsng.alfa11_ng, rtol=1e-6, atol=1e-5)
+    xo.assert_allclose(tw4_xs.alfy, tw4_xsng.alfa22_ng, rtol=1e-6, atol=1e-5)
+    xo.assert_allclose(tw4_xs.dx, tw4_xsng.dx_ng, rtol=1e-7, atol=1e-8)
+    xo.assert_allclose(tw4_xs.dy, tw4_xsng.dy_ng, rtol=1e-7, atol=1e-8)
+    xo.assert_allclose(tw4_xs.x, tw4_xsng.x_ng, rtol=1e-8, atol=1e-10)
+    xo.assert_allclose(tw4_xs.y, tw4_xsng.y_ng, rtol=1e-8, atol=1e-10)
+    xo.assert_allclose(tw4_xs.px, tw4_xsng.px_ng, rtol=1e-8, atol=1e-10)
+    xo.assert_allclose(tw4_xs.py, tw4_xsng.py_ng, rtol=1e-8, atol=1e-10)
+    xo.assert_allclose(tw4_xs.mux, tw4_xsng.mu1_ng, rtol=1e-8, atol=1e-5)
+    xo.assert_allclose(tw4_xs.muy, tw4_xsng.mu2_ng, rtol=1e-8, atol=1e-5)
+    
 def test_madng_slices():
     line = xt.load(test_data_folder /
                             'hllhc15_thick/lhc_thick_with_knobs.json')

{xtrack-0.94.1 → xtrack-0.95.0}/tests/test_misalign.py

@@ -8,7 +8,7 @@ import pytest
 import xobjects as xo
 import xtrack as xt
 import pymadng as ng
-
+from typing import Literal
 from xobjects.test_helpers import for_all_test_contexts
 
 
@@ -415,7 +415,7 @@ def test_misalign_dedicated_vs_beam_element(test_context, element_type):
     xo.assert_allclose(p_ref.zeta, p_test.zeta, atol=1e-15, rtol=1e-15)
     xo.assert_allclose(p_ref.s, p_test.s, atol=1e-15, rtol=1e-15)
 
-    # Check backtrak
+    # Check backtrack
     line_test.track(p_test, backtrack=True)
     xo.assert_allclose(p_test.x, p0.x, atol=1e-14, rtol=1e-14)
     xo.assert_allclose(p_test.px, p0.px, atol=1e-14, rtol=1e-14)
@@ -425,39 +425,266 @@ def test_misalign_dedicated_vs_beam_element(test_context, element_type):
     xo.assert_allclose(p_test.zeta, p0.zeta, atol=1e-14, rtol=1e-14)
     xo.assert_allclose(p_test.s, p0.s, atol=1e-14, rtol=1e-14)
 
-def test_errors_on_slices():
 
+def test_thick_slice_misaligned_bend():
+    length = 3
+    angle = 0.3
+    dx = 0.1
+    dy = 0.2
+    ds = 0.3
+    theta = 0.1  # rad
+    phi = 0.2  # rad
+    psi = 0.5  # rad
+    tilt = 0.1
+    anchor = 1  # m
+    n_slices = 5
+
+    bend = xt.Bend(
+        length=length,
+        angle=angle,
+        shift_x=dx,
+        shift_y=dy,
+        shift_s=ds,
+        rot_x_rad=phi,
+        rot_y_rad=theta,
+        rot_s_rad_no_frame=psi,
+        rot_s_rad=tilt,
+        rot_shift_anchor=anchor,
+        k0_from_h=True,
+        edge_entry_active=False,
+        edge_entry_model='full',
+        edge_entry_angle=0.05,
+        edge_entry_hgap=0.06,
+        edge_entry_fint=0.08,
+        edge_exit_active=False,
+        edge_exit_model='full',
+        edge_exit_angle=-0.05,
+        edge_exit_hgap=0.06,
+        edge_exit_fint=0.08,
+    )
+    line_test = xt.Line(elements=[bend], element_names=['bend'])
+    line_test.slice_thick_elements([xt.Strategy(slicing=xt.Teapot(n_slices, mode='thick'))])
+
+    line_ref = xt.Line(elements=[bend], element_names=['bend'])
+
+    assert {f'bend..{i}' for i in range(n_slices)} <= set(line_test.element_names)
+
+    p0 = xt.Particles(x=0.2, y=-0.6, px=-0.01, py=0.02, zeta=0.5, delta=0.9)
+
+    p_ref = p0.copy()
+    line_ref.track(p_ref)
+
+    p_test = p0.copy()
+    line_test.track(p_test)
+
+    assert p_test.state > 0
+    xo.assert_allclose(p_test.x, p_ref.x, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.px, p_ref.px, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.y, p_ref.y, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.py, p_ref.py, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.delta, p_ref.delta, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.zeta, p_ref.zeta, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.s, p_ref.s, atol=5e-14, rtol=8e-14)
+
+
+def test_thick_slice_misaligned_quad():
+    length = 3
+    k1 = 0.07
+    dx = 0.1
+    dy = 0.2
+    ds = 0.3
+    theta = 0.1  # rad
+    phi = 0.2  # rad
+    psi = 0.5  # rad
+    tilt = 0.1
+    anchor = 1  # m
+    n_slices = 5
+
+    quad = xt.Quadrupole(
+        length=length,
+        k1=k1,
+        shift_x=dx,
+        shift_y=dy,
+        shift_s=ds,
+        rot_x_rad=phi,
+        rot_y_rad=theta,
+        rot_s_rad_no_frame=psi,
+        rot_s_rad=tilt,
+        rot_shift_anchor=anchor,
+        edge_entry_active=True,
+        edge_exit_active=True,
+    )
+    line_test = xt.Line(elements=[quad], element_names=['quad'])
+    line_test.slice_thick_elements([xt.Strategy(slicing=xt.Teapot(n_slices, mode='thick'))])
+
+    line_ref = xt.Line(elements=[quad], element_names=['quad'])
+
+    assert {f'quad..{i}' for i in range(n_slices)} <= set(line_test.element_names)
+
+    p0 = xt.Particles(x=0.2, y=-0.6, px=-0.01, py=0.02, zeta=0.5, delta=0.9)
+
+    p_ref = p0.copy()
+    line_ref.track(p_ref)
+
+    p_test = p0.copy()
+    line_test.track(p_test)
+
+    assert p_test.state > 0
+    xo.assert_allclose(p_test.x, p_ref.x, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.px, p_ref.px, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.y, p_ref.y, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.py, p_ref.py, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.delta, p_ref.delta, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.zeta, p_ref.zeta, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.s, p_ref.s, atol=5e-14, rtol=8e-14)
+
+
+def test_thick_slice_misaligned_uniform_solenoid():
+    length = 3
+    ks = 0.7
+    dx = 0.1
+    dy = 0.2
+    ds = 0.3
+    theta = 0.1  # rad
+    phi = 0.2  # rad
+    psi = 0.5  # rad
+    tilt = 0.1
+    anchor = 1  # m
+    n_slices = 5
+
+    sol = xt.UniformSolenoid(
+        length=length,
+        ks=ks,
+        shift_x=dx,
+        shift_y=dy,
+        shift_s=ds,
+        rot_x_rad=phi,
+        rot_y_rad=theta,
+        rot_s_rad_no_frame=psi,
+        rot_s_rad=tilt,
+        rot_shift_anchor=anchor,
+    )
+    line_test = xt.Line(elements=[sol], element_names=['sol'])
+    line_test.slice_thick_elements([xt.Strategy(slicing=xt.Teapot(n_slices, mode='thick'))])
+
+    line_ref = xt.Line(elements=[sol], element_names=['sol'])
+
+    assert {f'sol..{i}' for i in range(n_slices)} <= set(line_test.element_names)
+
+    p0 = xt.Particles(x=0.2, y=-0.6, px=-0.01, py=0.02, zeta=0.5, delta=0.9)
+
+    p_ref = p0.copy()
+    line_ref.track(p_ref)
+
+    p_test = p0.copy()
+    line_test.track(p_test)
+
+    assert p_test.state > 0
+    xo.assert_allclose(p_test.x, p_ref.x, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.px, p_ref.px, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.y, p_ref.y, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.py, p_ref.py, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.delta, p_ref.delta, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.zeta, p_ref.zeta, atol=5e-14, rtol=8e-14)
+    xo.assert_allclose(p_test.s, p_ref.s, atol=5e-14, rtol=8e-14)
+
+
+@pytest.mark.parametrize(
+    'transformations,valid',
+    [
+        ({'rot_x_rad': 0.1}, False),
+        ({'rot_y_rad': -0.2}, False),
+        ({'rot_s_rad_no_frame': 0.3}, False),
+        ({'shift_x': 0.2}, True),
+        ({'shift_y': -0.3}, True),
+        ({'shift_s': 0.1}, True),
+        ({'rot_s_rad': 0.2}, True),
+    ],
+    ids=[
+        'rot_x_rad',
+        'rot_y_rad',
+        'rot_s_rad_no_frame',
+        'shift_x',
+        'shift_y',
+        'shift_s',
+        'rot_s_rad',
+    ]
+)
+def test_thin_slice_misaligned_bend_valid_invalid(transformations, valid):
     env = xt.Environment()
     line = env.new_line(components=[
-        env.new('b', 'Bend', angle=0.1, length=2)
+        env.new(
+            name='b',
+            parent='Bend',
+            angle=0.1,
+            length=2,
+            model='drift-kick-drift-expanded',  # compare to a similar model
+            **transformations,
+        ),
     ])
 
-    p = xt.Particles(p0c=1e9)
-    line.track(p)
-    assert p.state[0] == 1
+    line.slice_thick_elements([
+        xt.Strategy(slicing=xt.Teapot(50, mode='thin')),
+    ])
 
-    line['b'].shift_x = 0.1
-    line.track(p)
-    assert p.state[0] == 1
+    p0 = xt.Particles(x=0.01, py=0.03, p0c=1e9)
+    p_test = p0.copy()
+    line.track(p_test)
 
-    line.cut_at_s([0.5])
-    line.track(p)
-    assert p.state[0] == -41
+    if not valid:
+        assert p_test.state[0] == -42
+        return
 
-    p = xt.Particles(p0c=1e9)
-    line['b'].angle = 0
-    line.track(p)
-    assert p.state[0] == 1
+    p_ref = p0.copy()
+    line['b'].track(p_ref)
+
+    xo.assert_allclose(p_test.x, p_ref.x, atol=1e-6, rtol=1e-5)
+    xo.assert_allclose(p_test.y, p_ref.y, atol=1e-6, rtol=1e-5)
+    xo.assert_allclose(p_test.px, p_ref.px, atol=1e-14, rtol=1e-14)
+    xo.assert_allclose(p_test.py, p_ref.py, atol=1e-14, rtol=1e-14)
+    xo.assert_allclose(p_test.zeta, p_ref.zeta, atol=1e-7, rtol=1e-5)
+    xo.assert_allclose(p_test.delta, p_ref.delta, atol=1e-14, rtol=1e-14)
+
+
+@pytest.mark.parametrize('h', [0.0, 0.1], ids=['straight', 'polar'])
+def test_spin_drift(h):
+    bend = xt.Bend(
+        length=2,
+        h=h,
+        k0=0,
+        shift_x=0.01,
+        shift_y=-0.03,
+        shift_s=0.02,
+        rot_x_rad=-0.03,
+        rot_y_rad=0.02,
+        rot_s_rad_no_frame=0.01,
+        rot_s_rad=0.04,
+        rot_shift_anchor=0.2,
+    )
+    bend.integrator = 'uniform'
+    bend.num_multipole_kicks = 1
+
+    line_test = xt.Line(elements=[bend], element_names=['bend'])
+    line_test.configure_spin('auto')
+
+    p0 = xt.Particles(
+        x=0.2,
+        y=-0.6,
+        spin_z=1.,
+        mass0=xt.ELECTRON_MASS_EV,
+        anomalous_magnetic_moment=0.00115965218128,
+    )
 
-    line['b'].angle = 0.1
-    line.track(p)
-    assert p.state[0] == -41
+    p = p0.copy()
+    line_test.track(p)
 
-    line['b'].angle = 0
-    p = xt.Particles(p0c=1e9)
-    line.track(p)
-    assert p.state[0] == 1
+    # Check that spin norm is preserved
+    expected_norm = 1
+    result_norm = np.linalg.norm([p.spin_x, p.spin_y, p.spin_z])
+    xo.assert_allclose(result_norm, expected_norm, atol=1e-15, rtol=1e-15)
 
-    line['b'].rot_x_rad = 0.1
-    line.track(p)
-    assert p.state[0] == -40
+    # In the absence of magnetic field, spin should follow momentum
+    xo.assert_allclose(p.spin_x, p.px, atol=1e-15, rtol=1e-15)
+    xo.assert_allclose(p.spin_y, p.py, atol=1e-15, rtol=1e-15)
+    ps = np.sqrt(1 - p.px**2 - p.py**2)
+    xo.assert_allclose(p.spin_z, ps, atol=1e-15, rtol=1e-15)