xtrack 0.70.0__tar.gz → 0.70.2__tar.gz

{xtrack-0.70.0/xtrack.egg-info → xtrack-0.70.2}/PKG-INFO

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

xtrack-0.70.2/tests/test_h6_sps_beamline.py

@@ -0,0 +1,73 @@
+import pathlib
+from cpymad.madx import Madx
+import numpy as np
+import xtrack as xt
+import xobjects as xo
+
+test_data_folder = pathlib.Path(
+    __file__).parent.joinpath('../test_data').absolute()
+
+def test_h6_sps_beamline():
+
+    '''
+    This checks the parsing of a sequence defined in madx with refer=exit
+    and the TwissTable.get_R_matrix_table() method
+    '''
+
+    lattice_path = test_data_folder / 'h6_experimental_line/h6-fm.str'
+    sequence_path = test_data_folder / 'h6_experimental_line/h6fm04.seq'
+
+    mad = Madx()
+    mad.call(str(lattice_path))
+    mad.call(str(sequence_path))
+
+    mad.input('''
+    beam, particle=proton, sequence=H6, PC=120.0,
+        ex = 2e-07,
+        ey = 5e-08;
+
+    use, sequence=H6;
+    twiss, chrom=true, rmatrix=true, betx=10, alfx=0, bety=10, alfy=0;
+    ''')
+    tw_mad = xt.Table(mad.table.twiss)
+
+    env = xt.load_madx_lattice(sequence_path)
+    env.vars.load_madx(lattice_path)
+    line = env['h6']
+    line.particle_ref = xt.Particles(p0c=120e9, mass0=xt.PROTON_MASS_EV)
+    tt = line.get_table(attr=True)
+    line.configure_bend_model(edge='full')
+
+    tw = line.twiss(betx=10, bety=10)
+
+    check_at = [
+    't4..centre',
+    'vxsv.x0410104',
+    'begin.vac',
+    'xwca.x0410404',
+    'xsci.x0410475',
+    'xemc.x0410476',
+    'xdwc.x0410488',
+    'h6a',
+    'h6b',
+    'h6c']
+
+    tw_check = tw.rows[check_at]
+    tw_mad_check = tw_mad.rows[[nn+':1' for nn in check_at]]
+
+    xo.assert_allclose(tw_check.betx, tw_mad_check.betx, rtol=2e-5, atol=0)
+    xo.assert_allclose(tw_check.bety, tw_mad_check.bety, rtol=2e-5, atol=0)
+    xo.assert_allclose(tw_check.dx, tw_mad_check.dx, rtol=2e-5, atol=1e-4)
+    xo.assert_allclose(tw_check.dy, tw_mad_check.dy, rtol=2e-5, atol=1e-4)
+
+    trm = tw.get_R_matrix_table()
+    trm_check = trm.rows[check_at]
+
+    for ii in range(6):
+        for jj in range(6):
+            rterm_mad = tw_mad_check[f're{ii+1}{jj+1}']
+            rterm_xs = trm_check[f'r{ii+1}{jj+1}']
+            atol=1e-4*np.max(np.abs(rterm_mad))
+            if atol<1e-14:
+                atol=1e-14
+            xo.assert_allclose(rterm_xs, rterm_mad, rtol=2e-5, atol=atol)

{xtrack-0.70.0 → xtrack-0.70.2}/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.70.0 → xtrack-0.70.2}/tests/test_madnginterface.py

@@ -1,3 +1,4 @@
+import pytest
 import xtrack as xt
 import xobjects as xo
 import pathlib
@@ -6,6 +7,7 @@ import numpy as np
 test_data_folder = pathlib.Path(
     __file__).parent.joinpath('../test_data').absolute()
 
+@pytest.mark.xfail(strict=False) # sometimes madng fails to start the process (to be investigated)
 def test_madng_twiss():
     rdts = ["f4000", "f3100", "f2020", "f1120", 'f1001']
 
@@ -44,6 +46,7 @@ def test_madng_twiss():
     assert np.abs(tw_rdt.f2020).max() > 0
     assert np.abs(tw_rdt.f1120).max() > 0
 
+@pytest.mark.xfail(strict=False) # sometimes madng fails to start the process (to be investigated)
 def test_madng_interface_with_multipole_errors_and_misalignments():
     line = xt.Line.from_json(test_data_folder /
                             'hllhc15_thick/lhc_thick_with_knobs.json')

{xtrack-0.70.0 → xtrack-0.70.2}/tests/test_new_madloader.py

@@ -237,7 +237,7 @@ def test_vkick(example_sequence):
     assert vk1.length == 2
     assert vk1.knl[0] == 0
     assert vk1.ksl[0] == 3
-    assert vk1.rot_s_rad == -1
+    xo.assert_allclose(vk1.rot_s_rad, -1)
 
 
 def test_hkick(example_sequence):
@@ -259,7 +259,7 @@ def test_kick(example_sequence):
     assert ki1.length == 2
     assert ki1.knl[0] == -4
     assert ki1.ksl[0] == 3
-    assert ki1.rot_s_rad == 1
+    xo.assert_allclose(ki1.rot_s_rad, 1)
 
 
 def test_tkick(example_sequence):
@@ -482,7 +482,7 @@ def test_reversed_vkick(example_sequence):
     assert ivk1.length == 2
     assert ivk1.knl[0] == 0
     assert ivk1.ksl[0] == -3
-    assert ivk1.rot_s_rad == 1
+    xo.assert_allclose(ivk1.rot_s_rad,  1)
 
 
 def test_reversed_hkick(example_sequence):
@@ -504,7 +504,7 @@ def test_reversed_kick(example_sequence):
     assert ki1.length == 2
     assert ki1.knl[0] == -4
     assert ki1.ksl[0] == -3
-    assert ki1.rot_s_rad == -1
+    xo.assert_allclose(ki1.rot_s_rad, -1)
 
 
 def test_reversed_tkick(example_sequence):

{xtrack-0.70.0 → xtrack-0.70.2}/tests/test_trajectory_correcton.py

@@ -22,7 +22,8 @@ def test_orbit_correction_basics(test_context):
 
     # Define elements to be used as monitors for orbit correction
     # (for LHC all element names starting by "bpm" and not ending by "_entry" or "_exit")
-    tt_monitors = tt.rows['bpm.*'].rows['.*(?<!_entry)$'].rows['.*(?<!_exit)$']
+    #tt_monitors = tt.rows['bpm.*'].rows['.*(?<!_entry)$'].rows['.*(?<!_exit)$']
+    tt_monitors = tt.rows['bpm.*','.*(?<!_entry)$','.*(?<!_exit)$']
     line.steering_monitors_x = tt_monitors.name
     line.steering_monitors_y = tt_monitors.name
 

{xtrack-0.70.0 → xtrack-0.70.2}/xtrack/__init__.py

@@ -44,6 +44,7 @@ from .line import _lines_equal, _apertures_equal
 from .slicing import Strategy, Uniform, Teapot
 from .loss_location_refinement import _skip_in_loss_location_refinement
 from .trajectory_correction import TrajectoryCorrection
+from .mad_parser.loader import load_madx_lattice
 
 from xdeps import Table, FunctionPieceWiseLinear
 

xtrack-0.70.2/xtrack/_version.py

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

{xtrack-0.70.0 → xtrack-0.70.2}/xtrack/environment.py

@@ -26,14 +26,18 @@ def _argsort(seq, tol=10e-10):
 
 
 def _flatten_components(components, refer: ReferType = 'centre'):
-    if refer not in {'entry', 'centre'}:
+    if refer not in {'entry', 'centre', 'exit'}:
         raise ValueError(
-            f'Allowed values for refer are "entry" and "centre". Got "{refer}".'
+            f'Allowed values for refer are "entry", "centre" and "exit". Got "{refer}".'
         )
 
     flatt_components = []
     for nn in components:
         if isinstance(nn, Place) and isinstance(nn.name, xt.Line):
+            if refer == 'exit':
+                raise NotImplementedError(
+                    'Refer "exit" is not yet implemented for lines.'
+                )
             line = nn.name
             if not line.element_names:
                 continue
@@ -465,6 +469,7 @@ def _resolve_s_positions(seq_all_places, env, refer: ReferType = 'center'):
 
     s_center_for_place = {}
     s_entry_for_place = {}  # entry positions calculated assuming at is also pointing to entry
+    s_exit_for_place = {}  # exit positions calculated assuming at is also pointing to exit
     place_for_name = {}
     n_resolved = 0
     n_resolved_prev = -1
@@ -475,6 +480,7 @@ def _resolve_s_positions(seq_all_places, env, refer: ReferType = 'center'):
         # In case we want to allow for the length to be an expression
         s_center_for_place[seq_all_places[0]] = aux_tt['length', seq_all_places[0].name] / 2
         s_entry_for_place[seq_all_places[0]] = 0
+        s_exit_for_place[seq_all_places[0]] = aux_tt['length', seq_all_places[0].name]
         place_for_name[seq_all_places[0].name] = seq_all_places[0]
         n_resolved += 1
 
@@ -495,6 +501,8 @@ def _resolve_s_positions(seq_all_places, env, refer: ReferType = 'center'):
                                               + aux_tt['length', ss.name] / 2)
                     s_entry_for_place[ss] = (s_entry_for_place[ss_prev]
                                              + aux_tt['length', ss_prev.name])
+                    s_exit_for_place[ss] = (s_exit_for_place[ss_prev]
+                                            + aux_tt['length', ss.name])
                     place_for_name[ss.name] = ss
                     n_resolved += 1
             elif ss.at is None and ss._before:
@@ -509,6 +517,8 @@ def _resolve_s_positions(seq_all_places, env, refer: ReferType = 'center'):
                                               - aux_tt['length', ss.name] / 2)
                     s_entry_for_place[ss] = (s_entry_for_place[ss_next]
                                             - aux_tt['length', ss.name])
+                    s_exit_for_place[ss] = (s_exit_for_place[ss_next]
+                                            - aux_tt['length', ss_next.name])
                     place_for_name[ss.name] = ss
                     n_resolved += 1
             else:
@@ -520,6 +530,7 @@ def _resolve_s_positions(seq_all_places, env, refer: ReferType = 'center'):
                 if ss.from_ is None:
                     s_center_for_place[ss] = at
                     s_entry_for_place[ss] = at
+                    s_exit_for_place[ss] = at
                     place_for_name[ss.name] = ss
                     n_resolved += 1
                 elif ss.from_ in place_for_name:
@@ -528,11 +539,12 @@ def _resolve_s_positions(seq_all_places, env, refer: ReferType = 'center'):
                             f'Cannot resolve from_ for {ss.name} as {ss.from_} is duplicated')
                     s_center_for_place[ss] = s_center_for_place[place_for_name[ss.from_]] + at
                     s_entry_for_place[ss] = s_entry_for_place[place_for_name[ss.from_]] + at
+                    s_exit_for_place[ss] = s_exit_for_place[place_for_name[ss.from_]] + at
                     place_for_name[ss.name] = ss
                     n_resolved += 1
 
     if n_resolved != len(seq_all_places):
-        unresolved_pos = set(seq_all_places) - set(s_center_dct.keys())
+        unresolved_pos = set(seq_all_places) - set(s_center_for_place.keys())
         raise ValueError(f'Could not resolve all s positions: {unresolved_pos}')
 
     if n_resolved != len(seq_all_places):
@@ -541,8 +553,10 @@ def _resolve_s_positions(seq_all_places, env, refer: ReferType = 'center'):
 
     aux_s_center_expr = np.array([s_center_for_place[ss] for ss in seq_all_places])
     aux_s_entry_expr = np.array([s_entry_for_place[ss] for ss in seq_all_places])
+    aux_s_exit_expr = np.array([s_exit_for_place[ss] for ss in seq_all_places])
     aux_s_center = [ss._value if is_ref(ss) else ss for ss in aux_s_center_expr]
     aux_s_entry = [ss._value if is_ref(ss) else ss for ss in aux_s_entry_expr]
+    aux_s_exit = [ss._value if is_ref(ss) else ss for ss in aux_s_exit_expr]
 
     if refer == 'centre':
         aux_tt['s_center'] = np.concatenate([aux_s_center, [0]])
@@ -572,6 +586,20 @@ def _resolve_s_positions(seq_all_places, env, refer: ReferType = 'center'):
         tt_sorted['s_center'] = tt_sorted['s_entry'] + tt_sorted['length'] / 2
         tt_sorted['s_exit'] = tt_sorted['s_entry'] + tt_sorted['length']
         anchor_pos_dct = s_entry_for_place
+    elif refer == 'exit':
+        aux_tt['s_exit'] = np.concatenate([aux_s_exit, [0]])
+
+        i_sorted = _argsort(aux_s_exit)
+
+        name_sorted = [str(aux_tt.name[ii]) for ii in i_sorted]
+
+        # Temporary, should be replaced by aux_tt.rows[i_sorted], when table is fixed
+        data_sorted = {kk: aux_tt[kk][i_sorted] for kk in aux_tt._col_names}
+        tt_sorted = xt.Table(data_sorted)
+
+        tt_sorted['s_center'] = tt_sorted['s_exit'] - tt_sorted['length'] / 2
+        tt_sorted['s_entry'] = tt_sorted['s_exit'] - tt_sorted['length']
+        anchor_pos_dct = s_entry_for_place
     else:
         raise ValueError(f'Unknown refer value: {refer}')
 

{xtrack-0.70.0 → xtrack-0.70.2}/xtrack/line.py

@@ -4993,6 +4993,8 @@ class LineVars:
     def load_madx_optics_file(self, filename, mad_stdout=False):
         self.set_from_madx_file(filename, mad_stdout=mad_stdout)
 
+    load_madx = load_madx_optics_file
+
     def load_json(self, filename):
 
         with open(filename, 'r') as fid:

{xtrack-0.70.0 → xtrack-0.70.2}/xtrack/mad_parser/loader.py

@@ -126,6 +126,8 @@ class MadxLoader:
         self._new_builtin("ecollimator", "Drift")
         self._new_builtin("instrument", "Drift")
         self._new_builtin("monitor", "Drift")
+        self._new_builtin("hmonitor", "Drift")
+        self._new_builtin("vmonitor", "Drift")
         self._new_builtin("placeholder", "Drift")
         self._new_builtin("sbend", "Bend")  # no rbarc since we don't have an angle
         self._new_builtin("rbend", "Bend", rbend=True)
@@ -304,7 +306,11 @@ class MadxLoader:
                 name = self.env.new_line([drift_name, name, drift_name])
                 builder.place(name, at=at, from_=from_)
             else:
-                builder.new(name, parent, **el_params)
+                if name == parent:
+                    el_params.pop('extra', None)
+                    builder.place(name, **el_params)
+                else:
+                    builder.new(name, parent, **el_params)
 
     def _set_element(self, name, builder, **kwargs):
         self._parameter_cache[name].update(kwargs)
@@ -430,9 +436,11 @@ class MadxLoader:
             #  should be taken as is, and hope no one relies on it being < 0.
 
         if params.pop('aperture', None):
-            _warn(f'Ignoring aperture parameter for element `{name}` for now. '
-                  f'Only apertures on markers and standalone aperture elements '
-                  f'are supported for now.')
+            pass
+            # Avoid flooding the user with warnings
+            # _warn(f'Ignoring aperture parameter for element `{name}` for now. '
+            #       f'Only apertures on markers and standalone aperture elements '
+            #       f'are supported for now.')
 
         return params
 
@@ -626,3 +634,9 @@ class MadxLoader:
             )
 
         return element_name
+
+def load_madx_lattice(file):
+    loader = MadxLoader()
+    loader.load_file(file)
+    env = loader.env
+    return env

{xtrack-0.70.0 → xtrack-0.70.2}/xtrack/mad_writer.py

@@ -315,7 +315,8 @@ def to_madx_sequence(line, name='seq', mode='sequence'):
             if el_str is None:
                 continue
 
-            seq_str += f"{nn}: {el_str}, at={s_dict[nn]};\n"
+            nn_mad = nn.replace(':', '__') # : not supported in madx names
+            seq_str += f"{nn_mad}: {el_str}, at={s_dict[nn]};\n"
         seq_str += 'endsequence;'
         machine_str = seq_str
 

{xtrack-0.70.0 → xtrack-0.70.2}/xtrack/twiss.py

@@ -3162,6 +3162,41 @@ class TwissTable(Table):
 
         return R_matrix
 
+    def get_R_matrix_table(self):
+
+        Rot = np.zeros(shape=(len(self.s), 6, 6), dtype=np.float64)
+
+        cos_phix = np.cos(self.phix - self.phix[0])
+        sin_phix = np.sin(self.phix - self.phix[0])
+        cos_phiy = np.cos(self.phiy - self.phiy[0])
+        sin_phiy = np.sin(self.phiy - self.phiy[0])
+        cos_phizeta = np.cos(self.phizeta - self.phizeta[0])
+        sin_phizeta = np.sin(self.phizeta - self.phizeta[0])
+
+        Rot[:, 0, 0] = cos_phix
+        Rot[:, 0, 1] = sin_phix
+        Rot[:, 1, 0] = -sin_phix
+        Rot[:, 1, 1] = cos_phix
+        Rot[:, 2, 2] = cos_phiy
+        Rot[:, 2, 3] = sin_phiy
+        Rot[:, 3, 2] = -sin_phiy
+        Rot[:, 3, 3] = cos_phiy
+        Rot[:, 4, 4] = cos_phizeta
+        Rot[:, 4, 5] = sin_phizeta
+        Rot[:, 5, 4] = -sin_phizeta
+        Rot[:, 5, 5] = cos_phizeta
+
+        # Compute W @ Rot @ W_inv slice by slice
+        WW = self.W_matrix
+        R_matrix_ebe = np.einsum('ijk,ikl->ijl', WW, Rot) @ np.linalg.inv(WW[0, :, :])
+
+        out_dct = {'s': self.s, 'name': self.name, 'R_matrix': R_matrix_ebe}
+        for ii in range(6):
+            for jj in range(6):
+                out_dct[f'r{ii+1}{jj+1}'] = R_matrix_ebe[:, ii, jj]
+
+        return Table(out_dct)
+
     def get_normalized_coordinates(self, particles, nemitt_x=None, nemitt_y=None,
                                    nemitt_zeta=None, _force_at_element=None):
 
@@ -3443,7 +3478,9 @@ class TwissTable(Table):
             axleft=None,
             axright=None,
             axlattice=None,
-            hover=False
+            hover=False,
+            figsize=(6.4*1.2, 4.8),
+            lattice_only=False
             ):
         """
         Plot columns of the TwissTable
@@ -3494,6 +3531,10 @@ class TwissTable(Table):
 
         self._is_s_begin=True
 
+        if lattice_only:
+            yl = ''
+            yr = ''
+
         pl=TwissPlot(self,
                 x=x,
                 yl=yl,
@@ -3507,6 +3548,7 @@ class TwissTable(Table):
                 axright=axright,
                 axlattice=axlattice,
                 hover=hover,
+                figsize=figsize,
                 )
 
         if labels is not None:
@@ -3514,6 +3556,14 @@ class TwissTable(Table):
             labels=self[self._index][mask]
             xs=self[x][mask]
             pl.left.set_xticks(xs,labels)
+
+        if lattice_only:
+            ax1 = pl.lattice.twinx()
+            ax1.yaxis.set_label_position("left")
+            ax1.yaxis.set_ticks_position("left")
+            ax1.set_autoscale_on(True)
+            pl.left = ax1
+
         return pl
 
 

{xtrack-0.70.0 → xtrack-0.70.2}/xtrack/twissplot.py

@@ -84,6 +84,7 @@ class TwissPlot(object):
         axright=None,
         axlattice=None,
         hover=False,
+        figsize=(6.4*1.2, 4.8)
     ):
 
         import matplotlib.pyplot as plt
@@ -108,7 +109,7 @@ class TwissPlot(object):
         if ax is not None:
             self.figure = ax.figure
         elif figure is None:
-            self.figure = plt.figure(num=figlabel, figsize=(6.4*1.2, 4.8))
+            self.figure = plt.figure(num=figlabel, figsize=figsize)
         if figlabel is not None:
             self.figure.clf()
         for i in self.yl + self.yr:

{xtrack-0.70.0 → xtrack-0.70.2/xtrack.egg-info}/PKG-INFO

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

{xtrack-0.70.0 → xtrack-0.70.2}/xtrack.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ tests/test_fcc_ee_solenoid_correction_new_optimize_api.py
 tests/test_footprint.py
 tests/test_freeze_longitudinal.py
 tests/test_full_rings.py
+tests/test_h6_sps_beamline.py
 tests/test_hvkick.py
 tests/test_ions.py
 tests/test_lhc_match_phase_15.py

xtrack-0.70.0/xtrack/_version.py

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