xtrack 0.65.5__tar.gz → 0.66.1__tar.gz

{xtrack-0.65.5/xtrack.egg-info → xtrack-0.66.1}/PKG-INFO

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

xtrack-0.66.1/tests/test_periodic_symmetric_twiss_and_match.py

@@ -0,0 +1,154 @@
+
+import xtrack as xt
+import xobjects as xo
+import numpy as np
+
+def test_periodic_symmetric_twiss_and_match():
+
+    # Build line with half a cell
+    half_cell = xt.Line(
+        elements={
+            'start_cell': xt.Marker(),
+            'drift0': xt.Drift(length=1.),
+            'qf1': xt.Quadrupole(k1=0.027/2, length=1.),
+            'drift1_1': xt.Drift(length=1),
+            'bend1': xt.Bend(k0=3e-4, h=3e-4, length=45.),
+            'drift1_2': xt.Drift(length=1.),
+            'qd1': xt.Quadrupole(k1=-0.0271/2, length=1.),
+            'drift2': xt.Drift(length=1),
+            'mid_cell': xt.Marker(),
+        }
+    )
+    half_cell.particle_ref = xt.Particles(p0c=2e9)
+
+    tw_half_cell = half_cell.twiss4d(init='periodic_symmetric', # <--- periodic-symmetric boundary
+                                    strengths=True # to get the strengths in table
+                                    )
+
+    cell = xt.Line(
+        elements={
+            'start_cell': xt.Marker(),
+            'drift0': xt.Drift(length=1.),
+            'qf1':    xt.Quadrupole(k1=0.027/2, length=1.),
+            'drift1': xt.Drift(length=1),
+            'bend1':  xt.Bend(k0=3e-4, h=3e-4, length=45.),
+            'drift2': xt.Drift(length=1.),
+            'qd1':    xt.Quadrupole(k1=-0.0271/2, length=1.),
+            'drift3': xt.Drift(length=1),
+            'mid_cell': xt.Marker(),
+            'drift4': xt.Replica('drift3'),
+            'qd2':    xt.Replica('qd1'),
+            'drift5': xt.Replica('drift2'),
+            'bend2':  xt.Replica('bend1'),
+            'drift6': xt.Replica('drift1'),
+            'qf2':    xt.Replica('qf1'),
+            'drift7': xt.Replica('drift0'),
+            'end_cell': xt.Marker(),
+        }
+    )
+    cell.particle_ref = xt.Particles(p0c=2e9)
+    tw_cell = cell.twiss4d(strengths=True)
+
+    xo.assert_allclose(tw_half_cell.betx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].betx, atol=0, rtol=1e-8)
+    xo.assert_allclose(tw_half_cell.bety[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].bety, atol=0, rtol=1e-8)
+    xo.assert_allclose(tw_half_cell.alfx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].alfx, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.alfy[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].alfy, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.dx[:-1], # remove '_end_point'
+                    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.ax_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ax_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.ay_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ay_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.bx_chrom[:-1], # remove '_end_point'
+                        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.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)
+
+    for ll in [cell, half_cell]:
+        ll.vars['kqf'] = 0.027/2
+        ll.vars['kqd'] = -0.0271/2
+        ll.element_refs['qf1'].k1 = ll.vars['kqf']
+        ll.element_refs['qd1'].k1 = ll.vars['kqd']
+
+    tw_cell = cell.twiss4d(strengths=True)
+    tw_half_cell = half_cell.twiss4d(init='periodic_symmetric', strengths=True)
+
+    xo.assert_allclose(tw_cell.mux[-1], 0.231, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_cell.muy[-1], 0.233, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_half_cell.mux[-1], 0.231 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_half_cell.muy[-1], 0.233 / 2, atol=1e-3, rtol=0)
+
+    opt_halfcell = half_cell.match(
+        method='4d',
+        start='start_cell', end='mid_cell',
+        init='periodic_symmetric',
+        targets=xt.TargetSet(mux=0.2501/2, muy=0.2502/2, at='mid_cell'),
+        vary=xt.VaryList(['kqf', 'kqd'], step=1e-5),
+    )
+
+    tw_cell = cell.twiss4d(strengths=True)
+    tw_half_cell = half_cell.twiss4d(init='periodic_symmetric', strengths=True)
+
+    xo.assert_allclose(tw_half_cell.mux[-1], 0.2501 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_half_cell.muy[-1], 0.2502 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_cell.mux[-1], 0.231, atol=1e-3, rtol=0) # unaffected
+    xo.assert_allclose(tw_cell.muy[-1], 0.233, atol=1e-3, rtol=0) # unaffected
+
+    opt_cell = cell.match(
+        method='4d',
+        start='start_cell', end='end_cell',
+        init='periodic',
+        targets=xt.TargetSet(mux=0.2501, muy=0.2502, at='end_cell'),
+        vary=xt.VaryList(['kqf', 'kqd'], step=1e-5),
+    )
+
+    xo.assert_allclose(half_cell.vv['kqf'], cell.vv['kqf'], rtol=1e-9, atol=0)
+    xo.assert_allclose(half_cell.vv['kqd'], cell.vv['kqd'], rtol=1e-9, atol=0)
+
+    tw_cell = cell.twiss4d(strengths=True)
+    tw_half_cell = half_cell.twiss4d(init='periodic_symmetric', strengths=True)
+
+    xo.assert_allclose(tw_half_cell.mux[-1], 0.2501 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_half_cell.muy[-1], 0.2502 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_cell.mux[-1], 0.2501, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_cell.muy[-1], 0.2502, atol=1e-3, rtol=0)
+
+    xo.assert_allclose(tw_half_cell.betx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].betx, atol=0, rtol=1e-8)
+    xo.assert_allclose(tw_half_cell.bety[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].bety, atol=0, rtol=1e-8)
+    xo.assert_allclose(tw_half_cell.alfx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].alfx, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.alfy[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].alfy, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.dx[:-1], # remove '_end_point'
+                    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.ax_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ax_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.ay_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ay_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.bx_chrom[:-1], # remove '_end_point'
+                        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.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)
+

{xtrack-0.65.5 → xtrack-0.66.1}/tests/test_twiss.py

@@ -51,7 +51,6 @@ def test_twiss_4d_fodo_vs_beta_rel(test_context):
         xo.assert_allclose(tw.dqx, tw_4d_list[0].dqx, atol=1e-4, rtol=0)
         xo.assert_allclose(tw.dqy, tw_4d_list[0].dqy, atol=1e-4, rtol=0)
 
-
 @for_all_test_contexts
 def test_coupled_beta(test_context):
     mad = Madx(stdout=False)
@@ -1905,3 +1904,29 @@ def test_part_from_full_periodic(test_context, collider_for_test_twiss_range):
             tw_part2[kk, 'ip2'],
             tw[kk, 'ip2'] - tw[kk, 0] +(tw[kk, '_end_point'] - tw[kk, 'ip8']),
             rtol=1e-12, atol=5e-7)
+
+
+
+
+@for_all_test_contexts
+def test_twiss_add_strengths(test_context):
+    ## Generate a simple line
+    n = 6
+    fodo = [
+        xt.Multipole(length=0.2, knl=[0, +0.2], ksl=[0, 0]),
+        xt.Drift(length=1.0),
+        xt.Multipole(length=0.2, knl=[0, -0.2], ksl=[0, 0]),
+        xt.Drift(length=1.0),
+        xt.Multipole(length=1.0, knl=[2 * np.pi / n], hxl=[2 * np.pi / n]),
+        xt.Drift(length=1.0),
+    ]
+    line = xt.Line(elements=n * fodo + [xt.Cavity(frequency=1e9, voltage=0, lag=180)])
+    line.build_tracker(_context=test_context)
+
+    ## Twiss
+    line.particle_ref = xp.Particles(mass0=xp.PROTON_MASS_EV, q0=1, p0c=1e8)
+    tw = line.twiss(method="4d")
+
+    assert "length" not in tw.keys()
+    tw.add_strengths()
+    assert "length" in tw.keys()

xtrack-0.66.1/xtrack/_version.py

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

{xtrack-0.65.5 → xtrack-0.66.1}/xtrack/line.py

@@ -115,8 +115,7 @@ class Line:
         if isinstance(elements, dict):
             element_dict = elements
             if element_names is None:
-                raise ValueError('`element_names` must be provided'
-                                 ' if `elements` is a dictionary.')
+                element_names = list(element_dict.keys())
         else:
             if element_names is None:
                 element_names = [f"e{ii}" for ii in range(len(elements))]

{xtrack-0.65.5 → xtrack-0.66.1}/xtrack/match.py

@@ -104,7 +104,7 @@ class ActionTwiss(xd.Action):
                 if isinstance(twinit, xt.TwissInit):
                     twinit_list[ii] = twinit.copy()
                 elif isinstance(twinit, str):
-                    assert twinit == 'periodic'
+                    assert twinit == 'periodic' or twinit == 'periodic_symmetric'
 
         # Handle init_at as xt.START or xt.END
         for ii, init_at in enumerate(ele_init_list):
@@ -126,7 +126,7 @@ class ActionTwiss(xd.Action):
                 twinit_list[ii] = twinit.get_twiss_init(at_element=init_at)
                 ele_init_list[ii] = None
             else:
-                assert twinit is None or twinit == 'periodic'
+                assert twinit is None or twinit in ['periodic', 'periodic_symmetric']
 
         if not ismultiline:
             # Handle case in which twiss init is defined through kwargs

{xtrack-0.65.5 → xtrack-0.66.1}/xtrack/trajectory_correction.py

@@ -6,14 +6,17 @@ def _compute_correction(x_iter, response_matrix, n_micado=None, rcond=None,
 
     if isinstance(response_matrix, (list, tuple)):
         assert len(response_matrix) == 3 # U, S, Vt
-        U, S, Vt = response_matrix
+        U, S, Vh = response_matrix
         if n_singular_values is not None:
             U = U[:, :n_singular_values]
             S = S[:n_singular_values]
-            Vt = Vt[:n_singular_values, :]
-        response_matrix = U @ np.diag(S) @ Vt
+            Vh = Vh[:n_singular_values, :]
+        response_matrix = U @ np.diag(S) @ Vh
     else:
         assert n_singular_values is None
+        U = None
+        S = None
+        Vh = None
 
     n_hcorrectors = response_matrix.shape[1]
 
@@ -45,8 +48,16 @@ def _compute_correction(x_iter, response_matrix, n_micado=None, rcond=None,
         mask_corr[:] = True
 
     # Compute the correction with least squares
-    correction_masked, residual_x, rank_x, sval_x = np.linalg.lstsq(
-                response_matrix[:, mask_corr], -x_iter, rcond=rcond)
+    if mask_corr.all() and S is not None:
+        # Can reuse the SVD decomposition
+        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)
     correction_x = np.zeros(n_hcorrectors)
     correction_x[mask_corr] = correction_masked
 
@@ -60,11 +71,13 @@ def _build_response_matrix(tw, monitor_names, corrector_names,
     assert plane in ['x', 'y']
 
     # Build response matrix
-    bet_monitors = tw.rows[monitor_names]['bet' + plane]
-    bet_correctors = tw.rows[corrector_names]['bet' + plane]
+    mask_monitors = tw.mask[monitor_names]
+    mask_correctors = tw.mask[corrector_names]
+    bet_monitors = tw['bet' + plane][mask_monitors]
+    bet_correctors = tw['bet' + plane][mask_correctors]
 
-    mu_monitor = tw.rows[monitor_names]['mu' + plane]
-    mux_correctors = tw.rows[corrector_names]['mu' + plane]
+    mu_monitor = tw['mu' + plane][mask_monitors]
+    mux_correctors = tw['mu' + plane][mask_correctors]
 
     n_monitors = len(monitor_names)
     n_correctors = len(corrector_names)
@@ -159,13 +172,30 @@ class OrbitCorrectionSinglePlane:
         self.singular_vectors_out = U
         self.singular_vectors_in = Vt
 
-        self.s_correctors = self.twiss_table.rows[self.corrector_names].s
-        self.s_monitors = self.twiss_table.rows[self.monitor_names].s
+        # tw_table_local = self.twiss_table.rows[self.start:self.end]
+        # Parch: avoid issue with regular expression
+        if self.start is not None:
+            start = self.start.replace('$', '\\$')
+        else:
+            start = None
+        if self.end is not None:
+            end = self.end.replace('$', '\\$')
+        else:
+            end = None
+        tw_table_local = self.twiss_table.rows[start:end]
+
+        self._mask_monitors = tw_table_local.mask[self.monitor_names]
+        self._mask_correctors = tw_table_local.mask[self.corrector_names]
+        self.s_correctors = tw_table_local.s[self._mask_correctors]
+        self.s_monitors = tw_table_local.s[self._mask_monitors]
 
         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):
+                rcond=None, stop_iter_factor=0.1, verbose=True, _tw_orbit=None):
+
+        if _tw_orbit is not None and n_iter !=1:
+            raise ValueError('`_tw_orbit` can only be used with `n_iter=1`')
 
         assert n_iter == 'auto' or np.isscalar(n_iter)
         if n_iter == 'auto':
@@ -177,7 +207,7 @@ class OrbitCorrectionSinglePlane:
         i_iter = 0
         while True:
             try:
-                position = self._measure_position()
+                position = self._measure_position(tw_orbit=_tw_orbit)
             except xt.twiss.ClosedOrbitSearchError:
                 raise RuntimeError('Closed orbit not found. '
                     'Please use the `thread(...)` method to obtain a first guess, '
@@ -200,13 +230,17 @@ class OrbitCorrectionSinglePlane:
             i_iter += 1
             if n_iter != 'auto' and i_iter >= n_iter:
                 break
-        position = self._measure_position()
-        self._position_after = position
-        if verbose:
-            print(
-                f'Trajectory correction - iter {i_iter}, rms: {position.std()}')
 
-    def _measure_position(self):
+        if _tw_orbit is None:
+            position = self._measure_position()
+            self._position_after = position
+            if verbose:
+                print(
+                    f'Trajectory correction - iter {i_iter}, rms: {position.std()}')
+        else:
+            self._position_after = None
+
+    def _compute_tw_orbit(self):
         if self.mode == 'open':
             # Initialized with betx=1, bety=1 (use W_matrix to avoid compilation)
             twinit = xt.TwissInit(W_matrix=np.eye(6),
@@ -217,8 +251,14 @@ class OrbitCorrectionSinglePlane:
             twinit = None
         tw_orbit = self.line.twiss4d(only_orbit=True, start=self.start, end=self.end,
                                      init=twinit, reverse=False)
+        return tw_orbit
+
+    def _measure_position(self, tw_orbit=None):
 
-        position = tw_orbit.rows[self.monitor_names][self.plane]
+        if tw_orbit is None:
+            tw_orbit = self._compute_tw_orbit()
+
+        position = tw_orbit[self.plane][self._mask_monitors]
 
         return position
 
@@ -387,7 +427,8 @@ class TrajectoryCorrection:
             self.y_correction = None
 
     def correct(self, planes=None, n_micado=None, n_singular_values=None,
-                rcond=None, n_iter='auto', verbose=True, stop_iter_factor=0.1):
+                rcond=None, n_iter='auto', verbose=True, stop_iter_factor=0.1,
+                tol_position_std=1e-10):
 
         '''
         Correct the trajectory in the horizontal and/or vertical plane.
@@ -445,30 +486,58 @@ class TrajectoryCorrection:
         i_iter = 0
         stop_x = self.x_correction is None or 'x' not in planes
         stop_y = self.y_correction is None or 'y' not in planes
+
+        if stop_x and stop_y:
+            return
+
+        if self.x_correction is not None:
+            a_correction = self.x_correction
+        if self.y_correction is not None:
+            a_correction = self.y_correction
+
+        tw_orbit = a_correction._compute_tw_orbit()
+
         while True:
-            if not stop_x:
+
+            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)
-                if i_iter > 0 and n_iter == 'auto':
-                    stop_x = (self.x_correction._position_after.std()
-                        > (1. - stop_iter_factor) * self.x_correction._position_before.std())
-            if not stop_y:
+                            rcond=rcond_x, verbose=False, n_iter=1,
+                            _tw_orbit=tw_orbit)
+
+            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)
-                if i_iter > 0 and n_iter == 'auto':
-                    stop_y = (self.y_correction._position_after.std()
-                        > (1. - stop_iter_factor) * self.y_correction._position_before.std())
+                            rcond=rcond_y, verbose=False, n_iter=1,
+                            _tw_orbit=tw_orbit)
+
+            tw_orbit_prev = tw_orbit
+            tw_orbit = a_correction._compute_tw_orbit()
+
+            if n_iter == 'auto' and self.x_correction is not None and 'x' in planes:
+                new_position = self.x_correction._measure_position(tw_orbit)
+                old_position = self.x_correction._measure_position(tw_orbit_prev)
+                stop_x = (new_position.std() < tol_position_std or
+                    new_position.std() > (1. - stop_iter_factor) * old_position.std())
+
+            if n_iter == 'auto' and 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)
+                stop_y = (new_position.std() < tol_position_std or
+                    new_position.std() > (1. - stop_iter_factor) * old_position.std())
 
             if verbose:
                 str_2print = f'Iteration {i_iter}, '
                 if self.x_correction is not None and 'x' in planes:
-                    str_2print += (f'x_rms: {self.x_correction._position_before.std():.2e}'
-                        f' -> {self.x_correction._position_after.std():.2e}, ')
+                    new_position = self.x_correction._measure_position(tw_orbit)
+                    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.y_correction is not None and 'y' in planes:
-                    str_2print += (f'y_rms: {self.y_correction._position_before.std():.2e}'
-                        f' -> {self.y_correction._position_after.std():.2e}')
+                    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}')
                 print(str_2print)
             if stop_x and stop_y:
                 break
@@ -612,12 +681,15 @@ def _thread(line, ds_thread, twiss_table=None, rcond_short = None, rcond_long =
 
         if verbose:
             ocprint = ocorr_only_added_part
+            tw_orbit_print = ocprint.x_correction._compute_tw_orbit()
+            x_meas_print = ocprint.x_correction._measure_position(tw_orbit_print)
+            y_meas_print = ocprint.y_correction._measure_position(tw_orbit_print)
             str_2print = f'Stop at s={s_corr_end}, '
             str_2print += 'local rms  = ['
             str_2print += (f'x: {ocprint.x_correction._position_before.std():.2e}'
-                f' -> {ocprint.x_correction._position_after.std():.2e}, ')
+                f' -> {x_meas_print.std():.2e}, ')
             str_2print += (f'y: {ocprint.y_correction._position_before.std():.2e}'
-                f' -> {ocprint.y_correction._position_after.std():.2e}]')
+                f' -> {y_meas_print.std():.2e}]')
             print(str_2print)
 
         # Correct from start line to end of new added portion
@@ -634,12 +706,15 @@ def _thread(line, ds_thread, twiss_table=None, rcond_short = None, rcond_long =
 
         if verbose:
             ocprint = ocorr
+            tw_orbit_print = ocprint.x_correction._compute_tw_orbit()
+            x_meas_print = ocprint.x_correction._measure_position(tw_orbit_print)
+            y_meas_print = ocprint.y_correction._measure_position(tw_orbit_print)
             str_2print = f'Stop at s={s_corr_end}, '
             str_2print += 'global rms = ['
             str_2print += (f'x: {ocprint.x_correction._position_before.std():.2e}'
-                f' -> {ocprint.x_correction._position_after.std():.2e}, ')
+                f' -> {x_meas_print.std():.2e}, ')
             str_2print += (f'y: {ocprint.y_correction._position_before.std():.2e}'
-                f' -> {ocprint.y_correction._position_after.std():.2e}]')
+                f' -> {y_meas_print.std():.2e}]')
             print(str_2print)
 
         s_corr_end += ds_thread