xtrack 0.68.0__tar.gz → 0.69.1__tar.gz

{xtrack-0.68.0/xtrack.egg-info → xtrack-0.69.1}/PKG-INFO

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

{xtrack-0.68.0 → xtrack-0.69.1}/tests/test_environment.py

@@ -3,6 +3,9 @@ import xobjects as xo
 import xdeps as xd
 import numpy as np
 import pytest
+import pathlib
+
+test_data_folder = pathlib.Path(__file__).parent.joinpath('../test_data').absolute()
 
 @pytest.mark.parametrize('container_type', ['env', 'line'])
 def test_vars_and_element_access_modes(container_type):
@@ -568,13 +571,13 @@ def test_assemble_ring():
     # Check that the cell is matched to the rest of the ring
     tw = ring.twiss4d()
     tw_cell_from_ring = tw.rows['start.cell.3.arc.2':'end.cell.3.arc.2']
-    xo.assert_allclose(tw_cell_from_ring.betx, tw_cell.betx[:-1], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw_cell_from_ring.bety, tw_cell.bety[:-1], atol=0, rtol=2e-4)
+    xo.assert_allclose(tw_cell_from_ring.betx, tw_cell.betx[:-1], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw_cell_from_ring.bety, tw_cell.bety[:-1], atol=0, rtol=5e-4)
 
     tw2 = ring2.twiss4d()
     tw_cell_from_ring2 = tw2.rows['start.cell.3.arc.2':'end.cell.3.arc.2']
-    xo.assert_allclose(tw_cell_from_ring2.betx, tw_cell.betx[:-1], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw_cell_from_ring2.bety, tw_cell.bety[:-1], atol=0, rtol=2e-4)
+    xo.assert_allclose(tw_cell_from_ring2.betx, tw_cell.betx[:-1], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw_cell_from_ring2.bety, tw_cell.bety[:-1], atol=0, rtol=5e-4)
 
     # Check select
     cell3_select = ring2.select(start='start.cell.3.arc.2', end='end.cell.3.arc.2',
@@ -598,8 +601,8 @@ def test_assemble_ring():
     cell3_select.twiss4d()
 
     tw2_slice = ring2_sliced.twiss4d()
-    xo.assert_allclose(tw2_slice['betx', 'ip.l'], tw2['betx', 'ip.l'], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw2_slice['bety', 'ip.l'], tw2['bety', 'ip.l'], atol=0, rtol=2e-4)
+    xo.assert_allclose(tw2_slice['betx', 'ip.l'], tw2['betx', 'ip.l'], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw2_slice['bety', 'ip.l'], tw2['bety', 'ip.l'], atol=0, rtol=5e-4)
     xo.assert_allclose(tw2_slice['alfx', 'ip.l'], 0, atol=1e-6, rtol=0)
     xo.assert_allclose(tw2_slice['alfy', 'ip.l'], 0, atol=1e-6, rtol=0)
     xo.assert_allclose(tw2_slice['dx', 'ip.l'], 0, atol=1e-4, rtol=0)
@@ -976,13 +979,13 @@ def test_assemble_ring_builders():
     # Check that the cell is matched to the rest of the ring
     tw = ring.twiss4d()
     tw_cell_from_ring = tw.rows['start.cell.3.arc.2':'end.cell.3.arc.2']
-    xo.assert_allclose(tw_cell_from_ring.betx, tw_cell.betx[:-1], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw_cell_from_ring.bety, tw_cell.bety[:-1], atol=0, rtol=2e-4)
+    xo.assert_allclose(tw_cell_from_ring.betx, tw_cell.betx[:-1], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw_cell_from_ring.bety, tw_cell.bety[:-1], atol=0, rtol=5e-4)
 
     tw2 = ring2.twiss4d()
     tw_cell_from_ring2 = tw2.rows['start.cell.3.arc.2':'end.cell.3.arc.2']
-    xo.assert_allclose(tw_cell_from_ring2.betx, tw_cell.betx[:-1], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw_cell_from_ring2.bety, tw_cell.bety[:-1], atol=0, rtol=2e-4)
+    xo.assert_allclose(tw_cell_from_ring2.betx, tw_cell.betx[:-1], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw_cell_from_ring2.bety, tw_cell.bety[:-1], atol=0, rtol=5e-4)
 
     # Check select
     cell3_select = ring2.select(start='start.cell.3.arc.2', end='end.cell.3.arc.2',
@@ -1006,8 +1009,8 @@ def test_assemble_ring_builders():
     cell3_select.twiss4d()
 
     tw2_slice = ring2_sliced.twiss4d()
-    xo.assert_allclose(tw2_slice['betx', 'ip.l'], tw2['betx', 'ip.l'], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw2_slice['bety', 'ip.l'], tw2['bety', 'ip.l'], atol=0, rtol=2e-4)
+    xo.assert_allclose(tw2_slice['betx', 'ip.l'], tw2['betx', 'ip.l'], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw2_slice['bety', 'ip.l'], tw2['bety', 'ip.l'], atol=0, rtol=5e-4)
     xo.assert_allclose(tw2_slice['alfx', 'ip.l'], 0, atol=1e-6, rtol=0)
     xo.assert_allclose(tw2_slice['alfy', 'ip.l'], 0, atol=1e-6, rtol=0)
     xo.assert_allclose(tw2_slice['dx', 'ip.l'], 0, atol=1e-4, rtol=0)
@@ -1180,7 +1183,7 @@ def test_assemble_ring_repeated_elements():
     tt_cell = cell.get_table(attr=True)
     tt_cell['s_center'] = (
         tt_cell['s'] + tt_cell['length'] / 2 * np.float64(tt_cell['isthick']))
-    assert np.all(tt_cell.name == np.array(
+    assert np.all(tt_cell.env_name == np.array(
         ['mid', 'drift_9', 'ms.f', 'drift_3.f', 'mq.f', 'drift_2.f',
        'corrector.f', 'drift_1.f', 'drift_8', 'mb.3', 'drift_7', 'mb.2',
        'drift_6', 'mb.1', 'drift_5', 'drift_1.d', 'corrector.d',
@@ -1239,8 +1242,8 @@ def test_assemble_ring_repeated_elements():
     tt_arc = arc.get_table(attr=True)
     assert len(tt_arc) == 3 * (len(tt_cell)-1) + 1
     n_cell = len(tt_cell) - 1
-    assert np.all(tt_arc.name[n_cell:2*n_cell] == tt_cell.name[:-1])
-    for nn in tt_cell.name[:-1]:
+    assert np.all(tt_arc.env_name[n_cell:2*n_cell] == tt_cell.env_name[:-1])
+    for nn in tt_cell.env_name[:-1]:
         assert arc.get(nn) is env.get(nn)
         assert arc.get(nn) is env['cell'].get(nn)
 
@@ -1337,11 +1340,11 @@ def test_assemble_ring_repeated_elements():
 
     # Check that the cell is matched to the rest of the ring
     tw_ring = ring.twiss4d()
-    xo.assert_allclose(tw_ring.betx[0], tw_cell.betx[0], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw_ring.bety[0], tw_cell.bety[0], atol=0, rtol=2e-4)
+    xo.assert_allclose(tw_ring.betx[0], tw_cell.betx[0], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw_ring.bety[0], tw_cell.bety[0], atol=0, rtol=5e-4)
     tw_ring2 = ring2.twiss4d()
-    xo.assert_allclose(tw_ring2.betx[0], tw_cell.betx[0], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw_ring2.bety[0], tw_cell.bety[0], atol=0, rtol=2e-4)
+    xo.assert_allclose(tw_ring2.betx[0], tw_cell.betx[0], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw_ring2.bety[0], tw_cell.bety[0], atol=0, rtol=5e-4)
 
     # Check that they share the _element_dict
     assert cell._element_dict is env.element_dict
@@ -1351,14 +1354,29 @@ def test_assemble_ring_repeated_elements():
     assert insertion._element_dict is env.element_dict
     assert ring2._element_dict is env.element_dict
 
-    xo.assert_allclose(tw_ring2['betx', 'ip'], tw_half_insertion['betx', 'ip'], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw_ring2['bety', 'ip'], tw_half_insertion['bety', 'ip'], atol=0, rtol=2e-4)
-    xo.assert_allclose(tw_ring2['alfx', 'ip'], 0, atol=1e-6, rtol=0)
-    xo.assert_allclose(tw_ring2['alfy', 'ip'], 0, atol=1e-6, rtol=0)
-    xo.assert_allclose(tw_ring2['dx', 'ip'], 0, atol=1e-4, rtol=0)
-    xo.assert_allclose(tw_ring2['dpx', 'ip'], 0, atol=1e-6, rtol=0)
-    xo.assert_allclose(tw_ring2['dy', 'ip'], 0, atol=1e-4, rtol=0)
-    xo.assert_allclose(tw_ring2['dpy', 'ip'], 0, atol=1e-6, rtol=0)
+    xo.assert_allclose(tw_ring2['betx', 'ip::0'], tw_half_insertion['betx', 'ip'], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw_ring2['bety', 'ip::0'], tw_half_insertion['bety', 'ip'], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw_ring2['alfx', 'ip::0'], 0, atol=1e-6, rtol=0)
+    xo.assert_allclose(tw_ring2['alfy', 'ip::0'], 0, atol=1e-6, rtol=0)
+    xo.assert_allclose(tw_ring2['dx', 'ip::0'], 0, atol=1e-4, rtol=0)
+    xo.assert_allclose(tw_ring2['dpx', 'ip::0'], 0, atol=1e-6, rtol=0)
+    xo.assert_allclose(tw_ring2['dy', 'ip::0'], 0, atol=1e-4, rtol=0)
+    xo.assert_allclose(tw_ring2['dpy', 'ip::0'], 0, atol=1e-6, rtol=0)
+
+    # Check a line with the same marker at start and end
+    assert arc.element_names[0] == 'mid'
+    assert arc.element_names[-1] == 'mid'
+    twarc = arc.twiss4d()
+    xo.assert_allclose(twarc.s[0], 0, atol=1e-12, rtol=0)
+    xo.assert_allclose(twarc.s[-1], 228, atol=1e-10, rtol=0)
+    twarc_start_end = arc.twiss4d(start=xt.START, end=xt.END, init=twarc)
+    xo.assert_allclose(twarc_start_end.betx, twarc.betx, atol=1e-12, rtol=0)
+
+    tw_one_cell_ref = twarc.rows['mid::2':'mid::3']
+    tw_one_cell = arc.twiss4d(start='mid::2', end='mid::3', init='periodic')
+    tw_one_cell_stripped = tw_one_cell.rows[:-1] # remove _end_point
+    xo.assert_allclose(tw_one_cell_stripped.betx, tw_one_cell_ref.betx, atol=0, rtol=5e-4)
+
 
     # import matplotlib.pyplot as plt
     # plt.close('all')
@@ -1671,7 +1689,7 @@ def test_repeated_elements():
     ])
 
     tt = line.get_table()
-    assert np.all(tt.name == np.array(['mb', 'mb', 'drift_1', 'ip1', 'mb',
+    assert np.all(tt.env_name == np.array(['mb', 'mb', 'drift_1', 'ip1', 'mb',
                                     'mb', 'drift_2', 'mb', 'ip2', 'mb',
                                     'mb', '_end_point']))
     assert np.all(tt.s == np.array([
@@ -1692,7 +1710,7 @@ def test_repeated_elements():
         env.place(l1, at=-env.ref['s.l1'], from_='ip'),
     ])
     tt_twol1 = l_twol1.get_table()
-    assert np.all(tt_twol1.name == np.array(
+    assert np.all(tt_twol1.env_name == np.array(
         ['drift_3', 'mb', 'mb', 'mid', 'mb', 'mb', 'drift_4', 'ip',
         'drift_5', 'mb', 'mb', 'mid', 'mb', 'mb', '_end_point']))
     assert np.all(tt_twol1.s == np.array(
@@ -1705,7 +1723,42 @@ def test_repeated_elements():
     ])
     tt_mult = l_mult.get_table()
     assert np.all(tt_mult.name == np.array([
+        'mb::0', 'mb::1', 'mid::0', 'mb::2', 'mb::3', 'mb::4', 'mb::5',
+       'mid::1', 'mb::6', 'mb::7', 'mb::8', 'mb::9', '_end_point']))
+    assert np.all(tt_mult.env_name == np.array([
         'mb', 'mb', 'mid', 'mb', 'mb', 'mb', 'mb', 'mid', 'mb', 'mb', 'mb',
         'mb', '_end_point']))
     assert np.all(tt_mult.s == np.array(
-        [0. , 0.5, 1. , 1. , 1.5, 2. , 2.5, 3. , 3. , 3.5, 4. , 4.5, 5. ]))
+        [0. , 0.5, 1. , 1. , 1.5, 2. , 2.5, 3. , 3. , 3.5, 4. , 4.5, 5. ]))
+
+def test_select_in_multiline():
+
+    # --- Parameters
+    seq         = 'lhcb1'
+    ip_name     = 'ip1'
+    s_marker    = f'e.ds.l{ip_name[-1]}.b1'
+    e_marker    = f's.ds.r{ip_name[-1]}.b1'
+    #-------------------------------------
+
+    collider_file = test_data_folder / 'hllhc15_collider/collider_00_from_mad.json'
+
+    # Load the machine and select line
+    collider= xt.Multiline.from_json(collider_file)
+    collider.vars['test_vars'] = 3.1416
+    line   = collider[seq]
+    line_sel    = line.select(s_marker,e_marker)
+
+    assert line_sel.element_dict is line.element_dict
+    assert line.get('ip1') is line_sel.get('ip1')
+
+    line_sel['aaa'] = 1e-6
+    assert line_sel['aaa'] == 1e-6
+    assert line['aaa'] == 1e-6
+
+    line_sel.ref['mcbch.7r1.b1'].knl[0] += line.ref['aaa']
+    assert (str(line.ref['mcbch.7r1.b1'].knl[0]._expr)
+            == "((-vars['acbch7.r1b1']) + vars['aaa'])")
+    assert (str(line_sel.ref['mcbch.7r1.b1'].knl[0]._expr)
+            == "((-vars['acbch7.r1b1']) + vars['aaa'])")
+    assert line_sel.get('mcbch.7r1.b1').knl[0] == 1e-6
+    assert line.get('mcbch.7r1.b1').knl[0] == 1e-6

{xtrack-0.68.0 → xtrack-0.69.1}/tests/test_psb_chicane.py

@@ -376,7 +376,6 @@ def test_psb_chicane(test_context):
 
     line.enable_time_dependent_vars = True
     line.dt_update_time_dependent_vars = 3e-6
-    line.vars.cache_active = True
 
     print('Tracking...')
     line.track(p, num_turns=6000, time=True)

xtrack-0.69.1/xtrack/_version.py

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

{xtrack-0.68.0 → xtrack-0.69.1}/xtrack/environment.py

@@ -61,6 +61,12 @@ class Environment:
         out._name = name
         out.builder = Builder(env=self, components=components)
 
+        # Temporary solution to keep consistency in multiline
+        if hasattr(self, '_in_multiline') and self._in_multiline is not None:
+            out._var_management = None
+            out._in_multiline = self._in_multiline
+            out._name_in_multiline = self._name_in_multiline
+
         self._lines_weakrefs.add(out) # Weak references
         if name is not None:
             self.lines[name] = out
@@ -277,6 +283,7 @@ def _resolve_s_positions(seq_all_places, env):
     aux_line = env.new_line(components=names_unsorted)
     aux_tt = aux_line.get_table()
     aux_tt['length'] = np.diff(aux_tt._data['s'], append=0)
+    aux_tt.name = aux_tt.env_name # I want the repeated names here
 
     s_center_dct = {}
     s_center_dct_names = {}

{xtrack-0.68.0 → xtrack-0.69.1}/xtrack/line.py

@@ -131,18 +131,6 @@ class Line:
         else:
             if element_names is None:
                 element_names = [f"e{ii}" for ii in range(len(elements))]
-            if len(element_names) > len(set(element_names)):
-                log.warning("Repetition found in `element_names` -> renaming")
-                old_element_names = element_names
-                element_names = []
-                counters = {nn: 0 for nn in old_element_names}
-                for nn in old_element_names:
-                    if counters[nn] > 0:
-                        new_nn = nn + '_' + str(counters[nn])
-                    else:
-                        new_nn = nn
-                    counters[nn] += 1
-                    element_names.append(new_nn)
 
             assert len(element_names) == len(elements), (
                 "`elements` and `element_names` should have the same length"
@@ -733,7 +721,12 @@ class Line:
         for kk in data.keys():
             data[kk] = np.array(data[kk])
 
-        return xd.Table(data=data)
+        names_table = xd.Table(data={'name': data['name']})
+        names_unique = names_table.cols.get_index_unique()
+        data['env_name'] = data['name']
+        data['name'] = names_unique
+        out = xd.Table(data=data, sep_count='::::')
+        return out
 
     def get_strengths(self, reverse=None):
 
@@ -3482,6 +3475,14 @@ class Line:
 
         out = self.env.new_line(components=list(tt.name), name=name)
 
+        if hasattr(self, '_in_multiline') and self._in_multiline is not None:
+            out.env._var_management = None
+            out._var_management = None
+            out.env._in_multiline = self._in_multiline
+            out._in_multiline = self._in_multiline
+            out.env._name_in_multiline = self._name_in_multiline
+            out._name_in_multiline = self._name_in_multiline
+
         return out
 
     def set(self, name, *args, **kwargs):
@@ -3542,6 +3543,12 @@ class Line:
                                       _var_management=self._var_management)
             self.env._lines_weakrefs.add(self)
 
+            # Temporary solution to keep consistency in multiline
+            if hasattr(self, '_in_multiline') and self._in_multiline is not None:
+                self.env._var_management = None
+                self.env._in_multiline = self._in_multiline
+                self.env._name_in_multiline = self._name_in_multiline
+
     def extend(self, line):
         self.element_names.extend(line.element_names)
 
@@ -4252,6 +4259,13 @@ class Line:
                 new_ee = ee.get_equivalent_element()
                 self.element_dict[nn] = new_ee
 
+    @property
+    def _element_names_unique(self):
+        if not self._has_valid_tracker():
+            raise RuntimeError(
+                '`Line._element_names_unique` con only be called after `Line.build_tracker`')
+        return self.tracker._tracker_data_base._element_names_unique
+
 def frac(x):
     return x % 1
 
@@ -4628,8 +4642,6 @@ class LineVars:
 
     def __init__(self, line):
         self.line = line
-        self._cache_active = False
-        self._cached_setters = {}
         if '__vary_default' not in self.line._xdeps_vref._owner.keys():
             self.line._xdeps_vref._owner['__vary_default'] = {}
         self.val = VarValues(self)
@@ -4682,26 +4694,9 @@ class LineVars:
                 out.append(kk)
         return out
 
-    def _setter_from_cache(self, varname):
-        if varname not in self._cached_setters:
-            if self.line._xdeps_manager is None:
-                raise RuntimeError(
-                    f'Cannot access variable {varname} as the line has no '
-                    'xdeps manager')
-            try:
-                self.cache_active = False
-                self._cached_setters[varname] = VarSetter(self.line, varname)
-                self.cache_active = True
-            except Exception as ee:
-                self.cache_active = True
-                raise ee
-        return self._cached_setters[varname]
-
     def __getitem__(self, key):
         if key not in self: # uses __contains__ method
             raise KeyError(f'Variable `{key}` not found')
-        if self.cache_active:
-            return self._setter_from_cache(key)
         return self.line._xdeps_vref[key]
 
     def get(self,key,default=0):
@@ -4711,25 +4706,9 @@ class LineVars:
             return default
 
     def __setitem__(self, key, value):
-        if self.cache_active:
-            if isref(value) or isinstance(value, VarSetter):
-                raise ValueError('Cannot set a variable to a ref when the '
-                                 'cache is active')
-            self._setter_from_cache(key)(value)
-        else:
-            if isinstance(value, str):
-                value = self.line._xdeps_eval.eval(value)
-            self.line._xdeps_vref[key] = value
-
-    @property
-    def cache_active(self):
-        return self._cache_active
-
-    @cache_active.setter
-    def cache_active(self, value):
-        assert value in (True, False)
-        self._cache_active = value
-        self.line._xdeps_manager._tree_frozen = value
+        if isinstance(value, str):
+            value = self.line._xdeps_eval.eval(value)
+        self.line._xdeps_vref[key] = value
 
     def set_from_madx_file(self, filename, mad_stdout=False):
 
@@ -4761,9 +4740,6 @@ class LineVars:
         for ff in filename:
             mad.call(str(ff))
 
-        assert self.cache_active is False, (
-            'Cannot load optics file when cache is active')
-
         mad.input('''
         elm: marker; dummy: sequence, l=1; e:elm, at=0.5; endsequence;
         beam; use,sequence=dummy;''')
@@ -4829,8 +4805,6 @@ class ActionVars(Action):
         self.line = line
 
     def run(self, **kwargs):
-        assert not self.line.vars.cache_active, (
-            'Cannot run action when cache is active')
         return self.line._xdeps_vref._owner
 
 class ActionLine(Action):
@@ -4858,45 +4832,6 @@ class VarValues:
         else:
             return default
 
-class VarSetter:
-    def __init__(self, line, varname):
-        self.multiline = line
-        self.varname = varname
-
-        manager = self.multiline._xdeps_manager
-        if manager is None:
-            raise RuntimeError(
-                f'Cannot access variable {varname} as the line has no xdeps manager')
-        # assuming line._xdeps_vref is a direct view of a dictionary
-        self.owner = line._xdeps_vref[varname]._owner._owner
-        self.fstr = manager.mk_fun('setter', **{'val': line._xdeps_vref[varname]})
-        self.gbl = {k: r._owner for k, r in manager.containers.items()}
-        self._build_fun()
-
-    def get_value(self):
-        return self.owner[self.varname]
-
-    @property
-    def _value(self):
-        return self.get_value()
-
-    def _build_fun(self):
-        lcl = {}
-        exec(self.fstr, self.gbl.copy(), lcl)
-        self.fun = lcl['setter']
-
-    def __call__(self, value):
-        self.fun(val=value)
-
-    def __getstate__(self):
-        out = self.__dict__.copy()
-        out.pop('fun')
-        return out
-
-    def __setstate__(self, state):
-        self.__dict__.update(state)
-        self._build_fun()
-
 class LineAttrItem:
     def __init__(self, name, index=None, line=None):
         self.name = name

{xtrack-0.68.0 → xtrack-0.69.1}/xtrack/tracker.py

@@ -120,6 +120,10 @@ class Tracker:
             _context=_context,
             _buffer=_buffer,
             _no_resolve_parents=_prebuilding_kernels)
+        if not _prebuilding_kernels:
+            tracker_data_base._line_table = line.get_table()
+            tracker_data_base._element_names_unique = tuple(
+                    tracker_data_base._line_table.name[:-1]) # remove _endpoint
         line._freeze()
 
         if np.any([hasattr(ee, 'needs_rng') and ee.needs_rng for ee in line.elements]):