xtrack 0.93.0__tar.gz → 0.93.2__tar.gz

{xtrack-0.93.0/xtrack.egg-info → xtrack-0.93.2}/PKG-INFO

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

{xtrack-0.93.0 → xtrack-0.93.2}/tests/test_boris_spatial.py

@@ -7,7 +7,7 @@ import xtrack as xt
 from xtrack._temp.boris_and_solenoid_map.solenoid_field import SolenoidField
 
 
-def test_boris_spatial():
+def test_boris_spatial_solenoid_map():
     delta=np.array([0, 4])
     p0 = xt.Particles(mass0=xt.ELECTRON_MASS_EV, q0=1,
                     energy0=45.6e9/1000,
@@ -114,4 +114,49 @@ def test_boris_spatial():
         xo.assert_allclose(ax_ref[i_part, :], mon.ax[i_part, :],
                         rtol=0, atol=np.max(np.abs(ax_ref)*3e-2))
         xo.assert_allclose(ay_ref[i_part, :], mon.ay[i_part, :],
-                        rtol=0, atol=np.max(np.abs(ay_ref)*3e-2))
+                        rtol=0, atol=np.max(np.abs(ay_ref)*3e-2))
+
+def test_boris_spatial_drift():
+    def zero_field(x, y, z):
+        return (0*x, 0*y, 0*z)
+
+    integrator = xt.BorisSpatialIntegrator(fieldmap_callable=zero_field,
+                                            s_start=10,
+                                            s_end=20,
+                                            n_steps=15000)
+
+    drift = xt.Drift(length=10, model='exact')
+
+    p0 = xt.Particles('proton',
+            x=[1e-2, -1e-2], px=[15e-3, 0], delta=[0, 2], p0c=1e9, zeta=1)
+
+    p_integ = p0.copy()
+    integrator.track(p_integ)
+
+    p_drift = p0.copy()
+    drift.track(p_drift)
+
+    xo.assert_allclose(p_integ.x, p_drift.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.px, p_drift.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.y, p_drift.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.py, p_drift.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.s, p_drift.s, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.delta, p_drift.delta, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.zeta, p_drift.zeta, rtol=0, atol=1e-10)
+
+    # Check behavior with lost particles
+    p0 = xt.Particles('proton',
+            x=[1e-2, -1e-2], px=[15e-3, 0], delta=[0, 2], p0c=1e9, zeta=1,
+            state=[1, -1])
+
+    p_integ = p0.copy()
+    integrator.track(p_integ)
+    p_drift = p0.copy()
+    drift.track(p_drift)
+
+    xo.assert_allclose(p_integ.x, p_drift.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.px, p_drift.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.y, p_drift.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.py, p_drift.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.s, p_drift.s, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_integ.delta, p_drift.delta, rtol=0, atol=1e-10)

{xtrack-0.93.0 → xtrack-0.93.2}/tests/test_madnginterface.py

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

{xtrack-0.93.0 → xtrack-0.93.2}/tests/test_survey.py

@@ -492,5 +492,110 @@ def test_survey_against_madx():
 
     xo.assert_allclose(sv.s[1:], sv_mad.s, atol=1e-14, rtol=0)
 
+    xo.assert_allclose(p[:, 0], 1e-3, atol=1e-14)
+    xo.assert_allclose(p[:, 1], 2e-3, atol=1e-14)
+
+def test_survey_transforms_native_loader():
+
+    from cpymad.madx import Madx
+
+    seq_src = ("""
+
+        on_srot = 1;
+        pi = 3.14159265358979323846;
+
+        tr1: translation, dx=1e-2, dy=2e-2;
+
+        rs2: srotation, angle=-1.04*on_srot;
+
+        r3: yrotation, angle=-0.1;
+        r4: yrotation, angle=0.1;
+
+        rx1 : xrotation, angle=0.1;
+        rx2 : xrotation, angle=-0.1;
+
+        bh1 : sbend, angle=0.1, k0=1e-22, l=0.1;
+        bh2 : sbend, angle=-0.1, k0=1e-22, l=0.1;
+
+        bv1: sbend, tilt=pi/2, angle=0.2, k0=1e-22, l=0.1;
+        bv2: sbend, tilt=pi/2, angle=-0.2, k0=1e-22, l=0.1;
+
+        ss: sequence,l=20;
+            tr1, at=5;
+            rs2, at=5.5;
+            rx1, at=6;
+            rx2, at=7;
+            r3, at=8;
+            r4, at=9;
+            bh1, at=10;
+            bh2, at=11;
+            bv1, at=12;
+            bv2, at=14;
+            end: marker, at=16;
+        endsequence;
+    """)
+
+    mad = Madx()
+    mad.input(seq_src)
+
+    mad.input("""
+        beam;
+        use,sequence=ss;
+        twiss,betx=1,bety=1,x=1e-3,y=2e-3;
+        survey;
+
+        ptc_create_universe;
+        ptc_create_layout, model=1, method=6, exact=True, NST=100;
+        ptc_align;
+        ptc_twiss, icase=56, betx=1., bety=1., betz=1,x=1e-3, y=2e-3;
+
+        """)
+
+    line = xt.load(string=seq_src, format='madx').ss
+    line.particle_ref = xt.Particles(p0c=1E9)
+
+    line['bh1'].k0_from_h = False
+    line['bh2'].k0_from_h = False
+    line['bh1'].k0 = 0
+    line['bh2'].k0 = 0
+
+    sv_mad = xt.Table(mad.table.survey)
+    tw_ptc = xt.Table(mad.table.ptc_twiss)
+
+    line.build_tracker()
+
+    line.tracker.track_flags.XS_FLAG_IGNORE_GLOBAL_APERTURE = True
+    line.configure_drift_model(model='exact')
+
+    sv = line.survey()
+    tw = line.twiss(betx=1, bety=1, x=1e-3, y=2e-3)
+
+    p = tw.x[:, None] * sv.ex + tw.y[:, None] * sv.ey + sv.p0
+    X = p[:, 0]
+    Y = p[:, 1]
+    Z = p[:, 2]
+
+    assert (tw.name == np.array(
+        ['drift_1', 'tr1', 'drift_2', 'rs2', 'drift_3', 'rx1', 'drift_4',
+        'rx2', 'drift_5', 'r3', 'drift_6', 'r4', 'drift_7', 'bh1',
+        'drift_8', 'bh2', 'drift_9', 'bv1', 'drift_10', 'bv2', 'drift_11',
+        'end', 'drift_12', '_end_point'], dtype=object)).all()
+
+    assert (tw_ptc.name == np.array(['ss$start:1', 'drift_0:0', 'tr1:1', 'drift_1:0', 'rs2:1',
+        'drift_2:0', 'rx1:1', 'drift_3:0', 'rx2:1', 'drift_4:0', 'r3:1',
+        'drift_5:0', 'r4:1', 'drift_6:0', 'bh1:1', 'drift_7:0', 'bh2:1',
+        'drift_8:0', 'bv1:1', 'drift_9:0', 'bv2:1', 'drift_10:0', 'end:1',
+        'drift_11:0', 'ss$end:1'], dtype=object)).all()
+
+    # MAD gives results at the end of the element
+    xo.assert_allclose(tw.x[1:], tw_ptc.x[1:-1], atol=1e-14, rtol=0)
+    xo.assert_allclose(tw.y[1:], tw_ptc.y[1:-1], atol=1e-14, rtol=0)
+
+    xo.assert_allclose(sv.X[1:], sv_mad.x[1:-1], atol=1e-14, rtol=0)
+    xo.assert_allclose(sv.Y[1:], sv_mad.y[1:-1], atol=1e-14, rtol=0)
+    xo.assert_allclose(sv.Z[1:], sv_mad.z[1:-1], atol=1e-14, rtol=0)
+
+    xo.assert_allclose(sv.s[1:], sv_mad.s[1:-1], atol=1e-14, rtol=0)
+
     xo.assert_allclose(p[:, 0], 1e-3, atol=1e-14)
     xo.assert_allclose(p[:, 1], 2e-3, atol=1e-14)

xtrack-0.93.2/xtrack/_version.py

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

{xtrack-0.93.0 → xtrack-0.93.2}/xtrack/boris.py

@@ -18,27 +18,34 @@ class BorisSpatialIntegrator:
 
     def track(self, p):
 
+        mask_alive = p.state > 0
+
         x_log = []
         y_log = []
         z_log = []
-        s_in = p.s.copy()
-        p.s=self.s_start
+        s_in = p.s[mask_alive].copy()
+        p.s[mask_alive] = self.s_start
 
         for ii in range(self.n_steps):
 
             if self.verbose:
                 print(f's_in = {s_in[0]:.3f} s_in_map = {p.s[0]:.3f}', end='\r', flush=True)
 
-            q0 = p.q0
-            x = p.x.copy()
-            y = p.y.copy()
-            z = p.s.copy()
-            px = p.px.copy()
-            py = p.py.copy()
-            delta = p.delta.copy()
-            p0c = p.p0c
-
-            charge0_coulomb = q0 * qe
+            x = p.x[mask_alive].copy()
+            y = p.y[mask_alive].copy()
+            z = p.s[mask_alive].copy()
+            px = p.px[mask_alive].copy()
+            py = p.py[mask_alive].copy()
+            delta = p.delta[mask_alive].copy()
+            energy = p.energy[mask_alive].copy()
+            p0c = p.p0c[mask_alive].copy()
+            beta0 = p.beta0[mask_alive].copy()
+            charge = p.charge[mask_alive].copy()
+            mass = p.mass[mask_alive].copy()
+
+            charge_coulomb = charge * qe
+            mass_kg = mass * qe / clight**2
+            gamma = energy / mass
 
             P0 = p0c * qe / clight # in kg m/s
             P = P0 * (1 + delta)
@@ -51,19 +58,20 @@ class BorisSpatialIntegrator:
             w[:, 1] = Py
             w[:, 2] = P
 
-            x_new, y_new, z_new, w_new = step_spatial_boris_B(x, y, z, w,
-                charge0_coulomb, self.ds,
-                field_fn=self.fieldmap_callable)
-            p.x = x_new.copy()
-            p.y = y_new.copy()
-            p.s = z_new.copy()
-            p.px = w_new[:, 0] / P0
-            p.py = w_new[:, 1] / P0
+            x_new, y_new, z_new, w_new, dt = step_spatial_boris_B(x, y, z, w,
+                charge_coulomb, self.ds,
+                field_fn=self.fieldmap_callable, m_kg=mass_kg, gamma=gamma)
+            p.x[mask_alive] = x_new
+            p.y[mask_alive] = y_new
+            p.s[mask_alive] = z_new
+            p.px[mask_alive] = w_new[:, 0] / P0
+            p.py[mask_alive] = w_new[:, 1] / P0
+            p.zeta[mask_alive] += (self.ds - dt * clight * beta0)
 
             x_log.append(p.x.copy())
             y_log.append(p.y.copy())
             z_log.append(p.s.copy())
-        p.s = s_in + self.length
+        p.s[mask_alive] = s_in + self.length
         self.x_log = np.array(x_log)
         self.y_log = np.array(y_log)
         self.z_log = np.array(z_log)
@@ -72,7 +80,7 @@ class BorisSpatialIntegrator:
 import numpy as np
 c = 299_792_458.0  # m/s
 
-def step_spatial_boris_B(x, y, z, w, q, dz, field_fn):
+def step_spatial_boris_B(x, y, z, w, q, dz, field_fn, m_kg, gamma):
     """
     Spatial Boris step for magnetic fields only (E = 0),
     using constant total momentum magnitude P = w[:,2].
@@ -99,6 +107,8 @@ def step_spatial_boris_B(x, y, z, w, q, dz, field_fn):
         Updated momentum state (px, py, P).
     """
 
+    dt = 0.
+
     # --- Unpack and ensure arrays
     x = np.asarray(x)
     y = np.asarray(y)
@@ -113,6 +123,7 @@ def step_spatial_boris_B(x, y, z, w, q, dz, field_fn):
     xh = x + (px / pz) * (dz * 0.5)
     yh = y + (py / pz) * (dz * 0.5)
     zh = z + dz * 0.5
+    dt += (dz * 0.5) / pz * gamma * m_kg #  s
 
     # --- Evaluate magnetic field at mid-step
     Bx, By, Bz = field_fn(xh, yh, zh)
@@ -154,8 +165,9 @@ def step_spatial_boris_B(x, y, z, w, q, dz, field_fn):
     x1 = xh + (px1 / pz1) * (dz * 0.5)
     y1 = yh + (py1 / pz1) * (dz * 0.5)
     z1 = z + dz
+    dt += (dz * 0.5) / pz1 * gamma * m_kg #  s
 
     # --- Pack updated (px, py, P)
     w1 = np.stack([px1, py1, P], axis=1)
 
-    return x1, y1, z1, w1
+    return x1, y1, z1, w1, dt

{xtrack-0.93.0 → xtrack-0.93.2}/xtrack/mad_parser/loader.py

@@ -137,6 +137,10 @@ class MadxLoader:
         self._new_builtin("multipole", "Multipole", knl=6 * [0])
         self._new_builtin("solenoid", "UniformSolenoid")
         self._new_builtin("crabcavity", "CrabCavity")
+        self._new_builtin("xrotation", "XRotation")
+        self._new_builtin("yrotation", "YRotation")
+        self._new_builtin("srotation", "SRotation")
+        self._new_builtin("translation", "XYShift")
 
         for mad_apertype in _APERTURE_TYPES:
             self._new_builtin(mad_apertype, 'Marker')
@@ -466,6 +470,13 @@ class MadxLoader:
         elif parent_name == 'marker':
             params.pop('isthick', None)
             params.pop('length', None)
+        elif parent_name in {'srotation', 'xrotation', 'yrotation'}:
+            if (angle := params.pop('angle', None)):
+                params['angle'] = (angle * 180) / np.pi
+        elif parent_name == 'translation':
+            if (ds := params.pop('ds', None)):
+                raise NotImplementedError('`ds` parameter not supported yet for '
+                                          '`translation` elements.')
 
         if 'edge_entry_fint' in params and 'edge_exit_fint' not in params:
             params['edge_exit_fint'] = params['edge_entry_fint']