xtrack 0.69.3__tar.gz → 0.69.4__tar.gz

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

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

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

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

@@ -40,64 +40,39 @@ class Environment:
         self._drift_counter = 0
         self.ref = EnvRef(self)
 
-    @property
-    def manager(self):
-        if not hasattr(self, '_var_management') or self._var_management is None:
-            self._init_var_management()
-        return self._var_management['manager']
-
-    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')
@@ -111,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)
@@ -175,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):
@@ -200,7 +294,6 @@ 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
@@ -208,7 +301,7 @@ 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:
 
@@ -306,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:

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

@@ -3412,6 +3412,9 @@ class 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()
@@ -3506,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:
@@ -3549,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:
@@ -3557,6 +3596,10 @@ class Line:
             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:
@@ -3573,17 +3616,58 @@ class Line:
 #            raise KeyError(f'Element or variable {key} not found')
 
     @property
-    def manager(self):
+    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, vars):
-        return self.vars.get_expr(vars)
+    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:

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

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

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