xtrack 0.88.8__tar.gz → 0.89.0__tar.gz

{xtrack-0.88.8/xtrack.egg-info → xtrack-0.89.0}/PKG-INFO

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

{xtrack-0.88.8 → xtrack-0.89.0}/ducktrack/elements.py

@@ -4,6 +4,7 @@
 # ######################################### #
 
 import numpy as np
+import xtrack as xt
 from scipy.constants import c as clight
 from scipy.constants import epsilon_0
 from scipy.constants import mu_0
@@ -45,6 +46,7 @@ _factorial = np.array(
     ]
 )
 
+
 class Marker(Element):
 
     _description = []
@@ -52,6 +54,7 @@ class Marker(Element):
     def track(self, p):
         pass
 
+
 class Drift(Element):
     """Drift in expanded form"""
 
@@ -382,6 +385,216 @@ class Elens(Element):
         p.py = yp/p.rpp
 
 
+class Misalignment(Element):
+    _description = [
+        ("dx", "m", "Misalignment in x", 0),
+        ("dy", "m", "Misalignment in y", 0),
+        ("ds", "m", "Misalignment in s", 0),
+        ("theta", "rad", "Rotation around the y axis (positive s to x)", 0),
+        ("phi", "rad", "Rotation around the x axis (positive s to y)", 0),
+        ("psi", "rad", "Rotation around the s axis (positive y to x)", 0),
+        ("anchor", "", "Reference point, anchor, of the misalignment "
+                       "(0 for entry, 0.5 for middle, 1 for exit, etc.)", 0),
+        ("length", "m", "Length of the element to which the misalignment applies", 0),
+        ("angle", "rad", "Angle of bending if applicable (0 for straight)", 0),
+        ("tilt", "rad", "Tilt of the element (0 for no tilt, positive for tilt towards x)", 0),
+        ("is_exit", "", "Whether we are at the exit of the element", False),
+    ]
+
+    def track(self, particles):
+        if not self.is_exit:
+            if self.angle:
+                self.track_bent_entry(particles)
+            else:
+                self.track_straight_entry(particles)
+        else:
+            if self.angle:
+                self.track_bent_exit(particles)
+            else:
+                self.track_straight_exit(particles)
+
+    def track_bent_entry(self, particles):
+        dx, dy, ds = self.dx, self.dy, self.ds
+        theta, phi, psi = self.theta, self.phi, self.psi
+        f, length, angle, tilt = self.anchor, self.length, self.angle, self.tilt
+
+        s_phi, c_phi = np.sin(phi), np.cos(phi)
+        s_theta, c_theta = np.sin(theta), np.cos(theta)
+        s_psi, c_psi = np.sin(psi), np.cos(psi)
+        misalignment_matrix = np.array([
+            [-s_phi * s_psi * s_theta + c_psi * c_theta, -c_psi * s_phi * s_theta - c_theta * s_psi, c_phi * s_theta, dx],
+            [c_phi * s_psi, c_phi * c_psi, s_phi, dy],
+            [-c_theta * s_phi * s_psi - c_psi * s_theta, -c_psi * c_theta * s_phi + s_psi * s_theta, c_phi * c_theta, ds],
+            [0, 0, 0, 1],
+        ])
+
+        rho = length / angle
+        matrix_first_half = np.array([
+            [
+                (np.cos(f * angle) - 1) * np.cos(tilt) ** 2 + 1,
+                (np.cos(f * angle) - 1) * np.cos(tilt) * np.sin(tilt),
+                -np.cos(tilt) * np.sin(f * angle),
+                rho * (np.cos(f * angle) - 1) * np.cos(tilt),
+            ],
+            [
+                (np.cos(f * angle) - 1) * np.cos(tilt) * np.sin(tilt),
+                (np.cos(f * angle) - 1) * np.sin(tilt) ** 2 + 1,
+                -np.sin(f * angle) * np.sin(tilt),
+                rho * (np.cos(f * angle) - 1) * np.sin(tilt),
+            ],
+            [
+                np.cos(tilt) * np.sin(f * angle),
+                np.sin(f * angle) * np.sin(tilt),
+                np.cos(f * angle),
+                rho * np.sin(f * angle),
+            ],
+            [0, 0, 0, 1],
+        ])
+
+        inv_matrix_first_half = np.linalg.inv(matrix_first_half)
+
+        temp = matrix_first_half @ misalignment_matrix
+
+        misaligned_entry = temp @ inv_matrix_first_half
+
+        mis_x, mis_y, mis_s = misaligned_entry[:3, 3]
+        rot_theta = np.arctan2(misaligned_entry[0, 2], misaligned_entry[2, 2])
+        rot_phi = np.arctan2(misaligned_entry[1, 2], np.sqrt(misaligned_entry[1, 0] ** 2 + misaligned_entry[1, 1] ** 2))
+        rot_psi = np.arctan2(misaligned_entry[1, 0], misaligned_entry[1, 1])
+
+        line = xt.Line(
+            elements=[
+                xt.XYShift(dx=mis_x, dy=mis_y),
+                xt.DriftExact(length=mis_s),
+                xt.YRotation(angle=np.rad2deg(rot_theta)),
+                xt.XRotation(angle=np.rad2deg(-rot_phi)),  # flipped angle convention
+                xt.SRotation(angle=np.rad2deg(rot_psi)),
+            ]
+        )
+
+        particles.zeta -= mis_s
+        particles.s -= mis_s
+        line.track(particles)
+
+    def track_straight_entry(self, particles):
+        dx, dy, ds = self.dx, self.dy, self.ds
+        theta, phi, psi = self.theta, self.phi, self.psi
+        f, length, angle = self.anchor, self.length, self.angle
+
+        mis_x = dx - f * length * np.cos(phi) * np.sin(theta)
+        mis_y = dy - f * length * np.sin(phi)
+        mis_s = ds - f * length * (np.cos(phi) * np.cos(theta) - 1)
+
+        line = xt.Line(
+            elements=[
+                xt.XYShift(dx=mis_x, dy=mis_y),
+                xt.Solenoid(length=mis_s),
+                xt.YRotation(angle=np.rad2deg(theta)),
+                xt.XRotation(angle=np.rad2deg(-phi)),  # flipped angle convention
+                xt.SRotation(angle=np.rad2deg(psi)),
+            ]
+        )
+
+        particles.zeta -= mis_s
+        particles.s -= mis_s
+        line.track(particles)
+
+    def track_bent_exit(self, particles):
+        dx, dy, ds = self.dx, self.dy, self.ds
+        theta, phi, psi = self.theta, self.phi, self.psi
+        f, length, angle, tilt = self.anchor, self.length, self.angle, self.tilt
+
+        s_phi, c_phi = np.sin(phi), np.cos(phi)
+        s_theta, c_theta = np.sin(theta), np.cos(theta)
+        s_psi, c_psi = np.sin(psi), np.cos(psi)
+        misalignment_matrix = np.array([
+            [-s_phi * s_psi * s_theta + c_psi * c_theta, -c_psi * s_phi * s_theta - c_theta * s_psi, c_phi * s_theta, dx],
+            [c_phi * s_psi, c_phi * c_psi, s_phi, dy],
+            [-c_theta * s_phi * s_psi - c_psi * s_theta, -c_psi * c_theta * s_phi + s_psi * s_theta, c_phi * c_theta, ds],
+            [0, 0, 0, 1],
+        ])
+
+        m00, m01, m02, m03 = misalignment_matrix[0, :]
+        m10, m11, m12, m13 = misalignment_matrix[1, :]
+        m20, m21, m22, m23 = misalignment_matrix[2, :]
+        inv_misalignment_matrix = np.array([
+            [m00, m10, m20, -m00 * m03 - m10 * m13 - m20 * m23],
+            [m01, m11, m21, -m01 * m03 - m11 * m13 - m21 * m23],
+            [m02, m12, m22, -m02 * m03 - m12 * m13 - m22 * m23],
+            [0, 0, 0, 1],
+        ])
+
+        f_compl = 1 - f
+        rho = length / angle
+        matrix_second_half = np.array([
+            [
+                (np.cos(f_compl * angle) - 1) * np.cos(tilt) ** 2 + 1,
+                (np.cos(f_compl * angle) - 1) * np.cos(tilt) * np.sin(tilt),
+                np.cos(tilt) * -np.sin(f_compl * angle),
+                rho * (np.cos(f_compl * angle) - 1) * np.cos(tilt),
+            ],
+            [
+                (np.cos(f_compl * angle) - 1) * np.cos(tilt) * np.sin(tilt),
+                (np.cos(f_compl * angle) - 1) * np.sin(tilt) ** 2 + 1,
+                -np.sin(f_compl * angle) * np.sin(tilt),
+                rho * (np.cos(f_compl * angle) - 1) * np.sin(tilt),
+            ],
+            [
+                -np.cos(tilt) * -np.sin(f_compl * angle),
+                np.sin(f_compl * angle) * np.sin(tilt),
+                np.cos(f_compl * angle),
+                rho * np.sin(f_compl * angle),
+            ],
+            [0, 0, 0, 1],
+        ])
+
+        inv_matrix_second_half = np.linalg.inv(matrix_second_half)
+
+        realign = inv_matrix_second_half @ inv_misalignment_matrix @ matrix_second_half
+
+        mis_x, mis_y, mis_s = realign[:3, 3]
+        rot_theta = np.arctan2(realign[0, 2], realign[2, 2])
+        rot_phi = np.arctan2(realign[1, 2], np.sqrt(realign[1, 0] ** 2 + realign[1, 1] ** 2))
+        rot_psi = np.arctan2(realign[1, 0], realign[1, 1])
+
+        line = xt.Line(
+            elements=[
+                xt.XYShift(dx=mis_x, dy=mis_y),
+                xt.Solenoid(length=mis_s),
+                xt.YRotation(angle=np.rad2deg(rot_theta)),
+                xt.XRotation(angle=np.rad2deg(-rot_phi)),  # flipped angle convention
+                xt.SRotation(angle=np.rad2deg(rot_psi)),
+            ]
+        )
+
+        particles.zeta -= mis_s
+        particles.s -= mis_s
+        line.track(particles)
+
+    def track_straight_exit(self, particles):
+        dx, dy, ds = self.dx, self.dy, self.ds
+        theta, phi, psi = self.theta, self.phi, self.psi
+        f, length, angle = self.anchor, self.length, self.angle
+
+        mis_x = (f - 1) * length * np.cos(phi) * np.sin(theta) - dx
+        mis_y = (f - 1) * length * np.sin(phi) - dy
+        mis_s = (f - 1) * length * (np.cos(phi) * np.cos(theta) - 1) - ds
+
+        line = xt.Line(
+            elements=[
+                xt.SRotation(angle=np.rad2deg(-psi)),
+                xt.XRotation(angle=np.rad2deg(phi)),  # flipped angle convention
+                xt.YRotation(angle=np.rad2deg(-theta)),
+                xt.Solenoid(length=mis_s),
+                xt.XYShift(dx=mis_x, dy=mis_y),
+            ]
+        )
+
+        particles.zeta -= mis_s
+        particles.s -= mis_s
+        line.track(particles)
+
+
 class Wire(Element):
     """Current-carrying wire"""
 

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_chromatic_functions_vs_madx.py

@@ -11,7 +11,7 @@ test_data_folder = pathlib.Path(
 
 import numpy as np
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_chromatic_functions_vs_madx(test_context):
 
     collider = xt.load(test_data_folder /

xtrack-0.89.0/tests/test_coupling_edwards_teng.py

@@ -0,0 +1,131 @@
+import pathlib
+
+import numpy as np
+
+import xobjects as xo
+import xtrack as xt
+
+from cpymad.madx import Madx
+
+test_data_folder = pathlib.Path(
+    __file__).parent.joinpath('../test_data').absolute()
+
+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.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
+
+    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)
+
+
+    r11_mad, r12_mad, r21_mad, r22_mad = twmad.r11, twmad.r12, twmad.r21, twmad.r22
+
+    s_mad = twmad.s
+
+    r11_mad_at_s = np.interp(tw.s, s_mad, r11_mad)
+    r12_mad_at_s = np.interp(tw.s, s_mad, r12_mad)
+    r21_mad_at_s = np.interp(tw.s, s_mad, r21_mad)
+    r22_mad_at_s = np.interp(tw.s, s_mad, r22_mad)
+    betx_mad_at_s = np.interp(tw.s, s_mad, twmad.betx)
+    bety_mad_at_s = np.interp(tw.s, s_mad, twmad.bety)
+    alfx_mad_at_s = np.interp(tw.s, s_mad, twmad.alfx)
+    alfy_mad_at_s = np.interp(tw.s, s_mad, twmad.alfy)
+
+    rdt_mad_at_s = compute_rdt(r11_mad_at_s, r12_mad_at_s, r21_mad_at_s, r22_mad_at_s,
+                            betx_mad_at_s, bety_mad_at_s, alfx_mad_at_s, alfy_mad_at_s)
+
+    xo.assert_allclose(tw.r11_edw_teng, r11_mad_at_s,
+                    rtol=1e-5, atol=1e-5*np.max(np.abs(r11_mad_at_s)))
+    xo.assert_allclose(tw.r12_edw_teng, r12_mad_at_s,
+                    rtol=1e-5, atol=1e-5*np.max(np.abs(r12_mad_at_s)))
+    xo.assert_allclose(tw.r21_edw_teng, r21_mad_at_s,
+                    rtol=1e-5, atol=1e-5*np.max(np.abs(r21_mad_at_s)))
+    xo.assert_allclose(tw.r22_edw_teng, r22_mad_at_s,
+                    rtol=1e-5, atol=1e-5*np.max(np.abs(r22_mad_at_s)))
+    xo.assert_allclose(tw.betx_edw_teng, betx_mad_at_s, atol=0, rtol=1e-5)
+
+    xo.assert_allclose(tw.betx_edw_teng, betx_mad_at_s, atol=0, rtol=5e-8)
+    xo.assert_allclose(tw.alfx_edw_teng, alfx_mad_at_s, atol=1e-4, rtol=1e-8)
+    xo.assert_allclose(tw.bety_edw_teng, bety_mad_at_s, atol=0, rtol=5e-8)
+    xo.assert_allclose(tw.alfy_edw_teng, alfy_mad_at_s, atol=1e-4, rtol=1e-8)
+
+    xo.assert_allclose(tw.f1001, rdt_mad_at_s['f1001'],
+                    atol=1e-5 * np.max(np.abs(rdt_mad_at_s['f1001'])))
+    xo.assert_allclose(tw.f1010, rdt_mad_at_s['f1010'],
+                    atol=1e-5 * np.max(np.abs(rdt_mad_at_s['f1010'])))
+
+
+def compute_rdt(r11, r12, r21, r22, betx, bety, alfx, alfy):
+
+    '''
+    Developed by CERN OMC team.
+    Ported from:
+    https://pypi.org/project/optics-functions/
+    https://github.com/pylhc/optics_functions
+
+    Based on Calaga, Tomas, https://journals.aps.org/prab/pdf/10.1103/PhysRevSTAB.8.034001
+    '''
+
+    n = len(r11)
+    assert len(r12) == n
+    assert len(r21) == n
+    assert len(r22) == n
+    gx, r, inv_gy = np.zeros((n, 2, 2)), np.zeros((n, 2, 2)), np.zeros((n, 2, 2))
+
+    # Eq. (16)  C = 1 / (1 + |R|) * -J R J
+    # rs form after -J R^T J
+    r[:, 0, 0] = r22
+    r[:, 0, 1] = -r12
+    r[:, 1, 0] = -r21
+    r[:, 1, 1] = r11
+
+    r *= 1 / np.sqrt(1 + np.linalg.det(r)[:, None, None])
+
+    # Cbar = Gx * C * Gy^-1,   Eq. (5)
+    sqrt_betax = np.sqrt(betx)
+    sqrt_betay = np.sqrt(bety)
+
+    gx[:, 0, 0] = 1 / sqrt_betax
+    gx[:, 1, 0] = alfx * gx[:, 0, 0]
+    gx[:, 1, 1] = sqrt_betax
+
+    inv_gy[:, 1, 1] = 1 / sqrt_betay
+    inv_gy[:, 1, 0] = -alfy * inv_gy[:, 1, 1]
+    inv_gy[:, 0, 0] = sqrt_betay
+
+    c = np.matmul(gx, np.matmul(r, inv_gy))
+    gamma = np.sqrt(1 - np.linalg.det(c))
+
+    # Eq. (9) and Eq. (10)
+    denom = 1 / (4 * gamma)
+    f1001 = denom * (+c[:, 0, 1] - c[:, 1, 0] + (c[:, 0, 0] + c[:, 1, 1]) * 1j)
+    f1010 = denom * (-c[:, 0, 1] - c[:, 1, 0] + (c[:, 0, 0] - c[:, 1, 1]) * 1j)
+
+    return {'f1001': f1001, 'f1010': f1010}

xtrack-0.89.0/tests/test_elements_classflags.py

@@ -0,0 +1,57 @@
+import xtrack as xt
+
+checks = [
+    (xt.Drift,                   dict(_isthick=True, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.Multipole,               dict(allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.Marker,                  dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.ReferenceEnergyIncrease, dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.Cavity,                  dict(_isthick=True, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.XYShift,                 dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.ZetaShift,               dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.Elens,                   dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.Wire,                    dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.SRotation,               dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.YRotation,               dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.Solenoid,                dict(_isthick=True , allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.UniformSolenoid,         dict(_isthick=True , allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.VariableSolenoid,        dict(_isthick=True , allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.RFMultipole,             dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.DipoleEdge,              dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.SimpleThinBend,          dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.SimpleThinQuadrupole,    dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.LineSegmentMap,          dict(_isthick=True , allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.NonLinearLens,           dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.LimitEllipse,            dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.LimitRectEllipse,        dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.LimitRect,               dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.LimitRacetrack,          dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.LimitPolygon,            dict(_isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.DriftSlice,              dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=False, _inherit_strengths=False)),
+    (xt.DriftSliceBend,          dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=False, _inherit_strengths=False)),
+    (xt.DriftSliceOctupole,      dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=False, _inherit_strengths=False)),
+    (xt.DriftSliceQuadrupole,    dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=False, _inherit_strengths=False)),
+    (xt.DriftSliceSextupole,     dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=False, _inherit_strengths=False)),
+    (xt.ThickSliceBend,          dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThickSliceOctupole,      dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThickSliceUniformSolenoid,dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThickSliceQuadrupole,    dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThickSliceSextupole,     dict(_isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThinSliceBend,           dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThinSliceBendEntry,      dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=False)),
+    (xt.ThinSliceBendExit,       dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=False)),
+    (xt.ThinSliceOctupole,       dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThinSliceQuadrupole,     dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThinSliceSextupole,      dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThinSliceUniformSolenoidEntry, dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=False)),
+    (xt.ThinSliceUniformSolenoidExit,  dict(_isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=False)),
+]
+
+def test_elements_classflags():
+    for cls, kwargs in checks:
+        for kk, vv in kwargs.items():
+            if vv is not None:
+                assert getattr(cls, kk) == kwargs[kk], (
+                    f'{cls.__name__}.{kk} is {getattr(cls, kk)} instead of {kwargs[kk]}')
+            else:
+                assert not hasattr(cls, kk), (
+                    f'{cls.__name__}.{kk} should not be defined')

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_line.py

@@ -867,7 +867,7 @@ def test_insert_thin_elements_at_s_basic(test_context):
     assert t1.s[-2] == 5.
     assert t1.s[-3] == 5.
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_insert_thin_elements_at_s_lhc(test_context):
 
     line = xt.load(test_data_folder /

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_madloader.py

@@ -366,17 +366,24 @@ def test_thick_kicker_option():
 
     beam; use, sequence=ss;
     """)
-    line = MadLoader(mad.sequence.ss, enable_expressions=True, allow_thick=True, enable_thick_kickers=True).make_line()
+    line = xt.Line.from_madx_sequence(mad.sequence.ss, deferred_expressions=True)
 
     _, vk, hk, ki, vk_thin, hk_thin, ki_thin, _ = line.elements
 
-    assert isinstance(vk, xt.Magnet)
-    assert isinstance(hk, xt.Magnet)
-    assert isinstance(ki, xt.Magnet)
+    assert isinstance(vk, xt.Multipole)
+    assert isinstance(hk, xt.Multipole)
+    assert isinstance(ki, xt.Multipole)
     assert isinstance(vk_thin, xt.Multipole)
     assert isinstance(hk_thin, xt.Multipole)
     assert isinstance(ki_thin, xt.Multipole)
 
+    assert vk.isthick
+    assert hk.isthick
+    assert ki.isthick
+    assert not vk_thin.isthick
+    assert not hk_thin.isthick
+    assert not ki_thin.isthick
+
     def assert_integrated_strength_eq(value, expected):
         padded_expected = np.zeros_like(value)
         padded_expected[:len(expected)] = expected
@@ -512,7 +519,7 @@ def test_mad_elements_import():
     k2: kick2, at=0.34;
     k3: kick3, at=0.35;
     de0: dipedge0, at=0.38;
-    r0: rfm0, at=0.4;
+    !r0: rfm0, at=0.4; # Loading of RFMultipole not supported anymore
     cb0: crab0, at=0.41;
     cb1: crab1, at=0.42;
     w: wire1, at=1;
@@ -608,44 +615,32 @@ def test_mad_elements_import():
         assert line['de0'].fint == 4
         assert line['de0'].hgap == 0.02
 
-        assert isinstance(line['r0'], xt.RFMultipole)
-        assert line.get_s_position('r0') == 0.4
-        assert np.all(line['r0'].knl == np.array([2, 3]))
-        assert np.all(line['r0'].ksl == np.array([0, 5]))
-        assert np.all(line['r0'].pn == np.array([0.3 * 360, 0.4 * 360]))
-        assert np.all(line['r0'].ps == np.array([0.5 * 360, 0.6 * 360]))
-        assert line['r0'].voltage == 2e6
-        assert line['r0'].order == 1
-        assert line['r0'].frequency == 100e6
-        assert line['r0'].lag == 180
-
-        assert isinstance(line['cb0'], xt.RFMultipole)
+        # Loading of RFMultipole not supported anymore:
+        #
+        # assert isinstance(line['r0'], xt.RFMultipole)
+        # assert line.get_s_position('r0') == 0.4
+        # assert np.all(line['r0'].knl == np.array([2, 3, 0, 0, 0, 0]))
+        # assert np.all(line['r0'].ksl == np.array([0, 5, 0, 0, 0, 0]))
+        # assert np.all(line['r0'].pn == np.array([0.3 * 360, 0.4 * 360, 0, 0, 0, 0]))
+        # assert np.all(line['r0'].ps == np.array([0.5 * 360, 0.6 * 360, 0, 0, 0, 0]))
+        # assert line['r0'].voltage == 2e6
+        # assert line['r0'].order == 5
+        # assert line['r0'].frequency == 100e6
+        # assert line['r0'].lag == 180
+
+        assert isinstance(line['cb0'], xt.CrabCavity)
         assert line.get_s_position('cb0') == 0.41
-        assert len(line['cb0'].knl) == 1
-        assert len(line['cb0'].ksl) == 1
-        xo.assert_allclose(line['cb0'].knl[0], 2 * 1e6 / line.particle_ref.p0c[0],
+        xo.assert_allclose(line['cb0'].crab_voltage, 2 * 1e6,
                            rtol=0, atol=1e-12)
-        assert np.all(line['cb0'].ksl == 0)
-        assert np.all(line['cb0'].pn == np.array([270]))
-        assert np.all(line['cb0'].ps == 0.)
-        assert line['cb0'].voltage == 0
-        assert line['cb0'].order == 0
+        assert np.all(line['cb0'].lag == 180)
         assert line['cb0'].frequency == 100e6
-        assert line['cb0'].lag == 0
 
-        assert isinstance(line['cb1'], xt.RFMultipole)
+        assert isinstance(line['cb1'], xt.CrabCavity)
         assert line.get_s_position('cb1') == 0.42
-        assert len(line['cb1'].knl) == 1
-        assert len(line['cb1'].ksl) == 1
-        xo.assert_allclose(line['cb1'].ksl[0], -2 * 1e6 / line.particle_ref.p0c[0],
-                           rtol=0, atol=1e-12)
-        assert np.all(line['cb1'].knl == 0)
-        assert np.all(line['cb1'].ps == np.array([270]))
-        assert np.all(line['cb1'].pn == 0.)
-        assert line['cb1'].voltage == 0
-        assert line['cb1'].order == 0
+        assert line['cb1'].crab_voltage == 2 * 1e6
+        assert np.all(line['cb1'].lag == 180)
+        xo.assert_allclose(line['cb1'].rot_s_rad, np.pi / 2, rtol=0, atol=1e-12)
         assert line['cb1'].frequency == 100e6
-        assert line['cb1'].lag == 0
 
         assert isinstance(line['w'], xt.Wire)
         assert line.get_s_position('w') == 1

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_magnet.py

@@ -5,7 +5,7 @@ import xtrack as xt
 import xobjects as xo
 from xobjects.test_helpers import for_all_test_contexts
 
-from xtrack.beam_elements.magnets import Magnet, MagnetEdge
+from xtrack import Magnet, MagnetEdge
 
 
 def make_particles(context):

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_match_and_track_from_element.py

@@ -17,7 +17,7 @@ test_data_folder = pathlib.Path(
         __file__).parent.joinpath('../test_data').absolute()
 
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_match_and_track_from_element(test_context):
     # Load machine model (from pymask)
     filename = test_data_folder.joinpath('lhc_no_bb/line_and_particle.json')

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_match_coupling_knob.py

@@ -9,7 +9,7 @@ from xobjects.test_helpers import for_all_test_contexts
 test_data_folder = pathlib.Path(
         __file__).parent.joinpath('../test_data').absolute()
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_match_coupling_knob(test_context):
     line = xt.load(test_data_folder /
         'hllhc14_no_errors_with_coupling_knobs/line_b1.json')

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_match_nested.py

@@ -92,7 +92,7 @@ class ActionMatchPhaseWithMQTs(xd.Action):
                 self.line.vars[kk] = mqt_knob_values[kk]
         return res
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_match_nested(test_context):
 
     # Load the line

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_match_optics_and_ip_knob.py

@@ -9,7 +9,8 @@ from xobjects.test_helpers import for_all_test_contexts
 test_data_folder = pathlib.Path(
     __file__).parent.joinpath('../test_data').absolute()
 
-@for_all_test_contexts
+
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_ip_knob_matching(test_context):
 
     collider = xt.load(test_data_folder /

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_match_optics_and_ip_knob_new_optimize_api.py

@@ -9,7 +9,7 @@ from xobjects.test_helpers import for_all_test_contexts
 test_data_folder = pathlib.Path(
     __file__).parent.joinpath('../test_data').absolute()
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_ip_knob_matching_new_optimize_api(test_context):
 
     collider = xt.load(test_data_folder /
@@ -326,7 +326,7 @@ def test_ip_knob_matching_new_optimize_api(test_context):
     xo.assert_allclose(tw.lhcb1['px', 'ip8'], 120e-6, atol=1e-9, rtol=0)
     xo.assert_allclose(tw.lhcb2['px', 'ip8'], -120e-6, atol=1e-9, rtol=0)
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_match_ir8_optics_new_optimize_api(test_context):
 
     collider = xt.load(test_data_folder /

{xtrack-0.88.8 → xtrack-0.89.0}/tests/test_match_orbit_bump.py

@@ -601,7 +601,7 @@ def test_match_bump_sets_implicit_end(test_context):
     xo.assert_allclose(tw['y', 'mq.33l8.b1'], tw_before['y', 'mq.33l8.b1'], atol=1e-6)
     xo.assert_allclose(tw['py', 'mq.33l8.b1'], tw_before['py', 'mq.33l8.b1'], atol=1e-7)
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_match_bump_sets_init_end(test_context):
 
     line = xt.load(test_data_folder /
@@ -636,7 +636,7 @@ def test_match_bump_sets_init_end(test_context):
     xo.assert_allclose(tw['y', 'mq.33l8.b1'], tw_before['y', 'mq.33l8.b1'], atol=1e-6)
     xo.assert_allclose(tw['py', 'mq.33l8.b1'], tw_before['py', 'mq.33l8.b1'], atol=1e-7)
 
-@for_all_test_contexts
+@for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
 def test_match_bump_sets_init_middle(test_context):
 
     line = xt.load(test_data_folder /