xtrack 0.94.2__tar.gz → 0.96.0__tar.gz

{xtrack-0.94.2/xtrack.egg-info → xtrack-0.96.0}/PKG-INFO

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

{xtrack-0.94.2 → xtrack-0.96.0}/tests/test_acceleration.py

@@ -8,7 +8,6 @@ import pathlib
 
 import numpy as np
 import pandas as pd
-from cpymad.madx import Madx
 from scipy.constants import c as clight
 
 import xobjects as xo
@@ -64,20 +63,10 @@ def test_energy_program(test_context):
     # Shift the time scale for testing purposes
     t_s = t_s
 
-    # Load mad model and apply element shifts
-    mad = Madx(stdout=False)
-    mad.call(str(test_data_folder / 'psb_chicane/psb.seq'))
-    mad.call(str(test_data_folder / 'psb_chicane/psb_fb_lhc.str'))
-    mad.input('''
-        beam, particle=PROTON, pc=0.5708301551893517;
-        use, sequence=psb1;
-        twiss;
-    ''')
-
-    line = xt.Line.from_madx_sequence(mad.sequence.psb1, allow_thick=True,
-                                      deferred_expressions=True)
-    line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV,
-                                     gamma0=mad.sequence.psb1.beam.gamma)
+    env = xt.load([test_data_folder / 'psb_chicane/psb.seq',
+                   test_data_folder / 'psb_chicane/psb_fb_lhc.str'])
+    env.psb1.set_particle_ref('proton', p0c=0.5708301551893517e9)
+    line = env.psb1
 
     line.build_tracker(_context=test_context)
 
@@ -176,21 +165,10 @@ def test_energy_program(test_context):
 @for_all_test_contexts(excluding=('ContextPyopencl',))
 def test_acceleration_transverse_shrink(test_context):
 
-    mad = Madx(stdout=False)
-
-    # Load mad model and apply element shifts
-    mad.input(f'''
-    call, file = '{str(test_data_folder)}/psb_chicane/psb.seq';
-    call, file = '{str(test_data_folder)}/psb_chicane/psb_fb_lhc.str';
-    beam;
-    use, sequence=psb1;
-    ''')
-
-    line = xt.Line.from_madx_sequence(mad.sequence.psb1,
-                                        deferred_expressions=True)
-    e_kin_start_eV = 160e6
-    line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1.,
-                                    energy0=xt.PROTON_MASS_EV + e_kin_start_eV)
+    env = xt.load([test_data_folder / 'psb_chicane/psb.seq',
+                   test_data_folder / 'psb_chicane/psb_fb_lhc.str'])
+    env.psb1.set_particle_ref('proton', p0c=0.5708301551893517e9)
+    line = env.psb1
 
     # Slice to gain some tracking speed
     line.slice_thick_elements(

xtrack-0.96.0/tests/test_aperture_polygon.py

@@ -0,0 +1,121 @@
+import numpy as np
+
+import xobjects as xo
+import xtrack as xt
+
+def _polygon_signed_area(x, y):
+    x_close = np.concatenate([x, x[:1]])
+    y_close = np.concatenate([y, y[:1]])
+    return 0.5 * np.sum(x_close[:-1] * y_close[1:] - x_close[1:] * y_close[:-1])
+
+
+def _polygon_centroid(x, y):
+    x_close = np.concatenate([x, x[:1]])
+    y_close = np.concatenate([y, y[:1]])
+    cross = x_close[:-1] * y_close[1:] - x_close[1:] * y_close[:-1]
+    area = np.sum(cross) / 2.0
+    cx = np.sum((x_close[:-1] + x_close[1:]) * cross) / (6.0 * area)
+    cy = np.sum((y_close[:-1] + y_close[1:]) * cross) / (6.0 * area)
+    return np.array([cx, cy])
+
+
+def test_limitpolygon_area_signed():
+    x_ccw = np.array([-2.0, 2.0, 2.0, -2.0]) * 1e-2
+    y_ccw = np.array([-1.0, -1.0, 1.5, 1.5]) * 1e-2
+
+    aper_ccw = xt.LimitPolygon(
+        x_vertices=x_ccw,
+        y_vertices=y_ccw,
+    )
+
+    aper_cw = xt.LimitPolygon(
+        x_vertices=x_ccw[::-1],
+        y_vertices=y_ccw[::-1],
+    )
+
+    signed_expected = _polygon_signed_area(x_ccw, y_ccw)
+    assert signed_expected > 0
+
+    xo.assert_allclose(aper_ccw.area, abs(signed_expected), atol=0, rtol=0)
+    xo.assert_allclose(
+        aper_ccw.get_area(signed=True), signed_expected, atol=0, rtol=0
+    )
+    xo.assert_allclose(aper_cw.area, abs(signed_expected), atol=0, rtol=0)
+    xo.assert_allclose(
+        aper_cw.get_area(signed=True), -signed_expected, atol=0, rtol=0
+    )
+
+
+def test_limitpolygon_normals_point_inward():
+    x_vertices = np.array([-1.0, 2.0, 2.5, 0.0]) * 1e-2
+    y_vertices = np.array([-1.0, -1.0, 1.5, 2.0]) * 1e-2
+
+    aper = xt.LimitPolygon(
+        x_vertices=x_vertices,
+        y_vertices=y_vertices,
+    )
+
+    ctx = aper._buffer.context
+    Nx = ctx.nparray_from_context_array(aper.x_normal)
+    Ny = ctx.nparray_from_context_array(aper.y_normal)
+
+    xo.assert_allclose(np.sqrt(Nx**2 + Ny**2), 1.0, rtol=0, atol=1e-14)
+
+    xv = ctx.nparray_from_context_array(aper.x_vertices)
+    yv = ctx.nparray_from_context_array(aper.y_vertices)
+    centroid = _polygon_centroid(xv, yv)
+    xv_close = np.concatenate([xv, xv[:1]])
+    yv_close = np.concatenate([yv, yv[:1]])
+
+    for ii in range(len(xv)):
+        midpoint = np.array([
+            0.5 * (xv_close[ii] + xv_close[ii + 1]),
+            0.5 * (yv_close[ii] + yv_close[ii + 1]),
+        ])
+        vec_to_center = centroid - midpoint
+        normal = np.array([Nx[ii], Ny[ii]])
+        assert np.dot(normal, vec_to_center) > 0
+
+
+def test_limitpolygon_impact_point_and_normal():
+    x_vertices = np.array([-1.0, 1.0, 1.0, -1.0]) * 1e-2
+    y_vertices = np.array([-1.0, -1.0, 1.0, 1.0]) * 1e-2
+
+    aper = xt.LimitPolygon(
+        x_vertices=x_vertices,
+        y_vertices=y_vertices,
+    )
+
+    ctx = aper._buffer.context
+    to_ctx = ctx.nparray_to_context_array
+    from_ctx = ctx.nparray_from_context_array
+
+    x_in = to_ctx(np.array([0.0, 0.0]))
+    y_in = to_ctx(np.array([0.0, 0.0]))
+    z_in = to_ctx(np.array([0.0, 0.0]))
+    x_out = to_ctx(np.array([2.0e-2, 0.0]))
+    y_out = to_ctx(np.array([0.0, -2.0e-2]))
+    z_out = to_ctx(np.array([0.0, 0.0]))
+
+    x_int, y_int, z_int, Nx, Ny, i_found = aper.impact_point_and_normal(
+        x_in=x_in,
+        y_in=y_in,
+        z_in=z_in,
+        x_out=x_out,
+        y_out=y_out,
+        z_out=z_out,
+    )
+
+    x_int = from_ctx(x_int)
+    y_int = from_ctx(y_int)
+    z_int = from_ctx(z_int)
+    Nx = from_ctx(Nx)
+    Ny = from_ctx(Ny)
+    i_found = from_ctx(i_found)
+
+    xo.assert_allclose(x_int, np.array([1.0e-2, 0.0]), atol=1e-15, rtol=0)
+    xo.assert_allclose(y_int, np.array([0.0, -1.0e-2]), atol=1e-15, rtol=0)
+    xo.assert_allclose(z_int, np.array([0., 0]), atol=1e-15, rtol=0)
+    xo.assert_allclose(Nx, np.array([-1.0, 0.0]), atol=1e-14, rtol=0)
+    xo.assert_allclose(Ny, np.array([0.0, 1.0]), atol=1e-14, rtol=0)
+    assert np.all(i_found >= 0)

{xtrack-0.94.2 → xtrack-0.96.0}/tests/test_aperture_table.py

@@ -14,9 +14,8 @@ def test_aperture_table():
         'vtaf.51632.b_aper', 'vbrta.51633.a_aper', 'vbrta.51633.b_aper',
         'bgiha.51634.a_aper', 'bgiva.51674.a_aper']
 
-    env = xt.load(test_data_folder /
-                               'sps_with_apertures/EYETS 2024-2025.seq')
-    env.vars.load(str(test_data_folder / 'sps_with_apertures/lhc_q20.str'))
+    env = xt.load([test_data_folder / 'sps_with_apertures/EYETS 2024-2025.seq',
+                   test_data_folder / 'sps_with_apertures/lhc_q20.str'])
     line = env.sps
     line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1, p0c=26e9)
 
@@ -62,9 +61,9 @@ def test_aperture_table():
     aper_check = aper.rows['veba.20250.a_aper' : 'vebb.20270.b_aper']
 
     assert np.all(aper_check.name == np.array(
-        ['veba.20250.a_aper', 'drift_333..2', 'mba.20250', 'drift_334..0',
-        'veba.20250.b_aper', 'drift_334..1', 'vebb.20270.a_aper',
-        'drift_334..2', 'mbb.20270', 'drift_335..0', 'vebb.20270.b_aper']))
+        ['veba.20250.a_aper', '||drift_979', 'mba.20250', '||drift_991',
+       'veba.20250.b_aper', '||drift_671', 'vebb.20270.a_aper',
+       '||drift_992', 'mbb.20270', '||drift_993', 'vebb.20270.b_aper']))
     xo.assert_allclose(aper_check.s, np.array([
        1225.8247   , 1225.8247   , 1226.0176907, 1232.2777093,
        1232.4827   , 1232.4827   , 1232.4847   , 1232.4847   ,
@@ -133,8 +132,8 @@ def test_aperture_table_aper_at_same_s():
 
     import numpy as np
     import xobjects as xo
-    assert np.all(tt.name == ['drift_1', 'lrect', 'lellipse', 'drift_2', 'm', 'lellipse',
-        '_end_point'])
+    assert np.all(tt.name == ['||drift_1', 'lrect', 'lellipse', '||drift_2', 'm', 'lellipse',
+       '_end_point'])
     xo.assert_allclose(tt.s, np.array([0., 3., 3., 3., 5., 5., 5.]), rtol=0, atol=1e-6)
     xo.assert_allclose(tt.x_aper_low, np.array([-0.0505, -0.0505, -0.0205, -0.0205, -0.0205,
         -0.0205, -0.0205]), rtol=0, atol=1e-6)

{xtrack-0.94.2 → xtrack-0.96.0}/tests/test_apertures.py

@@ -9,6 +9,8 @@ import xobjects as xo
 import xtrack as xt
 import xpart as xp
 from xobjects.test_helpers import for_all_test_contexts
+import pytest
+from cpymad.madx import Madx
 
 
 @for_all_test_contexts
@@ -116,13 +118,10 @@ def test_aperture_polygon(test_context):
     xo.assert_allclose(ctx2np(parttest.state), 0)
 
 
-def test_mad_import():
+@pytest.mark.parametrize("loader", ['cpymad', 'native'])
+def test_mad_import(loader):
 
-    from cpymad.madx import Madx
-
-    mad = Madx(stdout=False)
-
-    mad.input("""
+    mad_src = """
         m_circle: marker, apertype="circle", aperture={.2};
         m_ellipse: marker, apertype="ellipse", aperture={.2, .1};
         m_rectangle: marker, apertype="rectangle", aperture={.07, .05};
@@ -140,14 +139,16 @@ def test_mad_import():
             m_octagon, at=0.05;
             m_polygon, at=0.06;
         endsequence;
-
-        use,sequence=ss;
-        twiss,betx=1,bety=1;
         """
-        )
-
-    line = xt.Line.from_madx_sequence(mad.sequence.ss, install_apertures=True)
-
+    if loader == 'cpymad':
+        mad = Madx()
+        mad.input(mad_src)
+        mad.beam()
+        mad.use('ss')
+        line = xt.Line.from_madx_sequence(mad.sequence.ss, install_apertures=True)
+    elif loader == 'native':
+        env = xt.load(string=mad_src, format='madx')
+        line = env.ss
     apertures = [ee for ee in line.elements if ee.__class__.__name__.startswith('Limit')]
 
     circ = apertures[0]
@@ -210,10 +211,15 @@ def test_mad_import():
     assert polyg.__class__.__name__ == 'LimitPolygon'
     assert len(polyg._xobject.x_vertices) == 3
     assert len(polyg._xobject.y_vertices) == 3
-    assert polyg._xobject.x_vertices[0] == -8.8e-2
-    assert polyg._xobject.y_vertices[0] == 0
-    assert polyg._xobject.x_vertices[1] == 5.8e-2
-    assert polyg._xobject.y_vertices[1] == -3.5e-2
+    # assert polyg._xobject.x_vertices[0] == -8.8e-2
+    # assert polyg._xobject.y_vertices[0] == 0
+    # assert polyg._xobject.x_vertices[1] == 5.8e-2
+    # assert polyg._xobject.y_vertices[1] == -3.5e-2
+    # breakpoint()
+    xo.assert_allclose(polyg.x_vertices, np.array([+5.800e-2,+5.800e-2,-8.800e-2]),
+                       atol=1e-14, rtol=0)
+    xo.assert_allclose(polyg.y_vertices, np.array([+3.500e-2,-3.500e-2,+0.000e+0]),
+                          atol=1e-14, rtol=0)
 
 
 @for_all_test_contexts
@@ -301,62 +307,64 @@ def test_aperture_svg_path():
     aper2=xt.LimitPolygon.from_dict(aper.to_dict())
     assert aper2.svg==aper.svg
 
-    x_expected = np.array([ 3.41600000e-03,  3.15400000e-03,  2.92800000e-03,  2.75000000e-03,
-        2.63200000e-03,  2.58600000e-03,  2.62400000e-03,  2.75800000e-03,
-        3.00000000e-03,  2.40800000e-03,  2.12700000e-03,  1.86400000e-03,
-        1.62500000e-03,  1.41600000e-03,  1.24300000e-03,  1.11200000e-03,
-        1.02900000e-03,  1.00000000e-03,  7.24296143e-04,  5.96239745e-04,
-        4.76593043e-04,  3.66655177e-04,  2.67619865e-04,  1.80562445e-04,
-        1.06428199e-04,  4.60220848e-05, -4.44089210e-19,  7.05663559e-04,
-        1.04481682e-03,  1.37237342e-03,  1.68655149e-03,  1.98564190e-03,
-        2.26801764e-03,  2.53214260e-03,  2.77657996e-03,  3.00000000e-03,
-        3.01200000e-03,  2.99700000e-03,  2.96800000e-03,  2.92500000e-03,
-        2.86800000e-03,  2.79700000e-03,  2.71200000e-03,  2.61300000e-03,
-        2.50000000e-03,  2.25600000e-03,  2.13100000e-03,  2.00400000e-03,
-        1.87500000e-03,  1.74400000e-03,  1.61100000e-03,  1.47600000e-03,
-        1.33900000e-03,  1.20000000e-03,  1.00800000e-03,  9.78000000e-04,
-        9.92000000e-04,  1.05000000e-03,  1.15200000e-03,  1.29800000e-03,
-        1.48800000e-03,  1.72200000e-03,  2.00000000e-03,  2.54000000e-03,
-        2.76500000e-03,  2.96000000e-03,  3.12500000e-03,  3.26000000e-03,
-        3.36500000e-03,  3.44000000e-03,  3.48500000e-03,  3.50000000e-03,
-        3.52000000e-03,  3.54500000e-03,  3.58000000e-03,  3.62500000e-03,
-        3.68000000e-03,  3.74500000e-03,  3.82000000e-03,  3.90500000e-03,
-        4.00000000e-03,  4.56952827e-03,  4.82689224e-03,  5.06408867e-03,
-        5.27982723e-03,  5.47293432e-03,  5.64235946e-03,  5.78718097e-03,
-        5.90661105e-03,  6.00000000e-03,  6.27570386e-03,  6.40376026e-03,
-        6.52340696e-03,  6.63334482e-03,  6.73238014e-03,  6.81943755e-03,
-        6.89357180e-03,  6.95397792e-03,  7.00000000e-03,  7.38400000e-03,
-        7.44100000e-03,  7.43200000e-03,  7.37500000e-03,  7.28800000e-03,
-        7.18900000e-03,  7.09600000e-03,  7.02700000e-03,  7.00000000e-03,
-        6.50400000e-03,  6.31600000e-03,  6.15200000e-03,  6.00000000e-03,
-        5.84800000e-03,  5.68400000e-03,  5.49600000e-03,  5.27200000e-03,
-        5.00000000e-03,  1.20000000e-02,  1.30000000e-02,  1.00000000e-02,
-        4.00000000e-03])
-    y_expected = np.array([-0.007504  , -0.007316  , -0.007152  , -0.007     , -0.006848  ,
-       -0.006684  , -0.006496  , -0.006272  , -0.006     , -0.005904  ,
-       -0.005811  , -0.005712  , -0.005625  , -0.005568  , -0.005559  ,
-       -0.005616  , -0.005757  , -0.006     , -0.00610643, -0.00618056,
-       -0.00626762, -0.00636666, -0.00647659, -0.00659624, -0.0067243 ,
-       -0.00685937, -0.007     , -0.00721282, -0.00735764, -0.00752707,
-       -0.00772017, -0.00793591, -0.00817311, -0.00843047, -0.0087066 ,
-       -0.009     , -0.00918   , -0.009255  , -0.00932   , -0.009375  ,
-       -0.00942   , -0.009455  , -0.00948   , -0.009495  , -0.0095    ,
-       -0.00956   , -0.009635  , -0.00974   , -0.009875  , -0.01004   ,
-       -0.010235  , -0.01046   , -0.010715  , -0.011     , -0.011512  ,
-       -0.011702  , -0.011848  , -0.01195   , -0.012008  , -0.012022  ,
-       -0.011992  , -0.011918  , -0.0118    , -0.011524  , -0.011389  ,
-       -0.011256  , -0.011125  , -0.010996  , -0.010869  , -0.010744  ,
-       -0.010621  , -0.0105    , -0.010288  , -0.010203  , -0.010132  ,
-       -0.010075  , -0.010032  , -0.010003  , -0.009988  , -0.009987  ,
-       -0.01      , -0.01046786, -0.01073198, -0.01101436, -0.01131345,
-       -0.01162763, -0.01195518, -0.01229434, -0.01264324, -0.013     ,
-       -0.01289357, -0.01281944, -0.01273238, -0.01263334, -0.01252341,
-       -0.01240376, -0.0122757 , -0.01214063, -0.012     , -0.011888  ,
-       -0.011757  , -0.011584  , -0.011375  , -0.011136  , -0.010873  ,
-       -0.010592  , -0.010299  , -0.01      , -0.010376  , -0.010414  ,
-       -0.010368  , -0.01025   , -0.010072  , -0.009846  , -0.009584  ,
-       -0.009298  , -0.009     , -0.003     , -0.        , -0.001     ,
-       -0.008     ])
+    x_expected = np.array([
+         4.00000000e-03,  1.00000000e-02,  1.30000000e-02,  1.20000000e-02,
+         5.00000000e-03,  5.27200000e-03,  5.49600000e-03,  5.68400000e-03,
+         5.84800000e-03,  6.00000000e-03,  6.15200000e-03,  6.31600000e-03,
+         6.50400000e-03,  7.00000000e-03,  7.02700000e-03,  7.09600000e-03,
+         7.18900000e-03,  7.28800000e-03,  7.37500000e-03,  7.43200000e-03,
+         7.44100000e-03,  7.38400000e-03,  7.00000000e-03,  6.95397792e-03,
+         6.89357180e-03,  6.81943755e-03,  6.73238014e-03,  6.63334482e-03,
+         6.52340696e-03,  6.40376026e-03,  6.27570386e-03,  6.00000000e-03,
+         5.90661105e-03,  5.78718097e-03,  5.64235946e-03,  5.47293432e-03,
+         5.27982723e-03,  5.06408867e-03,  4.82689224e-03,  4.56952827e-03,
+         4.00000000e-03,  3.90500000e-03,  3.82000000e-03,  3.74500000e-03,
+         3.68000000e-03,  3.62500000e-03,  3.58000000e-03,  3.54500000e-03,
+         3.52000000e-03,  3.50000000e-03,  3.48500000e-03,  3.44000000e-03,
+         3.36500000e-03,  3.26000000e-03,  3.12500000e-03,  2.96000000e-03,
+         2.76500000e-03,  2.54000000e-03,  2.00000000e-03,  1.72200000e-03,
+         1.48800000e-03,  1.29800000e-03,  1.15200000e-03,  1.05000000e-03,
+         9.92000000e-04,  9.78000000e-04,  1.00800000e-03,  1.20000000e-03,
+         1.33900000e-03,  1.47600000e-03,  1.61100000e-03,  1.74400000e-03,
+         1.87500000e-03,  2.00400000e-03,  2.13100000e-03,  2.25600000e-03,
+         2.50000000e-03,  2.61300000e-03,  2.71200000e-03,  2.79700000e-03,
+         2.86800000e-03,  2.92500000e-03,  2.96800000e-03,  2.99700000e-03,
+         3.01200000e-03,  3.00000000e-03,  2.77657996e-03,  2.53214260e-03,
+         2.26801764e-03,  1.98564190e-03,  1.68655149e-03,  1.37237342e-03,
+         1.04481682e-03,  7.05663559e-04, -4.44089210e-19,  4.60220848e-05,
+         1.06428199e-04,  1.80562445e-04,  2.67619865e-04,  3.66655177e-04,
+         4.76593043e-04,  5.96239745e-04,  7.24296143e-04,  1.00000000e-03,
+         1.02900000e-03,  1.11200000e-03,  1.24300000e-03,  1.41600000e-03,
+         1.62500000e-03,  1.86400000e-03,  2.12700000e-03,  2.40800000e-03,
+         3.00000000e-03,  2.75800000e-03,  2.62400000e-03,  2.58600000e-03,
+         2.63200000e-03,  2.75000000e-03,  2.92800000e-03,  3.15400000e-03,
+         3.41600000e-03])
+    y_expected = np.array([
+        -0.008     , -0.001     , -0.        , -0.003     , -0.009     ,
+       -0.009298  , -0.009584  , -0.009846  , -0.010072  , -0.01025   ,
+       -0.010368  , -0.010414  , -0.010376  , -0.01      , -0.010299  ,
+       -0.010592  , -0.010873  , -0.011136  , -0.011375  , -0.011584  ,
+       -0.011757  , -0.011888  , -0.012     , -0.01214063, -0.0122757 ,
+       -0.01240376, -0.01252341, -0.01263334, -0.01273238, -0.01281944,
+       -0.01289357, -0.013     , -0.01264324, -0.01229434, -0.01195518,
+       -0.01162763, -0.01131345, -0.01101436, -0.01073198, -0.01046786,
+       -0.01      , -0.009987  , -0.009988  , -0.010003  , -0.010032  ,
+       -0.010075  , -0.010132  , -0.010203  , -0.010288  , -0.0105    ,
+       -0.010621  , -0.010744  , -0.010869  , -0.010996  , -0.011125  ,
+       -0.011256  , -0.011389  , -0.011524  , -0.0118    , -0.011918  ,
+       -0.011992  , -0.012022  , -0.012008  , -0.01195   , -0.011848  ,
+       -0.011702  , -0.011512  , -0.011     , -0.010715  , -0.01046   ,
+       -0.010235  , -0.01004   , -0.009875  , -0.00974   , -0.009635  ,
+       -0.00956   , -0.0095    , -0.009495  , -0.00948   , -0.009455  ,
+       -0.00942   , -0.009375  , -0.00932   , -0.009255  , -0.00918   ,
+       -0.009     , -0.0087066 , -0.00843047, -0.00817311, -0.00793591,
+       -0.00772017, -0.00752707, -0.00735764, -0.00721282, -0.007     ,
+       -0.00685937, -0.0067243 , -0.00659624, -0.00647659, -0.00636666,
+       -0.00626762, -0.00618056, -0.00610643, -0.006     , -0.005757  ,
+       -0.005616  , -0.005559  , -0.005568  , -0.005625  , -0.005712  ,
+       -0.005811  , -0.005904  , -0.006     , -0.006272  , -0.006496  ,
+       -0.006684  , -0.006848  , -0.007     , -0.007152  , -0.007316  ,
+       -0.007504  ])
 
     xo.assert_allclose(aper.x_vertices, x_expected, atol=1e-6, rtol=0)
     xo.assert_allclose(aper.y_vertices, y_expected, atol=1e-6, rtol=0)
@@ -378,4 +386,4 @@ def test_limitrect_to_dict():
     assert lrectdef.min_x == -1e10
     assert lrectdef.max_x == 1e10
     assert lrectdef.min_y == -1e10
-    assert lrectdef.max_y == 1e10
+    assert lrectdef.max_y == 1e10

xtrack-0.96.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.2 → xtrack-0.96.0}/tests/test_coupling_edwards_teng.py

@@ -15,35 +15,42 @@ def test_coupling_edwards_teng():
     mad = Madx()
     mad.call(str(test_data_folder / 'lhc_2024/lhc.seq'))
     mad.call(str(test_data_folder / 'lhc_2024/injection_optics.madx'))
+    mad.options.rbarc = True # override setting in lhc.seq to be compatible with Xsuite
 
     mad.beam()
     mad.use('lhcb1')
 
-    mad.globals.on_x1 = 0
-    mad.globals.on_x2h = 0
-    mad.globals.on_x2v = 0
-    mad.globals.on_x5 = 0
-    mad.globals.on_x8h = 0
-    mad.globals.on_x8v = 0
-
-    mad.globals.on_sep1 = 0
-    mad.globals.on_sep2h = 0
-    mad.globals.on_sep2v = 0
-    mad.globals.on_sep5 = 0
-    mad.globals.on_sep8h = 0
-    mad.globals.on_sep8v = 0
-
-    mad.globals.on_a2 = 0
-    mad.globals.on_a8 = 0
-
-    mad.globals['kqs.a67b1'] = 1e-4
+    settings = dict(
+        on_x1 = 0,
+        on_x2h = 0,
+        on_x2v = 0,
+        on_x5 = 0,
+        on_x8h = 0,
+        on_x8v = 0,
+        on_sep1 = 0,
+        on_sep2h = 0,
+        on_sep2v = 0,
+        on_sep5 = 0,
+        on_sep8h = 0,
+        on_sep8v = 0,
+        on_a2 = 0,
+        on_a8 = 0,
+    )
+    settings['kqs.a67b1'] = 1e-4
+
+    for kk, vv in settings.items():
+        mad.globals[kk] = vv
 
     twmad = mad.twiss()
 
-    line = xt.Line.from_madx_sequence(mad.sequence.lhcb1, deferred_expressions=True)
-    line.particle_ref = xt.Particles(p0c=450e9)
-    tw = line.twiss4d(coupling_edw_teng=True)
+    env = xt.load([test_data_folder / 'lhc_2024/lhc.seq',
+                   test_data_folder / 'lhc_2024/injection_optics.madx'])
+    line = env['lhcb1']
+    line.set_particle_ref('proton', p0c=450e9)
+    for kk, vv in settings.items():
+        line[kk] = vv
 
+    tw = line.twiss4d(coupling_edw_teng=True)
 
     r11_mad, r12_mad, r21_mad, r22_mad = twmad.r11, twmad.r12, twmad.r21, twmad.r22
 

{xtrack-0.94.2 → xtrack-0.96.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.2 → xtrack-0.96.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