xtrack 0.61.0__tar.gz → 0.62.0__tar.gz

{xtrack-0.61.0/xtrack.egg-info → xtrack-0.62.0}/PKG-INFO

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

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_acceleration.py

@@ -3,18 +3,19 @@
 # Copyright (c) CERN, 2021.                 #
 # ######################################### #
 
-import pathlib
 import json
+import pathlib
+
 import numpy as np
 import pandas as pd
+from cpymad.madx import Madx
 from scipy.constants import c as clight
 
+import xobjects as xo
 import xpart as xp
 import xtrack as xt
 from xobjects.test_helpers import for_all_test_contexts
 
-from cpymad.madx import Madx
-
 test_data_folder = pathlib.Path(
     __file__).parent.joinpath('../test_data').absolute()
 
@@ -44,7 +45,7 @@ def test_acceleration(test_context):
     p_co = line.find_closed_orbit(particle_ref=xp.Particles.from_dict(
         input_data['particle']))
 
-    assert np.isclose(p_co._xobject.zeta[0], stable_z, atol=0, rtol=1e-2)
+    xo.assert_allclose(p_co._xobject.zeta[0], stable_z, atol=0, rtol=1e-2)
 
 
 @for_all_test_contexts
@@ -115,36 +116,36 @@ def test_energy_program(test_context):
     t_check = np.linspace(0, 20e-3, 1000)
     E_check = np.interp(t_check, t_turn_ref, E_kin_turn)
     E_check_ref = np.interp(t_check, t_s, E_kin_GeV*1e9)
-    assert np.allclose(E_check, E_check_ref, atol=0, rtol=2e-3)
+    xo.assert_allclose(E_check, E_check_ref, atol=0, rtol=2e-3)
 
     t_turn_check = line.energy_program.get_t_s_at_turn(np.arange(n_turn_test))
-    assert np.allclose(t_turn_check, t_turn_ref, atol=0, rtol=6e-4)
+    xo.assert_allclose(t_turn_check, t_turn_ref, atol=0, rtol=6e-4)
 
     p0c_check = line.energy_program.get_p0c_at_t_s(t_check)
     p0c_ref = np.interp(t_check,
                         t_turn_check,
                         line.particle_ref.mass0 * gamma_at_turn * beta_at_turn)
-    assert np.allclose(p0c_check, p0c_ref, atol=0, rtol=1e-3)
+    xo.assert_allclose(p0c_check, p0c_ref, atol=0, rtol=1e-3)
 
     kinetic_energy0_check = line.energy_program.get_kinetic_energy0_at_t_s(t_check)
     kinetic_energy0_ref = np.interp(t_check,
                         t_turn_check,
                         line.particle_ref.mass0 * (gamma_at_turn - 1))
-    assert np.allclose(kinetic_energy0_check, kinetic_energy0_ref, atol=0, rtol=2e-3)
+    xo.assert_allclose(kinetic_energy0_check, kinetic_energy0_ref, atol=0, rtol=2e-3)
 
     beta0_check = line.energy_program.get_beta0_at_t_s(t_check)
     beta0_ref = np.interp(t_check, t_turn_check, beta_at_turn)
-    assert np.allclose(beta0_check, beta0_ref, atol=0, rtol=1e-3)
+    xo.assert_allclose(beta0_check, beta0_ref, atol=0, rtol=1e-3)
 
     frev_check = line.energy_program.get_frev_at_t_s(t_check)
     frev_ref = np.interp(t_check, t_turn_check[:-1], 1/np.diff(t_turn_ref))
-    assert np.allclose(frev_check, frev_ref, atol=0, rtol=4e-5)
+    xo.assert_allclose(frev_check, frev_ref, atol=0, rtol=4e-5)
 
     p0c_increse_per_turn_check = line.energy_program.get_p0c_increse_per_turn_at_t_s(
         t_check)
     p0c_increse_per_turn_ref = np.interp(
         t_check, t_turn_check[:-1], np.diff(monitor.p0c[0, :]))
-    assert np.allclose(p0c_increse_per_turn_check - p0c_increse_per_turn_ref, 0,
+    xo.assert_allclose(p0c_increse_per_turn_check - p0c_increse_per_turn_ref, 0,
                        atol=5e-5 * p0c_ref[0], rtol=0)
 
     line.enable_time_dependent_vars = False
@@ -152,20 +153,20 @@ def test_energy_program(test_context):
 
     E_kin_expected = np.interp(line.vv['t_turn_s'], t_s, E_kin_GeV*1e9)
     E_tot_expected = E_kin_expected + line.particle_ref.mass0
-    assert np.isclose(
+    xo.assert_allclose(
         E_tot_expected, line.particle_ref.energy0[0], rtol=1e-4, atol=0)
-    assert np.isclose(
+    xo.assert_allclose(
         E_kin_expected, line.particle_ref.kinetic_energy0[0], rtol=1e-4, atol=0)
 
     tw = line.twiss(method='6d')
     # To check that it does not change
-    assert np.isclose(tw.zeta[0], -13.48, rtol=0, atol=1e-4)
-    assert np.isclose(line.particle_ref.mass0 * tw.gamma0, E_tot_expected,
+    xo.assert_allclose(tw.zeta[0], -13.48, rtol=0, atol=1e-4)
+    xo.assert_allclose(line.particle_ref.mass0 * tw.gamma0, E_tot_expected,
                       atol=0, rtol=1e-12)
 
     line.vars['t_turn_s'] = 0
     line.vars['on_chicane_k0'] = 0
     tw = line.twiss(method='6d')
-    assert np.allclose(tw.zeta[0], 0, rtol=0, atol=1e-12)
-    assert np.allclose(line.particle_ref.mass0 * tw.gamma0, line.particle_ref.mass0 + E_kin_turn[0],
+    xo.assert_allclose(tw.zeta[0], 0, rtol=0, atol=1e-12)
+    xo.assert_allclose(line.particle_ref.mass0 * tw.gamma0, line.particle_ref.mass0 + E_kin_turn[0],
                        rtol=1e-10, atol=0)

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_amplitude_detuning.py

@@ -1,4 +1,4 @@
-import numpy as np
+import xobjects as xo
 import xtrack as xt
 from xobjects.test_helpers import for_all_test_contexts
 
@@ -11,8 +11,7 @@ def test_amplitude_detuning(test_context):
 
     det = line.get_amplitude_detuning_coefficients()
 
-    assert np.isclose(det['det_xx'], 1000, atol=1e-1, rtol=0)
-    assert np.isclose(det['det_yy'], 2000, atol=1e-1, rtol=0)
-    assert np.isclose(det['det_xy'], 10, atol=1e-1, rtol=0)
-    assert np.isclose(det['det_yx'], 20, atol=1e-1, rtol=0)
-
+    xo.assert_allclose(det['det_xx'], 1000, atol=1e-1, rtol=0)
+    xo.assert_allclose(det['det_yy'], 2000, atol=1e-1, rtol=0)
+    xo.assert_allclose(det['det_xy'], 10, atol=1e-1, rtol=0)
+    xo.assert_allclose(det['det_yx'], 20, atol=1e-1, rtol=0)

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_aperture_turn_ele_and_monitor.py

@@ -5,6 +5,7 @@
 
 import numpy as np
 
+import xobjects as xo
 import xtrack as xt
 import xpart as xp
 from xobjects.test_helpers import for_all_test_contexts
@@ -79,13 +80,13 @@ def test_aperture_turn_ele_and_monitor(test_context):
     at_element_expected = np.int_(np.clip(at_element_expected, 0,
                                           n_slices-1))
 
-    assert np.allclose(part_s + at_turn_expected*line.get_length(), s_expected,
+    xo.assert_allclose(part_s + at_turn_expected*line.get_length(), s_expected,
                        atol=1e-3)
-    assert np.allclose(at_turn_expected, part_at_turn)
+    xo.assert_allclose(at_turn_expected, part_at_turn)
 
     # I need to add a tolerance of one element as a mismatch is visible
     # on a few slices due to rounding
-    assert np.allclose(at_element_expected, part_at_element, atol=1.1)
+    xo.assert_allclose(at_element_expected, part_at_element, atol=1.1)
 
     # Test monitor
     mon = line.record_last_track
@@ -192,13 +193,13 @@ def test_custom_monitor(test_context):
     at_element_expected = np.int_(np.clip(at_element_expected, 0,
                                           n_slices-1))
 
-    assert np.allclose(part_s + at_turn_expected * line.get_length(),
+    xo.assert_allclose(part_s + at_turn_expected * line.get_length(),
                        s_expected, atol=1e-3)
-    assert np.allclose(at_turn_expected, part_at_turn)
+    xo.assert_allclose(at_turn_expected, part_at_turn)
 
     # I need to add a tolerance of one element as a mismatch is visible
     # on a few slices due to rounding
-    assert np.allclose(at_element_expected, part_at_element, atol=1.1)
+    xo.assert_allclose(at_element_expected, part_at_element, atol=1.1)
 
     # Test monitor
     mon = monitor

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_apertures.py

@@ -104,7 +104,7 @@ def test_aperture_polygon(test_context):
                     x=x_vertices*0.99,
                     y=y_vertices*0.99)
     aper.track(parttest)
-    assert np.allclose(ctx2np(parttest.state), 1)
+    xo.assert_allclose(ctx2np(parttest.state), 1)
 
     # Try some particles outside
     parttest = xp.Particles(
@@ -113,7 +113,7 @@ def test_aperture_polygon(test_context):
                     x=x_vertices*1.01,
                     y=y_vertices*1.01)
     aper.track(parttest)
-    assert np.allclose(ctx2np(parttest.state), 0)
+    xo.assert_allclose(ctx2np(parttest.state), 0)
 
 
 def test_mad_import():
@@ -152,13 +152,13 @@ def test_mad_import():
 
     circ = apertures[0]
     assert circ.__class__.__name__ == 'LimitEllipse'
-    assert np.isclose(circ.a_squ, .2**2, atol=1e-13, rtol=0)
-    assert np.isclose(circ.b_squ, .2**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(circ.a_squ, .2**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(circ.b_squ, .2**2, atol=1e-13, rtol=0)
 
     ellip = apertures[1]
     assert ellip.__class__.__name__ == 'LimitEllipse'
-    assert np.isclose(ellip.a_squ, .2**2, atol=1e-13, rtol=0)
-    assert np.isclose(ellip.b_squ, .1**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(ellip.a_squ, .2**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(ellip.b_squ, .1**2, atol=1e-13, rtol=0)
 
     rect = apertures[2]
     assert rect.__class__.__name__ == 'LimitRect'
@@ -170,8 +170,8 @@ def test_mad_import():
     rectellip = apertures[3]
     assert rectellip.max_x == .2
     assert rectellip.max_y == .4
-    assert np.isclose(rectellip.a_squ, .25**2, atol=1e-13, rtol=0)
-    assert np.isclose(rectellip.b_squ, .45**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(rectellip.a_squ, .25**2, atol=1e-13, rtol=0)
+    xo.assert_allclose(rectellip.b_squ, .45**2, atol=1e-13, rtol=0)
 
     racetr = apertures[4]
     assert racetr.__class__.__name__ == 'LimitRacetrack'
@@ -185,26 +185,26 @@ def test_mad_import():
     octag = apertures[5]
     assert octag.__class__.__name__ == 'LimitPolygon'
     assert octag._xobject.x_vertices[0] == 0.4
-    assert np.isclose(octag._xobject.y_vertices[0], 0.4*np.tan(0.5), atol=1e-14, rtol=0)
+    xo.assert_allclose(octag._xobject.y_vertices[0], 0.4*np.tan(0.5), atol=1e-14, rtol=0)
     assert octag._xobject.y_vertices[1] == 0.5
-    assert np.isclose(octag._xobject.x_vertices[1], 0.5/np.tan(1.), atol=1e-14, rtol=0)
+    xo.assert_allclose(octag._xobject.x_vertices[1], 0.5/np.tan(1.), atol=1e-14, rtol=0)
 
     assert octag._xobject.y_vertices[2] == 0.5
-    assert np.isclose(octag._xobject.x_vertices[2], -0.5/np.tan(1.), atol=1e-14, rtol=0)
+    xo.assert_allclose(octag._xobject.x_vertices[2], -0.5/np.tan(1.), atol=1e-14, rtol=0)
     assert octag._xobject.x_vertices[3] == -0.4
-    assert np.isclose(octag._xobject.y_vertices[3], 0.4*np.tan(0.5), atol=1e-14, rtol=0)
+    xo.assert_allclose(octag._xobject.y_vertices[3], 0.4*np.tan(0.5), atol=1e-14, rtol=0)
 
 
     assert octag._xobject.x_vertices[4] == -0.4
-    assert np.isclose(octag._xobject.y_vertices[4], -0.4*np.tan(0.5), atol=1e-14, rtol=0)
+    xo.assert_allclose(octag._xobject.y_vertices[4], -0.4*np.tan(0.5), atol=1e-14, rtol=0)
     assert octag._xobject.y_vertices[5] == -0.5
-    assert np.isclose(octag._xobject.x_vertices[5], -0.5/np.tan(1.), atol=1e-14, rtol=0)
+    xo.assert_allclose(octag._xobject.x_vertices[5], -0.5/np.tan(1.), atol=1e-14, rtol=0)
 
 
     assert octag._xobject.y_vertices[6] == -0.5
-    assert np.isclose(octag._xobject.x_vertices[6], 0.5/np.tan(1.), atol=1e-14, rtol=0)
+    xo.assert_allclose(octag._xobject.x_vertices[6], 0.5/np.tan(1.), atol=1e-14, rtol=0)
     assert octag._xobject.x_vertices[7] == 0.4
-    assert np.isclose(octag._xobject.y_vertices[7], -0.4*np.tan(0.5), atol=1e-14, rtol=0)
+    xo.assert_allclose(octag._xobject.y_vertices[7], -0.4*np.tan(0.5), atol=1e-14, rtol=0)
 
     polyg = apertures[6]
     assert polyg.__class__.__name__ == 'LimitPolygon'

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_cavity_absolute_time.py

@@ -1,9 +1,9 @@
-import numpy as np
+import pathlib
+
+import xobjects as xo
 import xtrack as xt
 from xobjects.test_helpers import for_all_test_contexts
 
-import pathlib
-
 test_data_folder = pathlib.Path(
     __file__).parent.joinpath('../test_data').absolute()
 
@@ -39,9 +39,9 @@ def test_cavity_absolute_time(test_context):
 
     f_rev_expected = f_rf / h_rf
 
-    assert np.isclose(f_rev_expected, 1/tw1.T_rev, atol=1e-5, rtol=0)
-    assert np.allclose(tw1.delta, tw1.delta[0], atol=1e-5, rtol=0) # Check that it is flat
+    xo.assert_allclose(f_rev_expected, 1/tw1.T_rev, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw1.delta, tw1.delta[0], atol=1e-5, rtol=0) # Check that it is flat
     delta_expected = -df_rev / f_rev / eta
-    assert np.allclose(tw1.delta, delta_expected, atol=2e-6, rtol=0)
+    xo.assert_allclose(tw1.delta, delta_expected, atol=2e-6, rtol=0)
     tw_off_mom = line.twiss(method='4d', delta0=tw1.delta[0])
-    assert np.allclose(tw1.x, tw_off_mom.x, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw1.x, tw_off_mom.x, atol=1e-5, rtol=0)

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_chromatic_functions_vs_madx.py

@@ -1,5 +1,8 @@
 import pathlib
+
 from cpymad.madx import Madx
+
+import xobjects as xo
 import xtrack as xt
 from xobjects.test_helpers import for_all_test_contexts
 
@@ -61,12 +64,12 @@ def test_chromatic_functions_vs_madx(test_context):
         bx_ref = np.real(zx_ref)
         by_ref = np.real(zy_ref)
 
-        assert np.allclose(tw_test.wx_chrom, wx_ref, rtol=0, atol=2e-3 * np.max(wx_ref))
-        assert np.allclose(tw_test.wy_chrom, wy_ref, rtol=0, atol=2e-3 * np.max(wy_ref))
-        assert np.allclose(tw_test.ax_chrom, ax_ref, rtol=0, atol=2e-3 * np.max(ax_ref))
-        assert np.allclose(tw_test.ay_chrom, ay_ref, rtol=0, atol=2e-3 * np.max(ay_ref))
-        assert np.allclose(tw_test.bx_chrom, bx_ref, rtol=0, atol=2e-3 * np.max(bx_ref))
-        assert np.allclose(tw_test.by_chrom, by_ref, rtol=0, atol=2e-3 * np.max(by_ref))
+        xo.assert_allclose(tw_test.wx_chrom, wx_ref, rtol=0, atol=2e-3 * np.max(wx_ref))
+        xo.assert_allclose(tw_test.wy_chrom, wy_ref, rtol=0, atol=2e-3 * np.max(wy_ref))
+        xo.assert_allclose(tw_test.ax_chrom, ax_ref, rtol=0, atol=2e-3 * np.max(ax_ref))
+        xo.assert_allclose(tw_test.ay_chrom, ay_ref, rtol=0, atol=2e-3 * np.max(ay_ref))
+        xo.assert_allclose(tw_test.bx_chrom, bx_ref, rtol=0, atol=2e-3 * np.max(bx_ref))
+        xo.assert_allclose(tw_test.by_chrom, by_ref, rtol=0, atol=2e-3 * np.max(by_ref))
 
         # Open twiss
         init = tw.get_twiss_init('ip3')
@@ -74,13 +77,13 @@ def test_chromatic_functions_vs_madx(test_context):
                             compute_chromatic_properties=True)
 
         tw_ref_open = tw.rows['ip3':'ip6']
-        assert np.allclose(tw_open.wx_chrom[:-1], tw_ref_open.wx_chrom,
+        xo.assert_allclose(tw_open.wx_chrom[:-1], tw_ref_open.wx_chrom,
                         rtol=0, atol=2e-3 * np.max(tw_ref_open.wx_chrom))
-        assert np.allclose(tw_open.wy_chrom[:-1], tw_ref_open.wy_chrom,
+        xo.assert_allclose(tw_open.wy_chrom[:-1], tw_ref_open.wy_chrom,
                         rtol=0, atol=2e-3 * np.max(tw_ref_open.wy_chrom))
-        assert np.allclose(tw_open.ax_chrom[:-1], tw_ref_open.ax_chrom,
+        xo.assert_allclose(tw_open.ax_chrom[:-1], tw_ref_open.ax_chrom,
                             rtol=0, atol=2e-3 * np.max(tw_ref_open.ax_chrom))
-        assert np.allclose(tw_open.ay_chrom[:-1], tw_ref_open.ay_chrom,
+        xo.assert_allclose(tw_open.ay_chrom[:-1], tw_ref_open.ay_chrom,
                                 rtol=0, atol=2e-3 * np.max(tw_ref_open.ay_chrom))
-        assert np.allclose(tw_open.bx_chrom[:-1], tw_ref_open.bx_chrom,
+        xo.assert_allclose(tw_open.bx_chrom[:-1], tw_ref_open.bx_chrom,
                                 rtol=0, atol=2e-3 * np.max(tw_ref_open.bx_chrom))

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_coasting.py

@@ -1,9 +1,10 @@
-import numpy as np
-import xtrack as xt
 import pathlib
 
+import numpy as np
 from scipy.constants import c as clight
 
+import xtrack as xt
+
 test_data_folder = pathlib.Path(
     __file__).parent.joinpath('../test_data').absolute()
 
@@ -138,9 +139,9 @@ def test_coasting():
     print('f_measured: ', f_measured, ' Hz')
     print('Error:      ', f_measured - f_expected, 'Hz')
 
-    assert np.isclose(f_expected, f_measured, rtol=0, atol=5.) # 5 Hz tolerance (to account for random fluctuations)
-    assert np.isclose(np.mean(inten), inten_exp, rtol=1e-2, atol=0)
-    assert np.allclose(p.at_turn, num_turns*0.9, rtol=3e-2, atol=0) #beta1 defaults to 0.1
+    xo.assert_allclose(f_expected, f_measured, rtol=0, atol=5.) # 5 Hz tolerance (to account for random fluctuations)
+    xo.assert_allclose(np.mean(inten), inten_exp, rtol=1e-2, atol=0)
+    xo.assert_allclose(p.at_turn, num_turns*0.9, rtol=3e-2, atol=0) #beta1 defaults to 0.1
 
     tt = line.get_table()
     tt_synch = tt.rows[tt.element_type=='SyncTime']

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_collective_tracker.py

@@ -3,18 +3,11 @@
 # Copyright (c) CERN, 2021.                 #
 # ######################################### #
 
-import pathlib
-import json
-import numpy as np
-
 import xobjects as xo
-import xtrack as xt
-import xfields as xf
 import xpart as xp
+import xtrack as xt
 from xobjects.test_helpers import for_all_test_contexts
 
-import ducktrack as dtk
-
 
 @for_all_test_contexts
 def test_collective_tracker_indices_one_turn(test_context):
@@ -92,7 +85,7 @@ def test_get_non_collective_line(test_context):
     assert nc_line['e7'] is line['e7']
     assert nc_line.tracker.line is nc_line
 
-    assert np.allclose(nc_line.get_s_elements(), line.get_s_elements(),
+    xo.assert_allclose(nc_line.get_s_elements(), line.get_s_elements(),
                     rtol=0, atol=1e-15)
 
     assert nc_line.tracker is not line.tracker

{xtrack-0.61.0 → xtrack-0.62.0}/tests/test_collimation.py

@@ -4,13 +4,14 @@
 # ######################################### #
 
 import logging
-import pytest
 
 import numpy as np
+import pytest
 
 import xobjects as xo
-import xtrack as xt
 import xpart as xp
+import xtrack as xt
+
 
 def test_collimation_infrastructure():
 
@@ -218,7 +219,7 @@ def test_aperture_refinement(sandwitch_aper):
     r1 = np.sqrt(aper_1.a_squ)
     s_expected = s0 + (r_calc-r0)/(r1 - r0)*(s1 - s0)
     # TODO This threshold is a bit large
-    assert np.allclose(particles.s[mask_lost], s_expected[mask_lost], atol=0.11)
+    xo.assert_allclose(particles.s[mask_lost], s_expected[mask_lost], atol=0.11)
 
 
 def test_losslocationrefinement_thick_collective_collimator():
@@ -323,7 +324,7 @@ def test_losslocationrefinement_thick_collective_collimator():
 
     loss_loc_refinement.refine_loss_location(particles)
 
-    assert np.allclose(particles.s[mask_lost], 9.00,
+    xo.assert_allclose(particles.s[mask_lost], 9.00,
                        rtol=0, atol=loss_loc_refinement.ds*1.0001)
 
 def test_losslocationrefinement_skip_refinement_for_collimators():