xtrack 0.98.4__tar.gz → 0.98.6__tar.gz

{xtrack-0.98.4/xtrack.egg-info → xtrack-0.98.6}/PKG-INFO

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

{xtrack-0.98.4 → xtrack-0.98.6}/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.4 → xtrack-0.98.6}/tests/test_madnginterface.py

@@ -324,3 +324,19 @@ def test_madng_slices():
     xo.assert_allclose(twng_ip.wy_ng, twng_ip_sliced.wy_ng, rtol=1e-3)
     xo.assert_allclose(twng_ip.dx_ng, twng_ip_sliced.dx_ng, atol=1e-6)
     xo.assert_allclose(twng_ip.dy_ng, twng_ip_sliced.dy_ng, atol=1e-6)
+
+def test_madng_interface_amplitude_detuning_and_second_order_chrom():
+    line = xt.load(test_data_folder /
+                            'hllhc15_thick/lhc_thick_with_knobs.json')
+
+    twng = line.madng_twiss()
+    det = line.get_amplitude_detuning_coefficients(num_turns=512)
+
+    xo.assert_allclose(twng.dqxdjx_nf_ng, det['det_xx'], rtol=7e-2)
+    xo.assert_allclose(twng.dqydjy_nf_ng, det['det_yy'], rtol=7e-2)
+    xo.assert_allclose(twng.dqxdjy_nf_ng, det['det_xy'], rtol=7e-2)
+    xo.assert_allclose(twng.dqydjx_nf_ng, det['det_yx'], rtol=7e-2)
+
+    tw = line.twiss4d()
+    xo.assert_allclose(tw.ddqx, twng.d2q1_nf_ng, rtol=1e-2)
+    xo.assert_allclose(tw.ddqy, twng.d2q2_nf_ng, rtol=1e-2)

xtrack-0.98.6/xtrack/_version.py

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

{xtrack-0.98.4 → xtrack-0.98.6}/xtrack/builder.py

@@ -122,7 +122,7 @@ class Builder:
     def __len__(self):
         return len(self.components)
 
-    def resolve_s_positions(self):
+    def resolve_s_positions(self, sort=True):
         components = self.components
         if components is None:
             components = []
@@ -132,6 +132,8 @@ class Builder:
 
         seq_all_places = _all_places(flattened_components)
         tab_unsorted = _resolve_s_positions(seq_all_places, self.env, refer=self.refer)
+        if not sort:
+            return tab_unsorted
         tab_sorted = _sort_places(tab_unsorted)
         return tab_sorted
 
@@ -440,6 +442,7 @@ def _resolve_s_positions(seq_all_places, env, refer='center',
     tt_out['s_start'] = aux_s_start
     tt_out['s_center'] = aux_s_center
     tt_out['s_end'] = aux_s_end
+    tt_out['s']= aux_s_start
 
     tt_out['from_'] = np.array([ss.from_ for ss in seq_all_places])
     tt_out['from_anchor'] = np.array([ss.from_anchor for ss in seq_all_places])
@@ -455,6 +458,8 @@ def _sort_places(tt_unsorted, s_tol=1e-10, allow_non_existent_from=False):
     iii = _argsort_s(tt_unsorted.s_center, tol=s_tol)
     tt_s_sorted = tt_unsorted.rows[iii]
 
+    # Identify groups of elements with s_center with the same s position
+    # (basically thin elements, if not overlapping)
     group_id = np.zeros(len(tt_s_sorted), dtype=int)
     group_id[0] = 0
     for ii in range(1, len(tt_s_sorted)):
@@ -473,17 +478,23 @@ def _sort_places(tt_unsorted, s_tol=1e-10, allow_non_existent_from=False):
     # at each iteration.
     ind_name = {nn: ii for ii, nn in enumerate(tt_s_sorted.name)}
 
+    # Sort elements within each group
     n_places = len(tt_s_sorted)
     i_start_group = 0
     i_place_sorted = []
     while i_start_group < n_places:
+
+        # Identify group edges
         i_group = tt_s_sorted['group_id', i_start_group]
         i_end_group = i_start_group + 1
         while i_end_group < n_places and tt_s_sorted['group_id', i_end_group] == i_group:
             i_end_group += 1
+
+        # Debug
         # print(f'Group {i_group}: {tt_s_sorted.name[i_start_group:i_end_group]}')
 
         n_group = i_end_group - i_start_group
+
         if n_group == 1: # Single element
             i_place_sorted.append(tt_s_sorted.i_place[i_start_group])
             i_start_group = i_end_group
@@ -492,46 +503,95 @@ def _sort_places(tt_unsorted, s_tol=1e-10, allow_non_existent_from=False):
         if np.all(tt_s_sorted.from_anchor[i_start_group:i_end_group] == None): # Nothing to do
             i_place_sorted.extend(list(tt_s_sorted.i_place[i_start_group:i_end_group]))
             i_start_group = i_end_group
+            continue
+
+        # Geneal case to sort thin sandwiches:
+        #  - elements with from_ before the group go first (in order of appearance)
+        #  - elements with no from_ go next (in order of appearance)
+        #  - elements with from_ after the group go last (in order of appearance)
+        #  - elements with from_ inside the group get inserted based on their from_/from_anchor
 
         tt_group = tt_s_sorted.rows[i_start_group:i_end_group]
+
+        # Debug
         # tt_group.show(cols=['s_center', 'name', 'from_', 'from_anchor'])
 
-        for ff in tt_group.from_:
+        # Identify subgroups
+        subgroup_from_is_before = []
+        subgroup_from_is_after = []
+        subgroup_from_is_inside = []
+        subgroup_no_from = []
+        for ii in range(n_group):
+            ff = tt_group.from_[ii]
             if ff is None:
-                continue
-            if ff not in ind_name:
-                if allow_non_existent_from:
-                    continue
+                subgroup_no_from.append(ii)
+            else:
+                if ff not in ind_name:
+                    if allow_non_existent_from:
+                        subgroup_no_from.append(ii)
+                        continue
+                    else:
+                        raise ValueError(f'Element {ff} not found in the line')
+                i_from_global = ind_name[ff]
+                if i_from_global < i_start_group:
+                    subgroup_from_is_before.append(ii)
+                elif i_from_global >= i_end_group:
+                    subgroup_from_is_after.append(ii)
                 else:
-                    raise ValueError(f'Element {ff} not found in the line')
-            i_from_global = ind_name[ff] - i_start_group
-            key_sort = np.zeros(n_group, dtype=int)
-
-            if i_from_global < 0:
-                key_sort[:] = 2
-            elif i_from_global >= n_group:
-                key_sort[:] = -2
+                    subgroup_from_is_inside.append(ii)
+
+        # Build dicts with insertions from subgroup_from_is_inside
+        # (dictionary keys are the from_ names)
+        insertion_before = {}
+        insertion_after = {}
+        for ii in subgroup_from_is_inside:
+            from_ = tt_group.from_[ii]
+            from_anchor = tt_group.from_anchor[ii]
+            if from_anchor == 'start' or from_anchor == None:
+                if from_ not in insertion_before:
+                    insertion_before[from_] = []
+                insertion_before[from_].append(ii)
+            elif from_anchor == 'end':
+                if from_ not in insertion_after:
+                    insertion_after[from_] = []
+                insertion_after[from_].append(ii)
             else:
-                i_local = tt_group.rows.indices[ff][0] # I need to use this because it might change in the group resortings
-                key_sort[i_local] = 0
-                key_sort[:i_local] = -2
-                key_sort[i_local+1:] = 2
-
-            from_present = tt_group['from_']
-            from_anchor_present = tt_group['from_anchor']
-
-            mask_pack_before = (from_present == ff) & (from_anchor_present == 'start')
-            mask_pack_after = (from_present == ff) & (from_anchor_present == 'end')
-            key_sort[mask_pack_before] = -1
-            key_sort[mask_pack_after] = 1
-
-            if np.all(np.diff(key_sort) >=0):
-                continue # already sorted
-            tt_group = tt_group.rows[np.argsort(key_sort, kind='stable')]
-
+                raise ValueError(f'Unknown from_anchor {from_anchor}')
+
+        # Make insertions
+        subgroup_from_is_not_inside = (subgroup_from_is_before +
+                                subgroup_no_from +
+                                subgroup_from_is_after)
+        i_subgroup_sorted = subgroup_from_is_not_inside.copy()
+        while len(insertion_before) > 0 or len(insertion_after) > 0:
+            new_i_subgroup_sorted = []
+            for ii in i_subgroup_sorted:
+                nn = tt_group.name[ii]
+                if nn in insertion_before:
+                    new_i_subgroup_sorted.extend(insertion_before[nn])
+                    insertion_before.pop(nn)
+                new_i_subgroup_sorted.append(ii)
+                if nn in insertion_after:
+                    new_i_subgroup_sorted.extend(insertion_after[nn])
+                    insertion_after.pop(nn)
+
+            if len(new_i_subgroup_sorted) == len(i_subgroup_sorted):
+                # No changes -> done
+                raise ValueError('Could not sort elements within group; possible circular '
+                                 'dependency in from_ specifications')
+
+            i_subgroup_sorted = new_i_subgroup_sorted
+
+        # Sort the group subtable
+        tt_group = tt_group.rows[i_subgroup_sorted]
+
+        # Append the sorted indices
         i_place_sorted.extend(list(tt_group.i_place))
+
+        # Move to next group
         i_start_group = i_end_group
 
+    # Sort the entire table according to i_place_sorted
     tt_sorted = tt_unsorted.rows[i_place_sorted]
 
     tt_sorted['s_center'] = tt_sorted['s_start'] + tt_sorted['length'] / 2

{xtrack-0.98.4 → xtrack-0.98.6}/xtrack/environment.py

@@ -420,6 +420,9 @@ class Environment:
                 ])
         """
 
+        if isinstance(components, str):
+            raise ValueError('components must be a list or tuple, not a string')
+
         out = xt.Line(env=self, compose=True, length=length, refer=refer,
                       s_tol=s_tol, mirror=mirror)
 
@@ -1552,19 +1555,19 @@ class EnvElements:
     def __len__(self):
         return len(self.env._element_dict)
 
-    def get_table(self):
+    def get_table(self, attr=False):
         names = sorted(list(self.env._element_dict.keys()))
         dumline = self.env.new_line(components=names)
-        tt = dumline.get_table()
+        tt = dumline.get_table(attr=attr)
         assert tt.name[-1] == '_end_point'
         tt = tt.rows[:-1] # Remove endpoint
-        del tt['s']
-        del tt['s_start']
-        del tt['s_center']
-        del tt['s_end']
-        del tt['env_name']
-        tt['length'] = np.array(
-            [getattr(self.env._element_dict[nn], 'length', 0) for nn in tt.name])
+        for cc in ['s', 's_start', 's_center', 's_end', 'env_name']:
+            if cc in tt._col_names:
+                tt._col_names.remove(cc)
+                del tt._data[cc]
+        if 'length' not in tt._col_names:
+            tt['length'] = np.array(
+                [getattr(self.env._element_dict[nn], 'length', 0) for nn in tt.name])
         return tt
 
     def remove(self, name):
@@ -1619,11 +1622,11 @@ class EnvParticles:
         return len(self.env._particles)
 
     def get_table(self):
-        names = sorted(list(self.env._particles.keys()))
+        names = np.array(sorted(list(self.env._particles.keys())))
         mass0 = np.array(
-            [self.env._particles[nn].mass0[0] for nn in names])
+            [self.env._particles[nn].mass0 for nn in names])
         charge0 = np.array(
-            [self.env._particles[nn].charge0[0] for nn in names])
+            [self.env._particles[nn].q0 for nn in names])
         energy0 = np.array(
             [self.env._particles[nn].energy0[0] for nn in names])
         p0c = np.array(
@@ -2299,4 +2302,3 @@ def _disable_name_clash_checks(env):
         yield
     finally:
         env._enable_name_clash_check = old_value
-

{xtrack-0.98.4 → xtrack-0.98.6}/xtrack/madng_interface.py

@@ -297,10 +297,10 @@ def _tw_ng(line, rdts=(), normal_form=True,
             d4q2 = out_nf[9],
             d5q1 = out_nf[10],
             d5q2 = out_nf[11],
-            dqxdjx = out_nf[6]*2.,
-            dqydjy = out_nf[7]*2.,
-            dqxdjy = out_nf[8]*2.,
-            dqydjx = out_nf[9]*2.,
+            dqxdjx = out_nf[12]*2.,
+            dqydjy = out_nf[13]*2.,
+            dqxdjy = out_nf[14]*2.,
+            dqydjx = out_nf[15]*2.,
         )
         for nn in dct_nf:
             tw[nn+'_nf_ng'] = dct_nf[nn]

{xtrack-0.98.4 → xtrack-0.98.6/xtrack.egg-info}/PKG-INFO

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

xtrack-0.98.4/xtrack/_version.py

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