xtrack 0.70.3__tar.gz → 0.72.0__tar.gz

{xtrack-0.70.3/xtrack.egg-info → xtrack-0.72.0}/PKG-INFO

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

{xtrack-0.70.3 → xtrack-0.72.0}/tests/test_elements_thick.py

@@ -1209,6 +1209,237 @@ def test_solenoid_shifted_and_rotated_multipolar_kick(test_context):
     xo.assert_allclose(p_test.delta, p_ref.delta, rtol=0, atol=1e-16)
 
 
+@pytest.mark.parametrize('shift_x', (0, 1e-3))
+@pytest.mark.parametrize('shift_y', (0, 1e-3))
+@pytest.mark.parametrize('test_element_name', ('Bend', 'Quadrupole', 'Sextupole'))
+def test_solenoid_multipole_shifts(shift_x, shift_y, test_element_name):
+    ################################################################################
+    # User Parameters
+    ################################################################################
+    N_SLICES = int(1E3)
+
+    BETX = 100E-3
+    BETY = 1E-3
+    PX0 = 0
+
+    KS = 0.00
+    K0 = 1E-3
+    K1 = 1E-3
+    K2 = 1E-3
+
+    ################################################################################
+    # Build Test Elements
+    ################################################################################
+    drift0 = xt.Drift(length=1)
+    drift1 = xt.Drift(length=1)
+
+    bend = xt.Bend(length=1, k0=K0)
+    quad = xt.Quadrupole(length=1, k1=K1)
+    sext = xt.Sextupole(length=1, k2=K2)
+
+    bend_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS,
+                           knl=[K0 * (1 / N_SLICES), 0, 0], num_multipole_kicks=1)
+    quad_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS,
+                           knl=[0, K1 * (1 / N_SLICES), 0], num_multipole_kicks=1)
+    sext_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS,
+                           knl=[0, 0, K2 * (1 / N_SLICES)], num_multipole_kicks=1)
+
+    ################################################################################
+    # Comparisons
+    ################################################################################
+    test_element, test_sol = {
+        'Bend': (bend, bend_sol),
+        'Quadrupole': (quad, quad_sol),
+        'Sextupole': (sext, sext_sol),
+    }[test_element_name]
+
+    ########################################
+    # Build Lines
+    ########################################
+    line = xt.Line(
+        elements=[drift0] + [test_element] + [drift0],
+        particle_ref=xt.Particles(p0c=1E9, mass0=xt.ELECTRON_MASS_EV))
+    line.configure_bend_model(edge='suppressed')
+
+    sol_line = xt.Line(
+        elements=[drift1] + [test_sol] * N_SLICES + [drift1],
+        particle_ref=xt.Particles(p0c=1E9, mass0=xt.ELECTRON_MASS_EV))
+
+    # Slice test line
+    line.slice_thick_elements(
+        slicing_strategies=[
+            xt.Strategy(slicing=xt.Uniform(N_SLICES, mode='thin'), element_type=xt.Bend),
+            xt.Strategy(slicing=xt.Uniform(N_SLICES, mode='thin'), element_type=xt.Quadrupole),
+            xt.Strategy(slicing=xt.Uniform(N_SLICES, mode='thin'), element_type=xt.Sextupole)])
+
+    ########################################
+    # Test and plot with shifts
+    ########################################
+    test_element.shift_x = shift_x
+    test_element.shift_y = shift_y
+    test_sol.mult_shift_x = shift_x
+    test_sol.mult_shift_y = shift_y
+
+    tw = line.twiss(
+        _continue_if_lost=True,
+        start=xt.START,
+        end=xt.END,
+        betx=BETX,
+        bety=BETY,
+        px=PX0)
+    tw_sol = sol_line.twiss(
+        _continue_if_lost=True,
+        start=xt.START,
+        end=xt.END,
+        betx=BETX,
+        bety=BETY,
+        px=PX0)
+
+    ########################################
+    # Assertions
+    ########################################
+    assert np.isclose(tw.x[-1], tw_sol.x[-1], rtol=1E-6)
+    assert np.isclose(tw.y[-1], tw_sol.y[-1], rtol=1E-6)
+
+
+def test_solenoid_multipole_rotations():
+    N_SLICES = int(1E2)
+    K0 = 1E-3
+    L_SOL = 1
+    XING_RAD = 1E-3
+
+    BETX = 100E-3
+    BETY = 1E-3
+
+    ########################################
+    # Build Environment
+    ########################################
+    env = xt.Environment(particle_ref=xt.Particles(p0c=1E9))
+
+    ########################################
+    # Line (beamline frame)
+    ########################################
+    bl_components_in = [env.new('bl_drift0', xt.Drift, length=1)]
+    bl_components_out = [env.new('bl_drift1', xt.Drift, length=1)]
+
+    bl_components_sol = [
+        env.new(f'bl_sol.{i}', xt.Solenoid,
+                length=(L_SOL / N_SLICES),
+                ks=0,
+                knl=[K0 * (L_SOL / N_SLICES), 0, 0],
+                num_multipole_kicks=1)
+        for i in range(N_SLICES)]
+
+    bl_line = env.new_line(
+        components=bl_components_in + bl_components_sol + bl_components_out)
+
+    ########################################
+    # Line (horizontal rotated frame)
+    ########################################
+    hrot_components_in = [
+        env.new('hrot_drift0', xt.Drift, length=1),
+        env.new('hshift_in', xt.XYShift, dx=np.sin(XING_RAD) * L_SOL / 2),
+        env.new('hrot_in', xt.YRotation, angle=-np.rad2deg(XING_RAD))]
+
+    hrot_components_out = [
+        env.new('hrot_out', xt.YRotation, angle=np.rad2deg(XING_RAD)),
+        env.new('hshift_out', xt.XYShift, dx=np.sin(XING_RAD) * L_SOL / 2),
+        env.new('hrot_drift1', xt.Drift, length=1)]
+
+    hrot_components_sol = [
+        env.new(f'hrot_sol.{i}', xt.Solenoid,
+                length=(L_SOL / N_SLICES) * np.cos(XING_RAD),
+                ks=0,
+                knl=[K0 * (L_SOL / N_SLICES), 0, 0],
+                num_multipole_kicks=1,
+                mult_rot_y_rad=XING_RAD,
+                mult_shift_x=np.sin(XING_RAD) * L_SOL * (i / N_SLICES - 1 / 2))
+        for i in range(N_SLICES)]
+
+    hrot_line = env.new_line(
+        components=hrot_components_in + hrot_components_sol + hrot_components_out)
+
+    ########################################
+    # Line (vertical rotated frame)
+    ########################################
+    vrot_components_in = [
+        env.new('vrot_drift0', xt.Drift, length=1),
+        env.new('vshift_in', xt.XYShift, dy=np.sin(XING_RAD) * L_SOL / 2),
+        env.new('vrot_in', xt.XRotation, angle=np.rad2deg(XING_RAD))]
+    # TODO: Minus sign difference here as still inconsistent definition with XRotation and YRotation
+    vrot_components_out = [
+        env.new('vrot_out', xt.XRotation, angle=-np.rad2deg(XING_RAD)),
+        env.new('vshift_out', xt.XYShift, dy=np.sin(XING_RAD) * L_SOL / 2),
+        env.new('vrot_drift1', xt.Drift, length=1)]
+
+    vrot_components_sol = [
+        env.new(f'vrot_sol.{i}', xt.Solenoid,
+                length=(L_SOL / N_SLICES) * np.cos(XING_RAD),
+                ks=0,
+                knl=[K0 * (L_SOL / N_SLICES), 0, 0],
+                num_multipole_kicks=1,
+                mult_rot_x_rad=XING_RAD,
+                mult_shift_y=np.sin(XING_RAD) * L_SOL * (i / N_SLICES - 1 / 2))
+        for i in range(N_SLICES)]
+
+    vrot_line = env.new_line(
+        components=vrot_components_in + vrot_components_sol + vrot_components_out)
+
+    ################################################################################
+    # Comparisons
+    ################################################################################
+    bl_twiss = bl_line.twiss(
+        method='4d',
+        start=xt.START,
+        end=xt.END,
+        betx=BETX,
+        bety=BETY)
+
+    hrot_twiss = hrot_line.twiss(
+        method='4d',
+        start=xt.START,
+        end=xt.END,
+        betx=BETX,
+        bety=BETY)
+
+    vrot_twiss = vrot_line.twiss(
+        method='4d',
+        start=xt.START,
+        end=xt.END,
+        betx=BETX,
+        bety=BETY)
+
+    ################################################################################
+    # Test Assertions
+    ################################################################################
+    # Tolerances lower for derivative quantities (alfx, alfy, dpx, dpy)
+    assert np.isclose(bl_twiss['x'][-1], hrot_twiss['x'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['y'][-1], hrot_twiss['y'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['betx'][-1], hrot_twiss['betx'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['bety'][-1], hrot_twiss['bety'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['alfx'][-1], hrot_twiss['alfx'][-1], rtol=1E-4)
+    assert np.isclose(bl_twiss['alfy'][-1], hrot_twiss['alfy'][-1], rtol=1E-4)
+    assert np.isclose(bl_twiss['dx'][-1], hrot_twiss['dx'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['dy'][-1], hrot_twiss['dy'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['dpx'][-1], hrot_twiss['dpx'][-1], rtol=1E-4)
+    assert np.isclose(bl_twiss['dpy'][-1], hrot_twiss['dpy'][-1], rtol=1E-4)
+    assert np.isclose(bl_twiss['mux'][-1], hrot_twiss['mux'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['muy'][-1], hrot_twiss['muy'][-1], rtol=1E-6)
+
+    assert np.isclose(bl_twiss['x'][-1], vrot_twiss['x'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['y'][-1], vrot_twiss['y'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['betx'][-1], vrot_twiss['betx'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['bety'][-1], vrot_twiss['bety'][-1], rtol=1E-4)
+    assert np.isclose(bl_twiss['alfx'][-1], vrot_twiss['alfx'][-1], rtol=1E-4)
+    assert np.isclose(bl_twiss['alfy'][-1], vrot_twiss['alfy'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['dx'][-1], vrot_twiss['dx'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['dy'][-1], vrot_twiss['dy'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['dpx'][-1], vrot_twiss['dpx'][-1], rtol=1E-4)
+    assert np.isclose(bl_twiss['dpy'][-1], vrot_twiss['dpy'][-1], rtol=1E-4)
+    assert np.isclose(bl_twiss['mux'][-1], vrot_twiss['mux'][-1], rtol=1E-6)
+    assert np.isclose(bl_twiss['muy'][-1], vrot_twiss['muy'][-1], rtol=1E-6)
+
+
 @pytest.mark.parametrize(
     'radiation_mode,config',
     [

{xtrack-0.70.3 → xtrack-0.72.0}/tests/test_madnginterface.py

@@ -7,9 +7,9 @@ import numpy as np
 test_data_folder = pathlib.Path(
     __file__).parent.joinpath('../test_data').absolute()
 
-@pytest.mark.xfail(strict=False) # sometimes madng fails to start the process (to be investigated)
+# @pytest.mark.xfail(strict=False) # sometimes madng fails to start the process (to be investigated)
 def test_madng_twiss():
-    rdts = ["f4000", "f3100", "f2020", "f1120", 'f1001']
+    rdts = ["f4000", "f3100", "f2020", "f1120"]
 
     line = xt.Line.from_json(test_data_folder /
                             'hllhc15_thick/lhc_thick_with_knobs.json')
@@ -46,7 +46,7 @@ def test_madng_twiss():
     assert np.abs(tw_rdt.f2020).max() > 0
     assert np.abs(tw_rdt.f1120).max() > 0
 
-@pytest.mark.xfail(strict=False) # sometimes madng fails to start the process (to be investigated)
+# @pytest.mark.xfail(strict=False) # sometimes madng fails to start the process (to be investigated)
 def test_madng_interface_with_multipole_errors_and_misalignments():
     line = xt.Line.from_json(test_data_folder /
                             'hllhc15_thick/lhc_thick_with_knobs.json')
@@ -56,7 +56,7 @@ def test_madng_interface_with_multipole_errors_and_misalignments():
 
     # Introduce misalignments on all quadrupoles
     tt = line.get_table()
-    tt_quad = tt.rows['mq\..*']
+    tt_quad = tt.rows[r'mq\..*']
     rgen = np.random.RandomState(1) # fix seed for random number generator
                                     # (to have reproducible results)
     shift_x = rgen.randn(len(tt_quad)) * 0.01e-3 # 0.01 mm rms shift on all quads

{xtrack-0.70.3 → xtrack-0.72.0}/tests/test_slicing.py

@@ -459,3 +459,125 @@ def test_slicing_xdeps_consistency():
     )
     line.slice_thick_elements([sgy])
     assert len(line.to_dict()['_var_manager']) == num_elements * num_slices
+
+def test_slice_twice():
+    env = xt.Environment()
+    line = env.new_line(components=[
+        env.new('el', xt.Bend, length=4, k1=0.5, h=0.1, k0=0.8, knl=[0, 0, 0.03]),
+    ])
+
+    line.slice_thick_elements(
+        slicing_strategies=[
+            xt.Strategy(slicing=xt.Teapot(4, mode='thick'), element_type=xt.Bend),
+        ])
+
+    tt_first_slice = line.get_table(attr=True)
+
+    line.slice_thick_elements(
+        slicing_strategies=[
+            xt.Strategy(slicing=xt.Teapot(4, mode='thin'), element_type=xt.ThickSliceBend),
+        ])
+
+    tt_second_slice = line.get_table(attr=True)
+
+    assert np.all(tt_first_slice.name == np.array(
+        ['el_entry', 'el..entry_map', 'el..0', 'el..1', 'el..2', 'el..3',
+        'el..exit_map', 'el_exit', '_end_point']))
+
+    assert np.all(tt_first_slice.element_type == np.array(
+        ['Marker', 'ThinSliceBendEntry', 'ThickSliceBend', 'ThickSliceBend',
+        'ThickSliceBend', 'ThickSliceBend', 'ThinSliceBendExit', 'Marker',
+        '']))
+
+    # Check first table
+
+    xo.assert_allclose(tt_first_slice.angle_rad, np.array(
+        [0.  , 0.  , 0.05, 0.15, 0.15, 0.05, 0.  , 0.  , 0.  ]), rtol=0, atol=1e-12)
+    xo.assert_allclose(np.sum(tt_first_slice.angle_rad), 0.4, rtol=0, atol=1e-12)
+
+    xo.assert_allclose(tt_first_slice.k0l, np.array(
+        [0. , 0. , 0.4, 1.2, 1.2, 0.4, 0. , 0. , 0. ]), rtol=0, atol=1e-12)
+    xo.assert_allclose(np.sum(tt_first_slice.k0l), 3.2, rtol=0, atol=1e-12)
+
+    xo.assert_allclose(tt_first_slice.k1l, np.array(
+        [0.  , 0.  , 0.25, 0.75, 0.75, 0.25, 0.  , 0.  , 0.  ]), rtol=0, atol=1e-12)
+    xo.assert_allclose(np.sum(tt_first_slice.k1l), 2, rtol=0, atol=1e-12)
+
+    xo.assert_allclose(tt_first_slice.k2l, np.array(
+        [0.     , 0.     , 0.00375, 0.01125, 0.01125, 0.00375, 0. , 0., 0.]),
+        rtol=0, atol=1e-12)
+    xo.assert_allclose(np.sum(tt_first_slice.k2l), 0.03, rtol=0, atol=1e-12)
+
+    # Check second table
+
+    assert np.all(tt_second_slice.name == np.array(
+        ['el_entry', 'el..entry_map', 'el..0_entry', 'drift_el..0..0',
+        'el..0..0', 'drift_el..0..1', 'el..0..1', 'drift_el..0..2',
+        'el..0..2', 'drift_el..0..3', 'el..0..3', 'drift_el..0..4',
+        'el..0_exit', 'el..1_entry', 'drift_el..1..0', 'el..1..0',
+        'drift_el..1..1', 'el..1..1', 'drift_el..1..2', 'el..1..2',
+        'drift_el..1..3', 'el..1..3', 'drift_el..1..4', 'el..1_exit',
+        'el..2_entry', 'drift_el..2..0', 'el..2..0', 'drift_el..2..1',
+        'el..2..1', 'drift_el..2..2', 'el..2..2', 'drift_el..2..3',
+        'el..2..3', 'drift_el..2..4', 'el..2_exit', 'el..3_entry',
+        'drift_el..3..0', 'el..3..0', 'drift_el..3..1', 'el..3..1',
+        'drift_el..3..2', 'el..3..2', 'drift_el..3..3', 'el..3..3',
+        'drift_el..3..4', 'el..3_exit', 'el..exit_map', 'el_exit',
+        '_end_point']))
+
+    assert np.all(tt_second_slice.element_type == np.array(
+        ['Marker', 'ThinSliceBendEntry', 'Marker', 'DriftSliceBend',
+        'ThinSliceBend', 'DriftSliceBend', 'ThinSliceBend',
+        'DriftSliceBend', 'ThinSliceBend', 'DriftSliceBend',
+        'ThinSliceBend', 'DriftSliceBend', 'Marker', 'Marker',
+        'DriftSliceBend', 'ThinSliceBend', 'DriftSliceBend',
+        'ThinSliceBend', 'DriftSliceBend', 'ThinSliceBend',
+        'DriftSliceBend', 'ThinSliceBend', 'DriftSliceBend', 'Marker',
+        'Marker', 'DriftSliceBend', 'ThinSliceBend', 'DriftSliceBend',
+        'ThinSliceBend', 'DriftSliceBend', 'ThinSliceBend',
+        'DriftSliceBend', 'ThinSliceBend', 'DriftSliceBend', 'Marker',
+        'Marker', 'DriftSliceBend', 'ThinSliceBend', 'DriftSliceBend',
+        'ThinSliceBend', 'DriftSliceBend', 'ThinSliceBend',
+        'DriftSliceBend', 'ThinSliceBend', 'DriftSliceBend', 'Marker',
+        'ThinSliceBendExit', 'Marker', ''
+        ]))
+
+    xo.assert_allclose(tt_second_slice.angle_rad, np.array(
+        [0.    , 0.    , 0.    , 0.    , 0.0125, 0.    , 0.0125, 0.    ,
+            0.0125, 0.    , 0.0125, 0.    , 0.    , 0.    , 0.    , 0.0375,
+            0.    , 0.0375, 0.    , 0.0375, 0.    , 0.0375, 0.    , 0.    ,
+            0.    , 0.    , 0.0375, 0.    , 0.0375, 0.    , 0.0375, 0.    ,
+            0.0375, 0.    , 0.    , 0.    , 0.    , 0.0125, 0.    , 0.0125,
+            0.    , 0.0125, 0.    , 0.0125, 0.    , 0.    , 0.    , 0.    ,
+            0.    ]), rtol=0, atol=1e-12)
+    xo.assert_allclose(np.sum(tt_second_slice.angle_rad), 0.4, rtol=0, atol=1e-12)
+
+    xo.assert_allclose(tt_second_slice.k0l, np.array(
+        [0. , 0. , 0. , 0. , 0.1, 0. , 0.1, 0. , 0.1, 0. , 0.1, 0. , 0. ,
+        0. , 0. , 0.3, 0. , 0.3, 0. , 0.3, 0. , 0.3, 0. , 0. , 0. , 0. ,
+        0.3, 0. , 0.3, 0. , 0.3, 0. , 0.3, 0. , 0. , 0. , 0. , 0.1, 0. ,
+        0.1, 0. , 0.1, 0. , 0.1, 0. , 0. , 0. , 0. , 0. ]), rtol=0, atol=1e-12)
+    xo.assert_allclose(np.sum(tt_second_slice.k0l), 3.2, rtol=0, atol=1e-12)
+
+    xo.assert_allclose(tt_second_slice.k1l, np.array(
+        [0.    , 0.    , 0.    , 0.    , 0.0625, 0.    , 0.0625, 0.    ,
+        0.0625, 0.    , 0.0625, 0.    , 0.    , 0.    , 0.    , 0.1875,
+        0.    , 0.1875, 0.    , 0.1875, 0.    , 0.1875, 0.    , 0.    ,
+        0.    , 0.    , 0.1875, 0.    , 0.1875, 0.    , 0.1875, 0.    ,
+        0.1875, 0.    , 0.    , 0.    , 0.    , 0.0625, 0.    , 0.0625,
+        0.    , 0.0625, 0.    , 0.0625, 0.    , 0.    , 0.    , 0.    ,
+        0.    ]), rtol=0, atol=1e-12)
+    xo.assert_allclose(np.sum(tt_second_slice.k1l), 2, rtol=0, atol=1e-12)
+
+    xo.assert_allclose(tt_second_slice.k2l, np.array(
+        [0.       , 0.       , 0.       , 0.       , 0.0009375, 0.       ,
+        0.0009375, 0.       , 0.0009375, 0.       , 0.0009375, 0.       ,
+        0.       , 0.       , 0.       , 0.0028125, 0.       , 0.0028125,
+        0.       , 0.0028125, 0.       , 0.0028125, 0.       , 0.       ,
+        0.       , 0.       , 0.0028125, 0.       , 0.0028125, 0.       ,
+        0.0028125, 0.       , 0.0028125, 0.       , 0.       , 0.       ,
+        0.       , 0.0009375, 0.       , 0.0009375, 0.       , 0.0009375,
+        0.       , 0.0009375, 0.       , 0.       , 0.       , 0.       ,
+        0.       ]),
+        rtol=0, atol=1e-12)
+    xo.assert_allclose(np.sum(tt_second_slice.k2l), 0.03, rtol=0, atol=1e-12)

{xtrack-0.70.3 → xtrack-0.72.0}/xtrack/__init__.py

@@ -45,6 +45,7 @@ from .slicing import Strategy, Uniform, Teapot
 from .loss_location_refinement import _skip_in_loss_location_refinement
 from .trajectory_correction import TrajectoryCorrection
 from .mad_parser.loader import load_madx_lattice
+from . import json
 
 from xdeps import Table, FunctionPieceWiseLinear
 

xtrack-0.72.0/xtrack/_version.py

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

{xtrack-0.70.3 → xtrack-0.72.0}/xtrack/beam_elements/elements.py

@@ -1293,8 +1293,11 @@ class Solenoid(BeamElement):
         'inv_factorial_order': xo.Float64,
         'knl': xo.Float64[ALLOCATED_MULTIPOLE_ORDER + 1],
         'ksl': xo.Float64[ALLOCATED_MULTIPOLE_ORDER + 1],
+        'mult_rot_x_rad': xo.Float64,
         'mult_rot_y_rad': xo.Float64,
         'mult_shift_x': xo.Float64,
+        'mult_shift_y': xo.Float64,
+        'mult_shift_s': xo.Float64,
     }
 
     _skip_in_to_dict = ['_order', 'inv_factorial_order']  # defined by knl, etc.
@@ -1307,7 +1310,9 @@ class Solenoid(BeamElement):
         _pkg_root.joinpath('headers/synrad_spectrum.h'),
         _pkg_root.joinpath('beam_elements/elements_src/drift.h'),
         _pkg_root.joinpath('beam_elements/elements_src/track_multipolar_components.h'),
+        _pkg_root.joinpath('beam_elements/elements_src/track_xrotation.h'),
         _pkg_root.joinpath('beam_elements/elements_src/track_yrotation.h'),
+        _pkg_root.joinpath('beam_elements/elements_src/track_srotation.h'),
         _pkg_root.joinpath('beam_elements/elements_src/track_solenoid.h'),
         _pkg_root.joinpath('beam_elements/elements_src/solenoid.h'),
     ]

{xtrack-0.70.3 → xtrack-0.72.0}/xtrack/beam_elements/elements_src/solenoid.h

@@ -37,18 +37,33 @@ void Solenoid_track_local_particle(SolenoidData el, LocalParticle* part0) {
     const double slice_length = length / (num_multipole_kicks + 1);
     const double kick_weight = 1. / num_multipole_kicks;
 
+    double mult_rot_x_rad = SolenoidData_get_mult_rot_x_rad(el);
     double mult_rot_y_rad = SolenoidData_get_mult_rot_y_rad(el);
     double mult_shift_x = SolenoidData_get_mult_shift_x(el);
-    double sin_angle, cos_angle, tan_angle;
+    double mult_shift_y = SolenoidData_get_mult_shift_y(el);
+    double mult_shift_s = SolenoidData_get_mult_shift_s(el);
+    
+    double sin_x_rot, cos_x_rot, tan_x_rot;
+    double sin_y_rot, cos_y_rot, tan_y_rot;
+    if (mult_rot_x_rad != 0) {
+        sin_x_rot = sin(mult_rot_x_rad);
+        cos_x_rot = cos(mult_rot_x_rad);
+        tan_x_rot = sin_x_rot / cos_x_rot;
+    }
+    else {
+        sin_x_rot = 0;
+        cos_x_rot = 1;
+        tan_x_rot = 0;
+    }
     if (mult_rot_y_rad != 0) {
-        sin_angle = sin(mult_rot_y_rad);
-        cos_angle = cos(mult_rot_y_rad);
-        tan_angle = sin_angle / cos_angle;
+        sin_y_rot = sin(mult_rot_y_rad);
+        cos_y_rot = cos(mult_rot_y_rad);
+        tan_y_rot = sin_y_rot / cos_y_rot;
     }
     else {
-        sin_angle = 0;
-        cos_angle = 1;
-        tan_angle = 0;
+        sin_y_rot = 0;
+        cos_y_rot = 1;
+        tan_y_rot = 0;
     }
 
 
@@ -65,17 +80,27 @@ void Solenoid_track_local_particle(SolenoidData el, LocalParticle* part0) {
         Solenoid_thick_track_single_particle(part, slice_length, ks, radiation_flag);
 
         LocalParticle_add_to_x(part, -mult_shift_x);
-        if (sin_angle != 0) {
-            YRotation_single_particle(part, sin_angle, cos_angle, tan_angle);
+        LocalParticle_add_to_y(part, -mult_shift_y);
+        LocalParticle_add_to_s(part, -mult_shift_s);
+        if (sin_x_rot != 0) {
+            XRotation_single_particle(part, sin_x_rot, cos_x_rot, tan_x_rot);
+        }
+        if (sin_y_rot != 0) {
+            YRotation_single_particle(part, sin_y_rot, cos_y_rot, tan_y_rot);
         }
 
         track_multipolar_kick_bend(
                     part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
                     kick_weight, 0, 0, 0, 0);
 
-        if (sin_angle != 0) {
-            YRotation_single_particle(part, -sin_angle, cos_angle, -tan_angle);
+        if (sin_y_rot != 0) {
+            YRotation_single_particle(part, -sin_y_rot, cos_y_rot, -tan_y_rot);
+        }
+        if (sin_x_rot != 0) {
+            XRotation_single_particle(part, -sin_x_rot, cos_x_rot, -tan_x_rot);
         }
+        LocalParticle_add_to_s(part, mult_shift_s);
+        LocalParticle_add_to_y(part, mult_shift_y);
         LocalParticle_add_to_x(part, mult_shift_x);
     }
 

xtrack-0.70.3/xtrack/json_utils.py → xtrack-0.72.0/xtrack/json.py

@@ -5,7 +5,7 @@ import gzip
 from xobjects import JEncoder
 
 
-def to_json(data, file, indent):
+def dump(data, file, indent=1):
     if isinstance(file, io.IOBase):
         fh, close = file, False
     elif (isinstance(file, str) and file.endswith(".gz")) or (
@@ -21,7 +21,7 @@ def to_json(data, file, indent):
         fh.close()
 
 
-def from_json(file):
+def load(file):
     if isinstance(file, io.IOBase):
         fh, close = file, False
     elif (isinstance(file, str) and file.endswith(".gz")) or (

{xtrack-0.70.3 → xtrack-0.72.0}/xtrack/line.py

@@ -19,7 +19,7 @@ import numpy as np
 from scipy.constants import c as clight
 
 from . import linear_normal_form as lnf
-from . import json_utils
+from . import json as json_utils
 
 import xobjects as xo
 import xtrack as xt
@@ -57,9 +57,10 @@ log = logging.getLogger(__name__)
 
 
 _ALLOWED_ELEMENT_TYPES_IN_NEW = [xt.Drift, xt.Bend, xt.Quadrupole, xt.Sextupole,
-                              xt.Octupole, xt.Cavity, xt.Multipole, xt.Solenoid,
-                              xt.Marker, xt.Replica, xt.LimitRacetrack, xt.LimitRectEllipse,
-                              xt.LimitRect, xt.LimitEllipse]
+                                 xt.Octupole, xt.Cavity, xt.Multipole, xt.Solenoid,
+                                 xt.Marker, xt.Replica, xt.XYShift, xt.XRotation,
+                                 xt.YRotation, xt.SRotation, xt.LimitRacetrack,
+                                 xt.LimitRectEllipse, xt.LimitRect, xt.LimitEllipse]
 
 _ALLOWED_ELEMENT_TYPES_DICT = {'Drift': xt.Drift, 'Bend': xt.Bend,
                                'Quadrupole': xt.Quadrupole, 'Sextupole': xt.Sextupole,
@@ -68,7 +69,9 @@ _ALLOWED_ELEMENT_TYPES_DICT = {'Drift': xt.Drift, 'Bend': xt.Bend,
                                'Marker': xt.Marker, 'Replica': xt.Replica,
                                'LimitRacetrack': xt.LimitRacetrack,
                                'LimitRectEllipse': xt.LimitRectEllipse,
-                               'LimitRect': xt.LimitRect, 'LimitEllipse': xt.LimitEllipse}
+                               'LimitRect': xt.LimitRect, 'LimitEllipse': xt.LimitEllipse,
+                               'XYShift': xt.XYShift, 'XRotation': xt.XRotation,
+                               'YRotation': xt.YRotation, 'SRotation': xt.SRotation}
 
 _STR_ALLOWED_ELEMENT_TYPES_IN_NEW = ', '.join([tt.__name__ for tt in _ALLOWED_ELEMENT_TYPES_IN_NEW])
 
@@ -272,7 +275,7 @@ class Line:
 
         """
 
-        dct = json_utils.from_json(file)
+        dct = json_utils.load(file)
 
         if 'line' in dct.keys():
             dct_line = dct['line']
@@ -649,7 +652,7 @@ class Line:
 
         '''
 
-        json_utils.to_json(self.to_dict(**kwargs), file, indent=indent)
+        json_utils.dump(self.to_dict(**kwargs), file, indent=indent)
 
     def _to_table_dict(self):
 
@@ -3632,7 +3635,7 @@ class Line:
         else:
             raise KeyError(f'Element or variable {key} not found')
 
-    def info(self, key, limit=12):
+    def info(self, key, limit=30):
         """
             Get information about an element or a variable.
         """

{xtrack-0.70.3 → xtrack-0.72.0}/xtrack/linear_normal_form.py

@@ -182,9 +182,20 @@ def compute_linear_normal_form(M, symplectify=False, only_4d_block=False,
     b2 = v0[:,modes[1]].imag
     b3 = v0[:,modes[2]].imag
 
-    n1 = 1./np.sqrt(np.matmul(np.matmul(a1, S), b1))
-    n2 = 1./np.sqrt(np.matmul(np.matmul(a2, S), b2))
-    n3 = 1./np.sqrt(np.matmul(np.matmul(a3, S), b3))
+    n1_inv_sq = np.matmul(np.matmul(a1, S), b1)
+    n2_inv_sq = np.matmul(np.matmul(a2, S), b2)
+    n3_inv_sq = np.matmul(np.matmul(a3, S), b3)
+
+    if not n1_inv_sq > 0:
+        raise ValueError('Invalid n1')
+    if not n2_inv_sq > 0:
+        raise ValueError('Invalid n2')
+    if not n3_inv_sq > 0:
+        raise ValueError('Invalid n3')
+
+    n1 = 1./np.sqrt(n1_inv_sq)
+    n2 = 1./np.sqrt(n2_inv_sq)
+    n3 = 1./np.sqrt(n3_inv_sq)
 
     a1 *= n1
     a2 *= n2

{xtrack-0.70.3 → xtrack-0.72.0}/xtrack/mad_parser/loader.py

@@ -292,13 +292,16 @@ class MadxLoader:
             if (extras := el_params.pop('extra', None)):
                 _warn(f'Ignoring extra parameters {extras} for element `{name}`!')
 
-            if isinstance(self.env[name], BeamElement) and not self.env[name].isthick and length:
+
+            if (isinstance(self.env[name], BeamElement) and not self.env[name].isthick
+                 and length and not isinstance(self.env[name], xt.Marker)):
                 drift_name = f'drift_{name}'
                 self.env.new(drift_name, 'Drift', length=f'({length}) / 2')
                 name = builder.new_line([drift_name, name, drift_name])
             builder.place(name, **el_params)
         else:
-            if isinstance(self.env[parent], BeamElement) and not self.env[parent].isthick and length:
+            if (isinstance(self.env[parent], BeamElement) and not self.env[parent].isthick
+                and length and not isinstance(self.env[parent], xt.Marker)):
                 drift_name = f'{name}_drift'
                 self.env.new(drift_name, 'Drift', length=f'({length}) / 2')
                 at, from_ = el_params.pop('at', None), el_params.pop('from_', None)
@@ -635,8 +638,8 @@ class MadxLoader:
 
         return element_name
 
-def load_madx_lattice(file):
-    loader = MadxLoader()
+def load_madx_lattice(file, reverse_lines=None):
+    loader = MadxLoader(reverse_lines=reverse_lines)
     loader.load_file(file)
     env = loader.env
     return env