xtrack 0.65.4__tar.gz → 0.66.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.65.4
+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.4 → xtrack-0.66.0}/tests/test_match_optics_and_ip_knob.py

@@ -499,7 +499,7 @@ def test_match_ir8_optics(test_context):
     assert opt.log()['target_active', -1] == 'yyyyyynnnnnnyy'
     assert opt.log()['vary_active', -1] == 'yyyyyyyynnnnnnnnnnnn'
 
-    opt.step(10)
+    opt.step(12)
     assert opt.log()['penalty', -1] < 0.1
     assert opt.log()['target_active', -1] == 'yyyyyynnnnnnyy'
     assert opt.log()['vary_active', -1] == 'yyyyyyyynnnnnnnnnnnn'

{xtrack-0.65.4 → xtrack-0.66.0}/tests/test_match_optics_and_ip_knob_new_optimize_api.py

@@ -499,7 +499,7 @@ def test_match_ir8_optics_new_optimize_api(test_context):
     assert opt.log()['target_active', -1] == 'yyyyyynnnnnnyy'
     assert opt.log()['vary_active', -1] == 'yyyyyyyynnnnnnnnnnnn'
 
-    opt.step(10)
+    opt.step(12)
     assert opt.log()['penalty', -1] < 0.1
     assert opt.log()['target_active', -1] == 'yyyyyynnnnnnyy'
     assert opt.log()['vary_active', -1] == 'yyyyyyyynnnnnnnnnnnn'

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.4 → xtrack-0.66.0}/tests/test_random_gen.py

@@ -4,6 +4,7 @@
 # ######################################### #
 
 import copy
+import pytest
 
 import numpy as np
 
@@ -14,7 +15,8 @@ from xobjects.test_helpers import for_all_test_contexts
 
 
 @for_all_test_contexts
-def test_random_generation(test_context):
+@pytest.mark.parametrize('generator', ['RandomUniform', 'RandomUniformAccurate'])
+def test_random_generation(test_context, generator):
 
     part = xp.Particles(_context=test_context, p0c=6.5e12, x=[1,2,3])
     part._init_random_number_generator()
@@ -24,7 +26,7 @@ def test_random_generation(test_context):
             'dummy': xo.Float64,
             }
 
-        _depends_on = [xt.RandomUniform]
+        _depends_on = [getattr(xt, generator)]
 
         _extra_c_sources = [
             '''
@@ -32,11 +34,11 @@ def test_random_generation(test_context):
                 void TestElement_track_local_particle(
                         TestElementData el, LocalParticle* part0){
                     //start_per_particle_block (part0->part)
-                        double rr = RandomUniform_generate(part);
+                        double rr = !!GENERATOR!!_generate(part);
                         LocalParticle_set_x(part, rr);
                     //end_per_particle_block
                 }
-            '''
+            '''.replace('!!GENERATOR!!', generator)
         ]
 
     telem = TestElement(_context=test_context)

xtrack-0.66.0/tests/test_seeds.py

@@ -0,0 +1,51 @@
+import numpy as np
+import pytest
+
+import xtrack as xt
+import xpart as xp
+
+
+def test_seeds():
+    # Define a reference particle
+    particle_ref = xt.Particles(mass0=xt.ELECTRON_MASS_EV, q0=1, p0c=4e9)
+
+    # Create a particle object containing some particles with capacity twice the number of particles
+    n_part = 10
+    particles = xp.build_particles(particle_ref=particle_ref, num_particles=n_part, _capacity=2*n_part)
+
+    # Explicitly initialize the random number generator for the particle object
+    seeds = np.random.randint(0, np.iinfo(np.uint32).max, particles._capacity)
+    particles._init_random_number_generator(seeds=seeds)
+
+    # Save the seeds for the random number generator
+    rng_s1_before = particles._rng_s1.copy()
+    rng_s2_before = particles._rng_s2.copy()
+    rng_s3_before = particles._rng_s3.copy()
+    rng_s4_before = particles._rng_s4.copy()
+
+    # Manually kill some particles
+    n_part_to_kill = np.random.randint(1, n_part+1)
+    idx_part_to_kill = np.random.choice(n_part, n_part_to_kill, replace=False)
+
+    particles.state[idx_part_to_kill] = -1
+    particles._num_active_particles = sum(particles.state == 1)
+    particles._num_lost_particles = n_part - particles._num_lost_particles
+
+    # Create some new particles
+    n_part_new = np.random.randint(1, particles._capacity - n_part)
+    new_particles = xp.build_particles(particle_ref=particle_ref, num_particles=n_part_new)
+
+    # Add the new particles to the main particle object
+    particles.add_particles(new_particles)
+
+    # Save the seeds for the random number generator after the new particles addition
+    rng_s1_after = particles._rng_s1
+    rng_s2_after = particles._rng_s2
+    rng_s3_after = particles._rng_s3
+    rng_s4_after = particles._rng_s4
+
+    # Verify that the seeds for the random number generator stay the same
+    assert np.array_equal(rng_s1_after, rng_s1_before)
+    assert np.array_equal(rng_s2_after, rng_s2_before)
+    assert np.array_equal(rng_s3_after, rng_s3_before)
+    assert np.array_equal(rng_s4_after, rng_s4_before)

{xtrack-0.65.4 → 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.4 → xtrack-0.66.0}/xtrack/beam_elements/elements.py

@@ -12,7 +12,7 @@ import xobjects as xo
 import xtrack as xt
 
 from ..base_element import BeamElement
-from ..random import RandomUniform, RandomExponential, RandomNormal
+from ..random import RandomUniformAccurate, RandomExponential, RandomNormal
 from ..general import _pkg_root, _print
 from ..internal_record import RecordIndex, RecordIdentifier
 
@@ -588,7 +588,7 @@ class Multipole(BeamElement):
 
     _skip_in_to_dict = ['_order', 'inv_factorial_order']  # defined by knl, etc.
 
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
 
     _extra_c_sources = [
         _pkg_root.joinpath('headers/constants.h'),
@@ -1000,7 +1000,7 @@ class Sextupole(BeamElement):
         'order': '_order',
     }
 
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
 
     _extra_c_sources = [
@@ -1101,7 +1101,7 @@ class Octupole(BeamElement):
         'order': '_order',
     }
 
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
 
     _extra_c_sources = [
@@ -1312,7 +1312,7 @@ class Solenoid(BeamElement):
         _pkg_root.joinpath('beam_elements/elements_src/solenoid.h'),
     ]
 
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
 
     _internal_record_class = SynchrotronRadiationRecord
 
@@ -2289,7 +2289,7 @@ class FirstOrderTaylorMap(BeamElement):
         'm1': xo.Field(xo.Float64[6, 6], default=np.eye(6, dtype=np.float64)),
     }
 
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
 
     _extra_c_sources = [
         _pkg_root.joinpath('headers/constants.h'),

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/beam_elements/elements_src/dipole_fringe.h

@@ -6,9 +6,15 @@
 #ifndef XTRACK_FRINGE_H
 #define XTRACK_FRINGE_H
 
+#ifndef POW2
 #define POW2(X) ((X)*(X))
+#endif
+#ifndef POW3
 #define POW3(X) ((X)*(X)*(X))
+#endif
+#ifndef POW4
 #define POW4(X) ((X)*(X)*(X)*(X))
+#endif
 
 /*gpufun*/
 void Fringe_track_local_particle(

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/beam_elements/elements_src/track_dipole_fringe.h

@@ -6,9 +6,15 @@
 #ifndef XTRACK_TRACK_DIPOLE_FRINGE_H
 #define XTRACK_TRACK_DIPOLE_FRINGE_H
 
+#ifndef POW2
 #define POW2(X) ((X)*(X))
+#endif
+#ifndef POW3
 #define POW3(X) ((X)*(X)*(X))
+#endif
+#ifndef POW4
 #define POW4(X) ((X)*(X)*(X)*(X))
+#endif
 
 
 #ifndef XTRACK_FRINGE_FROM_PTC

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/beam_elements/elements_src/track_mult_fringe.h

@@ -6,8 +6,12 @@
 #ifndef XTRACK_TRACK_MULT_FRINGE_H
 #define XTRACK_TRACK_MULT_FRINGE_H
 
-#define POW2(x) ((x) * (x))
-#define POW3(x) ((x) * (x) * (x))
+#ifndef POW2
+#define POW2(X) ((X)*(X))
+#endif
+#ifndef POW3
+#define POW3(X) ((X)*(X)*(X))
+#endif
 
 /*gpufun*/
 void MultFringe_track_single_particle(

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/beam_elements/elements_src/track_thick_bend.h

@@ -6,7 +6,10 @@
 #ifndef XTRACK_TRACK_THICK_BEND_H
 #define XTRACK_TRACK_THICK_BEND_H
 
+#ifndef POW2
 #define POW2(X) ((X)*(X))
+#endif
+
 #define NONZERO(X) ((X) != 0.0)
 
 /*gpufun*/

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/beam_elements/elements_src/track_thick_cfd.h

@@ -6,7 +6,10 @@
 #ifndef XTRACK_TRACK_THICK_CFD_H
 #define XTRACK_TRACK_THICK_CFD_H
 
+#ifndef POW2
 #define POW2(X) ((X)*(X))
+#endif
+
 #define NONZERO(X) ((X) != 0.0)
 
 // From madx: https://github.com/MethodicalAcceleratorDesign/MAD-X/blob/8695bd422dc403a01aa185e9fea16603bbd5b3e1/src/trrun.f90#L4320

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/beam_elements/elements_src/track_wedge.h

@@ -6,7 +6,9 @@
 #ifndef XTRACK_TRACK_WEDGE_H
 #define XTRACK_TRACK_WEDGE_H
 
+#ifndef POW2
 #define POW2(X) ((X)*(X))
+#endif
 
 /*gpufun*/
 void Wedge_single_particle(

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/beam_elements/slice_elements.py

@@ -1,7 +1,7 @@
 import xobjects as xo
 
 from ..general import _pkg_root
-from ..random import RandomUniform, RandomExponential
+from ..random import RandomUniformAccurate, RandomExponential
 from .elements import (SynchrotronRadiationRecord, Quadrupole, Sextupole,
                        Octupole, Bend, Multipole, DipoleEdge)
 from ..base_element import BeamElement
@@ -30,7 +30,7 @@ class ThinSliceQuadrupole(BeamElement):
     allow_rot_and_shift = False
     rot_and_shift_from_parent = True
     _skip_in_to_dict = ['_parent']
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
     has_backtrack = True
     _force_moveable = True
@@ -78,7 +78,7 @@ class ThinSliceSextupole(BeamElement):
     allow_rot_and_shift = False
     rot_and_shift_from_parent = True
     _skip_in_to_dict = ['_parent']
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
     has_backtrack = True
     _force_moveable = True
@@ -126,7 +126,7 @@ class ThinSliceOctupole(BeamElement):
     allow_rot_and_shift = False
     rot_and_shift_from_parent = True
     _skip_in_to_dict = ['_parent']
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
     has_backtrack = True
     _force_moveable = True
@@ -174,7 +174,7 @@ class ThinSliceBend(BeamElement):
     allow_rot_and_shift = False
     rot_and_shift_from_parent = True
     _skip_in_to_dict = ['_parent']
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
     has_backtrack = True
     _force_moveable = True

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/beam_elements/slice_elements_thick.py

@@ -4,7 +4,7 @@ from ..general import _pkg_root
 from ..base_element import BeamElement
 from .elements import (SynchrotronRadiationRecord, Bend, Quadrupole, Sextupole,
                        Octupole, Solenoid, Drift)
-from ..random import RandomUniform, RandomExponential
+from ..random import RandomUniformAccurate, RandomExponential
 
 from .slice_elements import _slice_copy
 
@@ -89,7 +89,7 @@ class ThickSliceSextupole(BeamElement):
 
     _xofields = {'_parent': xo.Ref(Sextupole), **_common_xofields}
 
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
 
     _extra_c_sources = [
@@ -124,7 +124,7 @@ class ThickSliceOctupole(BeamElement):
 
     _xofields = {'_parent': xo.Ref(Octupole), **_common_xofields}
 
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
 
     _extra_c_sources = [
@@ -159,7 +159,7 @@ class ThickSliceSolenoid(BeamElement):
 
     _xofields = {'_parent': xo.Ref(Solenoid), **_common_xofields}
 
-    _depends_on = [RandomUniform, RandomExponential]
+    _depends_on = [RandomUniformAccurate, RandomExponential]
     _internal_record_class = SynchrotronRadiationRecord
 
     _extra_c_sources = [

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/headers/synrad_spectrum.h

@@ -189,7 +189,7 @@ double synrad_gen_photon_energy_normalized(LocalParticle *part)
       exact=SynRad(result);
       appr=a1/tmp;
     } else {				// use high energy approximation
-      double const u = RandomUniform_generate(part);
+      double const u = RandomUniformAccurate_generate(part);
       if (u < 1.e-50) continue;  // avoid log(0), retrigger generation
       result=xlow-log(u);
       exact=SynRad(result);

{xtrack-0.65.4 → 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))]
@@ -934,6 +933,20 @@ class Line:
             equals to False and no progress bar is displayed.
         """
 
+        if hasattr(particles, '_needs_pipeline') and particles._needs_pipeline:
+            if '_called_by_pipeline' not in kwargs or not kwargs['_called_by_pipeline']:
+                all_kwargs = locals()
+                multitracker = xt.PipelineMultiTracker(
+                    branches=[xt.PipelineBranch(line=self, particles=particles)])
+                all_kwargs.pop('self')
+                all_kwargs.pop('particles')
+                all_kwargs.pop('kwargs')
+                all_kwargs.pop('_called_by_pipeline', None)
+                return multitracker.track(**all_kwargs, **kwargs)
+
+        if '_called_by_pipeline' in kwargs: # Used only above
+            kwargs.pop('_called_by_pipeline')
+
         self._check_valid_tracker()
         return self.tracker._track(
             particles,

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

@@ -28,6 +28,10 @@ XTRACK_DEFAULT_WEIGHTS = {
     'muy': 10.,
     'qx': 10.,
     'qy': 10.,
+    'dx' : 10.,
+    'dpx': 100.,
+    'dy' : 10.,
+    'dpy': 100.,
 }
 
 ALLOWED_TARGET_KWARGS= ['x', 'px', 'y', 'py', 'zeta', 'delta', 'pzata', 'ptau',
@@ -100,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):
@@ -122,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
@@ -1069,4 +1073,4 @@ class ActionCall(Action):
         for ii in range(len(ftar)):
             tars.append(xt.Target(ii, ftar[ii], action=self))
 
-        return tars
+        return tars

{xtrack-0.65.4 → xtrack-0.66.0}/xtrack/particles/particles.py

@@ -876,16 +876,15 @@ class Particles(xo.HybridClass):
             # Reorganize particles
             with self._bypass_linked_vars():
                 for tt, nn in self.per_particle_vars:
+                    if nn.startswith('_rng'):
+                        continue
                     vv = getattr(self, nn)
                     vv_active = vv[mask_active]
                     vv_lost = vv[mask_lost]
 
                     vv[:n_active] = vv_active
                     vv[n_active:n_active + n_lost] = vv_lost
-                    if nn.startswith('_rng'):
-                        vv[n_active + n_lost:] = 0
-                    else:
-                        vv[n_active + n_lost:] = tt._dtype.type(LAST_INVALID_STATE)
+                    vv[n_active + n_lost:] = tt._dtype.type(LAST_INVALID_STATE)
 
         if isinstance(self._buffer.context, xo.ContextCpu):
             self._num_active_particles = n_active
@@ -988,6 +987,7 @@ class Particles(xo.HybridClass):
     def init_pipeline(self, name):
 
         self.name = name
+        self._needs_pipeline = True
 
     def show(self):