xtrack 0.80.1__tar.gz → 0.82.0__tar.gz

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

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

xtrack-0.82.0/tests/test_aperture_table.py

@@ -0,0 +1,158 @@
+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])
+
+def test_aperture_table_aper_at_same_s():
+
+    env = xt.Environment()
+
+    line = env.new_line(components=[
+        env.new('lrect', xt.LimitRect, min_x=-0.05, max_x=0.05, min_y=-0.02, max_y=0.02, at=3.),
+        env.new('lellipse', xt.LimitEllipse, a=0.02, b=0.01),
+        env.new('m', xt.Marker, at=5.),
+        env.place('lellipse')
+        ]
+    )
+
+    line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1, p0c=26e9)
+
+    tt = line.get_aperture_table()
+    #
+    # Table: 7 rows, 10 cols
+    # name                    s    x_aper_low   x_aper_high x_aper_low_discrete x_aper_high_discrete ...
+    # drift_1                 0       -0.0505        0.0495                 nan                  nan
+    # lrect                   3       -0.0505        0.0495             -0.0505               0.0495
+    # lellipse::0             3       -0.0205        0.0195             -0.0205               0.0195
+    # drift_2                 3       -0.0205        0.0195                 nan                  nan
+    # m                       5       -0.0205        0.0195                 nan                  nan
+    # lellipse::1             5       -0.0205        0.0195             -0.0205               0.0195
+    # _end_point              5       -0.0205        0.0195                 nan                  nan
+
+    import numpy as np
+    import xobjects as xo
+    assert np.all(tt.name == ['drift_1', 'lrect', 'lellipse', 'drift_2', 'm', 'lellipse',
+        '_end_point'])
+    xo.assert_allclose(tt.s, np.array([0., 3., 3., 3., 5., 5., 5.]), rtol=0, atol=1e-6)
+    xo.assert_allclose(tt.x_aper_low, np.array([-0.0505, -0.0505, -0.0205, -0.0205, -0.0205,
+        -0.0205, -0.0205]), rtol=0, atol=1e-6)
+    xo.assert_allclose(tt.x_aper_high, np.array([0.0495, 0.0495, 0.0195, 0.0195, 0.0195,
+        0.0195, 0.0195]), rtol=0, atol=1e-6)
+    xo.assert_allclose(tt.x_aper_low_discrete, np.array([np.nan, -0.0505, -0.0205, np.nan,
+        np.nan, -0.0205, np.nan]), rtol=0, atol=1e-6)
+    xo.assert_allclose(tt.x_aper_high_discrete, np.array([np.nan, 0.0495, 0.0195, np.nan,
+        np.nan, 0.0195, np.nan]), rtol=0, atol=1e-6)
+    xo.assert_allclose(tt.y_aper_low, np.array(
+        [-0.0205, -0.0205, -0.0105, -0.0105, -0.0105, -0.0105, -0.0105],
+        dtype=float), rtol=0, atol=1e-6)
+    xo.assert_allclose(tt.y_aper_high, np.array(
+        [0.0195, 0.0195, 0.0095, 0.0095, 0.0095, 0.0095, 0.0095],
+        dtype=float), rtol=0, atol=1e-6)
+    xo.assert_allclose(tt.y_aper_low_discrete, np.array(
+        [np.nan, -0.0205, -0.0105, np.nan, np.nan, -0.0105, np.nan],
+        dtype=float), rtol=0, atol=1e-6)
+    xo.assert_allclose(tt.y_aper_high_discrete, np.array(
+        [np.nan, 0.0195, 0.0095, np.nan, np.nan, 0.0095, np.nan],
+        dtype=float), rtol=0, atol=1e-6)

{xtrack-0.80.1 → xtrack-0.82.0}/tests/test_apertures.py

@@ -286,4 +286,79 @@ def test_aper_tilt(test_context):
     assert_allclose(np.mean(x_alive), 0.08, rtol=5e-2, atol=0)
     assert_allclose(np.mean(y_alive), 0.04, rtol=5e-2, atol=0)
     slope = np.polyfit(x_alive, y_alive, 1)[0]
-    assert_allclose(slope, np.tan(np.deg2rad(tilt_deg)), rtol=5e-2, atol=0)
+    assert_allclose(slope, np.tan(np.deg2rad(tilt_deg)), rtol=5e-2, atol=0)
+
+
+
+def test_aperture_svg_path():
+
+    svg= {"path": """M4 8 10 1 13 0 12 3 5 9C6 10 6 11 7 10 7 11 8 12 7 12A1.42 1.42 0 016 13 5 5 0 004 10Q3.5 9.9 3.5 10.5T2 11.8 1.2 11 2.5 9.5 3 9A5 5 90 000 7 1.42 1.42 0 011 6C1 5 2 6 3 6 2 7 3 7 4 8"""}
+
+    aper = xt.LimitPolygon(
+                    svg=svg)
+
+    assert aper.copy().svg==aper.svg
+    aper2=xt.LimitPolygon.from_dict(aper.to_dict())
+    assert aper2.svg==aper.svg
+
+    x_expected = np.array([ 3.41600000e-03,  3.15400000e-03,  2.92800000e-03,  2.75000000e-03,
+        2.63200000e-03,  2.58600000e-03,  2.62400000e-03,  2.75800000e-03,
+        3.00000000e-03,  2.40800000e-03,  2.12700000e-03,  1.86400000e-03,
+        1.62500000e-03,  1.41600000e-03,  1.24300000e-03,  1.11200000e-03,
+        1.02900000e-03,  1.00000000e-03,  7.24296143e-04,  5.96239745e-04,
+        4.76593043e-04,  3.66655177e-04,  2.67619865e-04,  1.80562445e-04,
+        1.06428199e-04,  4.60220848e-05, -4.44089210e-19,  7.05663559e-04,
+        1.04481682e-03,  1.37237342e-03,  1.68655149e-03,  1.98564190e-03,
+        2.26801764e-03,  2.53214260e-03,  2.77657996e-03,  3.00000000e-03,
+        3.01200000e-03,  2.99700000e-03,  2.96800000e-03,  2.92500000e-03,
+        2.86800000e-03,  2.79700000e-03,  2.71200000e-03,  2.61300000e-03,
+        2.50000000e-03,  2.25600000e-03,  2.13100000e-03,  2.00400000e-03,
+        1.87500000e-03,  1.74400000e-03,  1.61100000e-03,  1.47600000e-03,
+        1.33900000e-03,  1.20000000e-03,  1.00800000e-03,  9.78000000e-04,
+        9.92000000e-04,  1.05000000e-03,  1.15200000e-03,  1.29800000e-03,
+        1.48800000e-03,  1.72200000e-03,  2.00000000e-03,  2.54000000e-03,
+        2.76500000e-03,  2.96000000e-03,  3.12500000e-03,  3.26000000e-03,
+        3.36500000e-03,  3.44000000e-03,  3.48500000e-03,  3.50000000e-03,
+        3.52000000e-03,  3.54500000e-03,  3.58000000e-03,  3.62500000e-03,
+        3.68000000e-03,  3.74500000e-03,  3.82000000e-03,  3.90500000e-03,
+        4.00000000e-03,  4.56952827e-03,  4.82689224e-03,  5.06408867e-03,
+        5.27982723e-03,  5.47293432e-03,  5.64235946e-03,  5.78718097e-03,
+        5.90661105e-03,  6.00000000e-03,  6.27570386e-03,  6.40376026e-03,
+        6.52340696e-03,  6.63334482e-03,  6.73238014e-03,  6.81943755e-03,
+        6.89357180e-03,  6.95397792e-03,  7.00000000e-03,  7.38400000e-03,
+        7.44100000e-03,  7.43200000e-03,  7.37500000e-03,  7.28800000e-03,
+        7.18900000e-03,  7.09600000e-03,  7.02700000e-03,  7.00000000e-03,
+        6.50400000e-03,  6.31600000e-03,  6.15200000e-03,  6.00000000e-03,
+        5.84800000e-03,  5.68400000e-03,  5.49600000e-03,  5.27200000e-03,
+        5.00000000e-03,  1.20000000e-02,  1.30000000e-02,  1.00000000e-02,
+        4.00000000e-03])
+    y_expected = np.array([-0.007504  , -0.007316  , -0.007152  , -0.007     , -0.006848  ,
+       -0.006684  , -0.006496  , -0.006272  , -0.006     , -0.005904  ,
+       -0.005811  , -0.005712  , -0.005625  , -0.005568  , -0.005559  ,
+       -0.005616  , -0.005757  , -0.006     , -0.00610643, -0.00618056,
+       -0.00626762, -0.00636666, -0.00647659, -0.00659624, -0.0067243 ,
+       -0.00685937, -0.007     , -0.00721282, -0.00735764, -0.00752707,
+       -0.00772017, -0.00793591, -0.00817311, -0.00843047, -0.0087066 ,
+       -0.009     , -0.00918   , -0.009255  , -0.00932   , -0.009375  ,
+       -0.00942   , -0.009455  , -0.00948   , -0.009495  , -0.0095    ,
+       -0.00956   , -0.009635  , -0.00974   , -0.009875  , -0.01004   ,
+       -0.010235  , -0.01046   , -0.010715  , -0.011     , -0.011512  ,
+       -0.011702  , -0.011848  , -0.01195   , -0.012008  , -0.012022  ,
+       -0.011992  , -0.011918  , -0.0118    , -0.011524  , -0.011389  ,
+       -0.011256  , -0.011125  , -0.010996  , -0.010869  , -0.010744  ,
+       -0.010621  , -0.0105    , -0.010288  , -0.010203  , -0.010132  ,
+       -0.010075  , -0.010032  , -0.010003  , -0.009988  , -0.009987  ,
+       -0.01      , -0.01046786, -0.01073198, -0.01101436, -0.01131345,
+       -0.01162763, -0.01195518, -0.01229434, -0.01264324, -0.013     ,
+       -0.01289357, -0.01281944, -0.01273238, -0.01263334, -0.01252341,
+       -0.01240376, -0.0122757 , -0.01214063, -0.012     , -0.011888  ,
+       -0.011757  , -0.011584  , -0.011375  , -0.011136  , -0.010873  ,
+       -0.010592  , -0.010299  , -0.01      , -0.010376  , -0.010414  ,
+       -0.010368  , -0.01025   , -0.010072  , -0.009846  , -0.009584  ,
+       -0.009298  , -0.009     , -0.003     , -0.        , -0.001     ,
+       -0.008     ])
+
+    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)

xtrack-0.82.0/xtrack/_version.py

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

xtrack-0.82.0/xtrack/aperture_meas.py

@@ -0,0 +1,95 @@
+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
+
+    # I force the values, for the case in which there are multiple apertures
+    # at the same location
+    x_aper_low[mask_interp_low_h] = x_aper_low_discrete[mask_interp_low_h]
+    x_aper_high[mask_interp_low_h] = x_aper_high_discrete[mask_interp_low_h]
+    y_aper_low[mask_interp_high_h] = y_aper_low_discrete[mask_interp_high_h]
+    y_aper_high[mask_interp_high_h] = y_aper_high_discrete[mask_interp_high_h]
+
+    # Force nan at end_point
+    x_aper_low_discrete[-1] = np.nan
+    x_aper_high_discrete[-1] = np.nan
+    y_aper_low_discrete[-1] = np.nan
+    y_aper_high_discrete[-1] = 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