xtrack 0.84.7__tar.gz → 0.85.0__tar.gz

{xtrack-0.84.7/xtrack.egg-info → xtrack-0.85.0}/PKG-INFO

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

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_elements_classflags.py

@@ -13,6 +13,8 @@ checks = [
     (xt.SRotation,               dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
     (xt.YRotation,               dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
     (xt.Solenoid,                dict(isthick=True , allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.UniformSolenoid,         dict(isthick=True , allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
+    (xt.VariableSolenoid,        dict(isthick=True , allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
     (xt.RFMultipole,             dict(isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
     (xt.DipoleEdge,              dict(isthick=False, allow_rot_and_shift=True , rot_and_shift_from_parent=None , _inherit_strengths=None)),
     (xt.SimpleThinBend,          dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=None , _inherit_strengths=None)),
@@ -31,6 +33,7 @@ checks = [
     (xt.DriftSliceSextupole,     dict(isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=False, _inherit_strengths=False)),
     (xt.ThickSliceBend,          dict(isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
     (xt.ThickSliceOctupole,      dict(isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThickSliceUniformSolenoid,dict(isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
     (xt.ThickSliceQuadrupole,    dict(isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
     (xt.ThickSliceSextupole,     dict(isthick=True,  allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
     (xt.ThinSliceBend,           dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
@@ -39,6 +42,8 @@ checks = [
     (xt.ThinSliceOctupole,       dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
     (xt.ThinSliceQuadrupole,     dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
     (xt.ThinSliceSextupole,      dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=True )),
+    (xt.ThinSliceUniformSolenoidEntry, dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=False)),
+    (xt.ThinSliceUniformSolenoidExit,  dict(isthick=False, allow_rot_and_shift=False, rot_and_shift_from_parent=True , _inherit_strengths=False)),
 ]
 
 def test_elements_classflags():

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_elements_thick.py

@@ -1318,7 +1318,7 @@ def test_solenoid_against_madx(test_context, ks, ksi, length):
 
 @for_all_test_contexts
 def test_solenoid_thick_drift_like(test_context):
-    solenoid = xt.Solenoid(ks=1.001e-9, length=1, _context=test_context)
+    solenoid = xt.UniformSolenoid(ks=1.001e-9, length=1, _context=test_context)
     l_drift = xt.Line(elements=[xt.Drift(length=1)])
     l_drift.config.XTRACK_USE_EXACT_DRIFTS = True
     l_drift.build_tracker(_context=test_context)
@@ -1353,7 +1353,7 @@ def test_solenoid_thick_drift_like(test_context):
     ],
 )
 def test_solenoid_thick_analytic(test_context, length, expected):
-    solenoid = xt.Solenoid(
+    solenoid = xt.UniformSolenoid(
         ks=1,
         length=length,
         _context=test_context,
@@ -1392,8 +1392,9 @@ def test_solenoid_with_mult_kicks(test_context, backtrack):
     knl = np.array([0.1, 0.4, 0.5])
     ksl = np.array([0.2, 0.3, 0.6])
 
-    solenoid_with_kicks = xt.Solenoid(
+    solenoid_with_kicks = xt.UniformSolenoid(
         length=length,
+        integrator='uniform',
         ks=ks,
         num_multipole_kicks=num_kicks,
         knl=knl,
@@ -1402,11 +1403,11 @@ def test_solenoid_with_mult_kicks(test_context, backtrack):
 
     line_ref = xt.Line(
         elements=[
-            xt.Solenoid(length=length / (num_kicks + 1), ks=ks),
+            xt.UniformSolenoid(length=length / (num_kicks)/2, ks=ks),
             xt.Multipole(knl=knl / num_kicks, ksl=ksl / num_kicks),
-            xt.Solenoid(length=length / (num_kicks + 1), ks=ks),
+            xt.UniformSolenoid(length=length / (num_kicks), ks=ks),
             xt.Multipole(knl=knl / num_kicks, ksl=ksl / num_kicks),
-            xt.Solenoid(length=length / (num_kicks + 1), ks=ks),
+            xt.UniformSolenoid(length=length / (num_kicks) /2, ks=ks),
         ],
         element_names=[
             'sol_0', 'kick_0', 'sol_1', 'kick_1', 'sol_2',
@@ -1457,7 +1458,7 @@ def test_solenoid_shifted_and_rotated_multipolar_kick(test_context):
     mult_rot_y_rad = 0.2
     mult_shift_x = 0.3
 
-    solenoid = xt.Solenoid(
+    solenoid = xt.Solenoid( # Need to use legacy one
         ks=ks,
         length=length,
         knl=knl,
@@ -1467,7 +1468,7 @@ def test_solenoid_shifted_and_rotated_multipolar_kick(test_context):
         mult_shift_x=mult_shift_x,
     )
 
-    solenoid_no_kick = xt.Solenoid(ks=0.9, length=0.25)
+    solenoid_no_kick = xt.UniformSolenoid(ks=0.9, length=0.25)
     kick = xt.Multipole(knl=np.array(knl) / 3, ksl=np.array(ksl) / 3)
 
     line_test = xt.Line(elements=[solenoid])
@@ -1527,11 +1528,11 @@ def test_solenoid_multipole_shifts(shift_x, shift_y, test_element_name):
     quad = xt.Quadrupole(length=1, k1=K1)
     sext = xt.Sextupole(length=1, k2=K2)
 
-    bend_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS,
+    bend_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS, # need legacy
                            knl=[K0 * (1 / N_SLICES), 0, 0], num_multipole_kicks=1)
-    quad_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS,
+    quad_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS, # need legacy
                            knl=[0, K1 * (1 / N_SLICES), 0], num_multipole_kicks=1)
-    sext_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS,
+    sext_sol = xt.Solenoid(length=1 / N_SLICES, ks=KS, # need legacy
                            knl=[0, 0, K2 * (1 / N_SLICES)], num_multipole_kicks=1)
 
     ################################################################################
@@ -1588,8 +1589,8 @@ def test_solenoid_multipole_shifts(shift_x, shift_y, test_element_name):
     ########################################
     # Assertions
     ########################################
-    assert np.isclose(tw.x[-1], tw_sol.x[-1], rtol=1E-6)
-    assert np.isclose(tw.y[-1], tw_sol.y[-1], rtol=1E-6)
+    xo.assert_allclose(tw.x[-1], tw_sol.x[-1], rtol=2E-6)
+    xo.assert_allclose(tw.y[-1], tw_sol.y[-1], rtol=2E-6)
 
 
 def test_solenoid_multipole_rotations():
@@ -1613,7 +1614,7 @@ def test_solenoid_multipole_rotations():
     bl_components_out = [env.new('bl_drift1', xt.Drift, length=1)]
 
     bl_components_sol = [
-        env.new(f'bl_sol.{i}', xt.Solenoid,
+        env.new(f'bl_sol.{i}', xt.UniformSolenoid,
                 length=(L_SOL / N_SLICES),
                 ks=0,
                 knl=[K0 * (L_SOL / N_SLICES), 0, 0],
@@ -1637,7 +1638,7 @@ def test_solenoid_multipole_rotations():
         env.new('hrot_drift1', xt.Drift, length=1)]
 
     hrot_components_sol = [
-        env.new(f'hrot_sol.{i}', xt.Solenoid,
+        env.new(f'hrot_sol.{i}', xt.Solenoid, # need legacy
                 length=(L_SOL / N_SLICES) * np.cos(XING_RAD),
                 ks=0,
                 knl=[K0 * (L_SOL / N_SLICES), 0, 0],
@@ -1663,7 +1664,7 @@ def test_solenoid_multipole_rotations():
         env.new('vrot_drift1', xt.Drift, length=1)]
 
     vrot_components_sol = [
-        env.new(f'vrot_sol.{i}', xt.Solenoid,
+        env.new(f'vrot_sol.{i}', xt.Solenoid, # need legacy
                 length=(L_SOL / N_SLICES) * np.cos(XING_RAD),
                 ks=0,
                 knl=[K0 * (L_SOL / N_SLICES), 0, 0],
@@ -1753,7 +1754,7 @@ def test_drift_like_solenoid_with_kicks_radiation(radiation_mode, config):
     ])
 
     line_ref = xt.Line(elements=[
-        xt.Solenoid(ks=0, length=1, knl=knl, ksl=ksl, num_multipole_kicks=1)
+        xt.UniformSolenoid(ks=0, length=1, knl=knl, ksl=ksl, num_multipole_kicks=1)
     ])
 
     coords = np.linspace(-0.05, 0.05, 10)
@@ -1809,9 +1810,9 @@ def test_solenoid_with_kicks_radiation(radiation_mode, config):
     knl = [0.1, 0.4, 0.5]
     ksl = [0.2, 0.3, 0.6]
 
-    sol_ref = xt.Solenoid(ks=ks, length=l)
-    sol_1 = xt.Solenoid(ks=ks, length=l, knl=knl, ksl=ksl, num_multipole_kicks=1)
-    sol_3 = xt.Solenoid(ks=ks, length=l, knl=knl, ksl=ksl, num_multipole_kicks=3)
+    sol_ref = xt.UniformSolenoid(ks=ks, length=l)
+    sol_1 = xt.UniformSolenoid(ks=ks, length=l, knl=knl, ksl=ksl, num_multipole_kicks=1)
+    sol_3 = xt.UniformSolenoid(ks=ks, length=l, knl=knl, ksl=ksl, num_multipole_kicks=3)
 
     line_ref = xt.Line(elements=[sol_ref])
     line_1 = xt.Line(elements=[sol_1])
@@ -1852,7 +1853,7 @@ def test_solenoid_with_kicks_radiation(radiation_mode, config):
     d_delta_3 = p_3.delta - p0.delta
 
     xo.assert_allclose(
-        d_delta_1 - d_delta_ref, d_delta_3 - d_delta_ref, rtol=0.01, atol=1e-15
+        d_delta_1 - d_delta_ref, d_delta_3 - d_delta_ref, rtol=0.01, atol=2e-15
     )
 
 
@@ -2197,3 +2198,167 @@ def test_configure_model():
     assert line['o1'].edge_exit_active == False
     assert line['o1'].integrator == 'uniform'
     assert line['o1'].num_multipole_kicks == 7
+
+@for_all_test_contexts
+@pytest.mark.parametrize('reference', ['legacy', 'variable'])
+def test_uniform_solenoid_with_slices(test_context, reference):
+
+    length = 3.
+    ks = 2.
+
+    sol = xt.UniformSolenoid(length=length, ks=ks, _context=test_context)
+
+    if reference == 'legacy':
+        # Check against legacy solenoid
+        ref_sol = xt.Solenoid(length=length, ks=ks) # Old solenoid
+    elif reference == 'variable':
+        # Check against variable solenoid
+        ref_sol = xt.VariableSolenoid(length=length, ks_profile=[ks, ks])
+    else:
+        raise ValueError("Reference must be 'legacy' or 'variable'")
+
+    p0 = xt.Particles(p0c=1e9, x=1e-3, y=2e-3)
+
+    p = p0.copy(_context=test_context)
+    p_ref = p0.copy()
+
+    sol.track(p)
+    ref_sol.track(p_ref)
+
+    xo.assert_allclose(p.x, p_ref.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.y, p_ref.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.px, p_ref.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.py, p_ref.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.delta, p_ref.delta, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.ax, 0., rtol=0, atol=1e-10)
+    xo.assert_allclose(p.ay, 0., rtol=0, atol=1e-10)
+    xo.assert_allclose(p.kin_px, p_ref.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.kin_py, p_ref.py, rtol=0, atol=1e-10)
+
+    sol.edge_exit_active = False
+    p = p0.copy(_context=test_context)
+    sol.track(p)
+
+    xo.assert_allclose(p.x, p_ref.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.y, p_ref.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.px, p_ref.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.py, p_ref.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.delta, p_ref.delta, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.ax, p_ref.ax, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.ay, p_ref.ay, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.kin_px, p_ref.kin_px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p.kin_py, p_ref.kin_py, rtol=0, atol=1e-10)
+
+    p0_for_backtrack = p.copy()
+    p_for_backtrack = p0_for_backtrack.copy(_context=test_context)
+    lsol = xt.Line([sol])
+    lsol.build_tracker(_context=test_context)
+
+    sol.edge_entry_active = True
+    sol.edge_exit_active = True
+
+    lsol.track(p_for_backtrack, backtrack=True)
+    xo.assert_allclose(p_for_backtrack.x, p0.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.y, p0.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.px, p0.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.py, p0.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.delta, p0.delta, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.ax, 0., rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.ay, 0., rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.kin_px, p0.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.kin_py, p0.py, rtol=0, atol=1e-10)
+
+    sol.edge_entry_active = False
+    p_for_backtrack = p0_for_backtrack.copy(_context=test_context)
+    lsol.track(p_for_backtrack, backtrack=True)
+    xo.assert_allclose(p_for_backtrack.x, p0.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.y, p0.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.px, p0.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.py, p0.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.delta, p0.delta, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.ax, -ks /2 *p0.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.ay, ks /2 *p0.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.kin_px, p0.px + ks /2 *p0.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(p_for_backtrack.kin_py, p0.py - ks /2 *p0.x, rtol=0, atol=1e-10)
+
+
+    sol.edge_entry_active = True
+    sol.edge_exit_active = True
+
+    lsol_sliced = lsol.copy(shallow=True)
+    lsol_sliced.cut_at_s([length / 3, 2 * length / 3])
+    lsol_sliced.build_tracker(_context=test_context)
+    tt_sliced = lsol_sliced.get_table(attr=True)
+
+    assert np.all(tt_sliced.name == np.array(
+        ['e0_entry', 'e0..entry_map', 'e0..0', 'e0..1', 'e0..2',
+        'e0..exit_map', 'e0_exit', '_end_point']))
+
+    xo.assert_allclose(tt_sliced.s, np.array([0., 0., 0., 1., 2., 3., 3., 3.]),
+                    rtol=0, atol=1e-10)
+
+    assert np.all(tt_sliced.element_type == np.array(
+        ['Marker', 'ThinSliceUniformSolenoidEntry',
+        'ThickSliceUniformSolenoid', 'ThickSliceUniformSolenoid',
+        'ThickSliceUniformSolenoid', 'ThinSliceUniformSolenoidExit',
+        'Marker', '']))
+
+    lsol_sliced.particle_ref = xt.Particles(p0c=100e9)
+    tw = lsol_sliced.twiss(x=p0.x, px=p0.px, y=p0.y, py=p0.py, betx=1, bety=1)
+    p_ref = p0.copy()
+    ref_sol.track(p_ref)
+
+    xo.assert_allclose(tw.x[-1], p_ref.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw.px[-1], p_ref.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw.y[-1], p_ref.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw.py[-1], p_ref.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw.delta[-1], p_ref.delta, rtol=0, atol=1e-10)
+
+    tw['ax'] = tw.px - tw.kin_px
+    tw['ay'] = tw.py - tw.kin_py
+
+    # tw.cols['ax ay'] should look as follows:
+    # TwissTable: 8 rows, 3 cols
+    # name                     ax            ay
+    # e0_entry                  0             0
+    # e0..entry_map             0             0
+    # e0..0                -0.002         0.001
+    # e0..1          -0.000129201    0.00120122
+    # e0..2          -0.000724768  -0.000583627
+    # e0..exit_map    -0.00209988   0.000700686
+    # e0_exit                   0             0
+    # _end_point                0             0
+
+    tw_before = tw.rows[:'e0..entry_map']
+    tw_inside = tw.rows['e0..0':'e0..exit_map']
+    tw_after = tw.rows['e0_exit':]
+
+    xo.assert_allclose(tw_before.ax, 0, rtol=0, atol=1e-20)
+    xo.assert_allclose(tw_before.ay, 0, rtol=0, atol=1e-20)
+    xo.assert_allclose(tw_inside.ax, -0.5 * ks * tw_inside.y, rtol=0, atol=1e-15)
+    xo.assert_allclose(tw_inside.ay, 0.5 * ks * tw_inside.x, rtol=0, atol=1e-15)
+    xo.assert_allclose(tw_after.ax, 0, rtol=0, atol=1e-20)
+    xo.assert_allclose(tw_after.ay, 0, rtol=0, atol=1e-20)
+
+    # Twiss backwards
+    tw_back = lsol_sliced.twiss(init=tw.get_twiss_init('e0_exit'))
+    tw_back['ax'] = tw_back.px - tw_back.kin_px
+    tw_back['ay'] = tw_back.py - tw_back.kin_py
+
+    xo.assert_allclose(tw_back.x, tw.x, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw_back.px, tw.px, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw_back.y, tw.y, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw_back.py, tw.py, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw_back.delta, tw.delta, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw_back.ax, tw.ax, rtol=0, atol=1e-10)
+    xo.assert_allclose(tw_back.ay, tw.ay, rtol=0, atol=1e-10)
+
+    sol.edge_entry_active = False
+    tw_back = lsol_sliced.twiss(init=tw.get_twiss_init('e0_exit'))
+    tw_back['ax'] = tw_back.px - tw_back.kin_px
+    tw_back['ay'] = tw_back.py - tw_back.kin_py
+
+    xo.assert_allclose(tw_back.rows[:'e0..0'].ax, tw['ax', 'e0..0'],
+                    rtol=0, atol=1e-10)
+    xo.assert_allclose(tw_back.rows[:'e0..0'].ay, tw['ay', 'e0..0'],
+                    rtol=0, atol=1e-10)

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_fcc_ee_solenoid_correction.py

@@ -60,13 +60,14 @@ def test_fcc_ee_solenoid_correction():
 
     P0_J = line.particle_ref.p0c[0] * qe / clight
     brho = P0_J / qe / line.particle_ref.q0
-    ks = 0.5 * (bz_sol_slices[:-1] + bz_sol_slices[1:]) / brho
+    ks_entry = bz_sol_slices[:-1] / brho
+    ks_exit = bz_sol_slices[1:] / brho
     l_sol_slices = np.diff(s_sol_slices)
     s_sol_slices_entry = s_sol_slices[:-1]
 
     sol_slices = []
     for ii in range(len(s_sol_slices_entry)):
-        sol_slices.append(xt.Solenoid(length=l_sol_slices[ii], ks=0)) # Off for now
+        sol_slices.append(xt.VariableSolenoid(length=l_sol_slices[ii], ks_profile=[0, 0])) # Off for now
 
     s_ip = tt['s', ip_sol]
 
@@ -86,8 +87,8 @@ def test_fcc_ee_solenoid_correction():
     line.element_dict['sol_start_shift_'+ip_sol] = sol_start_shift
     line.element_dict['sol_end_shift_'+ip_sol] = sol_end_shift
 
-    line.element_dict['sol_entry_'+ip_sol] = xt.Solenoid(length=0, ks=0)
-    line.element_dict['sol_exit_'+ip_sol] = xt.Solenoid(length=0, ks=0)
+    line.element_dict['sol_entry_'+ip_sol] = xt.Marker()
+    line.element_dict['sol_exit_'+ip_sol] = xt.Marker()
 
     sol_slice_names = []
     sol_slice_names.append('sol_entry_'+ip_sol)
@@ -123,7 +124,8 @@ def test_fcc_ee_solenoid_correction():
     line.vars['on_sol_'+ip_sol] = 0
     for ii in range(len(s_sol_slices_entry)):
         nn = f'sol_slice_{ii}_{ip_sol}'
-        line.element_refs[nn].ks = ks[ii] * line.vars['on_sol_'+ip_sol]
+        line.element_refs[nn].ks_profile[0] = ks_entry[ii] * line.vars['on_sol_'+ip_sol]
+        line.element_refs[nn].ks_profile[1] = ks_exit[ii] * line.vars['on_sol_'+ip_sol]
 
     tt = line.get_table()
 

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_fcc_ee_solenoid_correction_new_optimize_api.py

@@ -60,13 +60,14 @@ def test_fcc_ee_solenoid_correction_new_optimizer_api():
 
     P0_J = line.particle_ref.p0c[0] * qe / clight
     brho = P0_J / qe / line.particle_ref.q0
-    ks = 0.5 * (bz_sol_slices[:-1] + bz_sol_slices[1:]) / brho
+    ks_entry = bz_sol_slices[:-1] / brho
+    ks_exit = bz_sol_slices[1:] / brho
     l_sol_slices = np.diff(s_sol_slices)
     s_sol_slices_entry = s_sol_slices[:-1]
 
     sol_slices = []
     for ii in range(len(s_sol_slices_entry)):
-        sol_slices.append(xt.Solenoid(length=l_sol_slices[ii], ks=0)) # Off for now
+        sol_slices.append(xt.VariableSolenoid(length=l_sol_slices[ii], ks_profile=[0, 0])) # Off for now
 
     s_ip = tt['s', ip_sol]
 
@@ -86,8 +87,8 @@ def test_fcc_ee_solenoid_correction_new_optimizer_api():
     line.element_dict['sol_start_shift_'+ip_sol] = sol_start_shift
     line.element_dict['sol_end_shift_'+ip_sol] = sol_end_shift
 
-    line.element_dict['sol_entry_'+ip_sol] = xt.Solenoid(length=0, ks=0)
-    line.element_dict['sol_exit_'+ip_sol] = xt.Solenoid(length=0, ks=0)
+    line.element_dict['sol_entry_'+ip_sol] = xt.Marker()
+    line.element_dict['sol_exit_'+ip_sol] = xt.Marker()
 
     sol_slice_names = []
     sol_slice_names.append('sol_entry_'+ip_sol)
@@ -123,7 +124,9 @@ def test_fcc_ee_solenoid_correction_new_optimizer_api():
     line.vars['on_sol_'+ip_sol] = 0
     for ii in range(len(s_sol_slices_entry)):
         nn = f'sol_slice_{ii}_{ip_sol}'
-        line.element_refs[nn].ks = ks[ii] * line.vars['on_sol_'+ip_sol]
+        line.element_refs[nn].ks_profile[0] = ks_entry[ii] * line.vars['on_sol_'+ip_sol]
+        line.element_refs[nn].ks_profile[1] = ks_exit[ii] * line.vars['on_sol_'+ip_sol]
+
 
     tt = line.get_table()
 

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_line.py

@@ -880,6 +880,7 @@ def test_insert_thin_elements_at_s_lhc(test_context):
     Teapot = xt.Teapot
     slicing_strategies = [
         Strategy(slicing=Teapot(1)),  # Default catch-all as in MAD-X
+        Strategy(slicing=None, element_type=xt.UniformSolenoid),
         Strategy(slicing=Teapot(4), element_type=xt.Bend),
         Strategy(slicing=Teapot(20), element_type=xt.Quadrupole),
         Strategy(slicing=Teapot(2), name=r'^mb\..*'),
@@ -1143,8 +1144,8 @@ def test_line_table_unique_names():
 
 def test_extend_knl_ksl():
 
-    classes_to_check = ['Bend', 'Quadrupole', 'Sextupole', 'Octupole', 'Solenoid',
-                        'Multipole']
+    classes_to_check = ['Bend', 'Quadrupole', 'Sextupole', 'Octupole', 'UniformSolenoid',
+                        'VariableSolenoid', 'Multipole']
 
     for cc in classes_to_check:
 
@@ -1188,7 +1189,9 @@ def test_extend_knl_ksl():
                 'a', 'b', 'c'], ksl=['d', 'e', 'f']),
         env.new('o1', xt.Octupole, length=1, knl=[
                 'a', 'b', 'c'], ksl=['d', 'e', 'f']),
-        env.new('s2', xt.Solenoid, length=1, knl=[
+        env.new('u1', xt.UniformSolenoid, length=1, knl=[
+                'a', 'b', 'c'], ksl=['d', 'e', 'f']),
+        env.new('v1', xt.VariableSolenoid, length=1, knl=[
                 'a', 'b', 'c'], ksl=['d', 'e', 'f']),
         env.new('m1', xt.Multipole, length=1, knl=[
                 'a', 'b', 'c'], ksl=['d', 'e', 'f']),
@@ -1210,7 +1213,7 @@ def test_extend_knl_ksl():
     assert line['q1'].order == order
     assert line['s1'].order == 5
     assert line['o1'].order == 5
-    assert line['s2'].order == 5
+    assert line['u1'].order == 5
     assert line['m1'].order == 2
 
     xo.assert_allclose(line['b1'].inv_factorial_order,
@@ -1221,7 +1224,9 @@ def test_extend_knl_ksl():
                        1/math.factorial(5), rtol=0, atol=1e-15)
     xo.assert_allclose(line['o1'].inv_factorial_order,
                        1/math.factorial(5), rtol=0, atol=1e-15)
-    xo.assert_allclose(line['s2'].inv_factorial_order,
+    xo.assert_allclose(line['u1'].inv_factorial_order,
+                       1/math.factorial(5), rtol=0, atol=1e-15)
+    xo.assert_allclose(line['v1'].inv_factorial_order,
                        1/math.factorial(5), rtol=0, atol=1e-15)
     xo.assert_allclose(line['m1'].inv_factorial_order,
                        1/math.factorial(2), rtol=0, atol=1e-15)
@@ -1242,9 +1247,13 @@ def test_extend_knl_ksl():
                        0., 0., 0.], rtol=0, atol=1e-15)
     xo.assert_allclose(line['o1'].ksl, [4., 5., 6.,
                        0., 0., 0.], rtol=0, atol=1e-15)
-    xo.assert_allclose(line['s2'].knl, [3., 2., 1.,
+    xo.assert_allclose(line['u1'].knl, [3., 2., 1.,
+                       0., 0., 0.], rtol=0, atol=1e-15)
+    xo.assert_allclose(line['u1'].ksl, [4., 5., 6.,
                        0., 0., 0.], rtol=0, atol=1e-15)
-    xo.assert_allclose(line['s2'].ksl, [4., 5., 6.,
+    xo.assert_allclose(line['v1'].knl, [3., 2., 1.,
+                       0., 0., 0.], rtol=0, atol=1e-15)
+    xo.assert_allclose(line['v1'].ksl, [4., 5., 6.,
                        0., 0., 0.], rtol=0, atol=1e-15)
     xo.assert_allclose(line['m1'].knl, [3., 2., 1.], rtol=0, atol=1e-15)
     xo.assert_allclose(line['m1'].ksl, [4., 5., 6.], rtol=0, atol=1e-15)
@@ -1255,13 +1264,15 @@ def test_extend_knl_ksl():
     assert line['q1'].order == 11
     assert line['s1'].order == 11
     assert line['o1'].order == 11
-    assert line['s2'].order == 11
+    assert line['u1'].order == 11
+    assert line['v1'].order == 11
     assert line['m1'].order == 11
     assert line['b1'].inv_factorial_order == 1/math.factorial(11)
     assert line['q1'].inv_factorial_order == 1/math.factorial(11)
     assert line['s1'].inv_factorial_order == 1/math.factorial(11)
     assert line['o1'].inv_factorial_order == 1/math.factorial(11)
-    assert line['s2'].inv_factorial_order == 1/math.factorial(11)
+    assert line['u1'].inv_factorial_order == 1/math.factorial(11)
+    assert line['v1'].inv_factorial_order == 1/math.factorial(11)
     assert line['m1'].inv_factorial_order == 1/math.factorial(11)
     xo.assert_allclose(line['b1'].knl, [3., 2., 1., 0.,
                        0., 0., 0., 0., 0., 0., 0., 0.], rtol=0, atol=1e-15)
@@ -1279,9 +1290,13 @@ def test_extend_knl_ksl():
                        0., 0., 0., 0., 0., 0., 0., 0.], rtol=0, atol=1e-15)
     xo.assert_allclose(line['o1'].ksl, [4., 5., 6., 0.,
                        0., 0., 0., 0., 0., 0., 0., 0.], rtol=0, atol=1e-15)
-    xo.assert_allclose(line['s2'].knl, [3., 2., 1., 0.,
+    xo.assert_allclose(line['u1'].knl, [3., 2., 1., 0.,
+                       0., 0., 0., 0., 0., 0., 0., 0.], rtol=0, atol=1e-15)
+    xo.assert_allclose(line['v1'].ksl, [4., 5., 6., 0.,
+                       0., 0., 0., 0., 0., 0., 0., 0.], rtol=0, atol=1e-15)
+    xo.assert_allclose(line['v1'].knl, [3., 2., 1., 0.,
                        0., 0., 0., 0., 0., 0., 0., 0.], rtol=0, atol=1e-15)
-    xo.assert_allclose(line['s2'].ksl, [4., 5., 6., 0.,
+    xo.assert_allclose(line['u1'].ksl, [4., 5., 6., 0.,
                        0., 0., 0., 0., 0., 0., 0., 0.], rtol=0, atol=1e-15)
     xo.assert_allclose(line['m1'].knl, [3., 2., 1., 0.,
                        0., 0., 0., 0., 0., 0., 0., 0.], rtol=0, atol=1e-15)

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_mad_writer.py

@@ -29,6 +29,7 @@ def test_mad_writer(case):
     mad_seq = line.to_madx_sequence(sequence_name='myseq')
 
     mad = Madx(stdout=True)
+    mad.options.rbarc = False
     mad.input(mad_seq)
     mad.beam(particle='proton', energy=7000e9)
     mad.use('myseq')
@@ -54,7 +55,7 @@ def test_mad_writer(case):
 
     assert np.all(tw2.rows['ip.*'].name == tw.rows['ip.*'].name)
 
-    xo.assert_allclose(tw2.rows['ip.*'].s, tw.rows['ip.*'].s, rtol=0, atol=2e-9)
+    xo.assert_allclose(tw2.rows['ip.*'].s, tw.rows['ip.*'].s, rtol=0, atol=2e-5)
     xo.assert_allclose(tw2.rows['ip.*'].x, tw.rows['ip.*'].x, rtol=0, atol=1e-9)
     xo.assert_allclose(tw2.rows['ip.*'].y, tw.rows['ip.*'].y, rtol=0, atol=1e-9)
     xo.assert_allclose(tw2.rows['ip.*'].px, tw.rows['ip.*'].px, rtol=0, atol=1e-9)

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_magnet.py

@@ -73,7 +73,7 @@ def test_magnet_exact_drift(test_context):
     assert magnet.model == 'drift-kick-drift-exact'
     assert magnet.integrator == 'teapot'
 
-    exact_drift = xt.Solenoid(length=2.0, _context=test_context)  # Solenoid is exact drift when off
+    exact_drift = xt.UniformSolenoid(length=2.0, _context=test_context)  # Solenoid is exact drift when off
 
     p0 = make_particles(test_context)
     p_test = p0.copy()

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_native_madloader.py

@@ -19,7 +19,7 @@ test_data_folder = (Path(__file__).parent / '../test_data').absolute()
 def test_simple_parser():
     sequence = """
     if (version>=50401){option,-rbarc;};  ! to be ignored
-    
+
     third = 1 / 3;
     power = 3^4;
     hello := third * twopi;
@@ -30,7 +30,7 @@ def test_simple_parser():
     mb: sbend, l := mb.l, angle := hello;
     qf: quadrupole, l := 1, k1 := 1;
     qd: quadrupole, l := 1, k1 := -1;
-    
+
     line: sequence, l = 12;
         ip1: marker, at = 0;
         qf1: qf, at := 1 + offset, from = ip1, slot_id = 1;
@@ -41,7 +41,7 @@ def test_simple_parser():
     mb1, k0 := hello, polarity = +1;
     qf1, knl := {0, 0, 0, 0.01, 0};
     qd1, knl := {0, 0, 0, -0.01, 0};
-    
+
     return;  ! should also be ignored
     """
 
@@ -480,7 +480,7 @@ def test_solenoid(example_sequence):
     # so: solenoid, l=2, ks=3;  ! ignore ksi
     so1 = env['so1/line']
     xo.assert_allclose(positions['so1/line'], 31)
-    assert isinstance(so1, xt.Solenoid)
+    assert isinstance(so1, xt.UniformSolenoid)
     assert so1.length == 2
     assert so1.ks == 3
 
@@ -683,7 +683,7 @@ def test_reversed_solenoid(example_sequence):
     # so: solenoid, l=2, ks=3;  ! ignore ksi
     so1 = env['so1/line_reversed']
     xo.assert_allclose(positions_reversed['so1/line_reversed'], 36 - 31)
-    assert isinstance(so1, xt.Solenoid)
+    assert isinstance(so1, xt.UniformSolenoid)
     assert so1.length == 2
     assert so1.ks == -3
 

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_radiation_equilibrium_emittances_thick.py

@@ -151,12 +151,12 @@ def test_eq_emitt(conf):
     elif not tilt_machine_by_90_degrees and vertical_orbit_distortion and not wiggler_on:
         xo.assert_allclose(ex, 7.0910e-10, atol=0,     rtol=1e-4)
         xo.assert_allclose(ey, 2.2195e-12, atol=0,     rtol=7e-3)
-        xo.assert_allclose(ez, 3.5607e-6,  atol=0,     rtol=1e-4)
+        xo.assert_allclose(ez, 3.5607e-6,  atol=0,     rtol=2e-4)
         checked = True
     elif tilt_machine_by_90_degrees and vertical_orbit_distortion and not wiggler_on:
         xo.assert_allclose(ex, 2.2154e-12, atol=0,     rtol=7e-3)
         xo.assert_allclose(ey, 7.0911e-10, atol=0,     rtol=1e-4)
-        xo.assert_allclose(ez, 3.5607e-6,  atol=0,     rtol=1e-4)
+        xo.assert_allclose(ez, 3.5607e-6,  atol=0,     rtol=2e-4)
         checked = True
     else:
         raise ValueError('Unknown configuration')

{xtrack-0.84.7 → xtrack-0.85.0}/tests/test_slice_elements.py

@@ -661,7 +661,7 @@ def test_thick_slice_octupole(test_context):
 @for_all_test_contexts
 def test_thick_slice_solenoid(test_context):
 
-    sol = xt.Solenoid(ks=0.1, length=1)
+    sol = xt.UniformSolenoid(ks=0.1, length=1)
 
     line = xt.Line(elements=[sol])
 
@@ -688,12 +688,12 @@ def test_thick_slice_solenoid(test_context):
 
     line.to_json('ttt_thick_solenoid.json')
     line2 = xt.Line.from_json('ttt_thick_solenoid.json')
-    assert isinstance(line2['e0..0'], xt.ThickSliceSolenoid)
+    assert isinstance(line2['e0..0'], xt.ThickSliceUniformSolenoid)
     assert line2['e0..0'].parent_name == 'e0'
     assert line2['e0..0']._parent is None
 
     line2.build_tracker(_context=test_context)
-    assert isinstance(line2['e0..0'], xt.ThickSliceSolenoid)
+    assert isinstance(line2['e0..0'], xt.ThickSliceUniformSolenoid)
     assert line2['e0..0'].parent_name == 'e0'
     assert line2['e0..0']._parent is line2.element_dict['e0']