xtrack 0.98.5__tar.gz → 0.98.7__tar.gz

{xtrack-0.98.5/xtrack.egg-info → xtrack-0.98.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xtrack
-Version: 0.98.5
+Version: 0.98.7
 Summary: Tracking library for particle accelerators
 Author: G. Iadarola et al.
 License-Expression: Apache-2.0

{xtrack-0.98.5 → xtrack-0.98.7}/tests/test_cavity_absolute_time.py

@@ -35,6 +35,7 @@ def test_cavity_absolute_time(test_context):
     tt = line.get_table()
     for nn in tt.rows[tt.element_type=='Cavity'].name:
         line[nn].absolute_time = 1 # Need property
+        line[nn].harmonic = 0
         line[nn].frequency = line.vars['f_rf']
 
     tw1 = line.twiss(search_for_t_rev=True)

xtrack-0.98.7/tests/test_cavity_harmonic.py

@@ -0,0 +1,282 @@
+import xtrack as xt
+import xpart as xp
+import xobjects as xo
+import numpy as np
+import pathlib
+from cpymad.madx import Madx
+
+test_data_folder = pathlib.Path(
+    __file__).parent.joinpath('../test_data').absolute()
+
+def test_cavity_harmonic():
+
+    # Fix numpy random seed for reproducibility
+    np.random.seed(42)
+
+    line = xt.load(test_data_folder /
+                   'hllhc15_thick/lhc_thick_with_knobs.json')
+
+    tt_harm = line.get_table(attr=True)
+    tt_harm_cav = tt_harm.rows.match(element_type='Cavity')
+
+    for nn in tt_harm_cav.name:
+        assert line[nn].frequency == 0
+        assert line[nn].harmonic == 35640
+
+    line['vrf400'] = 16
+    tw_harm = line.twiss6d()
+
+    pp_harm = xp.generate_matched_gaussian_bunch(line=line,
+                                            num_particles=100_000,
+                                            nemitt_x=2e-6,
+                                            nemitt_y=2.5e-6,
+                                            sigma_z=0.08)
+
+    # Switch to frequency mode
+    for nn in tt_harm_cav.name:
+        line[nn].harmonic = 0
+        line[nn].frequency=400.79e6
+
+    tt_freq = line.get_table(attr=True)
+    tt_freq_cav = tt_freq.rows.match(element_type='Cavity')
+
+    pp_freq = xp.generate_matched_gaussian_bunch(line=line,
+                                            num_particles=100_000,
+                                            nemitt_x=2e-6,
+                                            nemitt_y=2.5e-6,
+                                            sigma_z=0.08)
+
+    tt_freq = line.get_table(attr=True)
+    tt_freq_cav = tt_freq.rows.match(element_type='Cavity')
+    tw_freq = line.twiss6d()
+
+    xo.assert_allclose(tw_harm.qs, tw_freq.qs, rtol=0, atol=1e-7)
+    xo.assert_allclose(pp_harm.zeta.std(), pp_freq.zeta.std(), rtol=0.01)
+    xo.assert_allclose(pp_harm.delta.std(), pp_freq.delta.std(), rtol=0.01)
+
+    xo.assert_allclose(tt_harm_cav.frequency, 0, rtol=1e-15)
+    xo.assert_allclose(tt_freq_cav.frequency, 400.79e6, rtol=1e-15)
+    xo.assert_allclose(tt_harm_cav.harmonic, 35640, rtol=1e-15)
+    xo.assert_allclose(tt_freq_cav.harmonic, 0, rtol=1e-15)
+
+
+    # Getting a mix of the two modes
+    for nn in tt_harm_cav.name:
+        line[nn].frequency = 0
+        line[nn].harmonic = 0
+
+    line['acsca.d5l4.b1'].harmonic = 35640
+    line['acsca.c5l4.b1'].frequency = 400.79e6
+    line['acsca.b5l4.b1'].harmonic = 35640
+    line['acsca.a5l4.b1'].frequency = 400.79e6
+    line['acsca.a5r4.b1'].harmonic = 35640
+    line['acsca.b5r4.b1'].frequency = 400.79e6
+    line['acsca.c5r4.b1'].harmonic = 35640
+    line['acsca.d5r4.b1'].frequency = 400.79e6
+
+    mad_src = line.to_madx_sequence('seq')
+
+    env2 = xt.load(string=mad_src, format='madx')
+    line2 = env2['seq']
+
+    tt3 = line2.get_table(attr=True)
+    tt3_cav = tt3.rows.match(element_type='Cavity')
+    xo.assert_allclose(tt3_cav.frequency, [0, 400.79e6, 0, 400.79e6, 0, 400.79e6, 0, 400.79e6], rtol=1e-15)
+    xo.assert_allclose(tt3_cav.harmonic, [35640, 0, 35640, 0, 35640, 0, 35640, 0], rtol=1e-15)
+
+    line2.set_particle_ref('proton', p0c=7e12)
+    tw3 = line2.twiss6d()
+    xo.assert_allclose(tw_harm.qs, tw3.qs, rtol=0, atol=1e-7)
+
+    line_slice_thick = line.copy()
+    line_slice_thick.slice_thick_elements([
+        xt.Strategy(slicing=None),
+        xt.Strategy(slicing=xt.Uniform(3, mode='thick'), name='acsca.*'),
+    ])
+
+    tt_sliced = line_slice_thick.get_table(attr=True)
+    tt_sliced_cav = tt_sliced.rows.match(element_type='ThickSliceCav.*')
+
+    assert np.all(tt_sliced_cav.name == np.array([
+        'acsca.d5l4.b1..0', 'acsca.d5l4.b1..1', 'acsca.d5l4.b1..2',
+        'acsca.c5l4.b1..0', 'acsca.c5l4.b1..1', 'acsca.c5l4.b1..2',
+        'acsca.b5l4.b1..0', 'acsca.b5l4.b1..1', 'acsca.b5l4.b1..2',
+        'acsca.a5l4.b1..0', 'acsca.a5l4.b1..1', 'acsca.a5l4.b1..2',
+        'acsca.a5r4.b1..0', 'acsca.a5r4.b1..1', 'acsca.a5r4.b1..2',
+        'acsca.b5r4.b1..0', 'acsca.b5r4.b1..1', 'acsca.b5r4.b1..2',
+        'acsca.c5r4.b1..0', 'acsca.c5r4.b1..1', 'acsca.c5r4.b1..2',
+        'acsca.d5r4.b1..0', 'acsca.d5r4.b1..1', 'acsca.d5r4.b1..2']))
+
+    xo.assert_allclose(tt_sliced_cav.frequency,
+                    [0, 0, 0, 400.79e6, 400.79e6, 400.79e6,
+                        0, 0, 0, 400.79e6, 400.79e6, 400.79e6,
+                        0, 0, 0, 400.79e6, 400.79e6, 400.79e6,
+                        0, 0, 0, 400.79e6, 400.79e6, 400.79e6], rtol=1e-15)
+    xo.assert_allclose(tt_sliced_cav.harmonic,
+                        [35640, 35640, 35640, 0, 0, 0,
+                        35640, 35640, 35640, 0, 0, 0,
+                        35640, 35640, 35640, 0, 0, 0,
+                        35640, 35640, 35640, 0, 0, 0], rtol=1e-15)
+    xo.assert_allclose(tt_sliced_cav.voltage, 16 / 8 / 3 * 1e6, rtol=1e-3)
+
+    tw_slice_thick = line_slice_thick.twiss6d()
+    xo.assert_allclose(tw_harm.qs, tw_slice_thick.qs, rtol=0, atol=1e-7)
+
+    line_slice_thin = line.copy()
+    line_slice_thin.slice_thick_elements([
+        xt.Strategy(slicing=None),
+        xt.Strategy(slicing=xt.Uniform(2, mode='thin'), name='acsca.*'),
+    ])
+
+    tt_sliced_thin = line_slice_thin.get_table(attr=True)
+    tt_sliced_thin_cav = tt_sliced_thin.rows.match(element_type='.*SliceCav.*')
+
+    assert np.all(tt_sliced_thin_cav.name == np.array(['drift_acsca.d5l4.b1..0', 'acsca.d5l4.b1..0',
+        'drift_acsca.d5l4.b1..1', 'acsca.d5l4.b1..1',
+        'drift_acsca.d5l4.b1..2', 'drift_acsca.c5l4.b1..0',
+        'acsca.c5l4.b1..0', 'drift_acsca.c5l4.b1..1', 'acsca.c5l4.b1..1',
+        'drift_acsca.c5l4.b1..2', 'drift_acsca.b5l4.b1..0',
+        'acsca.b5l4.b1..0', 'drift_acsca.b5l4.b1..1', 'acsca.b5l4.b1..1',
+        'drift_acsca.b5l4.b1..2', 'drift_acsca.a5l4.b1..0',
+        'acsca.a5l4.b1..0', 'drift_acsca.a5l4.b1..1', 'acsca.a5l4.b1..1',
+        'drift_acsca.a5l4.b1..2', 'drift_acsca.a5r4.b1..0',
+        'acsca.a5r4.b1..0', 'drift_acsca.a5r4.b1..1', 'acsca.a5r4.b1..1',
+        'drift_acsca.a5r4.b1..2', 'drift_acsca.b5r4.b1..0',
+        'acsca.b5r4.b1..0', 'drift_acsca.b5r4.b1..1', 'acsca.b5r4.b1..1',
+        'drift_acsca.b5r4.b1..2', 'drift_acsca.c5r4.b1..0',
+        'acsca.c5r4.b1..0', 'drift_acsca.c5r4.b1..1', 'acsca.c5r4.b1..1',
+        'drift_acsca.c5r4.b1..2', 'drift_acsca.d5r4.b1..0',
+        'acsca.d5r4.b1..0', 'drift_acsca.d5r4.b1..1', 'acsca.d5r4.b1..1',
+        'drift_acsca.d5r4.b1..2']))
+    xo.assert_allclose(tt_sliced_thin_cav.frequency,
+                    [0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
+                        0.0000e+00, 4.0079e+08, 0.0000e+00, 4.0079e+08, 0.0000e+00,
+                        0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
+                        0.0000e+00, 4.0079e+08, 0.0000e+00, 4.0079e+08, 0.0000e+00,
+                        0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
+                        0.0000e+00, 4.0079e+08, 0.0000e+00, 4.0079e+08, 0.0000e+00,
+                        0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
+                        0.0000e+00, 4.0079e+08, 0.0000e+00, 4.0079e+08, 0.0000e+00], rtol=1e-15)
+
+    xo.assert_allclose(tt_sliced_thin_cav.harmonic,
+                    [    0., 35640.,     0., 35640.,     0.,     0.,     0.,     0.,
+                            0.,     0.,     0., 35640.,     0., 35640.,     0.,     0.,
+                            0.,     0.,     0.,     0.,     0., 35640.,     0., 35640.,
+                            0.,     0.,     0.,     0.,     0.,     0.,     0., 35640.,
+                            0., 35640.,     0.,     0.,     0.,     0.,     0.,     0.], rtol=1e-15)
+
+    xo.assert_allclose(tt_sliced_thin_cav.voltage,
+                    [      0., 1000000.,       0., 1000000.,       0.,       0.,
+                        1000000.,       0., 1000000.,       0.,       0., 1000000.,
+                            0., 1000000.,       0.,       0., 1000000.,       0.,
+                        1000000.,       0.,       0., 1000000.,       0., 1000000.,
+                            0.,       0., 1000000.,       0., 1000000.,       0.,
+                            0., 1000000.,       0., 1000000.,       0.,       0.,
+                        1000000.,       0., 1000000.,       0.], rtol=1e-15)
+
+def test_cavity_harmonic_loader_native():
+
+    env = xt.load([test_data_folder / 'lhc_2024/lhc.seq',
+                test_data_folder / 'lhc_2024/injection_optics.madx'],
+                reverse_lines=['lhcb2'])
+    env.lhcb1.set_particle_ref('proton', p0c=450e9)
+    env.lhcb2.set_particle_ref('proton', p0c=450e9)
+
+    tt1 = env.lhcb1.get_table(attr=True)
+    tt2 = env.lhcb2.get_table(attr=True)
+
+    tt1_cav = tt1.rows.match(element_type='Cavity')
+    tt2_cav = tt2.rows.match(element_type='Cavity')
+
+    assert len(tt1_cav) == 8
+    assert len(tt2_cav) == 8
+    xo.assert_allclose(tt1_cav.frequency, 0)
+    xo.assert_allclose(tt2_cav.frequency, 0)
+    xo.assert_allclose(tt1_cav.harmonic, 35640)
+    xo.assert_allclose(tt2_cav.harmonic, 35640)
+
+    env['vrf400'] = 8
+    env['lagrf400.b1'] = 0.5
+
+    tw_harm = env.lhcb1.twiss6d()
+
+    for nn in tt1_cav.name:
+        env[nn].harmonic = 0
+        env[nn].frequency = 400.79e6
+
+    tw_freq = env.lhcb1.twiss6d()
+
+    xo.assert_allclose(tw_freq.qs, tw_harm.qs, rtol=0, atol=1e-7)
+
+def test_cavity_harmonic_loader_cpymad():
+
+    mad = Madx()
+    mad.call(str(test_data_folder / 'lhc_2024/lhc.seq'))
+    mad.call(str(test_data_folder / 'lhc_2024/injection_optics.madx'))
+    mad.beam()
+    mad.use('lhcb1')
+
+    line = xt.Line.from_madx_sequence(mad.sequence.lhcb1,
+                                    deferred_expressions=True)
+
+    line.set_particle_ref('proton', p0c=450e9)
+
+    tt1 = line.get_table(attr=True)
+    tt1_cav = tt1.rows.match(element_type='Cavity')
+
+    assert len(tt1_cav) == 8
+    xo.assert_allclose(tt1_cav.frequency, 0)
+    xo.assert_allclose(tt1_cav.harmonic, 35640)
+
+    line['vrf400'] = 8
+    line['lagrf400.b1'] = 0.5
+
+    tw_harm = line.twiss6d()
+
+    for nn in tt1_cav.name:
+        line[nn].harmonic = 0
+        line[nn].frequency = 400.79e6
+
+    tw_freq = line.twiss6d()
+
+    xo.assert_allclose(tw_freq.qs, tw_harm.qs, rtol=0, atol=1e-7)
+
+def test_cavity_harmonic_more_loader_checks():
+    from cpymad.madx import Madx
+    import xtrack as xt
+    import xobjects as xo
+
+    madx_src = """
+    hh = 5;
+    ff = 100;
+    cav_harm: rfcavity, harmon:=hh;
+    cav_freq: rfcavity, freq:=ff;
+
+    seq: sequence, l=10;
+        cav_harm, at=5;
+        cav_freq, at=7;
+    endsequence;
+
+    """
+
+    mad = Madx()
+    mad.input(madx_src)
+    mad.input('''
+    beam;
+    use, sequence=seq;
+    ''')
+
+    lcpymad = xt.Line.from_madx_sequence(mad.sequence.seq,
+                                        deferred_expressions=True)
+
+    env_native = xt.load(string=madx_src, format='madx')
+    lnative = env_native['seq']
+
+    for ll in [lcpymad, lnative]:
+        assert str(ll.ref['cav_harm'].harmonic._expr) == "vars['hh']"
+        assert ll.ref['cav_harm'].frequency._expr is None
+        assert ll.ref['cav_harm'].frequency._value == 0
+
+        assert str(ll.ref['cav_freq'].frequency._expr) == "(vars['ff'] * 1000000.0)"
+        assert ll.ref['cav_freq'].harmonic._expr is None
+        assert ll.ref['cav_freq'].harmonic._value == 0

{xtrack-0.98.5 → xtrack-0.98.7}/tests/test_environment.py

@@ -4339,3 +4339,149 @@ def test_str_in_composer_to_dict_from_dict():
     assert line2.composer.components[0].at == 2
     assert line2.composer.components[1] == 'q1'
     assert line2.composer.components[2] == 'q1'
+
+def test_sandwitch_thin_elements():
+
+    # Create an environment
+    env = xt.Environment()
+
+    env.new('m0', xt.Marker)
+    env.new('m1', xt.Marker)
+    env.new('m2', xt.Marker)
+    env.new('m3', xt.Marker)
+    env.new('m4', xt.Marker)
+    env.new('m5', xt.Marker)
+    env.new('m6', xt.Marker)
+    env.new('m7', xt.Marker)
+    env.new('m8', xt.Marker)
+    env.new('m9', xt.Marker)
+    env.new('m10', xt.Marker)
+
+    env.new_line(name='myline', compose=True)
+    composer = env['myline'].composer
+
+    composer.components.extend([
+        env.place('m0'),
+        env.place('m3', at=10.),
+        env.place(['m1', 'm2']),
+        env.place(['m6', 'm7'], at='m3@end'),
+        env.place(['m4', 'm5'], at='m3@start'),
+        env.place('m8', at=10, from_='m0'),
+        env.place('m9', at=20.),
+        env.place('m10', at=-10, from_='m9'),
+    ])
+
+    tt_unsorted = composer.resolve_s_positions(sort=False)
+    tt_unsorted.cols['s from_ from_anchor'].show()
+    # prints:
+    # name             s from_ from_anchor
+    # m0               0 None  None
+    # m3              10 None  None
+    # m1              10 m3    end
+    # m2              10 m1    end
+    # m6              10 m3    end
+    # m7              10 m6    end
+    # m4              10 m3    start
+    # m5              10 m4    end
+    # m8              10 m0    None
+    # m9              20 None  None
+    # m10             10 m9    None
+
+    assert np.all(tt_unsorted.name == [
+        'm0', 'm3', 'm1', 'm2', 'm6', 'm7', 'm4', 'm5', 'm8', 'm9', 'm10'
+    ])
+    xo.assert_allclose(tt_unsorted.s, [
+        0., 10., 10., 10., 10., 10., 10., 10., 10., 20., 10.])
+    assert np.all(tt_unsorted.from_ == [
+        None, None, 'm3', 'm1', 'm3', 'm6', 'm3', 'm4', 'm0', None, 'm9'
+    ])
+    assert np.all(tt_unsorted.from_anchor == [
+        None, None, 'end', 'end', 'end', 'end', 'start', 'end', None, None, None
+    ])
+
+    tt_sorted = composer.resolve_s_positions(sort=True)
+    tt_sorted.cols['s from_ from_anchor'].show()
+    # prints:
+    # name             s from_ from_anchor
+    # m0               0 None  None
+    # m8              10 m0    None
+    # m4              10 m3    start
+    # m5              10 m4    end
+    # m3              10 None  None
+    # m1              10 m3    end
+    # m2              10 m1    end
+    # m6              10 m3    end
+    # m7              10 m6    end
+    # m10             10 m9    None
+    # m9              20 None  None
+
+    assert np.all(tt_sorted.name == [
+        'm0', 'm8', 'm4', 'm5', 'm3', 'm1', 'm2', 'm6', 'm7', 'm10', 'm9'
+    ])
+    xo.assert_allclose(tt_sorted.s, [
+        0., 10., 10., 10., 10., 10., 10., 10., 10., 10., 20.])
+    assert np.all(tt_sorted.from_ == [
+        None, 'm0', 'm3', 'm4', None, 'm3', 'm1', 'm3', 'm6', 'm9', None
+    ])
+    assert np.all(tt_sorted.from_anchor == [
+        None, None, 'start', 'end', None, 'end', 'end', 'end', 'end', None, None
+    ])
+
+def test_sandwitch_thin_elements_insert():
+
+    env = xt.Environment()
+
+    # Create a line with two quadrupoles and a marker
+    line = env.new_line(name='myline', components=[
+        env.new('q0', xt.Quadrupole, length=2.0, at=10.),
+        env.new('q1', xt.Quadrupole, length=2.0, at=20.),
+        env.new('m0', xt.Marker, at=40.),
+        ])
+
+    # Create a set of new elements to be placed
+    env.new('s1', xt.Sextupole, length=0.1, k2=0.2)
+    env.new('s2', xt.Sextupole, length=0.1, k2=-0.2)
+    env.new('m1', xt.Marker)
+    env.new('m2', xt.Marker)
+    env.new('m3', xt.Marker)
+
+    # Insert the new elements in the line
+    line.insert([
+        env.place('s1', at=5.),
+        env.place('s2', anchor='end', at=-5., from_='q1@start'),
+        env.place(['m1', 'm2'], at='m0@start'),
+        env.place('m3', at='m0@end'),
+        ])
+
+    tt = line.get_table()
+    tt.show(cols=['s_start', 's_center', 's_end'])
+    # is:
+    # name             s_start      s_center         s_end
+    # ||drift_4              0         2.475          4.95
+    # s1                  4.95             5          5.05
+    # ||drift_6           5.05         7.025             9
+    # q0                     9            10            11
+    # ||drift_7             11         12.45          13.9
+    # s2                  13.9         13.95            14
+    # ||drift_8             14          16.5            19
+    # q1                    19            20            21
+    # ||drift_3             21          30.5            40
+    # m1                    40            40            40
+    # m2                    40            40            40
+    # m0                    40            40            40
+    # m3                    40            40            40
+    # _end_point            40            40            40
+
+    assert np.all(tt.name == [
+        '||drift_4', 's1', '||drift_6', 'q0', '||drift_7', 's2',
+        '||drift_8', 'q1', '||drift_3', 'm1', 'm2', 'm0', 'm3', '_end_point'
+    ])
+    xo.assert_allclose(tt.s_start, [
+        0., 4.95, 5.05, 9., 11., 13.9, 14., 19., 21., 40., 40., 40., 40., 40.],
+        atol=1e-14)
+    xo.assert_allclose(tt.s_center, [
+        2.475, 5., 7.025, 10., 12.45, 13.95, 16.5, 20., 30.5, 40., 40., 40., 40., 40.],
+        atol=1e-14)
+    xo.assert_allclose(tt.s_end, [
+        4.95, 5.05, 9., 11., 13.9, 14., 19., 21., 40., 40., 40., 40., 40., 40.],
+        atol=1e-14)

{xtrack-0.98.5 → xtrack-0.98.7}/tests/test_madloader.py

@@ -602,8 +602,7 @@ def test_mad_elements_import():
 
         assert isinstance(line['c1'], xt.Cavity)
         assert line.get_s_position('c1') == 0.2
-        xo.assert_allclose(line['c1'].frequency, clight * line.particle_ref.beta0 / 10. * 8,
-                           rtol=0, atol=1e-7)
+        xo.assert_allclose(line['c1'].harmonic, 8, rtol=0, atol=1e-12)
         assert line['c1'].lag == 180
         assert line['c1'].voltage == 6e6
 

{xtrack-0.98.5 → xtrack-0.98.7}/tests/test_native_madloader.py

@@ -164,7 +164,7 @@ def example_sequence(temp_context_default_mod):
     se: sextupole, L=1, K2=2, K2S=3, TILT=2;  ! ignore ktap
     oc: octupole, L=2, K3=3, K3S=2, TILT=2;
     ma: marker;
-    rf: rfcavity, L=2, VOLT=1, LAG=2, FREQ=3, HARMON=2, NO_CAVITY_TOTALPATH;  ! ignore N_BESSEL
+    rf: rfcavity, L=2, VOLT=1, LAG=2, FREQ=3, NO_CAVITY_TOTALPATH;  ! ignore N_BESSEL
     mu: multipole, LRAD=1, TILT=2, KNL={3, 4, 5, 6}, KSL={1, 2, 3, 4};
     so: solenoid, l=2, ks=3;  ! ignore ksi
 
@@ -450,7 +450,7 @@ def test_marker(example_sequence):
 
 def test_rfcavity(example_sequence):
     env, positions, _ = example_sequence
-    # rf: rfcavity, L=2, VOLT=1, LAG=2, FREQ=3, HARMON=2;  ! ignore N_BESSEL, NO_CAVITY_TOTALPATH
+    # rf: rfcavity, L=2, VOLT=1, LAG=2, FREQ=3;  ! ignore N_BESSEL, NO_CAVITY_TOTALPATH
     rf1 = env['rf1/line']
     xo.assert_allclose(positions['rf1/line'], 27, atol=1e-14)
     assert isinstance(rf1, xt.Cavity)
@@ -655,7 +655,7 @@ def test_reversed_marker(example_sequence):
 
 
 def test_reversed_rfcavity(example_sequence):
-    env, _, positions_reversed = example_sequence    # ma: marker;    # rf: rfcavity, L=2, VOLT=1, LAG=2, FREQ=3, HARMON=2;  ! ignore N_BESSEL, NO_CAVITY_TOTALPATH
+    env, _, positions_reversed = example_sequence    # ma: marker;    # rf: rfcavity, L=2, VOLT=1, LAG=2, FREQ=3;  ! ignore N_BESSEL, NO_CAVITY_TOTALPATH
     rf1 = env['rf1/line_reversed']
     xo.assert_allclose(positions_reversed['rf1/line_reversed'], 36 - 27, atol=1e-14)
     assert isinstance(rf1, xt.Cavity)

{xtrack-0.98.5 → xtrack-0.98.7}/tests/test_tapering.py

@@ -2,6 +2,7 @@ import json
 import pathlib
 
 import numpy as np
+from scipy.constants import c as clight
 
 import xobjects as xo
 import xtrack as xt
@@ -25,6 +26,12 @@ def test_tapering_and_twiss_with_radiation():
     with open(filename, 'r') as f:
         line = xt.Line.from_dict(json.load(f))
 
+    # Use harmonic for one of the cavities
+    t_rev = line.get_length() / clight
+    harm = line['rf1'].frequency * t_rev
+    line['rf1'].frequency = 0
+    line['rf1'].harmonic = harm
+
     line.build_tracker()
 
     # Initial twiss (no radiation)
@@ -142,6 +149,12 @@ def test_tapering_zero_mean():
     line['rf2b'].voltage *= 2
     line['rf2a'].voltage *= 2
 
+    # Use harmonic for one of the cavities
+    t_rev = line.get_length() / clight
+    harm = line['rf1'].frequency * t_rev
+    line['rf1'].frequency = 0
+    line['rf1'].harmonic = line['rf1'].frequency * t_rev
+
     line.particle_ref.p0c = 4e9  # eV
 
     line.configure_radiation(model=None)

{xtrack-0.98.5 → xtrack-0.98.7}/tests/test_twiss.py

@@ -3,6 +3,7 @@ import pathlib
 from itertools import product
 
 import numpy as np
+from scipy.constants import c as clight
 import pytest
 from cpymad.madx import Madx
 
@@ -68,9 +69,6 @@ def test_coupled_beta(test_context):
     line = env['lhcb1']
     line.set_particle_ref('proton', p0c=7e12)
     line['mqwa.a4r3.b1..1'].ksl[1] = 1e-4
-    tt_cav = line.get_table().rows.match('Cavity', 'element_type')
-    for nn in tt_cav.name:
-        line[nn].frequency = 400.79e6
 
     line.build_tracker(_context=test_context)
 
@@ -107,10 +105,6 @@ def test_twiss_zeta0_delta0(test_context):
     line = env['lhcb1']
     line.set_particle_ref('proton', p0c=7e12)
 
-    tt_cav = line.get_table().rows.match('Cavity', 'element_type')
-    for nn in tt_cav.name:
-        line[nn].frequency = 400.79e6
-
     env['on_crab1'] = -190
     env['on_crab5'] = -190
 
@@ -1024,6 +1018,11 @@ def test_longitudinal_plane_against_matrix(machine, test_context):
         tw = line.twiss()
         circumference = tw.circumference
 
+        if line[cavity_name].harmonic:
+            frequency_rf = line[cavity_name].harmonic / (line.get_length() / tw.beta0 / clight)
+        else:
+            frequency_rf = line[cavity_name].frequency
+
         if longitudinal_mode == 'nonlinear':
             matrix = xt.LineSegmentMap(
                 qx=tw.qx, qy=tw.qy,
@@ -1033,7 +1032,7 @@ def test_longitudinal_plane_against_matrix(machine, test_context):
                 dx=tw.dx[0], dpx=tw.dpx[0],
                 dy=tw.dy[0], dpy=tw.dpy[0],
                 voltage_rf=line[cavity_name].voltage,
-                frequency_rf=line[cavity_name].frequency,
+                frequency_rf=frequency_rf,
                 lag_rf=line[cavity_name].lag,
                 momentum_compaction_factor=tw.momentum_compaction_factor,
                 length=circumference)
@@ -1047,7 +1046,7 @@ def test_longitudinal_plane_against_matrix(machine, test_context):
                 dx=tw.dx[0], dpx=tw.dpx[0],
                 dy=tw.dy[0], dpy=tw.dpy[0],
                 voltage_rf=line[cavity_name].voltage,
-                frequency_rf=line[cavity_name].frequency,
+                frequency_rf=frequency_rf,
                 lag_rf=line[cavity_name].lag,
                 momentum_compaction_factor=tw.momentum_compaction_factor,
                 length=circumference)
@@ -1592,14 +1591,17 @@ def test_longitudinal_beam_sizes(test_context):
         beam_sizes.sigma_zeta / beam_sizes.sigma_pzeta, tw.bets0, atol=0, rtol=5e-5)
 
 @for_all_test_contexts(excluding=('ContextCupy', 'ContextPyopencl'))
-def test_second_order_chromaticity_and_dispersion(test_context):
+@pytest.mark.parametrize('method', ['6d', '4d'])
+def test_second_order_chromaticity_and_dispersion(test_context, method):
 
     line = xt.load(test_data_folder /
                              'hllhc15_thick/lhc_thick_with_knobs.json')
     line.vars['on_x5'] = 300
+    line.vars['vrf400'] = 16
+
     line.build_tracker(_context=test_context)
 
-    tw = line.twiss(method='4d')
+    tw = line.twiss(method=method)
     tw_fw = line.twiss(start='ip4', end='ip6', init_at='ip4',
                 x=tw['x', 'ip4'], px=tw['px', 'ip4'],
                 y=tw['y', 'ip4'], py=tw['py', 'ip4'],
@@ -1643,14 +1645,14 @@ def test_second_order_chromaticity_and_dispersion(test_context):
     pxs_qy = np.polyfit(delta, qy_xs, 3)
 
     xo.assert_allclose(delta, nlchr.delta0, atol=1e-6, rtol=0)
-    xo.assert_allclose(tw['dx', location], pxs_x[-2], atol=0, rtol=1e-4)
-    xo.assert_allclose(tw['dpx', location], pxs_px[-2], atol=0, rtol=1e-4)
-    xo.assert_allclose(tw['dy', location], pxs_y[-2], atol=0, rtol=1e-4)
-    xo.assert_allclose(tw['dpy', location], pxs_py[-2], atol=0, rtol=1e-4)
-    xo.assert_allclose(tw['ddx', location], 2*pxs_x[-3], atol=0, rtol=1e-4)
-    xo.assert_allclose(tw['ddpx', location], 2*pxs_px[-3], atol=0, rtol=1e-4)
-    xo.assert_allclose(tw['ddy', location], 2*pxs_y[-3], atol=0, rtol=1e-4)
-    xo.assert_allclose(tw['ddpy', location], 2*pxs_py[-3], atol=0, rtol=1e-4)
+    xo.assert_allclose(tw['dx', location], pxs_x[-2], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw['dpx', location], pxs_px[-2], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw['dy', location], pxs_y[-2], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw['dpy', location], pxs_py[-2], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw['ddx', location], 2*pxs_x[-3], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw['ddpx', location], 2*pxs_px[-3], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw['ddy', location], 2*pxs_y[-3], atol=0, rtol=5e-4)
+    xo.assert_allclose(tw['ddpy', location], 2*pxs_py[-3], atol=0, rtol=5e-4)
     xo.assert_allclose(tw['dqx'], pxs_qx[-2], atol=0, rtol=1e-3)
     xo.assert_allclose(tw['ddqx'], pxs_qx[-3]*2, atol=0, rtol=1e-2)
     xo.assert_allclose(tw['dqy'], pxs_qy[-2], atol=0, rtol=1e-3)

{xtrack-0.98.5 → xtrack-0.98.7}/tests/test_twiss_vs_madx_psb.py

@@ -27,7 +27,6 @@ def test_twiss_psb(test_context):
     env = xt.load(test_data_folder / 'psb_injection/psb_injection.seq')
     line = env['psb']
     line.set_particle_ref('proton', gamma0=mad.sequence['psb'].beam.gamma)
-    line['br.c02'].frequency = 1 / line_ref.get_length() * clight * line_ref.particle_ref.beta0[0] # h_rf = 1
 
     line.build_tracker(_context=test_context)
     beta0 = line.particle_ref.beta0[0]

xtrack-0.98.7/xtrack/_version.py

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

{xtrack-0.98.5 → xtrack-0.98.7}/xtrack/base_element.py

@@ -531,14 +531,13 @@ class BeamElement(xo.HybridClass, metaclass=MetaBeamElement):
             raise ValueError("Invalid array type")
 
     def xoinitialize(self, **kwargs):
-        rot_s_rad = kwargs.pop('rot_s_rad', None)
-        # For the shifts we accept both shift_x and _shift_x for backward compatibility
+        rot_s_rad = kwargs.pop('rot_s_rad', kwargs.pop('_rot_s_rad', None))
         shift_x = kwargs.pop('shift_x', kwargs.pop('_shift_x', None))
         shift_y = kwargs.pop('shift_y', kwargs.pop('_shift_y', None))
         shift_s = kwargs.pop('shift_s', kwargs.pop('_shift_s', None))
-        rot_x_rad = kwargs.pop('rot_x_rad', None)
-        rot_y_rad = kwargs.pop('rot_y_rad', None)
-        rot_s_rad_no_frame = kwargs.pop('rot_s_rad_no_frame', None)
+        rot_x_rad = kwargs.pop('rot_x_rad', kwargs.pop('_rot_x_rad', None))
+        rot_y_rad = kwargs.pop('rot_y_rad', kwargs.pop('_rot_y_rad', None))
+        rot_s_rad_no_frame = kwargs.pop('rot_s_rad_no_frame', kwargs.pop('_rot_s_rad_no_frame', None))
 
         xo.HybridClass.xoinitialize(self, **kwargs)