xtrack 0.76.2__tar.gz → 0.77.1__tar.gz

{xtrack-0.76.2/xtrack.egg-info → xtrack-0.77.1}/PKG-INFO

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

{xtrack-0.76.2 → xtrack-0.77.1}/tests/test_environment.py

@@ -2971,3 +2971,194 @@ def test_builder_length():
     assert np.all(tt.name == np.array(['drift_1', 'mq', 'drift_2', '_end_point']))
     xo.assert_allclose(tt.s_center, np.array([ 4.75, 10.  , 15.25, 20.  ]),
                     rtol=0, atol=1e-10)
+
+def test_enviroment_from_two_lines():
+
+    env1 = xt.Environment()
+    env1.vars.default_to_zero  = True
+    line1 = env1.new_line(components=[
+        env1.new('qq1_thick', xt.Quadrupole, length=1., k1='kk', at=10),
+        env1.new('qq1_thin', xt.Quadrupole, length=1., k1='kk', at=20),
+        env1.new('qq_shared_thick', xt.Quadrupole, length=1., k1='kk', at=30),
+        env1.new('qq_shared_thin', xt.Quadrupole, length=1., k1='kk', at=40),
+    ])
+    line1.slice_thick_elements(
+        slicing_strategies=[
+            xt.Strategy(slicing=xt.Teapot(2, mode='thick'), name='qq1_thick'),
+            xt.Strategy(slicing=xt.Teapot(2, mode='thin'), name='qq1_thin'),
+            xt.Strategy(slicing=xt.Teapot(2, mode='thick'), name='qq_shared_thick'),
+            xt.Strategy(slicing=xt.Teapot(2, mode='thin'), name='qq_shared_thin'),
+        ])
+
+    env2 = xt.Environment()
+    env2.vars.default_to_zero  = True
+    line2 = env2.new_line(components=[
+        env2.new('qq2_thick', xt.Quadrupole, length=1., k1='kk', at=10),
+        env2.new('qq2_thin', xt.Quadrupole, length=1., k1='kk', at=20),
+        env2.new('qq_shared_thick', xt.Quadrupole, length=1., k1='kk', at=30),
+        env2.new('qq_shared_thin', xt.Quadrupole, length=1., k1='kk', at=40),
+    ])
+    line2.slice_thick_elements(
+        slicing_strategies=[
+            xt.Strategy(slicing=xt.Teapot(2, mode='thick'), name='qq2_thick'),
+            xt.Strategy(slicing=xt.Teapot(2, mode='thin'), name='qq2_thin'),
+            xt.Strategy(slicing=xt.Teapot(2, mode='thick'), name='qq_shared_thick'),
+            xt.Strategy(slicing=xt.Teapot(2, mode='thin'), name='qq_shared_thin'),
+        ])
+
+    # Merge the line in one environment
+    env = xt.Environment(lines={'line1': line1, 'line2': line2})
+
+    tt1 = env.line1.get_table()
+    tt2 = env.line2.get_table()
+
+    tt1.show(cols='name element_type parent_name')
+    # name                          element_type         parent_name
+    # drift_1                       Drift                None
+    # qq1_thick_entry               Marker               None
+    # qq1_thick..0                  ThickSliceQuadrupole qq1_thick
+    # qq1_thick..1                  ThickSliceQuadrupole qq1_thick
+    # qq1_thick_exit                Marker               None
+    # drift_2                       Drift                None
+    # qq1_thin_entry                Marker               None
+    # drift_qq1_thin..0             DriftSliceQuadrupole qq1_thin
+    # qq1_thin..0                   ThinSliceQuadrupole  qq1_thin
+    # drift_qq1_thin..1             DriftSliceQuadrupole qq1_thin
+    # qq1_thin..1                   ThinSliceQuadrupole  qq1_thin
+    # drift_qq1_thin..2             DriftSliceQuadrupole qq1_thin
+    # qq1_thin_exit                 Marker               None
+    # drift_3                       Drift                None
+    # qq_shared_thick_entry         Marker               None
+    # qq_shared_thick..0/line1      ThickSliceQuadrupole qq_shared_thick/line1
+    # qq_shared_thick..1/line1      ThickSliceQuadrupole qq_shared_thick/line1
+    # qq_shared_thick_exit          Marker               None
+    # drift_4                       Drift                None
+    # qq_shared_thin_entry          Marker               None
+    # drift_qq_shared_thin..0/line1 DriftSliceQuadrupole qq_shared_thin/line1
+    # qq_shared_thin..0/line1       ThinSliceQuadrupole  qq_shared_thin/line1
+    # drift_qq_shared_thin..1/line1 DriftSliceQuadrupole qq_shared_thin/line1
+    # qq_shared_thin..1/line1       ThinSliceQuadrupole  qq_shared_thin/line1
+    # drift_qq_shared_thin..2/line1 DriftSliceQuadrupole qq_shared_thin/line1
+    # qq_shared_thin_exit           Marker               None
+
+    tt2.show(cols='name element_type parent_name')
+    # name                          element_type         parent_name
+    # drift_5                       Drift                None
+    # qq2_thick_entry               Marker               None
+    # qq2_thick..0                  ThickSliceQuadrupole qq2_thick
+    # qq2_thick..1                  ThickSliceQuadrupole qq2_thick
+    # qq2_thick_exit                Marker               None
+    # drift_6                       Drift                None
+    # qq2_thin_entry                Marker               None
+    # drift_qq2_thin..0             DriftSliceQuadrupole qq2_thin
+    # qq2_thin..0                   ThinSliceQuadrupole  qq2_thin
+    # drift_qq2_thin..1             DriftSliceQuadrupole qq2_thin
+    # qq2_thin..1                   ThinSliceQuadrupole  qq2_thin
+    # drift_qq2_thin..2             DriftSliceQuadrupole qq2_thin
+    # qq2_thin_exit                 Marker               None
+    # drift_7                       Drift                None
+    # qq_shared_thick_entry         Marker               None
+    # qq_shared_thick..0/line2      ThickSliceQuadrupole qq_shared_thick/line2
+    # qq_shared_thick..1/line2      ThickSliceQuadrupole qq_shared_thick/line2
+    # qq_shared_thick_exit          Marker               None
+    # drift_8                       Drift                None
+    # qq_shared_thin_entry          Marker               None
+    # drift_qq_shared_thin..0/line2 DriftSliceQuadrupole qq_shared_thin/line2
+    # qq_shared_thin..0/line2       ThinSliceQuadrupole  qq_shared_thin/line2
+    # drift_qq_shared_thin..1/line2 DriftSliceQuadrupole qq_shared_thin/line2
+    # qq_shared_thin..1/line2       ThinSliceQuadrupole  qq_shared_thin/line2
+    # drift_qq_shared_thin..2/line2 DriftSliceQuadrupole qq_shared_thin/line2
+    # qq_shared_thin_exit           Marker               None
+    # _end_point                                         None
+
+    assert np.all(tt1.name == np.array([
+        'drift_1', 'qq1_thick_entry', 'qq1_thick..0', 'qq1_thick..1',
+        'qq1_thick_exit', 'drift_2', 'qq1_thin_entry', 'drift_qq1_thin..0',
+        'qq1_thin..0', 'drift_qq1_thin..1', 'qq1_thin..1',
+        'drift_qq1_thin..2', 'qq1_thin_exit', 'drift_3',
+        'qq_shared_thick_entry', 'qq_shared_thick..0/line1',
+        'qq_shared_thick..1/line1', 'qq_shared_thick_exit', 'drift_4',
+        'qq_shared_thin_entry', 'drift_qq_shared_thin..0/line1',
+        'qq_shared_thin..0/line1', 'drift_qq_shared_thin..1/line1',
+        'qq_shared_thin..1/line1', 'drift_qq_shared_thin..2/line1',
+        'qq_shared_thin_exit', '_end_point']))
+
+    assert np.all(tt1.element_type == np.array([
+        'Drift', 'Marker', 'ThickSliceQuadrupole', 'ThickSliceQuadrupole',
+        'Marker', 'Drift', 'Marker', 'DriftSliceQuadrupole',
+        'ThinSliceQuadrupole', 'DriftSliceQuadrupole',
+        'ThinSliceQuadrupole', 'DriftSliceQuadrupole', 'Marker', 'Drift',
+        'Marker', 'ThickSliceQuadrupole', 'ThickSliceQuadrupole', 'Marker',
+        'Drift', 'Marker', 'DriftSliceQuadrupole', 'ThinSliceQuadrupole',
+        'DriftSliceQuadrupole', 'ThinSliceQuadrupole',
+        'DriftSliceQuadrupole', 'Marker', '']))
+
+    assert np.all(tt1.parent_name == np.array([
+        None, None, 'qq1_thick', 'qq1_thick', None, None, None, 'qq1_thin',
+        'qq1_thin', 'qq1_thin', 'qq1_thin', 'qq1_thin', None, None, None,
+        'qq_shared_thick/line1', 'qq_shared_thick/line1', None, None, None,
+        'qq_shared_thin/line1', 'qq_shared_thin/line1',
+        'qq_shared_thin/line1', 'qq_shared_thin/line1',
+        'qq_shared_thin/line1', None, None]))
+
+    assert np.all(tt2.name == np.array([
+        'drift_5', 'qq2_thick_entry', 'qq2_thick..0', 'qq2_thick..1',
+        'qq2_thick_exit', 'drift_6', 'qq2_thin_entry', 'drift_qq2_thin..0',
+        'qq2_thin..0', 'drift_qq2_thin..1', 'qq2_thin..1',
+        'drift_qq2_thin..2', 'qq2_thin_exit', 'drift_7',
+        'qq_shared_thick_entry', 'qq_shared_thick..0/line2',
+        'qq_shared_thick..1/line2', 'qq_shared_thick_exit', 'drift_8',
+        'qq_shared_thin_entry', 'drift_qq_shared_thin..0/line2',
+        'qq_shared_thin..0/line2', 'drift_qq_shared_thin..1/line2',
+        'qq_shared_thin..1/line2', 'drift_qq_shared_thin..2/line2',
+        'qq_shared_thin_exit', '_end_point']))
+
+    assert np.all(tt2.element_type == np.array([
+        'Drift', 'Marker', 'ThickSliceQuadrupole', 'ThickSliceQuadrupole',
+        'Marker', 'Drift', 'Marker', 'DriftSliceQuadrupole',
+        'ThinSliceQuadrupole', 'DriftSliceQuadrupole',
+        'ThinSliceQuadrupole', 'DriftSliceQuadrupole', 'Marker', 'Drift',
+        'Marker', 'ThickSliceQuadrupole', 'ThickSliceQuadrupole', 'Marker',
+        'Drift', 'Marker', 'DriftSliceQuadrupole', 'ThinSliceQuadrupole',
+        'DriftSliceQuadrupole', 'ThinSliceQuadrupole',
+        'DriftSliceQuadrupole', 'Marker', '']))
+
+    assert np.all(tt2.parent_name == np.array([
+        None, None, 'qq2_thick', 'qq2_thick', None, None, None, 'qq2_thin',
+        'qq2_thin', 'qq2_thin', 'qq2_thin', 'qq2_thin', None, None, None,
+        'qq_shared_thick/line2', 'qq_shared_thick/line2', None, None, None,
+        'qq_shared_thin/line2', 'qq_shared_thin/line2',
+        'qq_shared_thin/line2', 'qq_shared_thin/line2',
+        'qq_shared_thin/line2', None, None]))
+
+    assert 'qq1_thick' in env.element_dict
+    assert 'qq1_thin' in env.element_dict
+    assert 'qq_shared_thick/line1' in env.element_dict
+    assert 'qq_shared_thin/line1' in env.element_dict
+    assert 'qq2_thick' in env.element_dict
+    assert 'qq2_thin' in env.element_dict
+    assert 'qq_shared_thick/line2' in env.element_dict
+    assert 'qq_shared_thin/line2' in env.element_dict
+
+    line1['kk'] = 1e-1
+    line2['kk'] = 1e-1
+    env['kk'] = 1e-1
+
+    particle_ref = xt.Particles(p0c=7e12)
+    line1.particle_ref = particle_ref
+    line2.particle_ref = particle_ref
+    env.line1.particle_ref = particle_ref
+    env.line2.particle_ref = particle_ref
+
+    tw1 = line1.twiss(betx=1, bety=2)
+    tw2 = line2.twiss(betx=1, bety=2)
+    tw1i = env.line1.twiss(betx=1, bety=2)
+    tw2i = env.line2.twiss(betx=1, bety=2)
+
+    assert np.allclose(tw1.s, tw1i.s, atol=0, rtol=1e-15)
+    assert np.allclose(tw1.betx, tw1i.betx, atol=0, rtol=1e-15)
+    assert np.allclose(tw1.bety, tw1i.bety, atol=0, rtol=1e-15)
+
+    assert np.allclose(tw2.s, tw2i.s, atol=0, rtol=1e-15)
+    assert np.allclose(tw2.betx, tw2i.betx, atol=0, rtol=1e-15)
+    assert np.allclose(tw2.bety, tw2i.bety, atol=0, rtol=1e-15)

{xtrack-0.76.2 → xtrack-0.77.1}/tests/test_native_madloader.py

@@ -9,6 +9,7 @@ from cpymad.madx import Madx
 
 from xdeps.refs import CompactFormatter
 import xtrack as xt
+from xtrack import Strategy, Uniform
 from xtrack.mad_parser.loader import MadxLoader
 from xtrack.mad_parser.parse import MadxOutputType, MadxParser
 
@@ -725,15 +726,23 @@ def test_load_b2_with_bv_minus_one(tmp_path):
     mad.input('set, format=".20g";')
     mad.save(file=tmp_seq_path)
 
-    line2_ref = xt.Line.from_madx_sequence(mad.sequence.lhcb2,
-                                       allow_thick=True,
-                                       deferred_expressions=True,
-                                       replace_in_expr={'bv_aux': 'bvaux_b2'})
+    line2_ref = xt.Line.from_madx_sequence(
+        sequence=mad.sequence.lhcb2,
+        allow_thick=True,
+        deferred_expressions=True,
+        replace_in_expr={'bv_aux': 'bvaux_b2'},
+    )
     line2_ref.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, p0c=7000e9)
 
     env = xt.load_madx_lattice(tmp_seq_path, reverse_lines=['lhcb2'])
     line2 = env['lhcb2']
 
+    # Remove apertures, they are not supported in the cpymadloader
+    line2.element_names = [
+        name for name in line2.element_names
+        if not isinstance(line2[name], xt.LimitRectEllipse)
+    ]
+
     # Bend done
 
     # Quadrupole
@@ -879,7 +888,6 @@ def test_refer_and_thin_elements():
 
 def test_import_seq_length():
     sequence = """
-
     qu: quadrupole, l=2, k1=3, k1s=4, tilt=2;  ! ignore thick and ktap
 
     line: sequence, l = ll;
@@ -897,3 +905,233 @@ def test_import_seq_length():
     assert np.all(tt.name == np.array(['drift_1', 'qu1', 'drift_2', '_end_point']))
     xo.assert_allclose(tt['s'], np.array([ 0., 18., 20., 30.]), rtol=0, atol=1e-15)
     assert env.line.builder.length == 'll'
+
+
+def test_repeated_element_mad_behaviour():
+    sequence = """
+    mar: marker;
+    ben: sbend, l=1;
+    
+    seq1: sequence, l=10;
+      ee: mar, at=5;
+    endsequence;
+    
+    seq2: sequence, l=10;
+      ee: ben, at=5;  ! in MAD-X this definition will be ignored
+    endsequence;
+    """
+
+    env = xt.load_madx_lattice(string=sequence)
+
+    element = env['ee']
+    assert env.seq1['ee'] == element
+    assert env.seq2['ee'] == element
+
+
+@pytest.mark.parametrize('aper_config', ['attached_to_marker', 'standalone'])
+def test_apertures_on_markers(aper_config):
+    if aper_config == 'attached_to_marker':
+        sequence = """
+            ! Attached to a marker
+            m_circle: marker, apertype="circle", aperture={.2};
+            m_ellipse: marker, apertype="ellipse", aperture={.2, .1};
+            m_rectangle: marker, apertype="rectangle", aperture={.07, .05};
+            m_rectellipse: marker, apertype="rectellipse", aperture={.2, .4, .25, .45};
+            m_racetrack: marker, apertype="racetrack", aperture={.6,.4,.2,.1};
+            m_octagon: marker, apertype="octagon", aperture={.4, .5, 0.5, 1.};
+            m_polygon: marker, apertype="circle", aper_vx={+5.800e-2,+5.800e-2,-8.800e-2}, aper_vy={+3.500e-2,-3.500e-2,+0.000e+0};
+            """
+    else:
+        sequence = """
+            ! Standalone
+            m_circle: circle, aperture={.2};
+            m_ellipse: ellipse, aperture={.2, .1};
+            m_rectangle: rectangle, aperture={.07, .05};
+            m_rectellipse: rectellipse, aperture={.2, .4, .25, .45};
+            m_racetrack: racetrack, aperture={.6,.4,.2,.1};
+            m_octagon: octagon, aperture={.4, .5, 0.5, 1.};
+            m_polygon: circle, aper_vx={+5.800e-2,+5.800e-2,-8.800e-2}, aper_vy={+3.500e-2,-3.500e-2,+0.000e+0};
+            """
+
+    sequence += """
+        line: sequence, l=1;
+            m_circle, at=0;
+            m_ellipse, at=0.01;
+            m_rectangle, at=0.02;
+            m_rectellipse, at=0.03;
+            m_racetrack, at=0.04;
+            m_octagon, at=0.05;
+            m_polygon, at=0.06;
+        endsequence;
+        """
+
+    env = xt.load_madx_lattice(string=sequence)
+    line = env.line
+
+    apertures = [ee for ee in line.elements if ee.__class__.__name__.startswith('Limit')]
+
+    assert isinstance(line[line['m_circle'].name_associated_aperture], xt.LimitEllipse)
+    circ = apertures[0]
+    assert circ.__class__.__name__ == 'LimitEllipse'
+    xo.assert_allclose(circ.a_squ, .2**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(circ.b_squ, .2**2, atol=1e-13, rtol=0)
+
+    assert isinstance(line[line['m_ellipse'].name_associated_aperture], xt.LimitEllipse)
+    ellip = apertures[1]
+    assert ellip.__class__.__name__ == 'LimitEllipse'
+    xo.assert_allclose(ellip.a_squ, .2**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(ellip.b_squ, .1**2, atol=1e-13, rtol=0)
+
+    assert isinstance(line[line['m_rectangle'].name_associated_aperture], xt.LimitRect)
+    rect = apertures[2]
+    assert rect.__class__.__name__ == 'LimitRect'
+    assert rect.min_x == -.07
+    assert rect.max_x == +.07
+    assert rect.min_y == -.05
+    assert rect.max_y == +.05
+
+    assert isinstance(line[line['m_rectellipse'].name_associated_aperture], xt.LimitRectEllipse)
+    rectellip = apertures[3]
+    assert rectellip.max_x == .2
+    assert rectellip.max_y == .4
+    xo.assert_allclose(rectellip.a_squ, .25**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(rectellip.b_squ, .45**2, atol=1e-13, rtol=0)
+
+    assert isinstance(line[line['m_racetrack'].name_associated_aperture], xt.LimitRacetrack)
+    racetr = apertures[4]
+    assert racetr.__class__.__name__ == 'LimitRacetrack'
+    assert racetr.min_x == -.6
+    assert racetr.max_x == +.6
+    assert racetr.min_y == -.4
+    assert racetr.max_y == +.4
+    assert racetr.a == .2
+    assert racetr.b == .1
+
+    assert isinstance(line[line['m_octagon'].name_associated_aperture], xt.LimitPolygon)
+    octag = apertures[5]
+    assert octag.__class__.__name__ == 'LimitPolygon'
+    assert octag._xobject.x_vertices[0] == 0.4
+    xo.assert_allclose(octag._xobject.y_vertices[0], 0.4*np.tan(0.5), atol=1e-14, rtol=0)
+    assert octag._xobject.y_vertices[1] == 0.5
+    xo.assert_allclose(octag._xobject.x_vertices[1], 0.5/np.tan(1.), atol=1e-14, rtol=0)
+
+    assert octag._xobject.y_vertices[2] == 0.5
+    xo.assert_allclose(octag._xobject.x_vertices[2], -0.5/np.tan(1.), atol=1e-14, rtol=0)
+    assert octag._xobject.x_vertices[3] == -0.4
+    xo.assert_allclose(octag._xobject.y_vertices[3], 0.4*np.tan(0.5), atol=1e-14, rtol=0)
+
+
+    assert octag._xobject.x_vertices[4] == -0.4
+    xo.assert_allclose(octag._xobject.y_vertices[4], -0.4*np.tan(0.5), atol=1e-14, rtol=0)
+    assert octag._xobject.y_vertices[5] == -0.5
+    xo.assert_allclose(octag._xobject.x_vertices[5], -0.5/np.tan(1.), atol=1e-14, rtol=0)
+
+
+    assert octag._xobject.y_vertices[6] == -0.5
+    xo.assert_allclose(octag._xobject.x_vertices[6], 0.5/np.tan(1.), atol=1e-14, rtol=0)
+    assert octag._xobject.x_vertices[7] == 0.4
+    xo.assert_allclose(octag._xobject.y_vertices[7], -0.4*np.tan(0.5), atol=1e-14, rtol=0)
+
+    assert isinstance(line[line['m_polygon'].name_associated_aperture], xt.LimitPolygon)
+    polyg = apertures[6]
+    assert polyg.__class__.__name__ == 'LimitPolygon'
+    assert len(polyg._xobject.x_vertices) == 3
+    assert len(polyg._xobject.y_vertices) == 3
+    # The below assertions don't match test_apertures.py::test_mad_import
+    # TODO: Figure out what mad_loader.py:971 is doing? It seems wrong
+    assert np.all(polyg.x_vertices == [5.8e-2, 5.8e-2, -8.8e-2])
+    assert np.all(polyg.y_vertices == [3.5e-2, -3.5e-2, 0.0])
+
+
+def test_aperture_setting():
+    sequence = """
+    m_ellipse: marker, apertype="ellipse", aperture={.2, .1};
+    m_aper: marker, apertype="rectangle", aperture={.3, .4};
+    
+    line: sequence, l=1;
+        m_ellipse, at=0;
+        m_aper, at=0.1;
+    endsequence;
+    
+    m_ellipse, aperture={.3, .2};  ! no apertype
+    m_aper, apertype="ellipse", aperture={.5, .6};  ! change apertype
+    """
+
+    env = xt.load_madx_lattice(string=sequence)
+    line = env.line
+
+    assert line['m_ellipse_aper'].a == .3
+    assert line['m_ellipse_aper'].b == .2
+
+    assert line['m_aper_aper'].a == .5
+    assert line['m_aper_aper'].b == .6
+
+
+def test_import_thick_with_apertures_and_slice():
+    sequence = """
+    k1=0.2;
+    tilt=0.1;
+
+    elm: sbend,
+        k1:=k1,
+        l=1,
+        angle=0.1,
+        tilt=0.2,
+        apertype="rectellipse",
+        aperture={0.1,0.2,0.11,0.22},
+        aper_tol={0.1,0.2,0.3},
+        aper_tilt:=tilt,
+        aper_offset={0.2, 0.3};
+
+    seq: sequence, l=1;
+    elm: elm, at=0.5;
+    endsequence;
+    """
+
+    env = xt.load_madx_lattice(string=sequence)
+    line = env.seq
+
+    def _assert_eq(a, b):
+        xo.assert_allclose(a, b, atol=1e-16)
+
+    _assert_eq(line[f'elm_aper'].rot_s_rad, 0.1)
+    _assert_eq(line[f'elm_aper'].shift_x, 0.2)
+    _assert_eq(line[f'elm_aper'].shift_y, 0.3)
+    _assert_eq(line[f'elm_aper'].max_x, 0.1)
+    _assert_eq(line[f'elm_aper'].max_y, 0.2)
+    _assert_eq(line[f'elm_aper'].a_squ, 0.11 ** 2)
+    _assert_eq(line[f'elm_aper'].b_squ, 0.22 ** 2)
+
+    _assert_eq(line[f'elm'].rot_s_rad, 0.2)
+
+    line.slice_thick_elements(slicing_strategies=[Strategy(Uniform(2))])
+
+    assert np.all(line.get_table().rows['elm_entry':'elm_exit'].name == [
+        'elm_entry',                    # entry marker
+        'elm_aper..0',                  # entry edge aperture
+        'elm..entry_map',               # entry edge (+transform)
+        'drift_elm..0',                 # drift 0
+        'elm_aper..1',                  # slice 1 aperture
+        'elm..0',                       # slice 0 (+transform)
+        'drift_elm..1',                 # drift 1
+        'elm_aper..2',                  # slice 2 aperture
+        'elm..1',                       # slice 2 (+transform)
+        'drift_elm..2',                 # drift 2
+        'elm_aper..3',                  # exit edge aperture
+        'elm..exit_map',                # exit edge (+transform)
+        'elm_exit',                     # exit marker
+    ])
+
+    line.build_tracker(compile=False) # To resolve parents
+
+    for i in range(4):
+        _assert_eq(line[f'elm_aper..{i}'].resolve(line).rot_s_rad, 0.1)
+        _assert_eq(line[f'elm_aper..{i}'].resolve(line).shift_x, 0.2)
+        _assert_eq(line[f'elm_aper..{i}'].resolve(line).shift_y, 0.3)
+        _assert_eq(line[f'elm_aper..{i}'].resolve(line).max_x, 0.1)
+        _assert_eq(line[f'elm_aper..{i}'].resolve(line).max_y, 0.2)
+        _assert_eq(line[f'elm_aper..{i}'].resolve(line).a_squ, 0.11 ** 2)
+        _assert_eq(line[f'elm_aper..{i}'].resolve(line).b_squ, 0.22 ** 2)
+
+    for i in range(2):
+        _assert_eq(line[f'elm..{i}']._parent.rot_s_rad, 0.2)

xtrack-0.77.1/xtrack/_version.py

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

{xtrack-0.76.2 → xtrack-0.77.1}/xtrack/beam_elements/apertures.py

@@ -266,7 +266,7 @@ class LimitPolygon(BeamElement):
                     **kwargs)
 
             lengths = np.sqrt(np.diff(self.x_closed)**2
-                            + np.diff(self.y_closed)**2)
+                              + np.diff(self.y_closed)**2)
 
             assert np.all(lengths>0)
 

{xtrack-0.76.2 → xtrack-0.77.1}/xtrack/environment.py

@@ -144,9 +144,14 @@ class Environment:
             # Identify common elements
             counts = Counter()
             for ll in lines.values():
+                # Extract names of all elements and parents
+                elems_and_parents = set(ll.element_names)
+                for nn in ll.element_names:
+                    if hasattr(ll.element_dict[nn], 'parent_name'):
+                        elems_and_parents.add(ll.element_dict[nn].parent_name)
                 # Count if it is not a marker or a drift, which will be handled by
                 # `import_line`
-                for nn in ll.element_names:
+                for nn in elems_and_parents:
                     if (not (isinstance(ll.element_dict[nn], (xt.Marker))) and
                         not bool(re.match(r'^drift_\d+$', nn))):
                         counts[nn] += 1
@@ -478,6 +483,31 @@ class Environment:
     def copy_element_from(self, name, source, new_name=None):
         return xt.Line.copy_element_from(self, name, source, new_name)
 
+
+    def _import_element(self, line, name, rename_elements, suffix_for_common_elements,
+                        already_imported):
+        new_name = name
+        if name in rename_elements:
+            new_name = rename_elements[name]
+        elif (bool(re.match(r'^drift_\d+$', name))
+            and line.ref[name].length._expr is None):
+            new_name = self._get_a_drift_name()
+        elif (name in self.element_dict and
+                not (isinstance(line[name], xt.Marker) and
+                    isinstance(self.element_dict.get(name), xt.Marker))):
+            new_name += suffix_for_common_elements
+
+        self.copy_element_from(name, line, new_name=new_name)
+        already_imported[name] = new_name
+        if hasattr(line.element_dict[name], 'parent_name'):
+            parent_name = line.element_dict[name].parent_name
+            if parent_name not in already_imported:
+                self._import_element(line, parent_name, rename_elements,
+                                     suffix_for_common_elements, already_imported)
+            self.element_dict[new_name].parent_name = already_imported[parent_name]
+
+        return new_name
+
     def import_line(
             self,
             line,
@@ -520,20 +550,11 @@ class Environment:
         self.vars.default_to_zero = old_default_to_zero
 
         components = []
+        already_imported = {}
         for name in line.element_names:
-            new_name = name
-
-            if name in rename_elements:
-                new_name = rename_elements[name]
-            elif (bool(re.match(r'^drift_\d+$', name))
-                and line.ref[name].length._expr is None):
-                new_name = self._get_a_drift_name()
-            elif (name in self.element_dict and
-                    not (isinstance(line[name], xt.Marker) and
-                        isinstance(self.element_dict.get(name), xt.Marker))):
-                new_name += suffix_for_common_elements
-
-            self.copy_element_from(name, line, new_name=new_name)
+            new_name = self._import_element(
+                line, name, rename_elements, suffix_for_common_elements,
+                already_imported)
 
             components.append(new_name)
 
@@ -1438,9 +1459,10 @@ def load_module_from_path(file_path):
 def _reverse_element(env, name):
     """Return a reversed element without modifying the original."""
 
-    SUPPORTED={'RBend', 'Bend', 'Quadrupole', 'Sextupole', 'Octupole',
+    SUPPORTED = {'RBend', 'Bend', 'Quadrupole', 'Sextupole', 'Octupole',
                 'Multipole', 'Cavity', 'Solenoid', 'RFMultipole',
-                'Marker', 'Drift'}
+                'Marker', 'Drift', 'LimitRect', 'LimitEllipse', 'LimitPolygon',
+                'LimitRectEllipse'}
 
     ee = env.get(name)
     ee_ref = env.ref[name]

{xtrack-0.76.2 → xtrack-0.77.1}/xtrack/line.py

@@ -59,7 +59,7 @@ _ALLOWED_ELEMENT_TYPES_IN_NEW = [xt.Drift, xt.Bend, xt.Quadrupole, xt.Sextupole,
                                  xt.Marker, xt.Replica, xt.XYShift, xt.XRotation,
                                  xt.YRotation, xt.SRotation, xt.LimitRacetrack,
                                  xt.LimitRectEllipse, xt.LimitRect, xt.LimitEllipse,
-                                 xt.RFMultipole, xt.RBend]
+                                 xt.LimitPolygon, xt.RFMultipole, xt.RBend]
 
 _ALLOWED_ELEMENT_TYPES_DICT = {'Drift': xt.Drift, 'Bend': xt.Bend,
                                'Quadrupole': xt.Quadrupole, 'Sextupole': xt.Sextupole,
@@ -69,6 +69,7 @@ _ALLOWED_ELEMENT_TYPES_DICT = {'Drift': xt.Drift, 'Bend': xt.Bend,
                                'LimitRacetrack': xt.LimitRacetrack,
                                'LimitRectEllipse': xt.LimitRectEllipse,
                                'LimitRect': xt.LimitRect, 'LimitEllipse': xt.LimitEllipse,
+                               'LimitPolygon': xt.LimitPolygon,
                                'XYShift': xt.XYShift, 'XRotation': xt.XRotation,
                                'YRotation': xt.YRotation, 'SRotation': xt.SRotation,
                                'RFMultipole': xt.RFMultipole, 'RBend': xt.RBend}
@@ -3943,12 +3944,13 @@ class Line:
             Rename the element in the new line/environment. If not provided, the
             element is copied with the same name.
         """
+        new_name_input = new_name if new_name != name else None
         new_name = new_name or name
         cls = type(source.element_dict[name])
 
-        if cls not in _ALLOWED_ELEMENT_TYPES_IN_NEW + [xt.DipoleEdge]: # No issue in copying DipoleEdge
-                                                                       # while creating it requires handling properties
-                                                                       # which are strings.
+        if (cls not in _ALLOWED_ELEMENT_TYPES_IN_NEW + [xt.DipoleEdge] # No issue in copying DipoleEdge while creating it requires handling properties which are strings.
+            and 'ThickSlice' not in cls.__name__ and 'ThinSlice' not in cls.__name__
+            and 'DriftSlice' not in cls.__name__):
             raise ValueError(
                 f'Only {_STR_ALLOWED_ELEMENT_TYPES_IN_NEW} elements are '
                 f'allowed in `copy_from_env` for now.'