xtrack 0.83.1__tar.gz → 0.83.2__tar.gz

{xtrack-0.83.1/xtrack.egg-info → xtrack-0.83.2}/PKG-INFO

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

{xtrack-0.83.1 → xtrack-0.83.2}/tests/test_apertures.py

@@ -361,4 +361,21 @@ def test_aperture_svg_path():
     xo.assert_allclose(aper.x_vertices, x_expected, atol=1e-6, rtol=0)
     xo.assert_allclose(aper.y_vertices, y_expected, atol=1e-6, rtol=0)
     xo.assert_allclose(aper2.x_vertices, x_expected, atol=1e-6, rtol=0)
-    xo.assert_allclose(aper2.y_vertices, y_expected, atol=1e-6, rtol=0)
+    xo.assert_allclose(aper2.y_vertices, y_expected, atol=1e-6, rtol=0)
+
+def test_limitrect_to_dict():
+
+    lrect = xt.LimitRect(min_x=-0.03, max_x=0.03, min_y=0.0, max_y=0.09)
+    lrect2 = xt.LimitRect.from_dict(lrect.to_dict())
+
+    assert lrect2.min_x == lrect.min_x
+    assert lrect2.max_x == lrect.max_x
+    assert lrect2.min_y == lrect.min_y
+    assert lrect2.max_y == lrect.max_y
+
+    lrectdef  = xt.LimitRect()
+
+    assert lrectdef.min_x == -1e10
+    assert lrectdef.max_x == 1e10
+    assert lrectdef.min_y == -1e10
+    assert lrectdef.max_y == 1e10

{xtrack-0.83.1 → xtrack-0.83.2}/tests/test_trajectory_correcton.py

@@ -531,3 +531,109 @@ def test_orbit_correction_tilt_monitors():
 
     # Check that there is no vertical reading in the tilted bpm BPMs
     xo.assert_allclose(correction.y_correction._position_before, 0, atol=1e-15, rtol=0)
+
+def test_orbit_correction_with_limits():
+
+    line = xt.Line.from_json(test_data_folder
+                             / 'hllhc15_thick/lhc_thick_with_knobs.json')
+    line.build_tracker()
+    tt = line.get_table()
+
+    # Define elements to be used as monitors for orbit correction
+    tt_monitors = tt.rows['bpm.*','.*(?<!_entry)$','.*(?<!_exit)$']
+    line.steering_monitors_x = tt_monitors.name
+    line.steering_monitors_y = tt_monitors.name
+
+    # Define elements to be used as correctors for orbit correction
+    tt_h_correctors = tt.rows['mcb.*'].rows[r'.*h\..*']
+    line.steering_correctors_x = tt_h_correctors.name
+    tt_v_correctors = tt.rows['mcb.*'].rows[r'.*v\..*']
+    line.steering_correctors_y = tt_v_correctors.name
+
+    # Reference twiss (no misalignments)
+    tw_ref = line.twiss4d()
+
+    # Introduce misalignments on all quadrupoles
+    tt = line.get_table()
+    tt_quad = tt.rows[tt.element_type == 'Quadrupole']
+    rgen = np.random.RandomState(1) # fix seed for random number generator
+    shift_x = rgen.randn(len(tt_quad)) * 0.01e-3 # 0.01 mm rms shift on all quads
+    shift_y = rgen.randn(len(tt_quad)) * 0.01e-3 # 0.01 mm rms shift on all quads
+    for nn_quad, sx, sy in zip(tt_quad.name, shift_x, shift_y):
+        line.element_refs[nn_quad].shift_x = sx
+        line.element_refs[nn_quad].shift_y = sy
+
+    # Twiss before correction
+    tw_before = line.twiss4d()
+
+    # Define limits for correctors (in radians)
+    limits_x = (-1e-6, 1e-6)  # 1 urad
+    limits_y = (-1e-6, 1e-6)  # 1 urad
+
+    # Orbit correction without limits as reference
+    orbit_correction_basic_no_limits = line.correct_trajectory(twiss_table=tw_ref)
+    
+    #print(np.max(np.abs(orbit_correction_basic_no_limits.x_correction.get_kick_values())))
+    #print(np.max(np.abs(orbit_correction_basic_no_limits.y_correction.get_kick_values())))
+
+    #Assert that at least one corrector is beyond each of the limits
+    assert np.any(np.abs(orbit_correction_basic_no_limits.x_correction.get_kick_values()) > limits_x[1])
+    assert np.any(np.abs(orbit_correction_basic_no_limits.y_correction.get_kick_values()) > limits_y[1])
+    orbit_correction_basic_no_limits.clear_correction_knobs()
+
+    # Set limits on the line
+    line.corrector_limits_x = limits_x
+    line.corrector_limits_y = limits_y
+
+    # First test: Basic method with limits
+    orbit_correction_basic = line.correct_trajectory(twiss_table=tw_ref)
+
+    # Twiss after basic correction
+    tw_after_basic = line.twiss4d()
+
+    # Extract correction strength from basic method
+    kicks_x_basic = orbit_correction_basic.x_correction.get_kick_values()
+    kicks_y_basic = orbit_correction_basic.y_correction.get_kick_values()
+
+    # Verify that the basic correction stays within limits
+    assert np.all(kicks_x_basic >= limits_x[0])
+    assert np.all(kicks_x_basic <= limits_x[1])
+    assert np.all(kicks_y_basic >= limits_y[0])
+    assert np.all(kicks_y_basic <= limits_y[1])
+
+    # Verify that the orbit is corrected in the correct direction with basic method
+    assert tw_before.x.std() > tw_after_basic.x.std()
+    assert tw_before.y.std() > tw_after_basic.y.std()
+
+    # Clear correction
+    orbit_correction_basic.clear_correction_knobs()
+
+    # Second test: Micado method with limits
+    n_micado = 5
+    orbit_correction_micado = line.correct_trajectory(twiss_table=tw_ref, n_micado=n_micado, n_iter=1)
+
+    # Twiss after micado correction
+    tw_after_micado = line.twiss4d()
+
+    # Extract correction strength from micado method
+    kicks_x_micado = orbit_correction_micado.x_correction.get_kick_values()
+    kicks_y_micado = orbit_correction_micado.y_correction.get_kick_values()
+
+    # Verify that the micado correction stays within limits
+    assert np.all(kicks_x_micado >= limits_x[0])
+    assert np.all(kicks_x_micado <= limits_x[1])
+    assert np.all(kicks_y_micado >= limits_y[0])
+    assert np.all(kicks_y_micado <= limits_y[1])
+
+    # Verify that the orbit is corrected with micado method
+    assert tw_after_micado.y.std() < tw_before.y.std()
+    assert tw_after_micado.x.std() < tw_before.x.std()
+
+    # Verify that micado uses at most the specified number of correctors
+    assert np.sum(np.abs(kicks_x_micado) > 1e-10) <= n_micado
+    assert np.sum(np.abs(kicks_y_micado) > 1e-10) <= n_micado
+
+    # Compare the two methods
+    # Basic method should use more correctors
+    assert np.sum(np.abs(kicks_x_basic) > 1e-10) > n_micado
+    assert np.sum(np.abs(kicks_y_basic) > 1e-10) > n_micado

xtrack-0.83.2/xtrack/_version.py

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

{xtrack-0.83.1 → xtrack-0.83.2}/xtrack/beam_elements/apertures.py

@@ -33,27 +33,16 @@ class LimitRect(BeamElement):
     """
 
     _xofields = {
-        "min_x": xo.Float64,
-        "max_x": xo.Float64,
-        "min_y": xo.Float64,
-        "max_y": xo.Float64,
+        "min_x": xo.Field(xo.Float64, default=-UNLIMITED),
+        "max_x": xo.Field(xo.Float64, default=UNLIMITED),
+        "min_y": xo.Field(xo.Float64, default=-UNLIMITED),
+        "max_y": xo.Field(xo.Float64, default=UNLIMITED),
     }
 
     has_backtrack = True
 
     _extra_c_sources = ['#include <beam_elements/apertures_src/limitrect.h>']
 
-    def __init__(
-        self,
-        min_x=-UNLIMITED,
-        max_x=UNLIMITED,
-        min_y=-UNLIMITED,
-        max_y=UNLIMITED,
-        **kwargs,
-    ):
-
-        super().__init__(min_x=min_x, max_x=max_x, min_y=min_y, max_y=max_y, **kwargs)
-
 
 class LimitRacetrack(BeamElement):
     """
@@ -77,10 +66,10 @@ class LimitRacetrack(BeamElement):
     """
 
     _xofields = {
-        "min_x": xo.Float64,
-        "max_x": xo.Float64,
-        "min_y": xo.Float64,
-        "max_y": xo.Float64,
+        "min_x": xo.Field(xo.Float64, default=-UNLIMITED),
+        "max_x": xo.Field(xo.Float64, default=UNLIMITED),
+        "min_y": xo.Field(xo.Float64, default=-UNLIMITED),
+        "max_y": xo.Field(xo.Float64, default=UNLIMITED),
         "a": xo.Float64,
         "b": xo.Float64,
     }
@@ -435,8 +424,8 @@ class LimitRectEllipse(BeamElement):
     """
 
     _xofields = {
-        "max_x": xo.Float64,
-        "max_y": xo.Float64,
+        "max_x": xo.Field(xo.Float64, default=UNLIMITED),
+        "max_y": xo.Field(xo.Float64, default=UNLIMITED),
         "a_squ": xo.Float64,
         "b_squ": xo.Float64,
         "a_b_squ": xo.Float64,
@@ -533,10 +522,10 @@ class LongitudinalLimitRect(BeamElement):
     """
 
     _xofields = {
-        "min_zeta": xo.Float64,
-        "max_zeta": xo.Float64,
-        "min_pzeta": xo.Float64,
-        "max_pzeta": xo.Float64,
+        "min_zeta": xo.Field(xo.Float64, default=-UNLIMITED),
+        "max_zeta": xo.Field(xo.Float64, default=UNLIMITED),
+        "min_pzeta": xo.Field(xo.Float64, default=-UNLIMITED),
+        "max_pzeta": xo.Field(xo.Float64, default=UNLIMITED),
     }
 
     has_backtrack = True

{xtrack-0.83.1 → xtrack-0.83.2}/xtrack/line.py

@@ -165,6 +165,8 @@ class Line:
         self._extra_config['steering_monitors_y'] = None
         self._extra_config['steering_correctors_x'] = None
         self._extra_config['steering_correctors_y'] = None
+        self._extra_config['corrector_limits_x'] = None
+        self._extra_config['corrector_limits_y'] = None
 
         if env is None:
             env = xt.Environment()
@@ -1590,8 +1592,8 @@ class Line:
                  monitor_names_x=None, corrector_names_x=None,
                  monitor_names_y=None, corrector_names_y=None,
                  n_micado=None, n_singular_values=None, rcond=None,
-                 monitor_alignment=None,
-                 ):
+                 monitor_alignment=None, corrector_limits_x=None,
+                 corrector_limits_y=None):
 
         '''
         Correct the beam trajectory using linearized response matrix from optics
@@ -1642,6 +1644,14 @@ class Line:
         rcond : float
             Cutoff for small singular values (relative to the largest singular
             value). Singular values smaller than `rcond` are considered zero.
+        corrector_limits_x : tuple of array-like or None
+            Limits for the horizontal corrector strengths. If not None, it should be a tuple
+            of two arrays (lower_limits, upper_limits) with the same length as
+            the number of horizontal correctors. If None, no limits are applied.
+        corrector_limits_y : tuple of array-like or None
+            Limits for the vertical corrector strengths. If not None, it should be a tuple
+            of two arrays (lower_limits, upper_limits) with the same length as
+            the number of vertical correctors. If None, no limits are applied.
 
         Returns
         -------
@@ -1658,7 +1668,9 @@ class Line:
                  corrector_names_y=corrector_names_y,
                  n_micado=n_micado, n_singular_values=n_singular_values,
                  rcond=rcond,
-                 monitor_alignment=monitor_alignment)
+                 monitor_alignment=monitor_alignment,
+                 corrector_limits_x=corrector_limits_x,
+                 corrector_limits_y=corrector_limits_y)
 
         if run:
             correction.correct(planes=planes, n_iter=n_iter)
@@ -3085,7 +3097,8 @@ class Line:
         if mode != 'deprecated':
             raise NameError('mode is deprecated, use model instead')
 
-        self._check_valid_tracker()
+        if not self._has_valid_tracker():
+            self.build_tracker()
 
         assert model in [None, 'mean', 'quantum']
         assert model_beamstrahlung in [None, 'mean', 'quantum']
@@ -4694,6 +4707,22 @@ class Line:
     def steering_correctors_y(self, value):
         self._extra_config['steering_correctors_y'] = value
 
+    @property
+    def corrector_limits_x(self):
+        return self._extra_config.get('corrector_limits_x', None)
+
+    @corrector_limits_x.setter
+    def corrector_limits_x(self, value):
+        self._extra_config['corrector_limits_x'] = value
+
+    @property
+    def corrector_limits_y(self):
+        return self._extra_config.get('corrector_limits_y', None)
+
+    @corrector_limits_y.setter
+    def corrector_limits_y(self, value):
+        self._extra_config['corrector_limits_y'] = value
+
     def __getitem__(self, key):
         if np.issubdtype(key.__class__, np.integer):
             key = self.element_names[key]

{xtrack-0.83.1 → xtrack-0.83.2}/xtrack/trajectory_correction.py

@@ -1,8 +1,13 @@
 import numpy as np
+from scipy.optimize import lsq_linear
 import xtrack as xt
 
+import logging
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.StreamHandler())
+
 def _compute_correction(x_iter, response_matrix, n_micado=None, rcond=None,
-                        n_singular_values=None):
+                        n_singular_values=None, corrector_limits=None):
 
     if isinstance(response_matrix, (list, tuple)):
         assert len(response_matrix) == 3 # U, S, Vt
@@ -36,8 +41,17 @@ def _compute_correction(x_iter, response_matrix, n_micado=None, rcond=None,
                     mask_corr[i_used] = True
 
                 # Compute the correction with least squares
-                _, residual_x, rank_x, sval_x = np.linalg.lstsq(
-                            response_matrix[:, mask_corr], -x_iter, rcond=rcond)
+                if corrector_limits is None:
+                    _, residual_x, rank_x, sval_x = np.linalg.lstsq(
+                                response_matrix[:, mask_corr], -x_iter, rcond=rcond)
+                else:
+                    # Apply limits only to the active correctors
+                    active_limits = (corrector_limits[0][mask_corr], corrector_limits[1][mask_corr])
+                    result = lsq_linear(response_matrix[:, mask_corr], -x_iter, 
+                                      bounds=active_limits)
+                    if not result.success:
+                        logger.warning(f'Bounded Least Squares warning: {result.message}')
+                    residual_x = np.array([result.cost])
                 residuals.append(residual_x[0])
             used_correctors.append(np.nanargmin(residuals))
 
@@ -48,16 +62,26 @@ def _compute_correction(x_iter, response_matrix, n_micado=None, rcond=None,
         mask_corr[:] = True
 
     # Compute the correction with least squares
-    if mask_corr.all() and S is not None:
-        # Can reuse the SVD decomposition
+    if mask_corr.all() and S is not None and corrector_limits is None:
+        # Can reuse the SVD decomposition only for unbounded case
         S_inv = np.zeros_like(S)
         S_inv[S > 0] = 1 / S[S > 0]
         if rcond is not None:
             S_inv[S < rcond * S[0]] = 0
         correction_masked = Vh.T.conj() @ (np.diag(S_inv) @ (U.T.conj() @ (-x_iter)))
     else:
-        correction_masked, residual_x, rank_x, sval_x = np.linalg.lstsq(
-                    response_matrix[:, mask_corr], -x_iter, rcond=rcond)
+        if corrector_limits is None:
+            correction_masked, residual_x, rank_x, sval_x = np.linalg.lstsq(
+                        response_matrix[:, mask_corr], -x_iter, rcond=rcond)
+        else:
+            # Apply limits only to the active correctors
+            active_limits = (corrector_limits[0][mask_corr], corrector_limits[1][mask_corr])
+            result = lsq_linear(response_matrix[:, mask_corr], -x_iter, 
+                              bounds=active_limits)
+            if not result.success:
+                logger.warning(f'Bounded Least Squares warning: {result.message}')
+            correction_masked = result.x
+
     correction_x = np.zeros(n_hcorrectors)
     correction_x[mask_corr] = correction_masked
 
@@ -104,7 +128,7 @@ class OrbitCorrectionSinglePlane:
 
     def __init__(self, line, plane, monitor_names, corrector_names,
                  start=None, end=None, twiss_table=None, n_micado=None,
-                 n_singular_values=None, rcond=None,
+                 n_singular_values=None, rcond=None, corrector_limits=None,
                  x_init=0, px_init=0, y_init=0, py_init=0, zeta_init=0, delta_init=0,
                  monitor_alignment=None):
 
@@ -164,6 +188,29 @@ class OrbitCorrectionSinglePlane:
         assert len(monitor_names) > 0
         assert len(corrector_names) > 0
 
+        if corrector_limits is None:
+            corrector_limits = getattr(line, f'corrector_limits_{plane}')
+
+        if corrector_limits is not None:
+            assert isinstance(corrector_limits, tuple)
+            assert len(corrector_limits) == 2
+
+            if isinstance(corrector_limits[0], (int, float)):
+                corrector_limits = (
+                    np.ones(len(corrector_names)) * corrector_limits[0],
+                    np.ones(len(corrector_names)) * corrector_limits[1]
+                )
+
+            elif isinstance(corrector_limits[0], (list, tuple)):
+                corrector_limits = (
+                    np.array(corrector_limits[0]),
+                    np.array(corrector_limits[1])
+                )
+            
+            assert len(corrector_limits) == 2
+            assert len(corrector_limits[0]) == len(corrector_limits[1])
+            assert len(corrector_limits[0]) == len(corrector_names)
+
         self.line = line
         self.plane = plane
         self.monitor_names = monitor_names
@@ -173,6 +220,7 @@ class OrbitCorrectionSinglePlane:
         self.n_micado = n_micado
         self.rcond = rcond
         self.n_singular_values = n_singular_values
+        self.corrector_limits = corrector_limits
 
         self.response_matrix = _build_response_matrix(plane=self.plane,
             tw=self.twiss_table, monitor_names=self.monitor_names,
@@ -208,7 +256,8 @@ class OrbitCorrectionSinglePlane:
         self._add_correction_knobs()
 
     def correct(self, n_iter='auto', n_micado=None, n_singular_values=None,
-                rcond=None, stop_iter_factor=0.1, verbose=True, _tw_orbit=None):
+                rcond=None, stop_iter_factor=0.1, verbose=True, _tw_orbit=None,
+                corrector_limits=None):
 
         if _tw_orbit is not None and n_iter !=1:
             raise ValueError('`_tw_orbit` can only be used with `n_iter=1`')
@@ -219,6 +268,7 @@ class OrbitCorrectionSinglePlane:
             assert stop_iter_factor < 1
 
         pos_rms_prev = 0
+        relative_limits = corrector_limits
 
         i_iter = 0
         while True:
@@ -242,13 +292,19 @@ class OrbitCorrectionSinglePlane:
 
             correction = self._compute_correction(position=position,
                                     n_micado=n_micado, rcond=rcond,
-                                    n_singular_values=n_singular_values)
+                                    n_singular_values=n_singular_values,
+                                    corrector_limits=relative_limits)
             self._apply_correction(correction)
 
             i_iter += 1
             if n_iter != 'auto' and i_iter >= n_iter:
                 break
 
+            if corrector_limits is not None:
+                current_correction = self.get_kick_values()
+                relative_limits = (corrector_limits[0] - current_correction,
+                                         corrector_limits[1] - current_correction)
+
         if _tw_orbit is None:
             position = self._measure_position()
             self._position_after = position
@@ -292,7 +348,7 @@ class OrbitCorrectionSinglePlane:
         return position
 
     def _compute_correction(self, position, n_micado=None,
-                            n_singular_values=None, rcond=None):
+                            n_singular_values=None, rcond=None, corrector_limits=None):
 
         if rcond is None:
             rcond = self.rcond
@@ -303,10 +359,11 @@ class OrbitCorrectionSinglePlane:
         if n_micado is None:
             n_micado = self.n_micado
 
+
         correction = _compute_correction(position,
             response_matrix=(self.singular_vectors_out, self.singular_values, self.singular_vectors_in),
             n_micado=n_micado,
-            rcond=rcond, n_singular_values=n_singular_values)
+            rcond=rcond, n_singular_values=n_singular_values, corrector_limits=corrector_limits)
 
         return correction
 
@@ -375,7 +432,8 @@ class TrajectoryCorrection:
                  monitor_names_y=None, corrector_names_y=None,
                  monitor_alignment=None,
                  x_init=0, px_init=0, y_init=0, py_init=0, zeta_init=0, delta_init=0,
-                 n_micado=None, n_singular_values=None, rcond=None):
+                 n_micado=None, n_singular_values=None, rcond=None,
+                 corrector_limits_x=None, corrector_limits_y=None):
 
         '''
         Trajectory correction using linearized response matrix from optics
@@ -418,6 +476,14 @@ class TrajectoryCorrection:
         rcond : float
             Cutoff for small singular values (relative to the largest singular
             value). Singular values smaller than `rcond` are considered zero.
+        corrector_limits_x : tuple of array-like or None
+            Limits for the horizontal corrector strengths. If not None, it should be a tuple
+            of two arrays (lower_limits, upper_limits) with the same length as
+            the number of horizontal correctors. If None, no limits are applied.
+        corrector_limits_y : tuple of array-like or None
+            Limits for the vertical corrector strengths. If not None, it should be a tuple
+            of two arrays (lower_limits, upper_limits) with the same length as
+            the number of vertical correctors. If None, no limits are applied.
         '''
 
         if isinstance(rcond, (tuple, list)):
@@ -452,6 +518,7 @@ class TrajectoryCorrection:
                 corrector_names=corrector_names_x, start=start, end=end,
                 twiss_table=twiss_table, n_micado=n_micado_x,
                 n_singular_values=n_singular_values_x, rcond=rcond_x,
+                corrector_limits=corrector_limits_x,
                 x_init=x_init, px_init=px_init, y_init=y_init, py_init=py_init,
                 zeta_init=zeta_init, delta_init=delta_init,
                 monitor_alignment=monitor_alignment)
@@ -466,6 +533,7 @@ class TrajectoryCorrection:
                 corrector_names=corrector_names_y, start=start, end=end,
                 twiss_table=twiss_table, n_micado=n_micado_y,
                 n_singular_values=n_singular_values_y, rcond=rcond_y,
+                corrector_limits=corrector_limits_y,
                 x_init=x_init, px_init=px_init, y_init=y_init, py_init=py_init,
                 zeta_init=zeta_init, delta_init=delta_init,
                 monitor_alignment=monitor_alignment)
@@ -543,19 +611,26 @@ class TrajectoryCorrection:
 
         tw_orbit = a_correction._compute_tw_orbit()
 
+        if self.x_correction is not None:
+            relative_limits_x = self.x_correction.corrector_limits
+        if self.y_correction is not None:
+            relative_limits_y = self.y_correction.corrector_limits
+
         while True:
 
             if self.x_correction is not None and 'x' in planes:
                 self.x_correction.correct(n_micado=n_micado_x,
                             n_singular_values=n_singular_values_x,
                             rcond=rcond_x, verbose=False, n_iter=1,
-                            _tw_orbit=tw_orbit)
+                            _tw_orbit=tw_orbit,
+                            corrector_limits=relative_limits_x)
 
             if self.y_correction is not None and 'y' in planes:
                 self.y_correction.correct(n_micado=n_micado_y,
                             n_singular_values=n_singular_values_y,
                             rcond=rcond_y, verbose=False, n_iter=1,
-                            _tw_orbit=tw_orbit)
+                            _tw_orbit=tw_orbit,
+                            corrector_limits=relative_limits_y)
 
             tw_orbit_prev = tw_orbit
             tw_orbit = a_correction._compute_tw_orbit()
@@ -579,11 +654,19 @@ class TrajectoryCorrection:
                     old_position = self.x_correction._measure_position(tw_orbit_prev)
                     str_2print += (f'x_rms: {old_position.std():.2e}'
                         f' -> {new_position.std():.2e}, ')
+                    if self.x_correction.corrector_limits is not None:
+                        correction_kicks_x = self.x_correction.get_kick_values()
+                        relative_limits_x = (self.x_correction.corrector_limits[0] - correction_kicks_x,
+                                             self.x_correction.corrector_limits[1] - correction_kicks_x)
                 if self.y_correction is not None and 'y' in planes:
                     new_position = self.y_correction._measure_position(tw_orbit)
                     old_position = self.y_correction._measure_position(tw_orbit_prev)
                     str_2print += (f'y_rms: {old_position.std():.2e}'
                         f' -> {new_position.std():.2e}')
+                    if self.y_correction.corrector_limits is not None:
+                        correction_kicks_y = self.y_correction.get_kick_values()
+                        relative_limits_y = (self.y_correction.corrector_limits[0] - correction_kicks_y,
+                                             self.y_correction.corrector_limits[1] - correction_kicks_y)
                 print(str_2print)
             if stop_x and stop_y:
                 break

{xtrack-0.83.1 → xtrack-0.83.2}/xtrack/twiss.py

@@ -2778,6 +2778,8 @@ class TwissInit:
             particle_on_co.s = s_ele_twiss
             self.__dict__['particle_on_co'] = particle_on_co
             self._temp_co_data = None
+        else:
+            particle_on_co = self.particle_on_co
 
         if self._temp_optics_data is not None:
 

{xtrack-0.83.1 → xtrack-0.83.2/xtrack.egg-info}/PKG-INFO

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

xtrack-0.83.1/xtrack/_version.py

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