xtrack 0.66.0__tar.gz → 0.67.0__tar.gz

{xtrack-0.66.0/xtrack.egg-info → xtrack-0.67.0}/PKG-INFO

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

xtrack-0.67.0/tests/test_environment.py

@@ -0,0 +1,443 @@
+import xtrack as xt
+import xobjects as xo
+import numpy as np
+import pytest
+
+@pytest.mark.parametrize('container_type', ['env', 'line'])
+def test_vars_and_element_access_modes(container_type):
+
+    env = xt.Environment()
+
+    env.vars({
+        'k.1': 1.,
+        'a': 2.,
+        'b': '2 * a + k.1',
+    })
+
+    line = env.new_line([])
+
+    ee = {'env': env, 'line': line}[container_type]
+
+    assert ee.vv['b'] == 2 * 2 + 1
+
+    ee.vars['a'] = ee.vars['k.1']
+    assert ee.vv['b'] == 2 * 1 + 1
+
+    ee.vars(a=3.)
+    ee.vars({'k.1': 'a'})
+    assert ee.vv['k.1'] == 3.
+    assert ee.vv['b'] == 2 * 3 + 3.
+
+    ee.vars['k.1'] = 2 * ee.vars['a'] + 5
+    assert ee.vv['k.1'] == 2 * 3 + 5
+    assert ee.vv['b'] == 2 * 3 + 2 * 3 + 5
+
+    ee.vars.set('a', 4.)
+    assert ee.vv['k.1'] == 2 * 4 + 5
+    assert ee.vv['b'] == 2 * 4 + 2 * 4 + 5
+
+    ee.vars.set('k.1', '2*a + 5')
+    assert ee.vv['k.1'] == 2 * 4 + 5
+    assert ee.vv['b'] == 2 * 4 + 2 * 4 + 5
+
+    ee.vars.set('k.1', 3 * ee.vars['a'] + 6)
+    assert ee.vv['k.1'] == 3 * 4 + 6
+    assert ee.vv['b'] == 2 * 4 + 3 * 4 + 6
+
+    env.set('c', '2*b')
+    assert env.vv['c'] == 2 * (2 * 4 + 3 * 4 + 6)
+    env.set('d', 6)
+    assert env.vv['d'] == 6
+    env.set('d', '7')
+    assert env.vv['d'] == 7
+
+    ee.set('a', 0.)
+    assert ee.vv['k.1'] == 3 * 0 + 6
+    assert ee.vv['b'] == 2 * 0 + 3 * 0 + 6
+
+    ee.set('a', 2.)
+    ee.set('k.1', '2 * a + 5')
+    assert ee.vv['k.1'] == 2 * 2 + 5
+    assert ee.vv['b'] == 2 * 2 + 2 * 2 + 5
+
+    ee.set('k.1', 3 * ee.vars['a'] + 6)
+    assert ee.vv['k.1'] == 3 * 2 + 6
+    assert ee.vv['b'] == 2 * 2 + 3 * 2 + 6
+
+    assert hasattr(ee.ref['k.1'], '_value') # is a Ref
+
+    ee.ref['a'] = 0
+    assert ee.vv['k.1'] == 3 * 0 + 6
+    assert ee.vv['b'] == 2 * 0 + 3 * 0 + 6
+
+    ee.ref['a'] = 2
+    ee.ref['k.1'] = 2 * ee.ref['a'] + 5
+    assert ee.vv['k.1'] == 2 * 2 + 5
+    assert ee.vv['b'] == 2 * 2 + 2 * 2 + 5
+
+    #--------------------------------------------------
+
+    ee.vars({
+        'a': 4.,
+        'b': '2 * a + 5',
+        'k.1': '2 * a + 5',
+    })
+
+    env.new('bb', xt.Bend, k0='2 * b', length=3+env.vars['a'] + env.vars['b'],
+            h=5.)
+    assert env['bb'].k0 == 2 * (2 * 4 + 5)
+    assert env['bb'].length == 3 + 4 + 2 * 4 + 5
+    assert env['bb'].h == 5.
+
+    env.vars['a'] = 2.
+    assert env['bb'].k0 == 2 * (2 * 2 + 5)
+    assert env['bb'].length == 3 + 2 + 2 * 2 + 5
+    assert env['bb'].h == 5.
+
+    line = env.new_line([
+        env.new('bb1', 'bb', length=3*env.vars['a'], at='2*a'),
+        env.place('bb', at=10 * env.vars['a'], from_='bb1'),
+    ])
+
+    assert hasattr(env.ref['bb1'].length, '_value') # is a Ref
+    assert not hasattr(env['bb1'].length, '_value') # a number
+    assert env.ref['bb1'].length._value == 3 * 2
+    assert env['bb1'].length == 3 * 2
+
+    assert hasattr(env.ref['bb1'].length, '_value') # is a Ref
+    assert not hasattr(env['bb1'].length, '_value') # a number
+    assert env.ref['bb1'].length._value == 3 * 2
+    assert env['bb1'].length == 3 * 2
+
+    assert line['bb1'] is not env['bb']
+    assert line['bb'] is env['bb']
+
+    a = env.vv['a']
+    assert line['bb1'].length == 3 * a
+    assert line['bb1'].k0 == 2 * (2 * a + 5)
+    assert line['bb1'].h == 5.
+
+    assert line['bb'].k0 == 2 * (2 * a + 5)
+    assert line['bb'].length == 3 + a + 2 * a + 5
+    assert line['bb'].h == 5.
+
+    tt = line.get_table(attr=True)
+    tt['s_center'] = tt['s'] + tt['length']/2
+
+    assert np.all(tt.name ==  np.array(['drift_1', 'bb1', 'drift_2', 'bb', '_end_point']))
+
+    assert tt['s_center', 'bb1'] == 2*a
+    assert tt['s_center', 'bb'] - tt['s_center', 'bb1'] == 10*a
+
+    old_a = a
+    line.vars['a'] = 3.
+    a = line.vv['a']
+    assert line['bb1'].length == 3 * a
+    assert line['bb1'].k0 == 2 * (2 * a + 5)
+    assert line['bb1'].h == 5.
+
+    assert line['bb'].k0 == 2 * (2 * a + 5)
+    assert line['bb'].length == 3 + a + 2 * a + 5
+    assert line['bb'].h == 5.
+
+    tt_new = line.get_table(attr=True)
+
+    # Drifts are not changed:
+    tt_new['length', 'drift_1'] == tt['length', 'drift_1']
+    tt_new['length', 'drift_2'] == tt['length', 'drift_2']
+
+def test_element_placing_at_s():
+
+    env = xt.Environment()
+
+    env.vars({
+        'l.b1': 1.0,
+        'l.q1': 0.5,
+        's.ip': 10,
+        's.left': -5,
+        's.right': 5,
+        'l.before_right': 1,
+        'l.after_left2': 0.5,
+    })
+
+    # names, tab_sorted = handle_s_places(seq)
+    line = env.new_line(components=[
+        env.new('b1', xt.Bend, length='l.b1'),
+        env.new('q1', xt.Quadrupole, length='l.q1'),
+        env.new('ip', xt.Marker, at='s.ip'),
+        (
+            env.new('before_before_right', xt.Marker),
+            env.new('before_right', xt.Sextupole, length=1),
+            env.new('right',xt.Quadrupole, length=0.8, at='s.right', from_='ip'),
+            env.new('after_right', xt.Marker),
+            env.new('after_right2', xt.Marker),
+        ),
+        env.new('left', xt.Quadrupole, length=1, at='s.left', from_='ip'),
+        env.new('after_left', xt.Marker),
+        env.new('after_left2', xt.Bend, length='l.after_left2'),
+    ])
+
+    tt = line.get_table(attr=True)
+    tt['s_center'] = tt['s'] + tt['length']/2
+    assert np.all(tt.name == np.array([
+        'b1', 'q1', 'drift_1', 'left', 'after_left', 'after_left2',
+        'drift_2', 'ip', 'drift_3', 'before_before_right', 'before_right',
+        'right', 'after_right', 'after_right2', '_end_point']))
+
+    xo.assert_allclose(env['b1'].length, 1.0, rtol=0, atol=1e-14)
+    xo.assert_allclose(env['q1'].length, 0.5, rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s', 'ip'], 10, rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s', 'before_before_right'], tt['s', 'before_right'],
+                    rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s_center', 'before_right'] - tt['s_center', 'right'],
+                    -(1 + 0.8)/2, rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s_center', 'right'] - tt['s', 'ip'], 5, rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s_center', 'after_right'] - tt['s_center', 'right'],
+                        0.8/2, rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s_center', 'after_right2'] - tt['s_center', 'right'],
+                        0.8/2, rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s_center', 'left'] - tt['s_center', 'ip'], -5,
+                    rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s_center', 'after_left'] - tt['s_center', 'left'], 1/2,
+                        rtol=0, atol=1e-14)
+    xo.assert_allclose(tt['s_center', 'after_left2'] - tt['s_center', 'after_left'],
+                    0.5/2, rtol=0, atol=1e-14)
+
+
+    # import matplotlib.pyplot as plt
+    # plt.close('all')
+    # line.survey().plot()
+
+    # plt.show()
+
+def test_assemble_ring():
+
+    env = xt.Environment()
+    env.particle_ref = xt.Particles(p0c=2e9)
+
+    n_bends_per_cell = 6
+    n_cells_par_arc = 3
+    n_arcs = 3
+
+    n_bends = n_bends_per_cell * n_cells_par_arc * n_arcs
+
+    env.vars({
+        'l.mq': 0.5,
+        'kqf': 0.027,
+        'kqd': -0.0271,
+        'l.mb': 10,
+        'l.ms': 0.3,
+        'k2sf': 0.001,
+        'k2sd': -0.001,
+        'angle.mb': 2 * np.pi / n_bends,
+        'k0.mb': 'angle.mb / l.mb',
+        'k0l.corrector': 0,
+        'k1sl.corrector': 0,
+        'l.halfcell': 38,
+    })
+
+    env.new('mb', xt.Bend, length='l.mb', k0='k0.mb', h='k0.mb')
+    env.new('mq', xt.Quadrupole, length='l.mq')
+    env.new('ms', xt.Sextupole, length='l.ms')
+    env.new('corrector', xt.Multipole, knl=[0], length=0.1)
+
+    girder = env.new_line(components=[
+        env.place('mq', at=1),
+        env.place('ms', at=0.8, from_='mq'),
+        env.place('corrector', at=-0.8, from_='mq'),
+    ])
+
+    girder_f = girder.clone(name='f')
+    girder_d = girder.clone(name='d', mirror=True)
+    env.set('mq.f', k1='3') # Test string with value
+    assert env['mq.f'].k1 == 3.
+    env.set('mq.f', k1='kqf')
+    env.set('mq.d', k1='kqd')
+
+    halfcell = env.new_line(components=[
+
+        # End of the half cell (will be mid of the cell)
+        env.new('mid', xt.Marker, at='l.halfcell'),
+
+        # Bends
+        env.new('mb.2', 'mb', at='l.halfcell / 2'),
+        env.new('mb.1', 'mb', at='-l.mb - 1', from_='mb.2'),
+        env.new('mb.3', 'mb', at='l.mb + 1', from_='mb.2'),
+
+        # Quadrupoles, sextupoles and correctors
+        env.place(girder_d, at=1.2),
+        env.place(girder_f, at='l.halfcell - 1.2'),
+
+    ])
+
+
+    hcell_left = halfcell.replicate(name='l', mirror=True)
+    hcell_right = halfcell.replicate(name='r')
+
+    cell = env.new_line(components=[
+        env.new('start', xt.Marker),
+        hcell_left,
+        hcell_right,
+        env.new('end', xt.Marker),
+    ])
+
+    opt = cell.match(
+        method='4d',
+        vary=xt.VaryList(['kqf', 'kqd'], step=1e-5),
+        targets=xt.TargetSet(
+            qx=0.333333,
+            qy=0.333333,
+        ))
+    tw_cell = cell.twiss4d()
+
+
+    env.vars({
+        'kqf.ss': 0.027 / 2,
+        'kqd.ss': -0.0271 / 2,
+    })
+
+    halfcell_ss = env.new_line(components=[
+
+        env.new('mid', xt.Marker, at='l.halfcell'),
+
+        env.new('mq.ss.d', 'mq', k1='kqd.ss', at = '0.5 + l.mq / 2'),
+        env.new('mq.ss.f', 'mq', k1='kqf.ss', at = 'l.halfcell - l.mq / 2 - 0.5'),
+
+        env.new('corrector.ss.v', 'corrector', at=0.75, from_='mq.ss.d'),
+        env.new('corrector.ss.h', 'corrector', at=-0.75, from_='mq.ss.f')
+    ])
+
+    hcell_left_ss = halfcell_ss.replicate(name='l', mirror=True)
+    hcell_right_ss = halfcell_ss.replicate(name='r')
+    cell_ss = env.new_line(components=[
+        env.new('start.ss', xt.Marker),
+        hcell_left_ss,
+        hcell_right_ss,
+        env.new('end.ss', xt.Marker),
+    ])
+
+    opt = cell_ss.match(
+        solve=False,
+        method='4d',
+        vary=xt.VaryList(['kqf.ss', 'kqd.ss'], step=1e-5),
+        targets=xt.TargetSet(
+            betx=tw_cell.betx[-1], bety=tw_cell.bety[-1], at='start.ss',
+        ))
+    opt.solve()
+
+
+    arc = env.new_line(components=[
+        cell.replicate(name='cell.1'),
+        cell.replicate(name='cell.2'),
+        cell.replicate(name='cell.3'),
+    ])
+
+
+    ss = env.new_line(components=[
+        cell_ss.replicate('cell.1'),
+        cell_ss.replicate('cell.2'),
+    ])
+
+    ring = env.new_line(components=[
+        arc.replicate(name='arc.1'),
+        ss.replicate(name='ss.1'),
+        arc.replicate(name='arc.2'),
+        ss.replicate(name='ss.2'),
+        arc.replicate(name='arc.3'),
+        ss.replicate(name='ss.3'),
+    ])
+
+    ## Insertion
+
+    env.vars({
+        'k1.q1': 0.025,
+        'k1.q2': -0.025,
+        'k1.q3': 0.025,
+        'k1.q4': -0.02,
+        'k1.q5': 0.025,
+    })
+
+    half_insertion = env.new_line(components=[
+
+        # Start-end markers
+        env.new('ip', xt.Marker),
+        env.new('e.insertion', xt.Marker, at=76),
+
+        # Quads
+        env.new('mq.1', xt.Quadrupole, k1='k1.q1', length='l.mq', at = 20),
+        env.new('mq.2', xt.Quadrupole, k1='k1.q2', length='l.mq', at = 25),
+        env.new('mq.3', xt.Quadrupole, k1='k1.q3', length='l.mq', at=37),
+        env.new('mq.4', xt.Quadrupole, k1='k1.q4', length='l.mq', at=55),
+        env.new('mq.5', xt.Quadrupole, k1='k1.q5', length='l.mq', at=73),
+
+        # Dipole correctors (will use h and v on the same corrector)
+        env.new('corrector.ss.1', 'corrector', at=0.75, from_='mq.1'),
+        env.new('corrector.ss.2', 'corrector', at=-0.75, from_='mq.2'),
+        env.new('corrector.ss.3', 'corrector', at=0.75, from_='mq.3'),
+        env.new('corrector.ss.4', 'corrector', at=-0.75, from_='mq.4'),
+        env.new('corrector.ss.5', 'corrector', at=0.75, from_='mq.5'),
+
+    ])
+
+    tw_arc = arc.twiss4d()
+
+    opt = half_insertion.match(
+        solve=False,
+        betx=tw_arc.betx[0], bety=tw_arc.bety[0],
+        alfx=tw_arc.alfx[0], alfy=tw_arc.alfy[0],
+        init_at='e.insertion',
+        start='ip', end='e.insertion',
+        vary=xt.VaryList(['k1.q1', 'k1.q2', 'k1.q3', 'k1.q4'], step=1e-5),
+        targets=[
+            xt.TargetSet(alfx=0, alfy=0, at='ip'),
+            xt.Target(lambda tw: tw.betx[0] - tw.bety[0], 0),
+            xt.Target(lambda tw: tw.betx.max(), xt.LessThan(400)),
+            xt.Target(lambda tw: tw.bety.max(), xt.LessThan(400)),
+            xt.Target(lambda tw: tw.betx.min(), xt.GreaterThan(2)),
+            xt.Target(lambda tw: tw.bety.min(), xt.GreaterThan(2)),
+        ]
+    )
+    opt.step(40)
+    opt.solve()
+
+    insertion = env.new_line([
+        half_insertion.replicate('l', mirror=True),
+        half_insertion.replicate('r')])
+
+
+
+    ring2 = env.new_line(components=[
+        arc.replicate(name='arcc.1'),
+        ss.replicate(name='sss.2'),
+        arc.replicate(name='arcc.2'),
+        insertion,
+        arc.replicate(name='arcc.3'),
+        ss.replicate(name='sss.3')
+    ])
+
+
+    # # Check buffer behavior
+    ring2_sliced = ring2.select()
+    ring2_sliced.cut_at_s(np.arange(0, ring2.get_length(), 0.5))
+
+
+    # import matplotlib.pyplot as plt
+    # plt.close('all')
+    # for ii, rr in enumerate([ring, ring2_sliced]):
+
+    #     tw = rr.twiss4d()
+
+    #     fig = plt.figure(ii, figsize=(6.4*1.2, 4.8))
+    #     ax1 = fig.add_subplot(2, 1, 1)
+    #     pltbet = tw.plot('betx bety', ax=ax1)
+    #     ax2 = fig.add_subplot(2, 1, 2, sharex=ax1)
+    #     pltdx = tw.plot('dx', ax=ax2)
+    #     fig.subplots_adjust(right=.85)
+    #     pltbet.move_legend(1.2,1)
+    #     pltdx.move_legend(1.2,1)
+
+    # ring2.survey().plot()
+
+    # plt.show()
+
+

{xtrack-0.66.0 → xtrack-0.67.0}/tests/test_line.py

@@ -656,36 +656,50 @@ def test_from_json_to_json(tmp_path):
     }
     line.metadata = example_metadata
 
+    def asserts():
+        assert len(result.element_dict.keys()) == 2
+        assert result.element_names == ['m', 'd', 'm', 'd']
+
+        assert isinstance(result['m'], xt.Multipole)
+        assert (result['m'].knl == [1, 2]).all()
+
+        assert isinstance(result['d'], xt.Drift)
+        assert result['d'].length == 1
+
+        assert result.metadata == example_metadata
+        result.metadata['qx']['lhcb1'] = result.metadata['qx']['lhcb1'] + 1
+        assert result.metadata != example_metadata
+        result.metadata['qx']['lhcb1'] = result.metadata['qx']['lhcb1'] - 1
+
     line.to_json(tmp_path / 'test.json')
     result = xt.Line.from_json(tmp_path / 'test.json')
 
-    assert len(result.element_dict.keys()) == 2
-    assert result.element_names == ['m', 'd', 'm', 'd']
+    asserts()
 
-    assert isinstance(result['m'], xt.Multipole)
-    assert (result['m'].knl == [1, 2]).all()
+    with open(tmp_path / 'test2.json', 'w') as f:
+        line.to_json(f)
 
-    assert isinstance(result['d'], xt.Drift)
-    assert result['d'].length == 1
+    with open(tmp_path / 'test2.json', 'r') as f:
+        result = xt.Line.from_json(f)
+
+    asserts()
 
     with open(tmp_path / 'test2.json', 'w') as f:
-        line.to_json(f)
+        line.to_json(f,indent=None)
 
     with open(tmp_path / 'test2.json', 'r') as f:
         result = xt.Line.from_json(f)
 
-    assert len(result.element_dict.keys()) == 2
-    assert result.element_names == ['m', 'd', 'm', 'd']
+    asserts()
 
-    assert isinstance(result['m'], xt.Multipole)
-    assert (result['m'].knl == [1, 2]).all()
+    with open(tmp_path / 'test2.json.gz', 'w') as f:
+        line.to_json(f,indent=2)
 
-    assert isinstance(result['d'], xt.Drift)
-    assert result['d'].length == 1
+    with open(tmp_path / 'test2.json.gz', 'r') as f:
+        result = xt.Line.from_json(f)
+
+    asserts()
 
-    assert result.metadata == example_metadata
-    result.metadata['qx']['lhcb1'] = result.metadata['qx']['lhcb1'] + 1
-    assert result.metadata != example_metadata
 
 @for_all_test_contexts
 def test_config_propagation(test_context):
@@ -1060,4 +1074,4 @@ def test_get_strengths(test_context):
             rtol=0, atol=1e-14)
     xo.assert_allclose(line['mbw.a6l3.b2'].h,
             str_table['angle_rad', 'mbw.a6l3.b2'] / str_table['length', 'mbw.a6l3.b2'],
-            rtol=0, atol=1e-14)
+            rtol=0, atol=1e-14)

{xtrack-0.66.0 → xtrack-0.67.0}/tests/test_periodic_symmetric_twiss_and_match.py

@@ -137,6 +137,8 @@ def test_periodic_symmetric_twiss_and_match():
                     tw_cell.rows[:'mid_cell'].dx, atol=1e-8, rtol=0)
     xo.assert_allclose(tw_half_cell.dpx[:-1], # remove '_end_point'
                         tw_cell.rows[:'mid_cell'].dpx, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.ddx[:-1], # remove '_end_point'
+                   tw_cell.rows[:'mid_cell'].ddx, atol=1e-7, rtol=0)
 
     xo.assert_allclose(tw_half_cell.ax_chrom[:-1], # remove '_end_point'
                         tw_cell.rows[:'mid_cell'].ax_chrom, atol=1e-5, rtol=0)
@@ -146,9 +148,17 @@ def test_periodic_symmetric_twiss_and_match():
                         tw_cell.rows[:'mid_cell'].bx_chrom, atol=1e-5, rtol=0)
     xo.assert_allclose(tw_half_cell.by_chrom[:-1], # remove '_end_point'
                         tw_cell.rows[:'mid_cell'].by_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.ddx[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ddx, atol=1e-7, rtol=0)
 
     xo.assert_allclose(tw_half_cell.qx, tw_cell.qx / 2, atol=1e-9, rtol=0)
     xo.assert_allclose(tw_half_cell.qy, tw_cell.qy / 2, atol=1e-9, rtol=0)
     xo.assert_allclose(tw_half_cell.dqx, tw_cell.dqx / 2, atol=1e-6, rtol=0)
     xo.assert_allclose(tw_half_cell.dqy, tw_cell.dqy / 2, atol=1e-6, rtol=0)
 
+    tw_off_mom_cell = cell.twiss4d(strengths=True, delta0=1e-3)
+    tw_off_mom_half_cell = half_cell.twiss4d(
+        init='periodic_symmetric', strengths=True, delta0=1e-3)
+
+    xo.assert_allclose(tw_off_mom_half_cell.x[:-1],
+                    tw_off_mom_cell.rows[:'mid_cell'].x, atol=1e-12, rtol=0)

{xtrack-0.66.0 → xtrack-0.67.0}/tests/test_slice_and_insert_with_replicas.py

@@ -236,6 +236,8 @@ def test_slice_thick_and_insert_with_replicas(test_context):
                 element_names=list(elements.keys()))
     line.build_tracker(_context=test_context)
 
+    assert line['e2']._movable
+
     element_no_repl={
         'e0': xt.Bend(k0=0.3, h=0.31, length=1),
         'e1': xt.Bend(k0=0.3, h=0.31, length=1),
@@ -275,18 +277,26 @@ def test_slice_thick_and_insert_with_replicas(test_context):
     assert_allclose(p2.zeta, p1.zeta, rtol=0, atol=1e-14)
     assert_allclose(p2.delta, p1.delta, rtol=0, atol=1e-14)
 
+    assert line['e2']._movable
+    # line['e2']._mark = True
+
     line.slice_thick_elements(
         slicing_strategies=[
             xt.Strategy(None),
             xt.Strategy(xt.Teapot(3, mode='thick'), name='e2|e3|e4')])
+    assert line['e2']._movable
     line.build_tracker(_context=test_context)
 
+    assert line['e2']._movable
+
     line_no_repl.slice_thick_elements(
         slicing_strategies=[
             xt.Strategy(None),
             xt.Strategy(xt.Teapot(3, mode='thick'), name='e2|e3|e4')])
     line_no_repl.build_tracker(_context=test_context)
 
+    assert line['e2']._movable
+
     tt = line.get_table()
     tt_no_repl = line_no_repl.get_table()
 
@@ -341,13 +351,17 @@ def test_slice_thick_and_insert_with_replicas(test_context):
     assert_allclose(p2.zeta, p1.zeta, rtol=0, atol=1e-14)
     assert_allclose(p2.delta, p1.delta, rtol=0, atol=1e-14)
 
+    assert line['e2']._movable
+
     line.discard_tracker()
+    assert line['e2']._movable
     line.insert_element(name='mkins1', element=xt.Marker(), at_s=0.5)
     line.insert_element(name='mkins2', element=xt.Marker(), at_s=1.5)
     line.insert_element(name='mkins3', element=xt.Marker(), at_s=2.5)
     line.insert_element(name='mkins4', element=xt.Marker(), at_s=3.5)
     line.insert_element(name='mkins5', element=xt.Marker(), at_s=4.5)
     line.build_tracker(_context=test_context)
+    assert line['e2']._movable
 
     line_no_repl.discard_tracker()
     line_no_repl.insert_element(name='mkins1', element=xt.Marker(), at_s=0.5)
@@ -356,6 +370,7 @@ def test_slice_thick_and_insert_with_replicas(test_context):
     line_no_repl.insert_element(name='mkins4', element=xt.Marker(), at_s=3.5)
     line_no_repl.insert_element(name='mkins5', element=xt.Marker(), at_s=4.5)
     line_no_repl.build_tracker(_context=test_context)
+    assert line['e2']._movable
 
     tt = line.get_table()
     tt_no_repl = line_no_repl.get_table()
@@ -428,6 +443,7 @@ def test_slice_thick_and_insert_with_replicas(test_context):
 
     line.track(p1)
     line_no_repl.track(p2)
+    assert line['e2']._movable
 
     assert_allclose(p2.x, p1.x, rtol=0, atol=1e-14)
     assert_allclose(p2.px, p1.px, rtol=0, atol=1e-14)

{xtrack-0.66.0 → xtrack-0.67.0}/xtrack/__init__.py

@@ -13,6 +13,7 @@ from .beam_elements import *
 from .random import *
 from .tracker_data import TrackerData
 from .line import Line, Node, freeze_longitudinal, _temp_knobs, EnergyProgram
+from .environment import Environment, Place
 from .tracker import Tracker, Log
 from .match import (Vary, Target, TargetList, VaryList, TargetInequality, Action,
                     TargetRelPhaseAdvance, TargetSet, GreaterThan, LessThan,

xtrack-0.67.0/xtrack/_version.py

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