xtrack 0.65.5__tar.gz → 0.66.0__tar.gz

{xtrack-0.65.5/xtrack.egg-info → xtrack-0.66.0}/PKG-INFO

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

xtrack-0.66.0/tests/test_periodic_symmetric_twiss_and_match.py

@@ -0,0 +1,154 @@
+
+import xtrack as xt
+import xobjects as xo
+import numpy as np
+
+def test_periodic_symmetric_twiss_and_match():
+
+    # Build line with half a cell
+    half_cell = xt.Line(
+        elements={
+            'start_cell': xt.Marker(),
+            'drift0': xt.Drift(length=1.),
+            'qf1': xt.Quadrupole(k1=0.027/2, length=1.),
+            'drift1_1': xt.Drift(length=1),
+            'bend1': xt.Bend(k0=3e-4, h=3e-4, length=45.),
+            'drift1_2': xt.Drift(length=1.),
+            'qd1': xt.Quadrupole(k1=-0.0271/2, length=1.),
+            'drift2': xt.Drift(length=1),
+            'mid_cell': xt.Marker(),
+        }
+    )
+    half_cell.particle_ref = xt.Particles(p0c=2e9)
+
+    tw_half_cell = half_cell.twiss4d(init='periodic_symmetric', # <--- periodic-symmetric boundary
+                                    strengths=True # to get the strengths in table
+                                    )
+
+    cell = xt.Line(
+        elements={
+            'start_cell': xt.Marker(),
+            'drift0': xt.Drift(length=1.),
+            'qf1':    xt.Quadrupole(k1=0.027/2, length=1.),
+            'drift1': xt.Drift(length=1),
+            'bend1':  xt.Bend(k0=3e-4, h=3e-4, length=45.),
+            'drift2': xt.Drift(length=1.),
+            'qd1':    xt.Quadrupole(k1=-0.0271/2, length=1.),
+            'drift3': xt.Drift(length=1),
+            'mid_cell': xt.Marker(),
+            'drift4': xt.Replica('drift3'),
+            'qd2':    xt.Replica('qd1'),
+            'drift5': xt.Replica('drift2'),
+            'bend2':  xt.Replica('bend1'),
+            'drift6': xt.Replica('drift1'),
+            'qf2':    xt.Replica('qf1'),
+            'drift7': xt.Replica('drift0'),
+            'end_cell': xt.Marker(),
+        }
+    )
+    cell.particle_ref = xt.Particles(p0c=2e9)
+    tw_cell = cell.twiss4d(strengths=True)
+
+    xo.assert_allclose(tw_half_cell.betx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].betx, atol=0, rtol=1e-8)
+    xo.assert_allclose(tw_half_cell.bety[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].bety, atol=0, rtol=1e-8)
+    xo.assert_allclose(tw_half_cell.alfx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].alfx, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.alfy[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].alfy, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.dx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].dx, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.dpx[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].dpx, atol=1e-8, rtol=0)
+
+    xo.assert_allclose(tw_half_cell.ax_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ax_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.ay_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ay_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.bx_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].bx_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.by_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].by_chrom, atol=1e-5, rtol=0)
+
+    xo.assert_allclose(tw_half_cell.qx, tw_cell.qx / 2, atol=1e-9, rtol=0)
+    xo.assert_allclose(tw_half_cell.qy, tw_cell.qy / 2, atol=1e-9, rtol=0)
+    xo.assert_allclose(tw_half_cell.dqx, tw_cell.dqx / 2, atol=1e-6, rtol=0)
+    xo.assert_allclose(tw_half_cell.dqy, tw_cell.dqy / 2, atol=1e-6, rtol=0)
+
+    for ll in [cell, half_cell]:
+        ll.vars['kqf'] = 0.027/2
+        ll.vars['kqd'] = -0.0271/2
+        ll.element_refs['qf1'].k1 = ll.vars['kqf']
+        ll.element_refs['qd1'].k1 = ll.vars['kqd']
+
+    tw_cell = cell.twiss4d(strengths=True)
+    tw_half_cell = half_cell.twiss4d(init='periodic_symmetric', strengths=True)
+
+    xo.assert_allclose(tw_cell.mux[-1], 0.231, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_cell.muy[-1], 0.233, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_half_cell.mux[-1], 0.231 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_half_cell.muy[-1], 0.233 / 2, atol=1e-3, rtol=0)
+
+    opt_halfcell = half_cell.match(
+        method='4d',
+        start='start_cell', end='mid_cell',
+        init='periodic_symmetric',
+        targets=xt.TargetSet(mux=0.2501/2, muy=0.2502/2, at='mid_cell'),
+        vary=xt.VaryList(['kqf', 'kqd'], step=1e-5),
+    )
+
+    tw_cell = cell.twiss4d(strengths=True)
+    tw_half_cell = half_cell.twiss4d(init='periodic_symmetric', strengths=True)
+
+    xo.assert_allclose(tw_half_cell.mux[-1], 0.2501 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_half_cell.muy[-1], 0.2502 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_cell.mux[-1], 0.231, atol=1e-3, rtol=0) # unaffected
+    xo.assert_allclose(tw_cell.muy[-1], 0.233, atol=1e-3, rtol=0) # unaffected
+
+    opt_cell = cell.match(
+        method='4d',
+        start='start_cell', end='end_cell',
+        init='periodic',
+        targets=xt.TargetSet(mux=0.2501, muy=0.2502, at='end_cell'),
+        vary=xt.VaryList(['kqf', 'kqd'], step=1e-5),
+    )
+
+    xo.assert_allclose(half_cell.vv['kqf'], cell.vv['kqf'], rtol=1e-9, atol=0)
+    xo.assert_allclose(half_cell.vv['kqd'], cell.vv['kqd'], rtol=1e-9, atol=0)
+
+    tw_cell = cell.twiss4d(strengths=True)
+    tw_half_cell = half_cell.twiss4d(init='periodic_symmetric', strengths=True)
+
+    xo.assert_allclose(tw_half_cell.mux[-1], 0.2501 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_half_cell.muy[-1], 0.2502 / 2, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_cell.mux[-1], 0.2501, atol=1e-3, rtol=0)
+    xo.assert_allclose(tw_cell.muy[-1], 0.2502, atol=1e-3, rtol=0)
+
+    xo.assert_allclose(tw_half_cell.betx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].betx, atol=0, rtol=1e-8)
+    xo.assert_allclose(tw_half_cell.bety[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].bety, atol=0, rtol=1e-8)
+    xo.assert_allclose(tw_half_cell.alfx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].alfx, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.alfy[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].alfy, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.dx[:-1], # remove '_end_point'
+                    tw_cell.rows[:'mid_cell'].dx, atol=1e-8, rtol=0)
+    xo.assert_allclose(tw_half_cell.dpx[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].dpx, atol=1e-8, rtol=0)
+
+    xo.assert_allclose(tw_half_cell.ax_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ax_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.ay_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].ay_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.bx_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].bx_chrom, atol=1e-5, rtol=0)
+    xo.assert_allclose(tw_half_cell.by_chrom[:-1], # remove '_end_point'
+                        tw_cell.rows[:'mid_cell'].by_chrom, atol=1e-5, rtol=0)
+
+    xo.assert_allclose(tw_half_cell.qx, tw_cell.qx / 2, atol=1e-9, rtol=0)
+    xo.assert_allclose(tw_half_cell.qy, tw_cell.qy / 2, atol=1e-9, rtol=0)
+    xo.assert_allclose(tw_half_cell.dqx, tw_cell.dqx / 2, atol=1e-6, rtol=0)
+    xo.assert_allclose(tw_half_cell.dqy, tw_cell.dqy / 2, atol=1e-6, rtol=0)
+

{xtrack-0.65.5 → xtrack-0.66.0}/tests/test_twiss.py

@@ -51,7 +51,6 @@ def test_twiss_4d_fodo_vs_beta_rel(test_context):
         xo.assert_allclose(tw.dqx, tw_4d_list[0].dqx, atol=1e-4, rtol=0)
         xo.assert_allclose(tw.dqy, tw_4d_list[0].dqy, atol=1e-4, rtol=0)
 
-
 @for_all_test_contexts
 def test_coupled_beta(test_context):
     mad = Madx(stdout=False)
@@ -1905,3 +1904,29 @@ def test_part_from_full_periodic(test_context, collider_for_test_twiss_range):
             tw_part2[kk, 'ip2'],
             tw[kk, 'ip2'] - tw[kk, 0] +(tw[kk, '_end_point'] - tw[kk, 'ip8']),
             rtol=1e-12, atol=5e-7)
+
+
+
+
+@for_all_test_contexts
+def test_twiss_add_strengths(test_context):
+    ## Generate a simple line
+    n = 6
+    fodo = [
+        xt.Multipole(length=0.2, knl=[0, +0.2], ksl=[0, 0]),
+        xt.Drift(length=1.0),
+        xt.Multipole(length=0.2, knl=[0, -0.2], ksl=[0, 0]),
+        xt.Drift(length=1.0),
+        xt.Multipole(length=1.0, knl=[2 * np.pi / n], hxl=[2 * np.pi / n]),
+        xt.Drift(length=1.0),
+    ]
+    line = xt.Line(elements=n * fodo + [xt.Cavity(frequency=1e9, voltage=0, lag=180)])
+    line.build_tracker(_context=test_context)
+
+    ## Twiss
+    line.particle_ref = xp.Particles(mass0=xp.PROTON_MASS_EV, q0=1, p0c=1e8)
+    tw = line.twiss(method="4d")
+
+    assert "length" not in tw.keys()
+    tw.add_strengths()
+    assert "length" in tw.keys()

xtrack-0.66.0/xtrack/_version.py

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

{xtrack-0.65.5 → xtrack-0.66.0}/xtrack/line.py

@@ -115,8 +115,7 @@ class Line:
         if isinstance(elements, dict):
             element_dict = elements
             if element_names is None:
-                raise ValueError('`element_names` must be provided'
-                                 ' if `elements` is a dictionary.')
+                element_names = list(element_dict.keys())
         else:
             if element_names is None:
                 element_names = [f"e{ii}" for ii in range(len(elements))]

{xtrack-0.65.5 → xtrack-0.66.0}/xtrack/match.py

@@ -104,7 +104,7 @@ class ActionTwiss(xd.Action):
                 if isinstance(twinit, xt.TwissInit):
                     twinit_list[ii] = twinit.copy()
                 elif isinstance(twinit, str):
-                    assert twinit == 'periodic'
+                    assert twinit == 'periodic' or twinit == 'periodic_symmetric'
 
         # Handle init_at as xt.START or xt.END
         for ii, init_at in enumerate(ele_init_list):
@@ -126,7 +126,7 @@ class ActionTwiss(xd.Action):
                 twinit_list[ii] = twinit.get_twiss_init(at_element=init_at)
                 ele_init_list[ii] = None
             else:
-                assert twinit is None or twinit == 'periodic'
+                assert twinit is None or twinit in ['periodic', 'periodic_symmetric']
 
         if not ismultiline:
             # Handle case in which twiss init is defined through kwargs

{xtrack-0.65.5 → xtrack-0.66.0}/xtrack/twiss.py

@@ -119,7 +119,7 @@ def twiss_line(line, particle_ref=None, method=None,
         normal form is used. If '4d' the 4D normal form is used.
     start : int or str, optional
         Index of the element at which the computation starts. If not provided,
-        the periodic sulution is computed. `init` must be provided if
+        the periodic solution is computed. `init` must be provided if
         `start` is provided.
     end : int or str, optional
         Index of the element at which the computation stops.
@@ -405,11 +405,13 @@ def twiss_line(line, particle_ref=None, method=None,
         if zero_at is None:
             out.zero_at(start)
         return _add_action_in_res(out, input_kwargs)
-    elif (init is not None and init != 'periodic'
+    elif (init is not None and init not in ['periodic', 'periodic_symmetric']
         or betx is not None or bety is not None):
         periodic = False
+        periodic_mode = None
     else:
         periodic = True
+        periodic_mode = init or 'periodic'
 
     if freeze_longitudinal:
         kwargs = _updated_kwargs_from_locals(kwargs, locals().copy())
@@ -615,6 +617,7 @@ def twiss_line(line, particle_ref=None, method=None,
             compute_R_element_by_element=compute_R_element_by_element,
             only_markers=only_markers,
             only_orbit=only_orbit,
+            periodic_mode=periodic_mode
             )
     else:
         # force
@@ -687,7 +690,8 @@ def twiss_line(line, particle_ref=None, method=None,
             num_turns=num_turns,
             hide_thin_groups=hide_thin_groups,
             only_markers=only_markers,
-            periodic=periodic)
+            periodic=periodic,
+            periodic_mode=periodic_mode)
         twiss_res._data.update(cols_chrom)
         twiss_res._data.update(scalars_chrom)
         twiss_res._col_names += list(cols_chrom.keys())
@@ -758,11 +762,7 @@ def twiss_line(line, particle_ref=None, method=None,
         twiss_res._data['values_at'] = 'entry'
 
     if strengths:
-        tt = line.get_table(attr=True).rows[list(twiss_res.name)]
-        for kk in (NORMAL_STRENGTHS_FROM_ATTR + SKEW_STRENGTHS_FROM_ATTR
-                   + OTHER_FIELDS_FROM_ATTR + OTHER_FIELDS_FROM_TABLE):
-            twiss_res._col_names.append(kk)
-            twiss_res._data[kk] = tt[kk].copy()
+        _add_strengths_to_twiss_res(twiss_res, line)
 
     twiss_res._data['method'] = method
     twiss_res._data['radiation_method'] = radiation_method
@@ -1245,7 +1245,8 @@ def _compute_chromatic_functions(line, init, delta_chrom, steps_r_matrix,
                     start=None, end=None, num_turns=None,
                     hide_thin_groups=False,
                     only_markers=False,
-                    periodic=False):
+                    periodic=False,
+                    periodic_mode=None):
 
     if only_markers:
         raise NotImplementedError('only_markers not supported anymore')
@@ -1264,13 +1265,19 @@ def _compute_chromatic_functions(line, init, delta_chrom, steps_r_matrix,
                 particle_on_co=on_momentum_twiss_res.particle_on_co.copy(),
                 nemitt_x=nemitt_x, nemitt_y=nemitt_y,
                 W_matrix=tw_init_chrom.W_matrix)
-            part_chrom = line.find_closed_orbit(delta0=dd, co_guess=part_guess,
+            if periodic_mode == 'periodic_symmetric':
+                part_chrom = part_guess.copy() # Finding closed orbit does not make sense in this case
+            else:
+                part_chrom = line.find_closed_orbit(delta0=dd, co_guess=part_guess,
                                     start=start, end=end, num_turns=num_turns)
             tw_init_chrom.particle_on_co = part_chrom
             RR_chrom = line.compute_one_turn_matrix_finite_differences(
                                         particle_on_co=tw_init_chrom.particle_on_co.copy(),
                                         start=start, end=end, num_turns=num_turns,
                                         steps_r_matrix=steps_r_matrix)['R_matrix']
+            if periodic_mode == 'periodic_symmetric':
+                RR_chrom = _compute_R_periodic_symmetric(RR_chrom)
+
             (WW_chrom, _, _, _) = lnf.compute_linear_normal_form(RR_chrom,
                                     only_4d_block=method=='4d',
                                     responsiveness_tol=matrix_responsiveness_tol,
@@ -1742,12 +1749,16 @@ def _find_periodic_solution(line, particle_on_co, particle_ref, method,
                             num_turns_search_t_rev=1,
                             compute_R_element_by_element=False,
                             only_markers=False,
-                            only_orbit=False):
+                            only_orbit=False,
+                            periodic_mode='periodic'):
 
     eigenvalues = None
     Rot = None
     RR_ebe = None
 
+    assert periodic_mode in ['periodic', 'periodic_symmetric']
+
+
     if start is not None or end is not None:
         assert start is not None and end is not None, (
             'start and end must be both None or both not None')
@@ -1758,6 +1769,11 @@ def _find_periodic_solution(line, particle_on_co, particle_ref, method,
     if method == '4d' and delta0 is None:
         delta0 = 0
 
+    if periodic_mode == 'periodic_symmetric':
+        assert R_matrix is None, 'R_matrix must be None for `periodic_symmetric`'
+        assert W_matrix is None, 'W_matrix must be None for `periodic_symmetric`'
+        assert delta0 == 0, 'delta0 must be 0 for `periodic_symmetric`'
+
     if particle_on_co is not None:
         part_on_co = particle_on_co
     else:
@@ -1780,6 +1796,15 @@ def _find_periodic_solution(line, particle_on_co, particle_ref, method,
     if only_orbit:
         W_matrix = np.eye(6)
 
+    if periodic_mode == 'periodic_symmetric':
+        assert np.allclose(part_on_co.x[0], 0, atol=1e-12, rtol=0)
+        assert np.allclose(part_on_co.px[0], 0, atol=1e-12, rtol=0)
+        assert np.allclose(part_on_co.y[0], 0, atol=1e-12, rtol=0)
+        assert np.allclose(part_on_co.py[0], 0, atol=1e-12, rtol=0)
+        assert np.allclose(part_on_co.delta[0], 0, atol=1e-12, rtol=0)
+        assert np.allclose(part_on_co.zeta[0], 0, atol=1e-12, rtol=0)
+
+
     if W_matrix is not None:
         W = W_matrix
         RR = None
@@ -1807,6 +1832,10 @@ def _find_periodic_solution(line, particle_on_co, particle_ref, method,
                     )
                 RR = RR_out['R_matrix']
                 RR_ebe = RR_out['R_matrix_ebe']
+
+                if periodic_mode == 'periodic_symmetric':
+                    RR = _compute_R_periodic_symmetric(RR)
+
                 if matrix_responsiveness_tol is not None:
                     lnf._assert_matrix_responsiveness(RR,
                         matrix_responsiveness_tol, only_4d=(method == '4d'))
@@ -3062,7 +3091,7 @@ class TwissTable(Table):
 
         return R_matrix
 
-    def get_normalized_coordinates(self, particles, nemitt_x=None, nemitt_y=None, 
+    def get_normalized_coordinates(self, particles, nemitt_x=None, nemitt_y=None,
                                    nemitt_zeta=None, _force_at_element=None):
 
         # TODO: check consistency of gamma0
@@ -3243,6 +3272,12 @@ class TwissTable(Table):
 
     ind_per_table = []
 
+    def add_strengths(self, line=None):
+        if line is None:
+            line = self._action.line
+        _add_strengths_to_twiss_res(self, line)
+        return self
+
     @classmethod
     def concatenate(cls, tables_to_concat):
 
@@ -3357,8 +3392,8 @@ class TwissTable(Table):
             yl='betx bety'
             yr='dx dy'
 
-        if 'length' not in self.keys():
-            lattice=False
+        if lattice and 'length' not in self.keys():
+            self.add_strengths()
 
         if mask is not None:
             if isinstance(mask,str):
@@ -3793,41 +3828,53 @@ def _reverse_strengths(out):
 
 
 def _W_phys2norm(x, px, y, py, zeta, pzeta, W_matrix, co_dict, nemitt_x=None, nemitt_y=None, nemitt_zeta=None):
-    
-    
+
     # Compute geometric emittances if normalized emittances are provided
-    gemitt_x = np.ones(shape=np.shape(co_dict['beta0'])) if nemitt_x is None else (nemitt_x / co_dict['beta0'] / co_dict['gamma0'])
-    gemitt_y = np.ones(shape=np.shape(co_dict['beta0'])) if nemitt_y is None else (nemitt_y / co_dict['beta0'] / co_dict['gamma0'])
-    gemitt_zeta = np.ones(shape=np.shape(co_dict['beta0'])) if nemitt_zeta is None else (nemitt_zeta / co_dict['beta0'] / co_dict['gamma0'])
+    gemitt_x = np.ones(shape=np.shape(co_dict['beta0'])) if nemitt_x is None else (
+        nemitt_x / co_dict['beta0'] / co_dict['gamma0'])
+    gemitt_y = np.ones(shape=np.shape(co_dict['beta0'])) if nemitt_y is None else (
+        nemitt_y / co_dict['beta0'] / co_dict['gamma0'])
+    gemitt_zeta = np.ones(shape=np.shape(co_dict['beta0'])) if nemitt_zeta is None else (
+        nemitt_zeta / co_dict['beta0'] / co_dict['gamma0'])
 
-    
     # Prepaing co arrray and gemitt array:
-    co = np.array([co_dict['x'], co_dict['px'], co_dict['y'], co_dict['py'], co_dict['zeta'], co_dict['ptau'] / co_dict['beta0']])
-    gemitt_values = np.array([gemitt_x, gemitt_x, gemitt_y, gemitt_y, gemitt_zeta, gemitt_zeta])
+    co = np.array([co_dict['x'], co_dict['px'], co_dict['y'], co_dict['py'],
+                  co_dict['zeta'], co_dict['ptau'] / co_dict['beta0']])
+    gemitt_values = np.array(
+        [gemitt_x, gemitt_x, gemitt_y, gemitt_y, gemitt_zeta, gemitt_zeta])
 
     # Ensuring consistent dimensions
-    for add_axis in range(-1,len(np.shape(x))-len(np.shape(co))):
-        co = co[:,np.newaxis]
-    for add_axis in range(-1,len(np.shape(x))-len(np.shape(gemitt_values))):
-        gemitt_values = gemitt_values[:,np.newaxis]
+    for add_axis in range(-1, len(np.shape(x))-len(np.shape(co))):
+        co = co[:, np.newaxis]
+    for add_axis in range(-1, len(np.shape(x))-len(np.shape(gemitt_values))):
+        gemitt_values = gemitt_values[:, np.newaxis]
 
-    
     # substracting closed orbit
     XX = np.array([x, px, y, py, zeta, pzeta])
     XX -= co
-    
 
     # Apply the inverse transformation matrix
     W_inv = np.linalg.inv(W_matrix)
-    
+
     if len(np.shape(XX)) == 3:
-        XX_norm = np.dot(W_inv, XX.reshape(6,x.shape[0]*x.shape[1]))
+        XX_norm = np.dot(W_inv, XX.reshape(6, x.shape[0]*x.shape[1]))
         XX_norm = XX_norm.reshape(6, x.shape[0], x.shape[1])
-    else:    
+    else:
         XX_norm = np.dot(W_inv, XX)
-    
+
     # Normalize the coordinates with the geometric emittances
     XX_norm /= np.sqrt(gemitt_values)
-    
 
     return XX_norm
+
+def _add_strengths_to_twiss_res(twiss_res, line):
+    tt = line.get_table(attr=True).rows[list(twiss_res.name)]
+    for kk in (NORMAL_STRENGTHS_FROM_ATTR + SKEW_STRENGTHS_FROM_ATTR
+                + OTHER_FIELDS_FROM_ATTR + OTHER_FIELDS_FROM_TABLE):
+        twiss_res._col_names.append(kk)
+        twiss_res._data[kk] = tt[kk].copy()
+
+def _compute_R_periodic_symmetric(RR):
+    inv_momenta = np.diag([1., -1., 1., -1., 1., 1.])
+    RR_symm = inv_momenta @ np.linalg.inv(RR) @ inv_momenta @ RR
+    return RR_symm

{xtrack-0.65.5 → xtrack-0.66.0/xtrack.egg-info}/PKG-INFO

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

{xtrack-0.65.5 → xtrack-0.66.0}/xtrack.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ tests/test_multiline.py
 tests/test_multisetter.py
 tests/test_multispecies.py
 tests/test_particles_api.py
+tests/test_periodic_symmetric_twiss_and_match.py
 tests/test_pipeline.py
 tests/test_prebuild_kernels.py
 tests/test_ps_against_ptc.py

xtrack-0.65.5/xtrack/_version.py

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