xtrack 0.65.4__tar.gz → 0.65.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.65.4
+Version: 0.65.5
 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.65.5}/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.65.5}/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.65.4 → xtrack-0.65.5}/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.65.5/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.5/xtrack/_version.py

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

{xtrack-0.65.4 → xtrack-0.65.5}/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.65.5}/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.65.5}/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.65.5}/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.65.5}/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.65.5}/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.65.5}/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.65.5}/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.65.5}/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.65.5}/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.65.5}/xtrack/line.py

@@ -934,6 +934,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.65.5}/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',
@@ -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.65.5}/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):
 

{xtrack-0.65.4 → xtrack-0.65.5}/xtrack/particles/rng_src/base_rng.h

@@ -14,16 +14,26 @@
 #define TAUSWORTHE(s,a,b,c,d) ((((s) &c) <<d) &MASK) ^ (((((s) <<a) &MASK)^(s)) >>b)
 #define LCG(s,A,C) ((((A*(s)) &MASK) + C) &MASK)
 
-
 /*gpufun*/
-double rng_get (uint32_t *s1, uint32_t *s2, uint32_t *s3, uint32_t *s4 ){
+uint32_t rng_get_int32 (uint32_t *s1, uint32_t *s2, uint32_t *s3, uint32_t *s4 ){
   *s1 = TAUSWORTHE (*s1, 13, 19, 4294967294UL, 12);  // p1=2^31-1
   *s2 = TAUSWORTHE (*s2, 2, 25, 4294967288UL, 4);    // p2=2^30-1
   *s3 = TAUSWORTHE (*s3, 3, 11, 4294967280UL, 17);   // p3=2^28-1
   *s4 = LCG(*s4, 1664525, 1013904223UL);             // p4=2^32
 
   // Combined period is lcm(p1,p2,p3,p4) ~ 2^121
-  return ((*s1) ^ (*s2) ^ (*s3) ^ (*s4)) / 4294967296.0 ;
+  return ((*s1) ^ (*s2) ^ (*s3) ^ (*s4));
+}
+
+#ifndef TWO_TO_32
+#define TWO_TO_32 4294967296.0
+#endif
+
+/*gpufun*/
+double rng_get (uint32_t *s1, uint32_t *s2, uint32_t *s3, uint32_t *s4 ){
+
+  return rng_get_int32(s1, s2, s3, s4) / TWO_TO_32; // uniform in [0, 1) 1e10 resolution
+
 }
 
 /*gpufun*/
@@ -47,5 +57,3 @@ void rng_set (uint32_t *s1, uint32_t *s2, uint32_t *s3, uint32_t *s4, uint32_t s
 }
 
 #endif /* XTRACK_BASE_RNG_H */
-
- 

{xtrack-0.65.4 → xtrack-0.65.5}/xtrack/pipeline/core.py

@@ -23,12 +23,12 @@ class PipelineCommunicator:
         self.messages[dest][tag].append(send_buffer)
         return self
 
-    def Recv(self,recieve_buffer,source,tag):
+    def Recv(self,receive_buffer,source,tag):
         assert source in self.messages.keys()
         assert tag in self.messages[source].keys()
         assert bool(self.messages[source][tag])
         message = self.messages[source][tag].pop(0)
-        recieve_buffer[:] = message[:]
+        receive_buffer[:] = message[:]
 
     def Iprobe(self,source, tag):
         if source in self.messages.keys():

{xtrack-0.65.4 → xtrack-0.65.5}/xtrack/pipeline/manager.py

@@ -36,10 +36,10 @@ class PipelineManager:
         self._elements[element_name] = len(self._elements)
 
     #
-    # The tag is a int that identifies messages given the rank of the sender and of the reciever
+    # The tag is a int that identifies messages given the rank of the sender and of the receiver
     #
-    def get_message_tag(self,element_name,sender_name,reciever_name,internal_tag=0):
-        tag = self._elements[element_name] + len(self._elements)*self._IDs[sender_name].number + len(self._elements)*len(self._IDs)*self._IDs[reciever_name].number + len(self._elements)*len(self._IDs)*len(self._IDs)*internal_tag
+    def get_message_tag(self,element_name,sender_name,receiver_name,internal_tag=0):
+        tag = self._elements[element_name] + len(self._elements)*self._IDs[sender_name].number + len(self._elements)*len(self._IDs)*self._IDs[receiver_name].number + len(self._elements)*len(self._IDs)*len(self._IDs)*internal_tag
         #if tag > self._max_tag:
         #    _print(f'PyPLINEDElement WARNING {self.name}: MPI message tag {tag} is larger than max ({self._max_tag})')
         return tag
@@ -47,41 +47,41 @@ class PipelineManager:
     #
     # The key is string that uniquely identifies a message
     #
-    def get_message_key(self,element_name,sender_name,reciever_name,tag=0):
-        return f'{element_name}_{sender_name}_{reciever_name}_{tag}'
+    def get_message_key(self,element_name,sender_name,receiver_name,tag=0):
+        return f'{element_name}_{sender_name}_{receiver_name}_{tag}'
 
-    def is_ready_to_send(self,element_name,sender_name,reciever_name,turn,internal_tag=0):
-        tag = self.get_message_tag(element_name=element_name,sender_name=sender_name,reciever_name=reciever_name,internal_tag=internal_tag)
-        key = self.get_message_key(element_name=element_name,sender_name=sender_name,reciever_name=reciever_name,tag=tag)
+    def is_ready_to_send(self,element_name,sender_name,receiver_name,turn,internal_tag=0):
+        tag = self.get_message_tag(element_name=element_name,sender_name=sender_name,receiver_name=receiver_name,internal_tag=internal_tag)
+        key = self.get_message_key(element_name=element_name,sender_name=sender_name,receiver_name=receiver_name,tag=tag)
         if key not in self._last_request_turn.keys():
             return True
         if turn <= self._last_request_turn[key]:
             if self.verbose:
-                _print(f'Pipeline manager {element_name}: {sender_name} at rank {self.get_particles_rank(sender_name)} has already sent a message to {reciever_name} at rank {self.get_particles_rank(reciever_name)} at turn {turn} with tag {tag}')
+                _print(f'Pipeline manager {element_name}: {sender_name} at rank {self.get_particles_rank(sender_name)} has already sent a message to {receiver_name} at rank {self.get_particles_rank(receiver_name)} at turn {turn} with tag {tag}')
             return False
         if not self._pending_requests[key].Test():
             if self.verbose:
-                _print(f'Pipeline manager {element_name}: {sender_name} at rank {self.get_particles_rank(sender_name)} previous message to {reciever_name} at rank {self.get_particles_rank(reciever_name)} with tag {tag} was not receviced yet')
+                _print(f'Pipeline manager {element_name}: {sender_name} at rank {self.get_particles_rank(sender_name)} previous message to {receiver_name} at rank {self.get_particles_rank(receiver_name)} with tag {tag} was not receviced yet')
             return False
         return True
 
-    def send_message(self,send_buffer,element_name,sender_name,reciever_name,turn,internal_tag=0):
-        tag = self.get_message_tag(element_name=element_name,sender_name=sender_name,reciever_name=reciever_name,internal_tag=internal_tag)
-        key = self.get_message_key(element_name=element_name,sender_name=sender_name,reciever_name=reciever_name,tag=tag)
+    def send_message(self,send_buffer,element_name,sender_name,receiver_name,turn,internal_tag=0):
+        tag = self.get_message_tag(element_name=element_name,sender_name=sender_name,receiver_name=receiver_name,internal_tag=internal_tag)
+        key = self.get_message_key(element_name=element_name,sender_name=sender_name,receiver_name=receiver_name,tag=tag)
         self._last_request_turn[key] = turn
         if self.verbose:
-            _print(f'Pipeline manager {element_name}: {sender_name} at rank {self.get_particles_rank(sender_name)} sending message to {reciever_name} at rank {self.get_particles_rank(reciever_name)} at turn {turn} with tag {tag}')
-        self._pending_requests[key] = self._communicator.Issend(send_buffer,dest=self.get_particles_rank(reciever_name),tag=tag)
+            _print(f'Pipeline manager {element_name}: {sender_name} at rank {self.get_particles_rank(sender_name)} sending message to {receiver_name} at rank {self.get_particles_rank(receiver_name)} at turn {turn} with tag {tag}')
+        self._pending_requests[key] = self._communicator.Issend(send_buffer,dest=self.get_particles_rank(receiver_name),tag=tag)
 
-    def is_ready_to_recieve(self,element_name,sender_name,reciever_name,internal_tag=0):
-        tag = self.get_message_tag(element_name=element_name,sender_name=sender_name,reciever_name=reciever_name,internal_tag=internal_tag)
+    def is_ready_to_receive(self,element_name,sender_name,receiver_name,internal_tag=0):
+        tag = self.get_message_tag(element_name=element_name,sender_name=sender_name,receiver_name=receiver_name,internal_tag=internal_tag)
         is_ready = self._communicator.Iprobe(source=self.get_particles_rank(sender_name), tag=tag)
         if self.verbose and not is_ready:
-            _print(f'Pipeline manager {element_name}: {reciever_name} at rank {self.get_particles_rank(reciever_name)} is not ready to recieve from {sender_name} at rank {self.get_particles_rank(sender_name)} with tag {tag}')
+            _print(f'Pipeline manager {element_name}: {receiver_name} at rank {self.get_particles_rank(receiver_name)} is not ready to receive from {sender_name} at rank {self.get_particles_rank(sender_name)} with tag {tag}')
         return is_ready
 
-    def recieve_message(self,recieve_buffer,element_name,sender_name,reciever_name,internal_tag=0):
-        tag = self.get_message_tag(element_name=element_name,sender_name=sender_name,reciever_name=reciever_name,internal_tag=internal_tag)
+    def receive_message(self,receive_buffer,element_name,sender_name,receiver_name,internal_tag=0):
+        tag = self.get_message_tag(element_name=element_name,sender_name=sender_name,receiver_name=receiver_name,internal_tag=internal_tag)
         if self.verbose:
-            _print(f'Pipeline manager {element_name}: {reciever_name} at rank {self.get_particles_rank(reciever_name)} recieving from {sender_name} at rank {self.get_particles_rank(sender_name)} with tag {tag}')
-        self._communicator.Recv(recieve_buffer,source=self.get_particles_rank(sender_name),tag=tag)
+            _print(f'Pipeline manager {element_name}: {receiver_name} at rank {self.get_particles_rank(receiver_name)} recieving from {sender_name} at rank {self.get_particles_rank(sender_name)} with tag {tag}')
+        self._communicator.Recv(receive_buffer,source=self.get_particles_rank(sender_name),tag=tag)

{xtrack-0.65.4 → xtrack-0.65.5}/xtrack/pipeline/multitracker.py

@@ -20,6 +20,9 @@ class PipelineBranch:
         self.particles = particles
         self.pipeline_status = None
 
+        if self.line.tracker is None:
+            raise ValueError('Tracker not built for line')
+
         self.line.tracker.enable_pipeline_hold = True
 
 class PipelineMultiTracker:
@@ -36,7 +39,8 @@ class PipelineMultiTracker:
 
         for branch in self.branches:
             branch.pipeline_status = branch.line.track(
-                 branch.particles, **kwargs)
+                 branch.particles, **kwargs,
+                 _called_by_pipeline=True)
 
         need_resume = True
         while need_resume:

xtrack-0.65.5/xtrack/random/__init__.py

@@ -0,0 +1,5 @@
+from .random_generators import (RandomUniform, RandomExponential, RandomNormal, RandomRutherford,
+                                RandomUniformAccurate)
+
+rng_classes = (RandomUniform, RandomExponential, RandomNormal, RandomRutherford,
+                RandomUniformAccurate)

{xtrack-0.65.4 → xtrack-0.65.5}/xtrack/random/random_generators.py

@@ -68,6 +68,32 @@ class RandomUniform(BeamElement):
                     (-1, n_samples_per_seed)
                 )
 
+class RandomUniformAccurate(RandomUniform):
+    _xofields = {
+        '_dummy': xo.UInt8,  # TODO: a hack for allocating an empty struct on OCL
+    }
+
+    allow_track = False
+
+    _depends_on = [RandomUniform]
+
+    _extra_c_sources = [
+        _pkg_root.joinpath('random','random_src','uniform_accurate.h')
+    ]
+
+    _per_particle_kernels = {
+        'sample_unif_accuurate': xo.Kernel(
+                c_name='RandomUniformAccurate_sample',
+                args=[
+                    xo.Arg(xo.Float64, pointer=True, name='samples'),
+                    xo.Arg(xo.Int64, name='n_samples_per_seed')
+                ]
+            )
+        }
+
+    def _sample(self, *args, **kwargs):
+        self.sample_unif_accuurate(*args, **kwargs)
+
 
 class RandomExponential(RandomUniform):
     _xofields = {

{xtrack-0.65.4 → xtrack-0.65.5}/xtrack/random/random_src/uniform.h

@@ -46,6 +46,28 @@ double RandomUniform_generate(LocalParticle* part){
     return r;
 }
 
+/*gpufun*/
+uint32_t RandomUniformUInt32_generate(LocalParticle* part){
+    uint32_t s1 = LocalParticle_get__rng_s1(part);
+    uint32_t s2 = LocalParticle_get__rng_s2(part);
+    uint32_t s3 = LocalParticle_get__rng_s3(part);
+    uint32_t s4 = LocalParticle_get__rng_s4(part);
+
+    if (s1==0 && s2==0 && s3==0 && s4==0) {
+        LocalParticle_kill_particle(part, RNG_ERR_SEEDS_NOT_SET);
+        return 0;
+    }
+
+    uint32_t r = rng_get_int32(&s1, &s2, &s3, &s4);
+
+    LocalParticle_set__rng_s1(part, s1);
+    LocalParticle_set__rng_s2(part, s2);
+    LocalParticle_set__rng_s3(part, s3);
+    LocalParticle_set__rng_s4(part, s4);
+
+    return r;
+}
+
 
 /*gpufun*/
 void RandomUniform_sample(RandomUniformData rng, LocalParticle* part0,