xtrack 0.69.7__tar.gz → 0.70.1__tar.gz

{xtrack-0.69.7/xtrack.egg-info → xtrack-0.70.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.69.7
+Version: 0.70.1
 Summary: Tracking library for particle accelerators
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xtrack
@@ -22,6 +22,7 @@ Requires-Dist: nafflib; extra == "tests"
 Requires-Dist: PyHEADTAIL; extra == "tests"
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-mock; extra == "tests"
+Requires-Dist: pymadng; extra == "tests"
 Provides-Extra: notebooks
 Requires-Dist: jupyter; extra == "notebooks"
 Requires-Dist: ipympl; extra == "notebooks"

{xtrack-0.69.7 → xtrack-0.70.1}/setup.py

@@ -48,7 +48,8 @@ setup(
         'xdeps'
         ],
     extras_require={
-        'tests': ['cpymad', 'nafflib', 'PyHEADTAIL', 'pytest', 'pytest-mock'],
+        'tests': ['cpymad', 'nafflib', 'PyHEADTAIL', 'pytest', 'pytest-mock',
+                  'pymadng'],
         'notebooks': ['jupyter', 'ipympl', 'xplt'],
     },
     )

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_acceleration.py

@@ -89,11 +89,13 @@ def test_energy_program(test_context):
     line['br1.acwf7l1.1'].frequency = 1e3
 
     # test to_dict and from_dict
+    lbefore = line
     line_dict = line.to_dict()
     line = xt.Line.from_dict(line_dict)
+    assert np.all(line.vars.get_table().name == lbefore.vars.get_table().name)
 
-    # test copy method
     line = line.copy()
+    assert np.all(line.vars.get_table().name == lbefore.vars.get_table().name)
 
     line.build_tracker(_context=test_context)
 

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_environment.py

@@ -3,6 +3,7 @@ import xobjects as xo
 import xdeps as xd
 import numpy as np
 import pytest
+import json
 import pathlib
 
 test_data_folder = pathlib.Path(__file__).parent.joinpath('../test_data').absolute()
@@ -1852,4 +1853,113 @@ def test_inpection_methods(container_type):
 
     tt = ee['bb'].get_table()
     assert tt['value', 'k0'] == 2 * (2 * 2 + 1)
-    assert tt['expr', 'k0'] == "(2.0 * vars['b'])"
+    assert tt['expr', 'k0'] == "(2.0 * vars['b'])"
+
+
+def test_vars_features(tmpdir):
+    env = xt.Environment()
+
+    try:
+        env['b'] = '3*a'
+    except KeyError:
+        pass
+    else:
+        raise ValueError('Variable a should not be present')
+
+    env.vars.default_to_zero = True
+    env['b'] = '3*a'
+
+    assert env['a'] == 0
+    assert env['b'] == 0
+
+    env['a'] = 3
+    assert env['b'] == 9
+
+    # Test compact and to_dict
+    tt = env.vars.get_table()
+    assert tt['expr', 'b'] == '(3.0 * a)'
+    dd = tt.to_dict()
+    assert dd['b'] == '(3.0 * a)'
+    assert dd['a'] == 3.0
+
+    ee = xt.Environment()
+    ee.vars.update(dd)
+    assert ee['a'] == 3.0
+    assert ee['b'] == 9.0
+    assert ee.vars.get_table()['expr', 'b'] == '(3.0 * a)'
+
+    with open(tmpdir / 'env.json', 'w') as fid:
+        json.dump(dd, fid)
+
+    ee2 = xt.Environment()
+    ee2.vars.load_json(tmpdir / 'env.json')
+    assert ee2['a'] == 3.0
+    assert ee2['b'] == 9.0
+    assert ee2.vars.get_table()['expr', 'b'] == '(3.0 * a)'
+
+    tt1 = env.vars.get_table(compact=False)
+    assert tt1['expr', 'b'] ==  "(3.0 * vars['a'])"
+    dd1 = tt1.to_dict()
+    assert dd1['b'] == "(3.0 * vars['a'])"
+    assert dd1['a'] == 3.0
+
+
+def test_call(tmpdir):
+    def _trim(string):
+        # Reduce indent level by one
+        return '\n'.join(map(lambda line: line[4:], filter(bool, string.split('\n'))))
+
+    preamble = _trim("""
+    import xtrack as xt
+    env = xt.get_environment()
+    env.vars.default_to_zero=True
+    """)
+
+    parameters = _trim("""
+    env['var1'] = 2
+    env['var2'] = 3
+    """)
+
+    elements = _trim("""
+    env.new('sbend', 'Bend')
+    env.new('drift', 'Drift')
+    
+    env.new('mb2', 'sbend', length=2)
+    env.new('drx', 'drift', length='var1 + var2')
+    """)
+
+    lattice = _trim("""
+    env.particle_ref = xt.Particles(mass0=xt.ELECTRON_MASS_EV, energy0=45.6e9)
+    
+    env.new_line(
+        name='seq',
+        components=['mb2', 'drx', 'mb2', 'drx'],
+    )
+    """)
+
+    parameter_file = tmpdir / 'parameters.py'
+    element_file = tmpdir / 'elements.py'
+    lattice_file = tmpdir / 'lattice.py'
+
+    with parameter_file.open('w') as f:
+        f.write(preamble + parameters)
+
+    with element_file.open('w') as f:
+        f.write(preamble + elements)
+
+    with lattice_file.open('w') as f:
+        f.write(preamble + lattice)
+
+    env = xt.Environment()
+    env.call(parameter_file)
+    env.call(element_file)
+    env.call(lattice_file)
+
+    line, = env.lines.values()
+    assert line.name == 'seq'
+    assert line.element_names == ['mb2', 'drx', 'mb2', 'drx']
+    assert env['mb2'].length == line['mb2'].length == 2
+    assert env['drx'].length == line['drx'].length == 5
+
+    env['var1'] = 10
+    assert env['drx'].length == 13

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_lhc_match_phase_15.py

@@ -559,10 +559,10 @@ def test_lhc_match_phase_15(test_context, config):
             xt.VaryList(['kqtf.b1', 'kqtd.b1', 'ksf.b1', 'ksd.b1'], step=1e-7),
             xt.VaryList(['kqtf.b2', 'kqtd.b2', 'ksf.b2', 'ksd.b2'], step=1e-7)],
         targets = [
-            xt.TargetSet(line='lhcb1', qx=62.315, qy=60.325, tol=1e-10),
-            xt.TargetSet(line='lhcb1', dqx=10.0, dqy=12.0, tol=1e-5),
-            xt.TargetSet(line='lhcb2', qx=62.316, qy=60.324, tol=1e-10),
-            xt.TargetSet(line='lhcb2', dqx=9.0, dqy=11.0, tol=1e-5)])
+            xt.TargetSet(line='lhcb1', qx=62.315, qy=60.325, tol=1e-6),
+            xt.TargetSet(line='lhcb1', dqx=10.0, dqy=12.0, tol=1e-4),
+            xt.TargetSet(line='lhcb2', qx=62.316, qy=60.324, tol=1e-6),
+            xt.TargetSet(line='lhcb2', dqx=9.0, dqy=11.0, tol=1e-4)])
     opt.solve()
 
     # Transfer knobs to madx model and check matched values

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_line.py

@@ -1075,3 +1075,21 @@ def test_get_strengths(test_context):
     xo.assert_allclose(line['mbw.a6l3.b2'].h,
             str_table['angle_rad', 'mbw.a6l3.b2'] / str_table['length', 'mbw.a6l3.b2'],
             rtol=0, atol=1e-14)
+
+
+
+def test_insert_repeated_names():
+
+    line = xt.Line(
+        elements=([xt.Drift(length=0)] # Start line marker
+                    + [xt.Drift(length=1) for _ in range(5)]
+                    + [xt.Drift(length=0)] # End line marker
+            ),
+        element_names=['d']*7
+        )
+    line.insert_element("m1",xt.Marker(),at="d::3")
+    assert line.element_names[3]=="m1"
+    line.insert_element("m2",xt.Marker(),at="d")
+    assert line.element_names[0]=="m2"
+
+

xtrack-0.70.1/tests/test_madnginterface.py

@@ -0,0 +1,98 @@
+import xtrack as xt
+import xobjects as xo
+import pathlib
+import numpy as np
+
+test_data_folder = pathlib.Path(
+    __file__).parent.joinpath('../test_data').absolute()
+
+def test_madng_twiss():
+    rdts = ["f4000", "f3100", "f2020", "f1120", 'f1001']
+
+    line = xt.Line.from_json(test_data_folder /
+                            'hllhc15_thick/lhc_thick_with_knobs.json')
+
+    line['test_dk1'] = 0
+    line['mb.b32l8.b1'].knl[1] = 'test_dk1'
+
+    tw = line.madng_twiss(normal_form=False)
+
+    opt = line.match(
+        solve=False,
+        vary=[
+            xt.Vary('on_x1', step=1e-3),
+        ],
+        targets=(
+            tw.target('px_ng', 50e-6, at='ip1'),
+            tw.target('py_ng', 0, at='ip1'),
+        ),
+    )
+    opt.step(3)
+    tw_after = line.madng_twiss(normal_form=False)
+    xo.assert_allclose(tw_after['px_ng', 'ip1'], 50e-6, rtol=5e-3, atol=0)
+
+    line['on_x1'] = 1.
+    xo.assert_allclose(line.madng_twiss()['px_ng', 'ip1'], 1e-6, rtol=5e-3, atol=0)
+
+    line['on_x1'] = -2.
+    xo.assert_allclose(line.madng_twiss()['px_ng', 'ip1'], -2e-6, rtol=5e-3, atol=0)
+
+    # We just check that rdts are there
+    tw_rdt = line.madng_twiss(rdts=rdts)
+    assert np.abs(tw_rdt.f4000).max() > 0
+    assert np.abs(tw_rdt.f3100).max() > 0
+    assert np.abs(tw_rdt.f2020).max() > 0
+    assert np.abs(tw_rdt.f1120).max() > 0
+
+def test_madng_interface_with_multipole_errors_and_misalignments():
+    line = xt.Line.from_json(test_data_folder /
+                            'hllhc15_thick/lhc_thick_with_knobs.json')
+
+    tt = line.get_table()
+    tt_quads = tt.rows[tt.element_type=='Quadrupole']
+
+    # Introduce misalignments on all quadrupoles
+    tt = line.get_table()
+    tt_quad = tt.rows['mq\..*']
+    rgen = np.random.RandomState(1) # fix seed for random number generator
+                                    # (to have reproducible results)
+    shift_x = rgen.randn(len(tt_quad)) * 0.01e-3 # 0.01 mm rms shift on all quads
+    shift_y = rgen.randn(len(tt_quad)) * 0.01e-3 # 0.01 mm rms shift on all quads
+    rot_s = rgen.randn(len(tt_quad)) * 1e-3 # 1 mrad rms rotation on all quads
+    k2l = rgen.rand(len(tt_quad)) * 1e-3
+
+    line['on_error'] = 1.
+    for nn_quad, sx, sy, rr, kkk in zip(tt_quad.name, shift_x, shift_y, rot_s, k2l):
+        line[nn_quad].shift_x = sx * line.ref['on_error']
+        line[nn_quad].shift_y = sy * line.ref['on_error']
+        line[nn_quad].rot_s_rad = rr * line.ref['on_error']
+        line[nn_quad].knl[2] = kkk * line.ref['on_error']
+    tw = line.madng_twiss()
+
+    xo.assert_allclose(tw.x, tw.x_ng, atol=5e-4*tw.x.std(), rtol=0)
+    xo.assert_allclose(tw.y, tw.y_ng, atol=5e-4*tw.y.std(), rtol=0)
+    xo.assert_allclose(tw.betx2, tw.beta12_ng, atol=0, rtol=2e-3)
+    xo.assert_allclose(tw.bety1, tw.beta21_ng, atol=0, rtol=2e-3)
+    xo.assert_allclose(tw.wx_chrom, tw.wx_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.wy_chrom, tw.wy_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.ax_chrom, tw.ax_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.ay_chrom, tw.ay_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.bx_chrom, tw.bx_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.by_chrom, tw.by_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)
+
+    line['on_error'] = 0
+    tw = line.madng_twiss()
+    xo.assert_allclose(tw.x, 0, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.y, 0, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.betx2, 0, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.bety1, 0, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.x, tw.x_ng, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.y, tw.y_ng, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.betx2, tw.beta12_ng, atol=1e-10, rtol=0)
+    xo.assert_allclose(tw.bety1, tw.beta21_ng, atol=1e-19, rtol=0)
+    xo.assert_allclose(tw.wx_chrom, tw.wx_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.wy_chrom, tw.wy_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.ax_chrom, tw.ax_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.ay_chrom, tw.ay_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.bx_chrom, tw.bx_ng, atol=5e-3*tw.wx_chrom.max(), rtol=0)
+    xo.assert_allclose(tw.by_chrom, tw.by_ng, atol=5e-3*tw.wy_chrom.max(), rtol=0)

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_match_nested.py

@@ -166,7 +166,7 @@ def test_match_nested(test_context):
             xd.Vary(name='kqf.a67', container=collider.vars, step=1e-5),
             xd.Vary(name='kqd.a67', container=collider.vars, step=1e-5),
         ])
-    optimize_phase_arc_67.solve()
+    optimize_phase_arc_67.solve(n_steps=5)
 
     # Checks
     resb1_after = action_arc_phase_s67_b1.run()

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_match_optics_and_ip_knob.py

@@ -184,16 +184,17 @@ def test_ip_knob_matching(test_context):
     assert np.all(np.array(vactive) == np.array(
         [True, True, True, True, True, True, True, True, False, False, False, False, False, False]))
 
+    assert len(opt.log()) == 1
     opt.step(10) # perform 10 steps without checking for convergence
 
     ll = opt.log()
-    assert len(ll) == 11
+    assert len(ll) == 13
     assert ll['vary_active', 0] == 'yyyyyyyyyyyyyy'
     assert ll['vary_active', 1] == 'yyyyyyyynnnnnn'
-    assert ll['vary_active', 10] == 'yyyyyyyynnnnnn'
+    assert ll['vary_active', 11] == 'yyyyyyyynnnnnn'
 
     # Check solution not found
-    assert ll['tol_met', 10] != 'yyyyyyyy'
+    assert ll['tol_met', 12] != 'yyyyyyyy'
 
     # Check that mcbxs did not move
     xo.assert_allclose(ll['vary_8', 1:], init_mcbx_plus, atol=1e-12, rtol=0)
@@ -219,17 +220,17 @@ def test_ip_knob_matching(test_context):
     ll = opt.log()
 
     # Check driving knob is enabled
-    assert np.all(ll['vary_active', 11:] == 'yyyyyyyyynnnnn')
+    assert np.all(ll['vary_active', 13:] == 'yyyyyyyyynnnnn')
 
     # Check solution found
     assert np.all(ll['tol_met', -1] == 'yyyyyyyy')
 
     # Check imposed relationship among varys
-    xo.assert_allclose(ll['vary_8', 11], ll['vary_9', 11], atol=1e-12, rtol=0)
-    xo.assert_allclose(ll['vary_8', 11], ll['vary_10', 11], atol=1e-12, rtol=0)
-    xo.assert_allclose(ll['vary_8', 11], -ll['vary_11', 11], atol=1e-12, rtol=0)
-    xo.assert_allclose(ll['vary_8', 11], -ll['vary_12', 11], atol=1e-12, rtol=0)
-    xo.assert_allclose(ll['vary_8', 11], -ll['vary_13', 11], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], ll['vary_9', 13], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], ll['vary_10', 13], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], -ll['vary_11', 13], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], -ll['vary_12', 13], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], -ll['vary_13', 13], atol=1e-12, rtol=0)
 
     opt.generate_knob()
 

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_match_optics_and_ip_knob_new_optimize_api.py

@@ -187,13 +187,13 @@ def test_ip_knob_matching_new_optimize_api(test_context):
     opt.step(10) # perform 10 steps without checking for convergence
 
     ll = opt.log()
-    assert len(ll) == 11
+    assert len(ll) == 13
     assert ll['vary_active', 0] == 'yyyyyyyyyyyyyy'
     assert ll['vary_active', 1] == 'yyyyyyyynnnnnn'
-    assert ll['vary_active', 10] == 'yyyyyyyynnnnnn'
+    assert ll['vary_active', 12] == 'yyyyyyyynnnnnn'
 
     # Check solution not found
-    assert ll['tol_met', 10] != 'yyyyyyyy'
+    assert ll['tol_met', 11] != 'yyyyyyyy'
 
     # Check that mcbxs did not move
     xo.assert_allclose(ll['vary_8', 1:], init_mcbx_plus, atol=1e-12, rtol=0)
@@ -219,17 +219,17 @@ def test_ip_knob_matching_new_optimize_api(test_context):
     ll = opt.log()
 
     # Check driving knob is enabled
-    assert np.all(ll['vary_active', 11:] == 'yyyyyyyyynnnnn')
+    assert np.all(ll['vary_active', 13:] == 'yyyyyyyyynnnnn')
 
     # Check solution found
     assert np.all(ll['tol_met', -1] == 'yyyyyyyy')
 
     # Check imposed relationship among varys
-    xo.assert_allclose(ll['vary_8', 11], ll['vary_9', 11], atol=1e-12, rtol=0)
-    xo.assert_allclose(ll['vary_8', 11], ll['vary_10', 11], atol=1e-12, rtol=0)
-    xo.assert_allclose(ll['vary_8', 11], -ll['vary_11', 11], atol=1e-12, rtol=0)
-    xo.assert_allclose(ll['vary_8', 11], -ll['vary_12', 11], atol=1e-12, rtol=0)
-    xo.assert_allclose(ll['vary_8', 11], -ll['vary_13', 11], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], ll['vary_9',   13], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], ll['vary_10',  13], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], -ll['vary_11', 13], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], -ll['vary_12', 13], atol=1e-12, rtol=0)
+    xo.assert_allclose(ll['vary_8', 13], -ll['vary_13', 13], atol=1e-12, rtol=0)
 
     opt.generate_knob()
 

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_match_orbit_bump.py

@@ -856,3 +856,188 @@ def test_match_bump_common_elements_targets_from_tables(test_context):
     xo.assert_allclose(tw.lhcb2['py', 'ip5'] + tw.lhcb1['py', 'ip5'], 0, rtol=0, atol=1e-10)
     xo.assert_allclose(tw.lhcb2['y', 's.ds.r5.b2'], 0, rtol=0, atol=1e-9)
     xo.assert_allclose(tw.lhcb2['py', 's.ds.r5.b2'], 0, rtol=0, atol=1e-9)
+
+@for_all_test_contexts
+def test_match_bump_clone_and_ref_in_inequality(test_context):
+
+    line = xt.Line.from_json(test_data_folder /
+                            'hllhc14_no_errors_with_coupling_knobs/line_b1.json')
+    line.build_tracker(test_context)
+
+    GreaterThan = xt.GreaterThan
+    LessThan = xt.LessThan
+
+    tw0 = line.twiss()
+    opt = line.match(
+        name='bump',
+        solve=False,
+        solver='jacobian',
+        # Portion of the beam line to be modified and initial conditions
+        start='mq.33l8.b1',
+        end='mq.17l8.b1',
+        init=tw0, init_at=xt.START,
+        # Dipole corrector strengths to be varied
+        vary=[
+            xt.Vary(name='acbv32.l8b1', step=1e-10, weight=0.7),
+            xt.Vary(name='acbv28.l8b1', step=1e-10, weight=0.3),
+            xt.Vary(name='acbv26.l8b1', step=1e-10),
+            xt.Vary(name='acbv24.l8b1', step=1e-10),
+            xt.Vary(name='acbv22.l8b1', step=1e-10, weight=1000),
+            xt.Vary(name='acbv18.l8b1', step=1e-10),
+        ],
+        targets=[
+            xt.Target('py', at='mb.b26l8.b1', value=0, tol=1e-6, weight=1e3),
+            xt.Target('y', at='mb.b26l8.b1', value=3e-3, tol=1e-4),
+            xt.Target('y', at='mq.17l8.b1', value=tw0, tol=1e-6),
+            xt.Target('py', at='mq.17l8.b1', value=tw0, tol=1e-7, weight=1e3),
+        ]
+    )
+
+    # Check target_mismatch
+    assert opt.name == 'bump'
+    ts = opt.target_status(ret=True)
+    assert len(ts) == 4
+    assert np.all(ts.tol_met == np.array([True, False, True, True]))
+    tm = opt.target_mismatch(ret=True)
+    assert len(tm) == 1
+    assert tm.id[0] == 1
+
+    opt.solve()
+
+    # I want to limit the negative excursion ot the bump
+    opt2 = opt.clone(name='limit',
+        add_targets=[
+            xt.Target('y', GreaterThan(-2e-3), at='mq.30l8.b1', tol=1e-6),
+            xt.Target('y', GreaterThan(-1e-3), at='mq.30l8.b1', tol=1e-6)])
+    opt2.solve()
+
+    assert opt2.name == 'limit'
+    assert len(opt2.targets) == 6
+    tm = opt2.target_mismatch(ret=True)
+    assert(len(tm) == 0)
+
+    tw = line.twiss()
+
+    assert np.isclose(tw['y', 'mq.33l8.b1'], 0, atol=1e-6, rtol=0)
+    assert np.isclose(tw['y', 'mq.17l8.b1'], 0, atol=1e-6, rtol=0)
+    assert np.isclose(tw['py', 'mq.17l8.b1'], 0, atol=1e-8, rtol=0)
+    assert np.isclose(tw['py', 'mq.33l8.b1'], 0, atol=1e-6, rtol=0)
+
+    assert np.isclose(tw['y', 'mb.b26l8.b1'], 3e-3, atol=1e-6, rtol=0)
+    assert np.isclose(tw['py', 'mb.b26l8.b1'], 0, atol=1e-8, rtol=0)
+
+    assert np.isclose(tw['y', 'mq.30l8.b1'], -1e-3, atol=1e-6, rtol=0)
+
+    # Test variable in inequality
+    line['myvar'] = -5e-3
+    line['myvar2'] = 4e-3
+    opt3 = opt2.clone(name='ineq',
+        add_targets=[
+            xt.Target('y', GreaterThan(line.ref['myvar']), at='mq.30l8.b1', tol=1e-6),
+            xt.Target('y', LessThan(line.ref['myvar2']), at='mb.b26l8.b1', tol=1e-6)])
+
+    assert len(opt3.target_mismatch(ret=True)) == 0
+    assert opt3.target_status(ret=True).residue[-1] == 0
+
+    line['myvar'] = -0.5e-3
+    line['myvar2'] = 2e-3
+    opt3.disable(target=1)
+    assert len(opt3.target_mismatch(ret=True)) == 2
+    xo.assert_allclose(opt3.target_mismatch(ret=True).residue[-2], -0.5e-3,
+                    atol=1e-5, rtol=0)
+    xo.assert_allclose(opt3.target_mismatch(ret=True).residue[-1], -1e-3,
+                    atol=1e-5, rtol=0)
+
+    opt3.solve()
+    assert len(opt3.target_mismatch(ret=True)) == 1 # The disabled target
+    assert opt3.target_mismatch(ret=True).id[0] == 1
+
+    tw = line.twiss()
+
+    assert np.isclose(tw['y', 'mq.33l8.b1'], 0, atol=1e-6, rtol=0)
+    assert np.isclose(tw['y', 'mq.17l8.b1'], 0, atol=1e-6, rtol=0)
+    assert np.isclose(tw['py', 'mq.17l8.b1'], 0, atol=1e-8, rtol=0)
+    assert np.isclose(tw['py', 'mq.33l8.b1'], 0, atol=1e-6, rtol=0)
+
+    assert np.isclose(tw['y', 'mb.b26l8.b1'], 2e-3, atol=1e-6, rtol=0)
+    assert np.isclose(tw['py', 'mb.b26l8.b1'], 0, atol=1e-8, rtol=0)
+
+    assert np.isclose(tw['y', 'mq.30l8.b1'], -0.5e-3, atol=1e-6, rtol=0)
+
+
+def test_match_autogen_tags_and_clone_options():
+
+    line = xt.Line.from_json(test_data_folder /
+        "hllhc15_thick/lhc_thick_with_knobs.json")
+
+    opt = line.match(
+        start='mq.30l8.b1', end='mq.23l8.b1',
+        betx=1, bety=1, y=0, py=0,
+        vary=[xt.VaryList(['acbv30.l8b1', 'acbv28.l8b1',],
+                        step=1e-10, limits=[-1e-3, 1e-3]),
+            xt.VaryList(['acbv26.l8b1', 'acbv24.l8b1'],
+                        step=1e-10, limits=[-1e-3, 1e-3], tag='mytag')],
+        targets = [
+            xt.TargetSet(y=3e-3, py=0, at='mb.b28l8.b1'),
+            xt.TargetSet(y=0, py=0, at=xt.END)
+        ])
+
+    # Check autogenerated tags
+    assert opt.targets[0].tag == 'mb.b28l8.b1_y'
+    assert opt.targets[1].tag == 'mb.b28l8.b1_py'
+    assert opt.targets[2].tag == 'END_y'
+    assert opt.targets[3].tag == 'END_py'
+
+    # Check target getitem
+    assert opt.targets[0] == opt.targets['mb.b28l8.b1_y']
+    assert opt.targets[1] == opt.targets['mb.b28l8.b1_py']
+    assert opt.targets[2] == opt.targets['END_y']
+    assert opt.targets[3] == opt.targets['END_py']
+
+    assert opt.targets['END.*'][0] is opt.targets[2]
+    assert opt.targets['END.*'][1] is opt.targets[3]
+
+    assert np.all(
+        opt.targets.status(ret=True).tag == opt.target_status(ret=True).tag)
+
+    assert opt.vary['myt.*'][0] is opt.vary[2]
+    assert opt.vary['myt.*'][1] is opt.vary[3]
+    assert np.all(opt.vary.status(ret=True).tag == np.array(['', '', 'mytag', 'mytag']))
+    assert np.all(opt.vary.status(ret=True).tag == opt.vary_status(ret=True).tag)
+    assert np.all(opt.vary.status(ret=True).name == np.array(
+        ['acbv30.l8b1', 'acbv28.l8b1', 'acbv26.l8b1', 'acbv24.l8b1']))
+
+    opt1 = opt.clone(name='opt1')
+    assert opt1.name == 'opt1'
+    assert str(opt1.targets[0]) == str(opt.targets[0])
+    assert str(opt1.targets[1]) == str(opt.targets[1])
+    assert str(opt1.targets[2]) == str(opt.targets[2])
+    assert str(opt1.targets[3]) == str(opt.targets[3])
+    assert str(opt1.vary[0]) == str(opt.vary[0])
+    assert str(opt1.vary[1]) == str(opt.vary[1])
+    assert str(opt1.vary[2]) == str(opt.vary[2])
+    assert str(opt1.vary[3]) == str(opt.vary[3])
+
+    opt2 = opt.clone(name='opt2', remove_vary=True)
+    assert len(opt2.vary) == 0
+    assert str(opt2.targets[0]) == str(opt.targets[0])
+    assert str(opt2.targets[1]) == str(opt.targets[1])
+    assert str(opt2.targets[2]) == str(opt.targets[2])
+    assert str(opt2.targets[3]) == str(opt.targets[3])
+
+    opt3 = opt.clone(name='opt3', remove_targets=True,
+                    add_targets=[xt.TargetSet(y=3e-3, py=0, at='mb.b28l8.b1')])
+    assert len(opt3.targets) == 2
+    assert opt.targets[0].tag == 'mb.b28l8.b1_y'
+    assert opt.targets[1].tag == 'mb.b28l8.b1_py'
+    assert str(opt3.vary[0]) == str(opt.vary[0])
+    assert str(opt3.vary[1]) == str(opt.vary[1])
+    assert str(opt3.vary[2]) == str(opt.vary[2])
+    assert str(opt3.vary[3]) == str(opt.vary[3])
+
+    opt4 = opt.clone(name='opt4', remove_vary=True, remove_targets=False,
+                        add_vary=xt.VaryList(['acbv30.l8b1', 'acbv28.l8b1']),
+                        )
+    assert len(opt4.vary) == 2
+    assert opt.vary[0].name == 'acbv30.l8b1'
+    assert opt.vary[1].name == 'acbv28.l8b1'

{xtrack-0.69.7 → xtrack-0.70.1}/tests/test_match_tune_chroma_cminus.py

@@ -1,6 +1,7 @@
 import json
 import pathlib
 import time
+from scipy.optimize import minimize
 
 import xobjects as xo
 import xpart as xp
@@ -130,6 +131,67 @@ def test_match_tune_chromaticity(test_context):
     xo.assert_allclose(tw_final['dqx'],  6.0, atol=0.05)
     xo.assert_allclose(tw_final['dqy'],  4.0, atol=0.05)
 
+@for_all_test_contexts
+def test_match_tune_chromaticity_scalar(test_context):
+
+    with open(path_line) as f:
+        dct = json.load(f)
+
+    line = xt.Line.from_dict(dct['line'])
+    line.particle_ref = xp.Particles.from_dict(dct['particle'])
+
+    line.build_tracker(_context=test_context)
+
+    print('\nInitial twiss parameters')
+    tw_before = line.twiss()
+    print(f"Qx = {tw_before['qx']:.5f} Qy = {tw_before['qy']:.5f} "
+        f"Q'x = {tw_before['dqx']:.5f} Q'y = {tw_before['dqy']:.5f}")
+
+    print(f"kqtf.b1 = {line.vars['kqtf.b1']._value}")
+    print(f"kqtd.b1 = {line.vars['kqtd.b1']._value}")
+    print(f"ksf.b1 = {line.vars['ksf.b1']._value}")
+    print(f"ksd.b1 = {line.vars['ksd.b1']._value}")
+
+    t1 = time.time()
+    opt = line.match(
+        solve=False,
+        vary=[
+            xt.Vary('kqtf.b1', step=1e-8),
+            xt.Vary('kqtd.b1', step=1e-8),
+            xt.Vary('ksf.b1', step=1e-8),
+            xt.Vary('ksd.b1', step=1e-8),
+        ],
+        targets = [
+            xt.Target('qx', 62.315, tol=1e-4),
+            xt.Target('qy', 60.325, tol=1e-4),
+            xt.Target('dqx', 10.0, tol=0.05),
+            xt.Target('dqy', 12.0, tol=0.05)])
+
+    merit_function = opt.get_merit_function(return_scalar=True, check_limits=False)
+    opt.check_limits = False
+    bounds = [(-1e-4, 1e-4), (-1e-4, 1e-4), (-10, 10), (-10, 10)]
+    x0 = merit_function.get_x()
+
+    result = minimize(merit_function, x0=x0, bounds=bounds, jac=merit_function.get_jacobian, method='L-BFGS-B')
+
+    t2 = time.time()
+    print('\nTime fsolve: ', t2-t1)
+
+    merit_function.set_x(result.x)
+
+    tw_final = line.twiss()
+    print('\nFinal twiss parameters')
+    print(f"Qx = {tw_final['qx']:.5f} Qy = {tw_final['qy']:.5f} "
+        f"Q'x = {tw_final['dqx']:.5f} Q'y = {tw_final['dqy']:.5f}")
+    print(f"kqtf.b1 = {line.vars['kqtf.b1']._value}")
+    print(f"kqtd.b1 = {line.vars['kqtd.b1']._value}")
+    print(f"ksf.b1 = {line.vars['ksf.b1']._value}")
+    print(f"ksd.b1 = {line.vars['ksd.b1']._value}")
+
+    xo.assert_allclose(tw_final['qx'], 62.315, atol=1e-7)
+    xo.assert_allclose(tw_final['qy'], 60.325, atol=1e-7)
+    xo.assert_allclose(tw_final['dqx'], 10.0, atol=0.05)
+    xo.assert_allclose(tw_final['dqy'], 12.0, atol=0.05)
 
 @for_all_test_contexts
 def test_match_coupling(test_context):