xtrack 0.69.2__tar.gz → 0.69.4__tar.gz

{xtrack-0.69.2/xtrack.egg-info → xtrack-0.69.4}/PKG-INFO

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

{xtrack-0.69.2 → xtrack-0.69.4}/tests/test_environment.py

@@ -1782,3 +1782,74 @@ def test_select_in_multiline():
             == "((-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
+
+@pytest.mark.parametrize('container_type', ['env', 'line'])
+def test_inpection_methods(container_type):
+
+    env = xt.Environment()
+
+    env.vars({
+        'k.1': 1.,
+        'a': 2.,
+        'b': '2 * a + k.1',
+    })
+
+    line = env.new_line([
+        env.new('bb', xt.Bend, k0='2 * b', length=3+env.vars['a'] + env.vars['b'],
+            h=5., ksl=[0, '3*b']),
+    ])
+
+    ee = {'env': env, 'line': line}[container_type]
+
+    # Line/Env methods (get, set, eval, get_expr, new_expr, info)
+    assert ee.get('b') == 2 * 2 + 1
+    assert ee.get('bb') is env.element_dict['bb']
+
+    assert str(ee.get_expr('b')) == "((2.0 * vars['a']) + vars['k.1'])"
+
+    assert ee.eval('3*a - sqrt(k.1)') == 5
+
+    ne = ee.new_expr('sqrt(3*a + 3)')
+    assert xd.refs.is_ref(ne)
+    assert str(ne) == "f.sqrt(((3.0 * vars['a']) + 3.0))"
+
+    ee.info('bb') # Check that it works
+    ee.info('b')
+    ee.info('a')
+
+    ee.set('c', '6*a')
+    assert ee.get('c') == 6 * 2
+
+    # Line/Env containers (env[...], env.ref[...]
+    assert ee['b'] == 2 * 2 + 1
+    assert type(ee['bb']).__name__ == 'View'
+    assert ee['bb'].__class__.__name__ == 'Bend'
+
+    # Vars methods (get, set, eval, get_expr, new_expr, info, get_table)
+    assert ee.vars.get('b') == 2 * 2 + 1
+
+    assert str(ee.vars.get_expr('b')) == "((2.0 * vars['a']) + vars['k.1'])"
+
+    assert ee.vars.eval('3*a - sqrt(k.1)') == 5
+
+    ne = ee.vars.new_expr('sqrt(3*a + 3)')
+    assert xd.refs.is_ref(ne)
+    assert str(ne) == "f.sqrt(((3.0 * vars['a']) + 3.0))"
+
+    ee.vars.info('b')
+    ee.vars.info('a')
+
+    ee.vars.set('d', '7*a')
+    assert ee.vars.get('d') == 7 * 2
+
+    assert xd.refs.is_ref(ee.vars['b'])
+
+    # View methods get_expr, get_value, get_info, get_table (for now)
+    assert xd.refs.is_ref(ee['bb'].get_expr('k0'))
+    assert str(ee['bb'].get_expr('k0')) == "(2.0 * vars['b'])"
+    assert ee['bb'].get_expr('k0')._value == 2 * (2 * 2 + 1)
+    assert ee['bb'].get_value('k0') == 2 * (2 * 2 + 1)
+
+    tt = ee['bb'].get_table()
+    assert tt['value', 'k0'] == 2 * (2 * 2 + 1)
+    assert tt['expr', 'k0'] == "(2.0 * vars['b'])"

{xtrack-0.69.2 → xtrack-0.69.4}/tests/test_survey.py

@@ -12,6 +12,11 @@ tilted = True
 orientation = 'acw'
 transform_to_actual_elements = True
 
+if hasattr(np, 'trapezoid'): # numpy >= 2.0
+    trapz = np.trapezoid
+else:
+    trapz = np.trapz
+
 @for_all_test_contexts
 @pytest.mark.parametrize(
     'slice_mode',
@@ -103,17 +108,17 @@ def test_survey_slicing(test_context, slice_mode, tilted, orientation,
 
     if not tilted and orientation == 'acw':
         assert_allclose(np.abs(sv.Y), 0, rtol=0, atol=1e-14)
-        assert_allclose(np.trapezoid(sv.X, sv.Z), -4.818 , rtol=0, # anti-clockwise
+        assert_allclose(trapz(sv.X, sv.Z), -4.818 , rtol=0, # anti-clockwise
                         atol=(2e-3 if slice_mode is not None else 0.5))
     elif not tilted and orientation == 'cw':
         assert_allclose(np.abs(sv.Y), 0, rtol=0, atol=1e-14)
-        assert_allclose(np.trapezoid(sv.X, sv.Z), 4.818 , rtol=0, # clockwise
+        assert_allclose(trapz(sv.X, sv.Z), 4.818 , rtol=0, # clockwise
                         atol=(2e-3 if slice_mode is not None else 0.5))
     elif tilted and orientation == 'acw':
         assert_allclose(np.abs(sv.X), 0, rtol=0, atol=1e-14)
-        assert_allclose(np.trapezoid(sv.Y, sv.Z), -4.818 , rtol=0, # anti-clockwise
+        assert_allclose(trapz(sv.Y, sv.Z), -4.818 , rtol=0, # anti-clockwise
                         atol=(2e-3 if slice_mode is not None else 0.5))
     elif tilted and orientation == 'cw':
         assert_allclose(np.abs(sv.X), 0, rtol=0, atol=1e-14)
-        assert_allclose(np.trapezoid(sv.Y, sv.Z), 4.818 , rtol=0, # clockwise
+        assert_allclose(trapz(sv.Y, sv.Z), 4.818 , rtol=0, # clockwise
                         atol=(2e-3 if slice_mode is not None else 0.5))

xtrack-0.69.4/xtrack/_version.py

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

{xtrack-0.69.2 → xtrack-0.69.4}/xtrack/environment.py

@@ -40,58 +40,39 @@ class Environment:
         self._drift_counter = 0
         self.ref = EnvRef(self)
 
-    def new_line(self, components=None, name=None):
-        out = xt.Line()
-        out.particle_ref = self.particle_ref
-        out.env = self
-        out._element_dict = self.element_dict # Avoid copying
-        if components is None:
-            components = []
-
-        for ii, nn in enumerate(components):
-            if (isinstance(nn, Place) and isinstance(nn.name, str)
-                    and nn.name in self.lines):
-                nn.name = self.lines[nn.name]
-            if isinstance(nn, str) and nn in self.lines:
-                components[ii] = self.lines[nn]
-
-        flattened_components = _flatten_components(components)
-        out.element_names = handle_s_places(flattened_components, self)
-        out._var_management = self._var_management
-        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
-
-        return out
-
-    def new_builder(self, components=None, name=None):
-        return Builder(env=self, components=components, name=name)
-
-    def _ensure_tracker_consistency(self, buffer):
-        for ln in self._lines_weakrefs:
-            if ln._has_valid_tracker() and ln._buffer is not buffer:
-                ln.discard_tracker()
-
-    def _get_a_drift_name(self):
-        self._drift_counter += 1
-        nn = f'drift_{self._drift_counter}'
-        if nn not in self.element_dict:
-            return nn
-        else:
-            return self._get_a_drift_name()
-
-    def new(self, name, cls, mode=None, at=None, from_=None, extra=None,
+    def new(self, name, parent, mode=None, at=None, from_=None, extra=None,
             mirror=False, **kwargs):
 
+        '''
+        Create a new element or line.
+
+        Parameters
+        ----------
+        name : str
+            Name of the new element or line
+        parent : str or class
+            Parent class or name of the parent element
+        mode : str, optional
+             - clone: clone the parent element or line.
+               The parent element or line is copied, together with the associated
+               expressions.
+             - replica: replicate the parent elements or lines are made.
+        at : float or str, optional
+            Position of the created object.
+        from_: str, optional
+            Name of the element from which the position is calculated (its center
+            is used as reference).
+        mirror : bool, optional
+            Can only be used when cloning lines. If True, the order of the elements
+            is reversed.
+
+        Returns
+        -------
+        str or Place
+            Name of the created element or line or a Place object if at or from_ is
+            provided.
+        '''
+
         if from_ is not None or at is not None:
             all_kwargs = locals()
             all_kwargs.pop('self')
@@ -105,60 +86,60 @@ class Environment:
         _ALLOWED_ELEMENT_TYPES_DICT = xt.line._ALLOWED_ELEMENT_TYPES_DICT
         _STR_ALLOWED_ELEMENT_TYPES_IN_NEW = xt.line._STR_ALLOWED_ELEMENT_TYPES_IN_NEW
 
-        if cls in self.lines:
-            cls = self.lines[cls]
+        if parent in self.lines:
+            parent = self.lines[parent]
 
-        if isinstance(cls, xt.Line):
+        if isinstance(parent, xt.Line):
             assert len(kwargs) == 0, 'No kwargs allowed when creating a line'
             if mode == 'replica':
                 assert name is not None, 'Name must be provided when replicating a line'
-                return cls.replicate(name=name, mirror=mirror)
+                return parent.replicate(name=name, mirror=mirror)
             else:
                 assert mode in [None, 'clone'], f'Unknown mode {mode}'
                 assert name is not None, 'Name must be provided when cloning a line'
-                return cls.clone(name=name, mirror=mirror)
+                return parent.clone(name=name, mirror=mirror)
 
-        assert mirror is False, 'mirror=True only allowed when cloning or  lines.'
+        assert mirror is False, 'mirror=True only allowed when cloning lines.'
 
-        if cls is xt.Line or (cls=='Line' and (
+        if parent is xt.Line or (parent=='Line' and (
             'Line' not in self.lines and 'Line' not in self.element_dict)):
             assert mode is None, 'Mode not allowed when cls is Line'
             return self.new_line(name=name, **kwargs)
 
         if mode == 'replica':
-            assert cls in self.element_dict, f'Element {cls} not found, cannot replicate'
-            kwargs['parent_name'] = xo.String(cls)
-            cls = xt.Replica
+            assert parent in self.element_dict, f'Element {parent} not found, cannot replicate'
+            kwargs['parent_name'] = xo.String(parent)
+            parent = xt.Replica
         elif mode == 'clone':
-            assert cls in self.element_dict, f'Element {cls} not found, cannot clone'
+            assert parent in self.element_dict, f'Element {parent} not found, cannot clone'
         else:
             assert mode is None, f'Unknown mode {mode}'
 
         _eval = self._xdeps_eval.eval
 
-        assert isinstance(cls, str) or cls in _ALLOWED_ELEMENT_TYPES_IN_NEW, (
+        assert isinstance(parent, str) or parent in _ALLOWED_ELEMENT_TYPES_IN_NEW, (
             'Only '
             + _STR_ALLOWED_ELEMENT_TYPES_IN_NEW
             + ' elements are allowed in `new` for now.')
 
         needs_instantiation = True
-        if isinstance(cls, str):
-            if cls in self.element_dict:
+        if isinstance(parent, str):
+            if parent in self.element_dict:
                 # Clone an existing element
-                self.element_dict[name] = xt.Replica(parent_name=cls)
-                self.replace_replica(name)
-                cls = type(self.element_dict[name])
+                self.element_dict[name] = xt.Replica(parent_name=parent)
+                xt.Line.replace_replica(self, name)
+                parent = type(self.element_dict[name])
                 needs_instantiation = False
-            elif cls in _ALLOWED_ELEMENT_TYPES_DICT:
-                cls = _ALLOWED_ELEMENT_TYPES_DICT[cls]
+            elif parent in _ALLOWED_ELEMENT_TYPES_DICT:
+                parent = _ALLOWED_ELEMENT_TYPES_DICT[parent]
                 needs_instantiation = True
             else:
-                raise ValueError(f'Element type {cls} not found')
+                raise ValueError(f'Element type {parent} not found')
 
-        ref_kwargs, value_kwargs = _parse_kwargs(cls, kwargs, _eval)
+        ref_kwargs, value_kwargs = _parse_kwargs(parent, kwargs, _eval)
 
         if needs_instantiation: # Parent is a class and not another element
-            self.element_dict[name] = cls(**value_kwargs)
+            self.element_dict[name] = parent(**value_kwargs)
 
         _set_kwargs(name=name, ref_kwargs=ref_kwargs, value_kwargs=value_kwargs,
                     element_dict=self.element_dict, element_refs=self.element_refs)
@@ -169,9 +150,128 @@ class Environment:
 
         return name
 
+    def new_line(self, components=None, name=None):
+
+        '''
+        Create a new line.
+
+        Parameters
+        ----------
+        components : list, optional
+            List of components to be added to the line. It can include strings,
+            place objects, and lines.
+        name : str, optional
+            Name of the new line.
+
+        Returns
+        -------
+        line
+            The new line.
+
+        Examples
+        --------
+        .. code-block:: python
+
+            env = xt.Environment()
+            env['a'] = 3 # Define a variable
+            env.new('mq1', xt.Quadrupole, length=0.3, k1='a')  # Create an element
+            env.new('mq2', xt.Quadrupole, length=0.3, k1='-a')  # Create another element
+
+            ln = env.new_line(name='myline', components=[
+                'mq',  # Add the element 'mq' at the start of the line
+                env.new('mymark', xt.Marker, at=10.0),  # Create a marker at s=10
+                env.new('mq1_clone', 'mq1', k1='2a'),   # Clone 'mq1' with a different k1
+                env.place('mq2', at=20.0, from='mymark'),  # Place 'mq2' at s=20
+                ])
+        '''
+
+        out = xt.Line()
+        out.particle_ref = self.particle_ref
+        out.env = self
+        out._element_dict = self.element_dict # Avoid copying
+        if components is None:
+            components = []
+
+        for ii, nn in enumerate(components):
+            if (isinstance(nn, Place) and isinstance(nn.name, str)
+                    and nn.name in self.lines):
+                nn.name = self.lines[nn.name]
+            if isinstance(nn, str) and nn in self.lines:
+                components[ii] = self.lines[nn]
+
+        flattened_components = _flatten_components(components)
+        out.element_names = handle_s_places(flattened_components, self)
+        out._var_management = self._var_management
+        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
+
+        return out
+
     def place(self, name, at=None, from_=None, anchor=None, from_anchor=None):
+        '''
+        Create a place object.
+
+        Parameters
+        ----------
+        name : str or Line
+            Name of the element or line to be placed.
+        at : float or str, optional
+            Position of the created object.
+        from_: str, optional
+            Name of the element from which the position is calculated (its center
+            is used as reference).
+
+        Returns
+        -------
+        Place
+            The new place object.
+        '''
+
         return Place(name, at=at, from_=from_, anchor=anchor, from_anchor=from_anchor)
 
+    def new_builder(self, components=None, name=None):
+        '''
+        Create a new builder.
+
+        Parameters
+        ----------
+        components : list, optional
+            List of components to be added to the builder. It can include strings,
+            place objects, and lines.
+        name : str, optional
+            Name of the line that will be built by the builder.
+
+        Returns
+        -------
+        Builder
+            The new builder.
+        '''
+
+        return Builder(env=self, components=components, name=name)
+
+    def _ensure_tracker_consistency(self, buffer):
+        for ln in self._lines_weakrefs:
+            if ln._has_valid_tracker() and ln._buffer is not buffer:
+                ln.discard_tracker()
+
+    def _get_a_drift_name(self):
+        self._drift_counter += 1
+        nn = f'drift_{self._drift_counter}'
+        if nn not in self.element_dict:
+            return nn
+        else:
+            return self._get_a_drift_name()
+
     def __setitem__(self, key, value):
 
         if isinstance(value, xt.Line):
@@ -194,10 +294,14 @@ Environment.element_refs = xt.Line.element_refs
 Environment.vars = xt.Line.vars
 Environment.varval = xt.Line.varval
 Environment.vv = xt.Line.vv
-Environment.replace_replica = xt.Line.replace_replica
 Environment.__getitem__ = xt.Line.__getitem__
 Environment.set = xt.Line.set
 Environment.get = xt.Line.get
+Environment.eval = xt.Line.eval
+Environment.info = xt.Line.info
+Environment.get_expr = xt.Line.get_expr
+Environment.new_expr = xt.Line.new_expr
+Environment.ref_manager = xt.Line.ref_manager
 
 class Place:
 
@@ -295,7 +399,7 @@ def _resolve_s_positions(seq_all_places, env):
     if seq_all_places[0].at is None and not seq_all_places[0]._before:
         # In case we want to allow for the length to be an expression
         s_center_dct[seq_all_places[0]] = aux_tt['length', seq_all_places[0].name] / 2
-        # s_center_dct[seq_all_places[0]] = _length_expr_or_val(seq_all_places[0], aux_line) / 2
+        s_center_dct_names[seq_all_places[0].name] = s_center_dct[seq_all_places[0]]
         n_resolved += 1
 
     while n_resolved != n_resolved_prev:
@@ -356,7 +460,7 @@ def _resolve_s_positions(seq_all_places, env):
             aux_s_center.append(ss)
     aux_tt['s_center'] = np.concatenate([aux_s_center, [0]])
 
-    i_sorted = np.argsort(aux_s_center, stable=True)
+    i_sorted = np.argsort(aux_s_center, kind='stable')
 
     name_sorted = [str(aux_tt.name[ii]) for ii in i_sorted]
 

{xtrack-0.69.2 → xtrack-0.69.4}/xtrack/line.py

@@ -3405,12 +3405,16 @@ class Line:
 
     def __add__(self, other):
         self._env_if_needed
-        assert isinstance(other, Line), 'Only Line can be added to Line'
+        #assert isinstance(other, Line), 'Only Line can be added to Line'
+        assert other.__class__.__name__=="Line", 'Only Line can be added to Line'
         assert other.env is self.env, 'Lines must be in the same environment'
         out = self.env.new_line(
             components=list(self.element_names) + list(other.element_names))
         return out
 
+    def __sub__(self, other):
+        return self + (-other)
+
     def replicate(self, name, mirror=False):
 
         self._env_if_needed()
@@ -3505,6 +3509,27 @@ class Line:
         return out
 
     def set(self, name, *args, **kwargs):
+        '''
+        Set the values or expressions of variables or element properties.
+
+        Parameters
+        ----------
+        name : str
+            Name of the variable or element.
+        value: float or str
+            Value or expression of the variable to set. Can be provided only
+            if the name is associated to a variable.
+        **kwargs, float or str
+            Attributes to set. Can be provided only if the name is associated
+            to an element.
+
+        Examples
+        --------
+        >>> line.set('a', 0.1)
+        >>> line.set('k1', '3*a')
+        >>> line.set('quad', k1=0.1, k2='3*a')
+
+        '''
         _eval = self._xdeps_eval.eval
 
         if hasattr(self, 'lines') and name in self.lines:
@@ -3548,6 +3573,21 @@ class Line:
                 self.vars[name] = value
 
     def get(self, key):
+        '''
+        Get an element or the value of a variable.
+
+        Parameters
+        ----------
+        key : str
+            Name of the element or variable.
+
+        Returns
+        -------
+        element : Element or float
+            Element or value of the variable.
+
+        '''
+
         if key in self.element_dict:
             return self.element_dict[key]
         elif key in self.vars:
@@ -3555,6 +3595,80 @@ class Line:
         else:
             raise KeyError(f'Element or variable {key} not found')
 
+    def info(self, key, limit=12):
+        """
+            Get information about an element or a variable.
+        """
+
+        if key in self.element_dict:
+            return self[key].get_info()
+        elif key in self.vars:
+            return self.vars.info(key, limit=limit)
+        else:
+            raise KeyError(f'Element or variable {key} not found')
+
+#    def get_value(self, key):
+#        if key in self.element_dict:
+#            return self.element_dict[key].get_value()
+#        elif key in self.vars:
+#            return self.vars.get_value(key)
+#        else:
+#            raise KeyError(f'Element or variable {key} not found')
+
+    @property
+    def ref_manager(self):
+        return self._xdeps_manager
+
+    def eval(self, expr):
+        '''
+        Get the value of an expression
+
+        Parameters
+        ----------
+        expr : str
+            Expression to evaluate.
+
+        Returns
+        -------
+        value : float
+            Value of the expression.
+        '''
+
+        return self.vars.eval(expr)
+
+    def new_expr(self, expr):
+        '''
+        Create a new expression
+
+        Parameters
+        ----------
+        expr : str
+            Expression to create.
+
+        Returns
+        -------
+        expr : Expression
+            New expression.
+        '''
+        return self.vars.new_expr(expr)
+
+    def get_expr(self, var):
+        '''
+        Get expression associated to a variable
+
+        Parameters
+        ----------
+        var: str
+            Name of the variable
+
+        Returns
+        -------
+        expr : Expression
+            Expression associated to the variable
+        '''
+
+        return self.vars.get_expr(var)
+
     def _env_if_needed(self):
         if not hasattr(self, 'env') or self.env is None:
             self.env = xt.Environment(element_dict=self.element_dict,
@@ -4700,26 +4814,17 @@ class LineVars:
 
         return xd.Table({'name': name, 'value': value, 'expr': expr})
 
-    def expr(self, var):
-        raise NotImplementedError # Untested
-        if isinstance(var,str):
-            ref=self.line._xdeps_vref[var]
-        elif is_expr(var):
-            ref=var
-        else:
-            raise ValueError(f"`{var}` not valid, must be str or expr")
-        expr=ref._expr
-        if expr is None:
-            raise NameError(f"`{var}` does not have any expression")
-        return expr
+    def new_expr(self, expr):
+        return self.line._xdeps_eval.eval(expr)
 
     def eval(self, expr):
-        raise NotImplementedError # Untested
-        return self.line._xdeps_eval.eval(expr)
+        return self.new_expr(expr)._get_value()
 
-    def value(self, expr):
-        raise NotImplementedError # Untested
-        return eval(self)._get_value()
+    def info(self, var, limit=10):
+        return self[var]._info(limit=limit)
+
+    def get_expr(self, var):
+        return self[var]._expr
 
     def __contains__(self, key):
         if self.line._xdeps_vref is None:
@@ -4844,6 +4949,9 @@ class LineVars:
         else:
             self[name] = value
 
+    def get(self, name):
+        return self[name]._value
+
 class ActionVars(Action):
 
     def __init__(self, line):

{xtrack-0.69.2 → xtrack-0.69.4/xtrack.egg-info}/PKG-INFO

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

xtrack-0.69.2/xtrack/_version.py

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