xtrack 0.71.0__tar.gz → 0.72.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.71.0
+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.71.0 → 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.71.0 → 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.72.0/xtrack/_version.py

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

{xtrack-0.71.0 → 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.71.0 → 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.71.0 → xtrack-0.72.0}/xtrack/line.py

@@ -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])
 

{xtrack-0.71.0 → xtrack-0.72.0}/xtrack/slicing.py

@@ -245,6 +245,7 @@ class Slicer:
         for ii, name in enumerate(progress(collapsed_names, desc='Slicing line')):
 
             element = self._line.element_dict[name]
+
             subsequence = self._slice_element(
                 name, element, _edge_markers=_edge_markers)
 
@@ -369,7 +370,6 @@ class Slicer:
             nn = f'{name}..entry_map'
             ee = element._entry_slice_class(
                     _parent=element, _buffer=element._buffer)
-            element._movable = True # Force movable
             ee.parent_name = parent_name
             self._line.element_dict[nn] = ee
             slices_to_append.append(nn)
@@ -379,51 +379,49 @@ class Slicer:
             assert hasattr(element, '_parent')
             assert element.isthick
             elem_length = element._parent.length * element.weight
-            for weight, is_drift in chosen_slicing.iter_weights(elem_length):
-
-                if not is_drift:
-                    continue
+            elem_weight = element.weight
+            slice_parent_name = element.parent_name
+            slice_parent = element._parent
+            isdriftslice = type(element).__name__.startswith('DriftSlice')
+        else:
+            elem_length = element.length
+            elem_weight = 1.
+            slice_parent_name = parent_name
+            slice_parent = element
+            isdriftslice = False
 
-                nn = f'{name}..{element_idx}'
-                ee = type(element)(
-                        _parent=element._parent, _buffer=element._buffer,
-                        weight=weight * element.weight)
-                element._parent._movable = True # Force movable
-                ee.parent_name = element.parent_name
-                self._line.element_dict[nn] = ee
-                slices_to_append.append(nn)
-                element_idx += 1
-        elif chosen_slicing.mode == 'thin':
-            for weight, is_drift in chosen_slicing.iter_weights(element.length):
+        if chosen_slicing.mode == 'thin' or isdriftslice:
+            for weight, is_drift in chosen_slicing.iter_weights(elem_length):
                 if is_drift:
-                    nn = f'drift_{name}..{drift_idx}'
-                    ee = element._drift_slice_class(
-                            _parent=element, _buffer=element._buffer,
-                            weight=weight)
-                    element._movable = True # Force movable
-                    ee.parent_name = parent_name
+                    nn = f'{name}..{drift_idx}'
+                    if not isdriftslice:
+                        nn = 'drift_' + nn
+                    ee = slice_parent._drift_slice_class(
+                            _parent=slice_parent, _buffer=element._buffer,
+                            weight=weight * elem_weight)
+                    ee.parent_name = slice_parent_name
                     self._line.element_dict[nn] = ee
                     slices_to_append.append(nn)
                     drift_idx += 1
                 else:
+                    if isdriftslice:
+                        continue
                     nn = f'{name}..{element_idx}'
-                    if element._thin_slice_class is not None:
-                        ee = element._thin_slice_class(
-                                _parent=element, _buffer=element._buffer,
-                                weight=weight)
-                        element._movable = True # Force movable
-                        ee.parent_name = parent_name
+                    if slice_parent._thin_slice_class is not None:
+                        ee = slice_parent._thin_slice_class(
+                                _parent=slice_parent, _buffer=element._buffer,
+                                weight=weight * elem_weight)
+                        ee.parent_name = slice_parent_name
                         self._line.element_dict[nn] = ee
                         slices_to_append.append(nn)
                         element_idx += 1
-        elif hasattr(element, 'length'):
-            for weight, is_drift in chosen_slicing.iter_weights(element.length):
+        elif chosen_slicing.mode == 'thick':
+            for weight, is_drift in chosen_slicing.iter_weights(elem_length):
                 nn = f'{name}..{element_idx}'
-                ee = element._thick_slice_class(
-                        _parent=element, _buffer=element._buffer,
-                        weight=weight)
-                element._movable = True # Force movable
-                ee.parent_name = parent_name
+                ee = slice_parent._thick_slice_class(
+                        _parent=slice_parent, _buffer=element._buffer,
+                        weight=weight * elem_weight)
+                ee.parent_name = slice_parent_name
                 self._line.element_dict[nn] = ee
                 slices_to_append.append(nn)
                 element_idx += 1
@@ -434,11 +432,13 @@ class Slicer:
             nn = f'{name}..exit_map'
             ee = element._exit_slice_class(
                     _parent=element, _buffer=element._buffer)
-            element._movable = True # Force movable
             ee.parent_name = parent_name
             self._line.element_dict[nn] = ee
             slices_to_append.append(nn)
 
+        slice_parent._movable = True # Force movable
+        element._movable = True # Force movable
+
         return slices_to_append
 
     def _make_copies(self, element_names, index):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.71.0
+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.71.0/xtrack/_version.py

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