xtrack 0.80.1__tar.gz → 0.81.0__tar.gz

{xtrack-0.80.1/xtrack.egg-info → xtrack-0.81.0}/PKG-INFO

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

xtrack-0.81.0/tests/test_aperture_table.py

@@ -0,0 +1,106 @@
+import pathlib
+
+import xtrack as xt
+import numpy as np
+import xobjects as xo
+from cpymad.madx import Madx
+
+test_data_folder = pathlib.Path(
+    __file__).parent.joinpath('../test_data').absolute()
+
+def test_aperture_table():
+
+    aper_blacklist = [
+        'vtaf.51632.b_aper', 'vbrta.51633.a_aper', 'vbrta.51633.b_aper',
+        'bgiha.51634.a_aper', 'bgiva.51674.a_aper']
+
+    env = xt.load_madx_lattice(test_data_folder /
+                               'sps_with_apertures/EYETS 2024-2025.seq')
+    env.vars.load_madx(str(test_data_folder / 'sps_with_apertures/lhc_q20.str'))
+    line = env.sps
+    line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1, p0c=26e9)
+
+    tw0 = line.twiss4d()
+
+
+    mad = Madx()
+    mad.input('''
+    SPS : SEQUENCE, refer = centre,    L = 7000;
+    a: marker, at = 20;
+    endsequence;
+    ''')
+    mad.call(str(test_data_folder /
+                 'sps_with_apertures/APERTURE_EYETS 2024-2025.seq'))
+    mad.beam()
+    mad.use('SPS')
+    line_aper = xt.Line.from_madx_sequence(mad.sequence.SPS, install_apertures=True)
+
+    tt_aper = line_aper.get_table().rows['.*_aper']
+
+    insertions = []
+    for nn in tt_aper.name:
+        if nn in aper_blacklist:
+            continue
+        env.elements[nn] = line_aper.get(nn).copy()
+        insertions.append(env.place(nn, at=tt_aper['s', nn]))
+
+    for ins in insertions:
+        if ins.name.endswith('.a_aper'):
+            ins.at += 1e-3
+        if ins.name.endswith('.b_aper'):
+            ins.at -= 1e-3
+
+    line = env.sps
+    line.insert(insertions)
+
+    line.build_tracker()
+    aper = line.get_aperture_table(dx=1e-3, dy=1e-3,
+                                x_range=(-0.1, 0.1), y_range=(-0.1, 0.1))
+
+
+    ###########
+    aper_check = aper.rows['veba.20250.a_aper' : 'vebb.20270.b_aper']
+
+    assert np.all(aper_check.name == np.array(
+        ['veba.20250.a_aper', 'drift_333..2', 'mba.20250', 'drift_334..0',
+        'veba.20250.b_aper', 'drift_334..1', 'vebb.20270.a_aper',
+        'drift_334..2', 'mbb.20270', 'drift_335..0', 'vebb.20270.b_aper']))
+    xo.assert_allclose(aper_check.s, np.array([
+        1225.8247    , 1225.8247    , 1226.02017417, 1232.28019277,
+        1232.4827    , 1232.4827    , 1232.4847    , 1232.4847    ,
+        1232.67019277, 1238.93021138, 1239.1227    ]), rtol=0, atol=1e-6)
+    xo.assert_allclose(aper_check.x_aper_low, np.array(
+        [-0.0765, -0.0765, -0.0765, -0.0765, -0.0765, -0.0765, -0.0645,
+        -0.0645, -0.0645, -0.0645, -0.0645]), rtol=0, atol=1e-3)
+    xo.assert_allclose(aper_check.x_aper_high, np.array(
+        [0.0755, 0.0755, 0.0755, 0.0755, 0.0755, 0.0755, 0.0645, 0.0645,
+        0.0645, 0.0645, 0.0645]), rtol=0, atol=1e-3)
+    xo.assert_allclose(aper_check.y_aper_low, np.array(
+        [-0.0195, -0.0195, -0.0195, -0.0195, -0.0195, -0.0195, -0.0265,
+        -0.0265, -0.0265, -0.0265, -0.0265]), rtol=0, atol=1e-3)
+    xo.assert_allclose(aper_check.y_aper_high, np.array(
+        [0.0195, 0.0195, 0.0195, 0.0195, 0.0195, 0.0195, 0.0265, 0.0265,
+        0.0265, 0.0265, 0.0265]), rtol=0, atol=1e-3)
+
+    assert np.all(np.isnan(aper_check.x_aper_low_discrete) == np.array(
+        [False,  True,  True,  True, False,  True, False,  True,  True,
+            True, False]))
+    assert np.all(np.isnan(aper_check.x_aper_high_discrete) == np.array(
+        [False,  True,  True,  True, False,  True, False,  True,  True,
+            True, False]))
+    assert np.all(np.isnan(aper_check.y_aper_low_discrete) == np.array(
+        [False,  True,  True,  True, False,  True, False,  True,  True,
+            True, False]))
+    assert np.all(np.isnan(aper_check.y_aper_high_discrete) == np.array(
+        [False,  True,  True,  True, False,  True, False,  True,  True,
+            True, False]))
+
+    mask_not_none = ~np.isnan(aper_check.x_aper_low_discrete)
+    assert np.all(aper_check.x_aper_low_discrete[mask_not_none]
+                    == aper_check.x_aper_low[mask_not_none])
+    assert np.all(aper_check.x_aper_high_discrete[mask_not_none]
+                    == aper_check.x_aper_high[mask_not_none])
+    assert np.all(aper_check.y_aper_low_discrete[mask_not_none]
+                    == aper_check.y_aper_low[mask_not_none])
+    assert np.all(aper_check.y_aper_high_discrete[mask_not_none]
+                    == aper_check.y_aper_high[mask_not_none])

xtrack-0.81.0/xtrack/_version.py

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

xtrack-0.81.0/xtrack/aperture_meas.py

@@ -0,0 +1,82 @@
+import numpy as np
+import xtrack as xt
+
+def measure_aperture(line,
+            dx=1e-3, dy=1e-3, x_range=(-0.1, 0.1), y_range=(-0.1, 0.1)):
+    x_test = np.arange(x_range[0], x_range[1], dx)
+    y_test = np.arange(y_range[0], y_range[1], dy)
+
+    n_x = len(x_test)
+
+    x_probe = np.concatenate([x_test, 0*y_test])
+    y_probe = np.concatenate([0*x_test, y_test])
+
+    p = line.build_particles(x=x_probe, y=y_probe)
+
+    with xt.line._preserve_config(line):
+        line.freeze_longitudinal()
+        line.freeze_vars(['x', 'px', 'y', 'py'])
+        line.config.XSUITE_RESTORE_LOSS = True
+
+        line.track(p, turn_by_turn_monitor='ONE_TURN_EBE')
+        mon = line.record_last_track
+
+    x_h_aper = mon.x[:n_x, :]
+    s_h_aper = mon.s[:n_x, :]
+    state_h_aper = mon.state[:n_x, :]
+    state_h_aper[:, :-1] = state_h_aper[:, 1:] # due to the way they are logged
+
+    mean_x = 0.5*(x_h_aper[:-1, :] + x_h_aper[1:, :])
+    diff_loss_h = np.diff(state_h_aper, axis=0)
+    zeros = mean_x * 0
+    x_aper_low_mat = np.where(diff_loss_h>0, mean_x, zeros)
+    x_aper_low_discrete = x_aper_low_mat.sum(axis=0)
+    x_aper_high_mat = np.where(diff_loss_h<0, mean_x, zeros)
+    x_aper_high_discrete = x_aper_high_mat.sum(axis=0)
+
+    y_v_aper = mon.y[n_x:, :]
+    state_v_aper = mon.state[n_x:, :]
+    state_v_aper[:, :-1] = state_v_aper[:, 1:] # due to the way they are logged
+
+    mean_y = 0.5*(y_v_aper[:-1, :] + y_v_aper[1:, :])
+    diff_loss_v = np.diff(state_v_aper, axis=0)
+    zeros = mean_y * 0
+    y_aper_low_mat = np.where(diff_loss_v>0, mean_y, zeros)
+    y_aper_low_discrete = y_aper_low_mat.sum(axis=0)
+    y_aper_high_mat = np.where(diff_loss_v<0, mean_y, zeros)
+    y_aper_high_discrete = y_aper_high_mat.sum(axis=0)
+
+    s_aper = s_h_aper[0, :]
+
+    mask_interp_low_h = x_aper_low_discrete != 0
+    x_aper_low = np.interp(s_aper,
+                            s_aper[mask_interp_low_h], x_aper_low_discrete[mask_interp_low_h])
+    mask_interp_high_h = x_aper_high_discrete != 0
+    x_aper_high = np.interp(s_aper,
+                            s_aper[mask_interp_high_h], x_aper_high_discrete[mask_interp_high_h])
+    x_aper_low_discrete[~mask_interp_low_h] = np.nan
+    x_aper_high_discrete[~mask_interp_high_h] = np.nan
+
+    mask_interp_low_v = y_aper_low_discrete != 0
+    y_aper_low = np.interp(s_aper,
+                            s_aper[mask_interp_low_v], y_aper_low_discrete[mask_interp_low_v])
+    mask_interp_high_v = y_aper_high_discrete != 0
+    y_aper_high = np.interp(s_aper,
+                            s_aper[mask_interp_high_v], y_aper_high_discrete[mask_interp_high_v])
+    y_aper_low_discrete[~mask_interp_low_v] = np.nan
+    y_aper_high_discrete[~mask_interp_high_v] = np.nan
+
+    out = xt.Table({
+        'name': np.array(list(line.element_names) + ['_end_point']),
+        's': s_aper,
+        'x_aper_low': x_aper_low,
+        'x_aper_high': x_aper_high,
+        'x_aper_low_discrete': x_aper_low_discrete,
+        'x_aper_high_discrete': x_aper_high_discrete,
+        'y_aper_low': y_aper_low,
+        'y_aper_high': y_aper_high,
+        'y_aper_low_discrete': y_aper_low_discrete,
+        'y_aper_high_discrete': y_aper_high_discrete,
+    })
+
+    return out

{xtrack-0.80.1 → xtrack-0.81.0}/xtrack/line.py

@@ -37,6 +37,7 @@ from xtrack.twiss import (compute_one_turn_matrix_finite_differences,
                           get_non_linear_chromaticity,
                           DEFAULT_MATRIX_STABILITY_TOL,
                           DEFAULT_MATRIX_RESPONSIVENESS_TOL)
+from xtrack.aperture_meas import measure_aperture
 from .match import match_line, closed_orbit_correction, match_knob_line, Action
 from .tapering import compensate_radiation_energy_loss
 from .mad_loader import MadLoader
@@ -799,6 +800,42 @@ class Line:
             True: 'reverse', False: 'proper'}[reverse]
         return tab
 
+    def get_aperture_table(self, dx=1e-3, dy=1e-3, x_range=(-0.1, 0.1),
+                           y_range=(-0.1, 0.1)):
+        '''
+        Return a table with the horizontal and vertical aperture estimated at all
+        elements of the line.
+        The aperture is estimated by tracking a particle through the line and
+        measuring the maximum and minumum horizontal and vertical position
+        at which particles survive. For elements at which no lost particles are
+        detected, the aperture is estimated by interpolating the values
+        of the neighbouring elements.
+
+        Parameters
+        ----------
+        dx : float, optional
+            Required horizontal resolution (in m) for the aperture measurement.
+            Default is 1e-3.
+        dy : float, optional
+            Required vertical resolution (in m) for the aperture measurement.
+            Default is 1e-3.
+        x_range : tuple, optional
+            Horizontal range (in m) for the aperture measurement.
+            Default is (-0.1, 0.1).
+        y_range : tuple, optional
+            Vertical range (in m) for the aperture measurement.
+            Default is (-0.1, 0.1).
+
+        Returns
+        -------
+        aperture_table : xtrack.Table
+            Table with the horizontal and vertical aperture at all elements
+            of the line.
+        '''
+
+        return xt.aperture_meas.measure_aperture(self,
+            dx=1e-3, dy=1e-3, x_range=(-0.1, 0.1), y_range=(-0.1, 0.1))
+
     def copy(self, shallow=False, _context=None, _buffer=None):
         '''
         Return a copy of the line.
@@ -4067,7 +4104,9 @@ class Line:
         >>> line.set(['e', 'f'], '3*a')
 
         '''
-        if hasattr(name, 'name'):
+        if hasattr(name, 'env_name'):
+            name = name.env_name
+        elif hasattr(name, 'name'):
             name = name.name
 
         if isinstance(name, Iterable) and not isinstance(name, str):

{xtrack-0.80.1 → xtrack-0.81.0}/xtrack/linear_normal_form.py

@@ -186,11 +186,14 @@ def compute_linear_normal_form(M, symplectify=False, only_4d_block=False,
     n2_inv_sq = np.matmul(np.matmul(a2, S), b2)
     n3_inv_sq = np.matmul(np.matmul(a3, S), b3)
 
+    if only_4d_block:
+        n3_inv_sq = 1.0 # Just to avoid errors
+
     if not n1_inv_sq > 0:
         raise ValueError('Invalid n1')
     if not n2_inv_sq > 0:
         raise ValueError('Invalid n2')
-    if not n3_inv_sq > 0:
+    if not n3_inv_sq > 0 :
         raise ValueError('Invalid n3')
 
     n1 = 1./np.sqrt(n1_inv_sq)

{xtrack-0.80.1 → xtrack-0.81.0}/xtrack/mad_parser/loader.py

@@ -675,6 +675,7 @@ def load_madx_lattice(file=None, string=None, reverse_lines=None):
         del new_env.lines['__DUMMY__'] # keep the elements but not the line
 
         env = new_env
-        print('Done reversing lines')
+
+    env.vars.default_to_zero = False
 
     return env

{xtrack-0.80.1 → xtrack-0.81.0}/xtrack/monitors/particles_monitor.h

@@ -65,10 +65,14 @@ void ParticlesMonitor_track_local_particle(ParticlesMonitorData el,
         }
     }
 
-
+    #ifdef XSUITE_RESTORE_LOSS
+    LocalParticle_set_state(part, 1);
+    #endif
 
     //end_per_particle_block
 
 }
 
 #endif
+
+

{xtrack-0.80.1 → xtrack-0.81.0}/xtrack/particles/particles.py

@@ -1749,6 +1749,9 @@ class Particles(xo.HybridClass):
         int64_t check_is_active(LocalParticle* part) {
             int64_t ipart=0;
             while (ipart < part->_num_active_particles){
+                #ifdef XSUITE_RESTORE_LOSS
+                ipart++;
+                #else
                 if (part->state[ipart]<1){
                     LocalParticle_exchange(
                         part, ipart, part->_num_active_particles-1);
@@ -1758,6 +1761,7 @@ class Particles(xo.HybridClass):
                 else{
                     ipart++;
                 }
+                #endif
             }
 
             if (part->_num_active_particles==0){

{xtrack-0.80.1 → xtrack-0.81.0}/xtrack/twiss.py

@@ -1345,9 +1345,8 @@ def _compute_chromatic_functions(line, init, delta_chrom, steps_r_matrix,
                                         symmetrize=(periodic_mode == 'periodic_symmetric'),
                                         include_collective=include_collective,
                                         )['R_matrix']
-
             (WW_chrom, _, _, _) = lnf.compute_linear_normal_form(RR_chrom,
-                                    only_4d_block=method=='4d',
+                                    only_4d_block=True,
                                     responsiveness_tol=matrix_responsiveness_tol,
                                     stability_tol=matrix_stability_tol,
                                     symplectify=symplectify)
@@ -2377,15 +2376,15 @@ def compute_one_turn_matrix_finite_differences(
     ddelta = steps_r_matrix["ddelta"]
     part_temp = xpart.build_particles(_context=context,
             particle_ref=particle_on_co, mode='shift',
-            x  =    [dx,  0., 0.,  0.,    0.,     0., -dx,   0.,  0.,   0.,     0.,      0.],
-            px =    [0., dpx, 0.,  0.,    0.,     0.,  0., -dpx,  0.,   0.,     0.,      0.],
-            y  =    [0.,  0., dy,  0.,    0.,     0.,  0.,   0., -dy,   0.,     0.,      0.],
-            py =    [0.,  0., 0., dpy,    0.,     0.,  0.,   0.,  0., -dpy,     0.,      0.],
-            zeta =  [0.,  0., 0.,  0., dzeta,     0.,  0.,   0.,  0.,   0., -dzeta,      0.],
-            delta = [0.,  0., 0.,  0.,    0., ddelta,  0.,   0.,  0.,   0.,     0., -ddelta],
+            x  =    [0., dx,  0., 0.,  0.,    0.,     0., -dx,   0.,  0.,   0.,     0.,      0.],
+            px =    [0., 0., dpx, 0.,  0.,    0.,     0.,  0., -dpx,  0.,   0.,     0.,      0.],
+            y  =    [0., 0.,  0., dy,  0.,    0.,     0.,  0.,   0., -dy,   0.,     0.,      0.],
+            py =    [0., 0.,  0., 0., dpy,    0.,     0.,  0.,   0.,  0., -dpy,     0.,      0.],
+            zeta =  [0., 0.,  0., 0.,  0., dzeta,     0.,  0.,   0.,  0.,   0., -dzeta,      0.],
+            delta = [0., 0.,  0., 0.,  0.,    0., ddelta,  0.,   0.,  0.,   0.,     0., -ddelta],
             )
     dpzeta = float(context.nparray_from_context_array(
-        (part_temp.ptau[5] - part_temp.ptau[11])/2/part_temp.beta0[0]))
+        (part_temp.ptau[6] - part_temp.ptau[12])/2/part_temp.beta0[0]))
     if particle_on_co._xobject.at_element[0]>0:
         part_temp.s[:] = particle_on_co._xobject.s[0]
         part_temp.at_element[:] = particle_on_co._xobject.at_element[0]
@@ -2421,7 +2420,7 @@ def compute_one_turn_matrix_finite_differences(
                 line.config.XSUITE_MIRROR = True
                 line.track(part_temp, num_turns=num_turns)
 
-    temp_mat = np.zeros(shape=(6, 12), dtype=np.float64)
+    temp_mat = np.zeros(shape=(6, 13), dtype=np.float64)
     temp_mat[0, :] = context.nparray_from_context_array(part_temp.x)
     temp_mat[1, :] = context.nparray_from_context_array(part_temp.px)
     temp_mat[2, :] = context.nparray_from_context_array(part_temp.y)
@@ -2433,13 +2432,13 @@ def compute_one_turn_matrix_finite_differences(
     RR = np.zeros(shape=(6, 6), dtype=np.float64)
 
     for jj, dd in enumerate([dx, dpx, dy, dpy, dzeta, dpzeta]):
-        RR[:, jj] = (temp_mat[:, jj] - temp_mat[:, jj+6])/(2*dd)
+        RR[:, jj] = (temp_mat[:, jj+1] - temp_mat[:, jj+1+6])/(2*dd)
 
     out = {'R_matrix': RR}
 
     if element_by_element:
         mon = line.record_last_track
-        temp_mad_ebe = np.zeros(shape=(len(line._element_names_unique) + 1, 6, 12), dtype=np.float64)
+        temp_mad_ebe = np.zeros(shape=(len(line._element_names_unique) + 1, 6, 13), dtype=np.float64)
         temp_mad_ebe[:, 0, :] = mon.x.T
         temp_mad_ebe[:, 1, :] = mon.px.T
         temp_mad_ebe[:, 2, :] = mon.y.T
@@ -2449,7 +2448,7 @@ def compute_one_turn_matrix_finite_differences(
 
         RR_ebe = np.zeros(shape=(len(line._element_names_unique) + 1, 6, 6), dtype=np.float64)
         for jj, dd in enumerate([dx, dpx, dy, dpy, dzeta, dpzeta]):
-            RR_ebe[:, :, jj] = (temp_mad_ebe[:, :, jj] - temp_mad_ebe[:, :, jj+6])/(2*dd)
+            RR_ebe[:, :, jj] = (temp_mad_ebe[:, :, jj+1] - temp_mad_ebe[:, :, jj+1+6])/(2*dd)
 
         if only_markers:
             mask_twiss = line.tracker._get_twiss_mask_markers()

{xtrack-0.80.1 → xtrack-0.81.0/xtrack.egg-info}/PKG-INFO

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

{xtrack-0.80.1 → xtrack-0.81.0}/xtrack.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ ducktrack/be_beamfields/slicing.py
 ducktrack/be_beamfields/spacecharge.py
 tests/test_acceleration.py
 tests/test_amplitude_detuning.py
+tests/test_aperture_table.py
 tests/test_aperture_turn_ele_and_monitor.py
 tests/test_apertures.py
 tests/test_attr_replicas_and_slices.py
@@ -110,6 +111,7 @@ tests/test_vs_madx.py
 tests/test_xmask_orbit_correction.py
 xtrack/__init__.py
 xtrack/_version.py
+xtrack/aperture_meas.py
 xtrack/base_element.py
 xtrack/environment.py
 xtrack/footprint.py

xtrack-0.80.1/xtrack/_version.py

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