xtrack 0.95.0__tar.gz → 0.96.1__tar.gz

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

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

{xtrack-0.95.0 → xtrack-0.96.1}/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.1/tests/test_acdipole.py

@@ -0,0 +1,263 @@
+"""
+Test suite for ACDipole elements in Xtrack.
+
+This module tests the behavior of the ACDipole
+elements, focusing on their kick effects during ramp-up, flattop, and ramp-down phases.
+Tests verify that only the appropriate coordinate (py for vertical, px for horizontal)
+receives the expected kick while others remain zero.
+"""
+
+from collections import namedtuple
+from typing import Any
+
+import pytest
+from xobjects.test_helpers import for_all_test_contexts
+
+import xtrack as xt
+import xobjects as xo
+
+
+# Constants
+KICK_FACTOR = 300e-3  # Conversion factor for kick strength (mrad/V)
+TOLERANCE = 1e-10  # Numerical tolerance for kick comparisons
+
+RAMP_LENGTH = 10.0  # Number of turns for ramp up/down phases
+FLATTOP_START = 100  # Turn number when flattop phase begins
+
+# Turn numbers defining ramp phases: [start, end_ramp_up, start_ramp_down, end]:
+RAMP_SCHEDULE = [0, RAMP_LENGTH, FLATTOP_START, FLATTOP_START + RAMP_LENGTH]
+
+PLANES = ["x", "y"]
+
+
+def get_acdipole_results(
+    test_context: Any,
+    turn: int,
+    plane: str,
+    test_voltage: float = 1.5,
+    test_freq: float = 0.25,
+    test_lag: float = 0.0,
+) -> tuple[float, float, float, float]:
+    """
+    Track particles through an ACDipole and return final coordinates.
+
+    Args:
+        test_context: The computational context for the simulation.
+        acdipole_class: The ACDipole class to instantiate (vertical or horizontal).
+        turn: The turn number for tracking.
+        test_voltage: Voltage setting for the ACDipole.
+        test_freq: Frequency setting for the ACDipole.
+        test_lag: Phase lag setting for the ACDipole.
+
+    Returns:
+        Tuple of (x, px, y, py) coordinates after tracking.
+    """
+    particles = xt.Particles(at_turn=turn, _context=test_context)  # Must be 0.
+
+    acdipole = xt.ACDipole(
+        volt=test_voltage,
+        freq=test_freq,
+        lag=test_lag,
+        ramp=RAMP_SCHEDULE,
+        _context=test_context,
+        plane="h",
+    )
+    # Test the setter
+    acdipole.plane = plane
+
+    acdipole.track(particles)
+    return particles.x[0], particles.px[0], particles.y[0], particles.py[0]
+
+
+def assert_acdipole_kick(
+    *,
+    test_context: Any,
+    test_turn: int,
+    test_plane: str,
+    test_volt: float,
+    test_freq: float,
+    test_lag: float,
+    expected_kick: float,
+) -> None:
+    """
+    Assert that only the specified coordinate receives the expected kick.
+
+    Tracks particles through the ACDipole and verifies that only the coordinate
+    corresponding to kick_attr receives the expected kick, while all other
+    coordinates remain zero.
+
+    Args:
+        test_context: The computational context for the simulation.
+        acdipole_class: The ACDipole class to test.
+        test_turn: Turn number for the test.
+        test_volt: Voltage setting.
+        test_freq: Frequency setting.
+        test_lag: Phase lag setting.
+        kick_attr: The coordinate that should receive the kick ("px" or "py").
+        expected_kick: The expected kick value for the specified coordinate.
+
+    Raises:
+        AssertionError: If the kick is not applied correctly.
+    """
+    x, px, y, py = get_acdipole_results(
+        test_context, test_turn, test_plane, test_volt, test_freq, test_lag
+    )
+    vals = {"x": x, "px": px, "y": y, "py": py}  # Map coordinate names to values
+    for coord in vals:
+        if coord == f"p{test_plane}":
+            xo.assert_allclose(vals[coord], expected_kick, atol=TOLERANCE, rtol=0)
+        else:
+            assert vals[coord] == 0.0, (
+                f"Turn {test_turn}: Expected {coord}=0, but got {coord}={vals[coord]}"
+            )
+
+
+# =====================
+# Flattop Test Parameters and Helper
+# =====================
+FlattopCase = namedtuple("FlattopCase", ["volt", "turn", "freq", "lag", "desc"])
+FLATTOP_CASES = [
+    FlattopCase(2.25, 45, 0.25, 0.0, "flattop, 2.25V, freq=0.25, lag=0.0"),
+    FlattopCase(1.5, 46, 1 / 3, -1 / 3, "flattop, 1.5V, freq=0.333..., lag=-0.333..."),
+    FlattopCase(1.5, 47, 1 / 3, 1 / 12, "flattop, 1.5V, freq=0.333..., lag=0.0833..."),
+]
+
+
+def _calculate_flattop_kick(test_volt: float, test_turn: int) -> float:
+    """
+    Compute the expected kick during the flattop phase.
+
+    During flattop (turns 45-47), the kick depends on the turn:
+    - Turn 45: Positive kick
+    - Turn 46: Zero kick (phase cancellation)
+    - Turn 47: Negative kick
+
+    Args:
+        test_volt: The voltage setting.
+        test_turn: The turn number.
+
+    Returns:
+        The expected kick value.
+
+    Raises:
+        ValueError: If test_turn is not 45, 46, or 47.
+    """
+    if test_turn == 45:
+        return test_volt * KICK_FACTOR
+    if test_turn == 46:
+        return 0
+    if test_turn == 47:
+        return -test_volt * KICK_FACTOR
+    raise ValueError(
+        f"Unexpected test_turn={test_turn} in flattop tests. Expected 45, 46, or 47."
+    )
+
+
+# =====================
+# Flattop Tests
+# =====================
+@for_all_test_contexts
+@pytest.mark.parametrize("plane", PLANES, ids=lambda o: o.upper())
+@pytest.mark.parametrize("case", FLATTOP_CASES, ids=lambda c: c.desc)
+def test_acdipole_flattop(
+    test_context: Any,
+    case: FlattopCase,
+    plane: str,
+) -> None:
+    """
+    Test ACDipole behavior during flattop phase for both orientations.
+
+    Verifies that the ACDipole applies the correct kick during the flattop
+    phase (constant amplitude) for vertical and horizontal orientations.
+    The test is parametrized over different voltage, frequency, and lag settings.
+    """
+    expected_kick = _calculate_flattop_kick(case.volt, case.turn)
+    assert_acdipole_kick(
+        test_context=test_context,
+        test_turn=case.turn,
+        test_plane=plane,
+        test_volt=case.volt,
+        test_freq=case.freq,
+        test_lag=case.lag,
+        expected_kick=expected_kick,
+    )
+
+
+# =====================
+# Ramp Test Parameters and Helper
+# =====================
+AcdipoleRampCase = namedtuple(
+    "AcdipoleRampCase", ["volt", "turn", "freq", "lag", "desc"]
+)
+ACDIPOLE_RAMP_CASES = [
+    AcdipoleRampCase(1.5, 5, 0.25, 0.0, "First ramp up, quarter period, no lag"),
+    AcdipoleRampCase(
+        1.5, 105, 1.25, 0.0, "Ramp down, after 100 turns, freq > 1, no lag"
+    ),
+    AcdipoleRampCase(2.25, 6, 1 / 3, -0.25, "Early ramp, third period, negative lag"),
+    AcdipoleRampCase(
+        1.5, 107, 1 / 3, 1 / 12, "Late ramp, third period, small positive lag"
+    ),
+]
+
+
+def _calculate_ramp_kick(test_volt: float, test_turn: int) -> float:
+    """
+    Compute the expected kick during ramp phases.
+
+    The ACDipole has three phases based on turn number:
+    - Ramp up: turns 0-100, kick increases linearly
+    - Flattop: turns 100-110, constant kick (handled separately)
+    - Ramp down: turns >100, kick decreases linearly
+
+    The kick sign alternates based on turn number modulo 5.
+
+    Args:
+        test_volt: The voltage setting.
+        test_turn: The turn number.
+
+    Returns:
+        The expected kick value.
+    """
+    # Alternating sign based on turn number (simulates AC oscillation)
+    kick_sign = (-1) ** (test_turn % 5 > 0)
+    if test_turn > FLATTOP_START:
+        # Ramp down phase: kick decreases from max to zero over RAMP_LENGTH turns
+        return (
+            kick_sign
+            * test_volt
+            * KICK_FACTOR
+            * (1 - (test_turn - FLATTOP_START) / RAMP_LENGTH)
+        )
+    # Ramp up phase: kick increases linearly from zero to max over RAMP_LENGTH turns
+    return kick_sign * test_volt * KICK_FACTOR * (test_turn / RAMP_LENGTH)
+
+
+# =====================
+# Ramp Tests
+# =====================
+@for_all_test_contexts
+@pytest.mark.parametrize("plane", PLANES, ids=lambda o: o.upper())
+@pytest.mark.parametrize("case", ACDIPOLE_RAMP_CASES, ids=lambda c: c.desc)
+def test_acdipole_ramp(
+    test_context: Any,
+    case: AcdipoleRampCase,
+    plane: str,
+) -> None:
+    """
+    Test ACDipole behavior during ramp phases for both orientations.
+
+    Verifies that the ACDipole applies linearly increasing/decreasing kicks
+    during ramp-up and ramp-down phases, with alternating signs to simulate
+    AC field oscillations. Only the appropriate coordinate receives the kick.
+    """
+    expected_kick = _calculate_ramp_kick(case.volt, case.turn)
+    assert_acdipole_kick(
+        test_context=test_context,
+        test_turn=case.turn,
+        test_plane=plane,
+        test_volt=case.volt,
+        test_freq=case.freq,
+        test_lag=case.lag,
+        expected_kick=expected_kick,
+    )

xtrack-0.96.1/tests/test_acdipole_twiss.py

@@ -0,0 +1,61 @@
+from typing import Any
+
+import pytest
+import xobjects as xo
+import xpart as xp
+from xobjects.test_helpers import for_all_test_contexts
+
+import xtrack as xt
+
+
+@for_all_test_contexts
+@pytest.mark.parametrize("qx_shift", [-0.015, 0.035], ids=lambda v: f"qx_shift={v}")
+@pytest.mark.parametrize("qy_shift", [0.015, -0.02], ids=lambda v: f"qy_shift={v}")
+def test_ac_dipole_twiss(test_context: Any, qx_shift: float, qy_shift: float):
+    """Test the effect of a thin AC dipole on the tune shift."""
+    n = 4  # Number of FODO cells
+    fodo = [
+        xt.Multipole(length=0.2, knl=[0, +0.2], ksl=[0, 0]),
+        xt.Drift(length=1.0),
+        xt.Multipole(length=0.2, knl=[0, -0.2], ksl=[0, 0]),
+        xt.Drift(length=1.0),
+    ]
+    line = xt.Line(elements=n * fodo)
+    line.particle_ref = xp.Particles(mass0=xp.PROTON_MASS_EV, q0=1, p0c=1e9)
+    line.build_tracker(_context=test_context)
+    base_tws = line.twiss(method="4d")
+    nat_qx, nat_qy = base_tws["qx"], base_tws["qy"]
+    e5_pos = line.get_s_position("e5")
+    e5_betx = base_tws.rows["e5"]["betx"].item()
+    e5_bety = base_tws.rows["e5"]["bety"].item()
+
+    drv_qx, drv_qy = nat_qx + qx_shift, nat_qy + qy_shift
+
+    # Define AC dipole elements
+    line.env.elements["e5_hacd"] = xt.ACDipole(
+        natural_q=nat_qx,
+        freq=drv_qx,
+        beta_at_acdipole=e5_betx,
+        plane="h",
+        twiss_mode=True,
+    )
+    line.env.elements["e5_vacd"] = xt.ACDipole(
+        natural_q=nat_qy,
+        freq=drv_qy,
+        beta_at_acdipole=e5_bety,
+        plane="v",
+    )
+
+    line.insert("e5_hacd", at=e5_pos)
+    line.insert("e5_vacd", at=e5_pos)
+
+    # Test the setter of twiss_mode property
+    line.env.elements["e5_vacd"].twiss_mode = True
+
+    line.build_tracker(_context=test_context)
+    tws_both = line.twiss(method="4d")
+
+    xo.assert_allclose(tws_both["qx"], drv_qx, rtol=1e-10, atol=1e-15)
+    xo.assert_allclose(tws_both["qy"], drv_qy, rtol=1e-10, atol=1e-15)
+
+    del line

xtrack-0.96.1/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.95.0 → xtrack-0.96.1}/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)