xtrack 0.83.1__tar.gz → 0.83.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.83.1
+Version: 0.83.3
 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.3}/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.3}/tests/test_environment.py

@@ -618,6 +618,7 @@ def test_assemble_ring():
     cell3_select = ring2.select(start='start.cell.3.arc.2', end='end.cell.3.arc.2',
                                 name='cell3_copy')
     assert 'cell3_copy' in env.lines
+    assert cell3_select.particle_ref is not None
     assert env.lines['cell3_copy'] is cell3_select
     assert cell3_select._element_dict is env.element_dict
     assert cell3_select.element_names[0] == 'start.cell.3.arc.2'

{xtrack-0.83.1 → xtrack-0.83.3}/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.3/xtrack/_version.py

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

{xtrack-0.83.1 → xtrack-0.83.3}/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.3}/xtrack/beam_elements/elements_src/track_magnet_radiation.h

@@ -116,95 +116,99 @@ void magnet_apply_radiation_single_particle(
 
     if ((spin_flag != 0) && (spin_x_0 != 0. || spin_y_0 != 0. || spin_z_0 != 0.)){
 
-        double const kin_px_mean = (old_px + new_ax);
-        double const kin_py_mean = (old_py + new_ay);
-
-        double const kin_pz_mean = sqrt((1 + delta)*(1 + delta) - kin_px_mean * kin_px_mean - kin_py_mean * kin_py_mean);
-
-        double const beta_x = beta * (kin_px_mean / kin_pz_mean);
-        double const beta_y = beta * (kin_py_mean / kin_pz_mean);
-        double const beta_z = sqrt(beta*beta - beta_x * beta_x - beta_y * beta_y);
-
-        double const iv_x = beta_x / beta;
-        double const iv_y = beta_y / beta;
-        double const iv_z = beta_z / beta;
-
-        double B_par_spin = Bx_T * iv_x + By_T * iv_y + Bz_T * iv_z;
-        double const B_par_spin_x = B_par_spin * iv_x;
-        double const B_par_spin_y = B_par_spin * iv_y;
-        double const B_par_spin_z = B_par_spin * iv_z;
-
-        double const B_perp_spin_x = Bx_T - B_par_spin_x;
-        double const B_perp_spin_y = By_T - B_par_spin_y;
-        double const B_perp_spin_z = Bz_T - B_par_spin_z;
-
-        double const brho_part = P_J / (q0 * QELEM);
-
-        double const G_spin = LocalParticle_get_anomalous_magnetic_moment(part);
-
-        double const Omega_BMT_x = -1/brho_part * (
-            (1 + G_spin*gamma) * B_perp_spin_x + (1 + G_spin) * B_par_spin_x);
-        double const Omega_BMT_y = -1/brho_part * (
-            (1 + G_spin*gamma) * B_perp_spin_y + (1 + G_spin) * B_par_spin_y);
-        double const Omega_BMT_z = -1/brho_part * (
-            (1 + G_spin*gamma) * B_perp_spin_z + (1 + G_spin) * B_par_spin_z);
-
-        double Omega_BMT_mod = sqrt(Omega_BMT_x * Omega_BMT_x +
-            Omega_BMT_y * Omega_BMT_y + Omega_BMT_z * Omega_BMT_z);
-
-        if (Omega_BMT_mod > 1e-10){
-
-            double const omega_x = Omega_BMT_x / Omega_BMT_mod;
-            double const omega_y = Omega_BMT_y / Omega_BMT_mod;
-            double const omega_z = Omega_BMT_z / Omega_BMT_mod;
-
-            double const phi = Omega_BMT_mod * l_path;
-
-            double const sin_phi_2 = sin(phi/2);
-            double const cos_phi_2 = cos(phi/2);
-
-            // Quaternion rotation
-            double const t0 = cos_phi_2;
-            double const tx = omega_x * sin_phi_2;
-            double const ty = omega_y * sin_phi_2;
-            double const tz = omega_z * sin_phi_2;
-
-            // Rotation matrix
-            double const M11 = t0 * t0 + tx * tx - ty * ty - tz * tz;
-            double const M12 = 2 * (tx * ty - t0 * tz);
-            double const M13 = 2 * (tx * tz + t0 * ty);
-            double const M21 = 2 * (tx * ty + t0 * tz);
-            double const M22 = t0 * t0 - tx * tx + ty * ty - tz * tz;
-            double const M23 = 2 * (ty * tz - t0 * tx);
-            double const M31 = 2 * (tx * tz - t0 * ty);
-            double const M32 = 2 * (ty * tz + t0 * tx);
-            double const M33 = t0 * t0 - tx * tx - ty * ty + tz * tz;
-
-            double sin_hxl2 = 0.;
-            double cos_hxl2 = 1.;
-            if (hx != 0.){
-                sin_hxl2 = sin(hx * length / 2);
-                cos_hxl2 = cos(hx * length / 2);
+        #ifdef XSUITE_BACKTRACK
+            LocalParticle_set_state(part, -33);
+        #else
+            double const kin_px_mean = (old_px + new_ax);
+            double const kin_py_mean = (old_py + new_ay);
+
+            double const kin_pz_mean = sqrt((1 + delta)*(1 + delta) - kin_px_mean * kin_px_mean - kin_py_mean * kin_py_mean);
+
+            double const beta_x = beta * (kin_px_mean / kin_pz_mean);
+            double const beta_y = beta * (kin_py_mean / kin_pz_mean);
+            double const beta_z = sqrt(beta*beta - beta_x * beta_x - beta_y * beta_y);
+
+            double const iv_x = beta_x / beta;
+            double const iv_y = beta_y / beta;
+            double const iv_z = beta_z / beta;
+
+            double B_par_spin = Bx_T * iv_x + By_T * iv_y + Bz_T * iv_z;
+            double const B_par_spin_x = B_par_spin * iv_x;
+            double const B_par_spin_y = B_par_spin * iv_y;
+            double const B_par_spin_z = B_par_spin * iv_z;
+
+            double const B_perp_spin_x = Bx_T - B_par_spin_x;
+            double const B_perp_spin_y = By_T - B_par_spin_y;
+            double const B_perp_spin_z = Bz_T - B_par_spin_z;
+
+            double const brho_part = P_J / (q0 * QELEM);
+
+            double const G_spin = LocalParticle_get_anomalous_magnetic_moment(part);
+
+            double const Omega_BMT_x = -1/brho_part * (
+                (1 + G_spin*gamma) * B_perp_spin_x + (1 + G_spin) * B_par_spin_x);
+            double const Omega_BMT_y = -1/brho_part * (
+                (1 + G_spin*gamma) * B_perp_spin_y + (1 + G_spin) * B_par_spin_y);
+            double const Omega_BMT_z = -1/brho_part * (
+                (1 + G_spin*gamma) * B_perp_spin_z + (1 + G_spin) * B_par_spin_z);
+
+            double Omega_BMT_mod = sqrt(Omega_BMT_x * Omega_BMT_x +
+                Omega_BMT_y * Omega_BMT_y + Omega_BMT_z * Omega_BMT_z);
+
+            if (Omega_BMT_mod > 1e-10){
+
+                double const omega_x = Omega_BMT_x / Omega_BMT_mod;
+                double const omega_y = Omega_BMT_y / Omega_BMT_mod;
+                double const omega_z = Omega_BMT_z / Omega_BMT_mod;
+
+                double const phi = Omega_BMT_mod * l_path;
+
+                double const sin_phi_2 = sin(phi/2);
+                double const cos_phi_2 = cos(phi/2);
+
+                // Quaternion rotation
+                double const t0 = cos_phi_2;
+                double const tx = omega_x * sin_phi_2;
+                double const ty = omega_y * sin_phi_2;
+                double const tz = omega_z * sin_phi_2;
+
+                // Rotation matrix
+                double const M11 = t0 * t0 + tx * tx - ty * ty - tz * tz;
+                double const M12 = 2 * (tx * ty - t0 * tz);
+                double const M13 = 2 * (tx * tz + t0 * ty);
+                double const M21 = 2 * (tx * ty + t0 * tz);
+                double const M22 = t0 * t0 - tx * tx + ty * ty - tz * tz;
+                double const M23 = 2 * (ty * tz - t0 * tx);
+                double const M31 = 2 * (tx * tz - t0 * ty);
+                double const M32 = 2 * (ty * tz + t0 * tx);
+                double const M33 = t0 * t0 - tx * tx - ty * ty + tz * tz;
+
+                double sin_hxl2 = 0.;
+                double cos_hxl2 = 1.;
+                if (hx != 0.){
+                    sin_hxl2 = sin(hx * length / 2);
+                    cos_hxl2 = cos(hx * length / 2);
+                }
+                // Entry rotation (bend frame)
+                double const spin_x_1 = spin_x_0 * cos_hxl2 + spin_z_0 * sin_hxl2;
+                double const spin_y_1 = spin_y_0;
+                double const spin_z_1 = -spin_x_0 * sin_hxl2 + spin_z_0 * cos_hxl2;
+
+                // BMT rotation
+                double const spin_x_2 = M11 * spin_x_1 + M12 * spin_y_1 + M13 * spin_z_1;
+                double const spin_y_2 = M21 * spin_x_1 + M22 * spin_y_1 + M23 * spin_z_1;
+                double const spin_z_2 = M31 * spin_x_1 + M32 * spin_y_1 + M33 * spin_z_1;
+
+                // Exit rotation (bend frame)
+                double const spin_x_3 = spin_x_2 * cos_hxl2 + spin_z_2 * sin_hxl2;
+                double const spin_y_3 = spin_y_2;
+                double const spin_z_3 = -spin_x_2 * sin_hxl2 + spin_z_2 * cos_hxl2;
+
+                LocalParticle_set_spin_x(part, spin_x_3);
+                LocalParticle_set_spin_y(part, spin_y_3);
+                LocalParticle_set_spin_z(part, spin_z_3);
             }
-            // Entry rotation (bend frame)
-            double const spin_x_1 = spin_x_0 * cos_hxl2 + spin_z_0 * sin_hxl2;
-            double const spin_y_1 = spin_y_0;
-            double const spin_z_1 = -spin_x_0 * sin_hxl2 + spin_z_0 * cos_hxl2;
-
-            // BMT rotation
-            double const spin_x_2 = M11 * spin_x_1 + M12 * spin_y_1 + M13 * spin_z_1;
-            double const spin_y_2 = M21 * spin_x_1 + M22 * spin_y_1 + M23 * spin_z_1;
-            double const spin_z_2 = M31 * spin_x_1 + M32 * spin_y_1 + M33 * spin_z_1;
-
-            // Exit rotation (bend frame)
-            double const spin_x_3 = spin_x_2 * cos_hxl2 + spin_z_2 * sin_hxl2;
-            double const spin_y_3 = spin_y_2;
-            double const spin_z_3 = -spin_x_2 * sin_hxl2 + spin_z_2 * cos_hxl2;
-
-            LocalParticle_set_spin_x(part, spin_x_3);
-            LocalParticle_set_spin_y(part, spin_y_3);
-            LocalParticle_set_spin_z(part, spin_z_3);
-        }
+        #endif
     }
 
     // Synchrotron radiation

{xtrack-0.83.1 → xtrack-0.83.3}/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)
@@ -2236,8 +2248,10 @@ class Line:
     def cut_at_s(self, s: List[float], s_tol=1e-6, return_slices=False):
         """Slice the line so that positions in s never fall inside an element."""
 
-        if self._has_valid_tracker():
-            self.discard_tracker()
+        if not self._has_valid_tracker():
+            self.build_tracker() # To resolve replicase and slices
+
+        self.discard_tracker()
 
         cuts_for_element = self._elements_intersecting_s(s, s_tol=s_tol)
         strategies = [Strategy(None)]  # catch-all, ignore unaffected elements
@@ -3085,7 +3099,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']
@@ -4169,6 +4184,7 @@ class Line:
         self._env_if_needed()
 
         out = self.env.new_line(components=list(tt.env_name), name=name)
+        out.particle_ref = self.particle_ref.copy() if self.particle_ref else None
 
         if hasattr(self, '_in_multiline') and self._in_multiline is not None:
             out.env._var_management = None
@@ -4694,6 +4710,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.3}/xtrack/particles/particles.py

@@ -221,7 +221,7 @@ class Particles(xo.HybridClass):
 
         accepted_args = set(self._xofields.keys()) | {
             'energy0', 'tau', 'pzeta', 'mass_ratio', 'mass', 'kinetic_energy0',
-            '_context', '_buffer', '_offset', 'p0',
+            '_context', '_buffer', '_offset', 'p0', 'name',
         }
         if set(kwargs.keys()) - accepted_args:
             raise NameError(f'Invalid argument(s) provided: '
@@ -383,6 +383,8 @@ class Particles(xo.HybridClass):
         if isinstance(self._context, xo.ContextCpu) and not _no_reorganize:
             self.reorganize()
 
+        if 'name' in kwargs.keys():
+            self.name = kwargs['name']
 
     @classmethod
     def from_dict(cls, dct, load_rng_state=True, **kwargs):

{xtrack-0.83.1 → xtrack-0.83.3}/xtrack/tapering.py

@@ -7,7 +7,9 @@ import xtrack as xt
 import xobjects as xo
 
 def compensate_radiation_energy_loss(line, delta0=0, rtol_eneloss=1e-12,
-                                     max_iter=100, verbose=True, **kwargs):
+                                     max_iter=100, verbose=True,
+                                     co_search_at=None,
+                                     **kwargs):
 
     assert isinstance(line._context, xo.ContextCpu), "Only CPU context is supported"
     assert line.particle_ref is not None, "Particle reference is not set"
@@ -24,7 +26,7 @@ def compensate_radiation_energy_loss(line, delta0=0, rtol_eneloss=1e-12,
 
     line.config.XTRACK_MULTIPOLE_NO_SYNRAD = True
     with xt.freeze_longitudinal(line):
-        particle_on_co = line.find_closed_orbit()
+        particle_on_co = line.find_closed_orbit(co_search_at=co_search_at)
     line.config.XTRACK_MULTIPOLE_NO_SYNRAD = False
 
     beta0 = float(particle_on_co._xobject.beta0[0])