xfields 0.20.2__tar.gz → 0.20.3__tar.gz

{xfields-0.20.2/xfields.egg-info → xfields-0.20.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xfields
-Version: 0.20.2
+Version: 0.20.3
 Summary: Field Maps and Particle In Cell
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xfields

{xfields-0.20.2 → xfields-0.20.3}/tests/test_compressed_profile_interp_result.py

@@ -67,7 +67,7 @@ def test_compressed_profile_interp_result():
                              data_shape_1=comp_prof.data.shape[1],
                              data_shape_2=comp_prof.data.shape[2],
                              data=comp_prof.data,
-                             i_bunch_particles=np.zeros(num_parts, dtype=int),
+                             i_slot_particles=np.zeros(num_parts, dtype=int),
                              i_slice_particles=i_slice_particles,
                              out=interpolated_result
                              )

xfields-0.20.3/tests/test_element_with_slicer_filling_scheme.py

@@ -0,0 +1,189 @@
+import xfields as xf
+import xtrack as xt
+import numpy as np
+import xobjects as xo
+import pytest
+
+
+from xfields.beam_elements.element_with_slicer import ElementWithSlicer
+
+@pytest.mark.parametrize('buffer_round_trip', [True, False])
+@pytest.mark.parametrize('num_turns', [1, 2, 3])
+def test_element_with_slicer_filling_scheme(buffer_round_trip, num_turns):
+    ele = ElementWithSlicer(
+        zeta_range=(-1, 1),
+        num_slices=10,
+        filling_scheme=[1, 0, 1, 1],
+        bunch_spacing_zeta=5,
+        num_turns=num_turns,
+        circumference=100,
+        with_compressed_profile=True)
+    slicer = ele.slicer
+
+    ele1 = ElementWithSlicer(
+        zeta_range=(-1, 1),
+        num_slices=10,
+        filling_scheme=[1, 0, 1, 1],
+        bunch_spacing_zeta=5,
+        num_turns=num_turns,
+        circumference=100,
+        bunch_selection=[1, 2],
+        with_compressed_profile=True)
+    slicer1 = ele1.slicer
+
+    ele2 = ElementWithSlicer(
+        zeta_range=(-1, 1),
+        num_slices=10,
+        filling_scheme=[1, 0, 1, 1],
+        bunch_spacing_zeta=5,
+        num_turns=num_turns,
+        circumference=100,
+        bunch_selection=[0],
+        with_compressed_profile=True)
+    slicer2 = ele2.slicer
+
+    zeta = np.linspace(-20, 20, 1000000)
+    particles = xt.Particles(p0c=7000e9,
+                            zeta=zeta)
+
+    # different weight for the different bunches
+    zeta = particles.zeta
+    mask_bunch0 = (zeta > -1) & (zeta < 1)
+    particles.weight[mask_bunch0] = 1
+    mask_bunch1 = (zeta > -6) & (zeta < -4)
+    particles.weight[mask_bunch1] = 2
+    mask_bunch2 = (zeta > -11) & (zeta < -9)
+    particles.weight[mask_bunch2] = 3
+    mask_bunch3 = (zeta > -16) & (zeta < -14)
+    particles.weight[mask_bunch3] = 4
+
+    # line density
+    num_particles_bunch0 = np.sum(particles.weight[mask_bunch0])
+    xo.assert_allclose(num_particles_bunch0, 50000.0, rtol=1e-5, atol=0)
+
+    ele.track(particles)
+    ele1.track(particles)
+    ele2.track(particles)
+
+    if buffer_round_trip:
+        slicer = xf.UniformBinSlicer._from_npbuffer(slicer._to_npbuffer())
+        slicer1 = xf.UniformBinSlicer._from_npbuffer(slicer1._to_npbuffer())
+        slicer2 = xf.UniformBinSlicer._from_npbuffer(slicer2._to_npbuffer())
+
+    assert (slicer.filled_slots == np.array([0, 2, 3])).all()
+    assert (slicer1.filled_slots == np.array([0, 2, 3])).all()
+    assert (slicer2.filled_slots == np.array([0, 2, 3])).all()
+    assert (slicer.bunch_selection == np.array([0, 1, 2])).all()
+    assert (slicer1.bunch_selection == np.array([1, 2])).all()
+    assert (slicer2.bunch_selection == np.array([0])).all()
+    assert slicer.num_bunches == 3
+    assert slicer1.num_bunches == 2
+    assert slicer2.num_bunches == 1
+
+    xo.assert_allclose(slicer.zeta_centers,
+        np.array([[ -0.9,  -0.7,  -0.5,  -0.3,  -0.1,   0.1,   0.3,   0.5,   0.7,   0.9],
+                [-10.9, -10.7, -10.5, -10.3, -10.1,  -9.9,  -9.7,  -9.5,  -9.3,  -9.1],
+                [-15.9, -15.7, -15.5, -15.3, -15.1, -14.9, -14.7, -14.5, -14.3, -14.1]]),
+        rtol=0, atol=1e-12)
+
+    xo.assert_allclose(slicer1.zeta_centers,
+        np.array([[-10.9, -10.7, -10.5, -10.3, -10.1,  -9.9,  -9.7,  -9.5,  -9.3,  -9.1],
+                [-15.9, -15.7, -15.5, -15.3, -15.1, -14.9, -14.7, -14.5, -14.3, -14.1]]),
+        rtol=0, atol=1e-12)
+
+    xo.assert_allclose(slicer2.zeta_centers,
+        np.array([[-0.9,  -0.7,  -0.5,  -0.3,  -0.1,   0.1,   0.3,   0.5,   0.7,   0.9]]),
+        rtol=0, atol=1e-12)
+
+    xo.assert_allclose(slicer.zeta_range[0], -1, rtol=0, atol=1e-12)
+    xo.assert_allclose(slicer1.zeta_range[0], -1, rtol=0, atol=1e-12)
+    xo.assert_allclose(slicer2.zeta_range[0], -1, rtol=0, atol=1e-12)
+    xo.assert_allclose(slicer.zeta_range[1], 1, rtol=0, atol=1e-12)
+    xo.assert_allclose(slicer1.zeta_range[1], 1, rtol=0, atol=1e-12)
+    xo.assert_allclose(slicer2.zeta_range[1], 1, rtol=0, atol=1e-12)
+
+    xo.assert_allclose(slicer.num_particles,
+        np.array([
+            [ 5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.],
+            [15000., 15000., 15000., 15000., 15000., 15000., 15000., 15000., 15000., 15000.],
+            [20000., 20000., 20000., 20000., 20000., 20000., 20000., 20000., 20000., 20000.]]),
+        rtol=0, atol=1e-12)
+
+    xo.assert_allclose(slicer1.num_particles,
+        np.array([
+            [15000., 15000., 15000., 15000., 15000., 15000., 15000., 15000., 15000., 15000.],
+            [20000., 20000., 20000., 20000., 20000., 20000., 20000., 20000., 20000., 20000.]]),
+        rtol=0, atol=1e-12)
+
+    xo.assert_allclose(slicer2.num_particles,
+        np.array([
+            [ 5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.],
+            ]),
+        rtol=0, atol=1e-12)
+
+    z_prof, prof = ele.moments_data.get_moment_profile('num_particles', i_turn=0)
+    xo.assert_allclose(z_prof,
+        np.array([-15.9, -15.7, -15.5, -15.3, -15.1, -14.9, -14.7, -14.5, -14.3,
+                -14.1, -10.9, -10.7, -10.5, -10.3, -10.1,  -9.9,  -9.7,  -9.5,
+                -9.3,  -9.1,  -5.9,  -5.7,  -5.5,  -5.3,  -5.1,  -4.9,  -4.7,
+                -4.5,  -4.3,  -4.1,  -0.9,  -0.7,  -0.5,  -0.3,  -0.1,   0.1,
+                    0.3,   0.5,   0.7,   0.9]), rtol=0, atol=1e-12)
+    z_prof1, prof1 = ele1.moments_data.get_moment_profile('num_particles', i_turn=0)
+    z_prof2, prof2 = ele2.moments_data.get_moment_profile('num_particles', i_turn=0)
+
+    xo.assert_allclose(z_prof, z_prof1, rtol=0, atol=1e-12)
+    xo.assert_allclose(z_prof, z_prof2, rtol=0, atol=1e-12)
+
+    xo.assert_allclose(prof,
+        np.array([20000., 20000., 20000., 20000., 20000., 20000., 20000., 20000.,
+                20000., 20000., 15000., 15000., 15000., 15000., 15000., 15000.,
+                15000., 15000., 15000., 15000.,     0.,     0.,     0.,     0.,
+                    0.,     0.,     0.,     0.,     0.,     0.,  5000.,  5000.,
+                5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.,  5000.]),
+        rtol=0, atol=1e-12)
+
+    xo.assert_allclose(prof1,
+        np.array([20000., 20000., 20000., 20000., 20000., 20000., 20000., 20000.,
+                20000., 20000., 15000., 15000., 15000., 15000., 15000., 15000.,
+                15000., 15000., 15000., 15000.,     0.,     0.,     0.,     0.,
+                    0.,     0.,     0.,     0.,     0.,     0.,     0.,     0.,
+                    0.,     0.,     0.,     0.,     0.,     0.,     0.,     0.]),
+        rtol=0, atol=1e-12)
+
+    xo.assert_allclose(prof2,
+        np.array([   0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,
+                    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,
+                    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,
+                    0.,    0.,    0., 5000., 5000., 5000., 5000., 5000., 5000.,
+                5000., 5000., 5000., 5000.]),
+        rtol=0, atol=1e-12)
+
+    ele1._add_slicer_moments_to_moments_data(ele2.slicer)
+    ele2._add_slicer_moments_to_moments_data(ele1.slicer)
+
+    z_prof1_sum, prof1_sum = ele1.moments_data.get_moment_profile('num_particles', i_turn=0)
+    z_prof2_sum, prof2_sum = ele2.moments_data.get_moment_profile('num_particles', i_turn=0)
+
+    xo.assert_allclose(z_prof1_sum, z_prof, rtol=0, atol=1e-12)
+    xo.assert_allclose(z_prof2_sum, z_prof, rtol=0, atol=1e-12)
+    xo.assert_allclose(prof1_sum, prof, rtol=0, atol=1e-12)
+    xo.assert_allclose(prof2_sum, prof, rtol=0, atol=1e-12)
+
+    for i_turn in range(1, num_turns):
+        particles.weight *= 2
+        ele.track(particles)
+        ele1.track(particles)
+        ele2.track(particles)
+        ele1._add_slicer_moments_to_moments_data(ele2.slicer)
+        ele2._add_slicer_moments_to_moments_data(ele1.slicer)
+
+    for i_check in range(1, num_turns):
+        z_prof_turn,  prof_turn = ele.moments_data.get_moment_profile('num_particles', i_turn=i_check)
+        z_prof1_turn, prof1_turn = ele1.moments_data.get_moment_profile('num_particles', i_turn=i_check)
+        z_prof2_turn, prof2_turn = ele2.moments_data.get_moment_profile('num_particles', i_turn=i_check)
+        xo.assert_allclose(z_prof_turn, z_prof, rtol=0, atol=1e-12)
+        xo.assert_allclose(z_prof1_turn, z_prof, rtol=0, atol=1e-12)
+        xo.assert_allclose(z_prof2_turn, z_prof, rtol=0, atol=1e-12)
+
+        xo.assert_allclose(prof_turn, (2**(num_turns-1-i_check)) * prof, rtol=0, atol=1e-12)
+

{xfields-0.20.2 → xfields-0.20.3}/tests/test_slicer.py

@@ -33,7 +33,7 @@ def test_slicer_zeta(test_context):
 def test_slice_attribution_single_bunch(test_context):
     slicer = xf.UniformBinSlicer(zeta_range=(-1, 1), num_slices=3,
                                  _context=test_context)
-    assert slicer.num_bunches == 1  # Single-bunch mode
+    assert slicer.num_bunches == 1
 
     p0 = xt.Particles(
         zeta=[-2, -1.51, -1.49, -1, -0.51, -0.49, 0, 0.49, 0.51, 1, 1.49, 1.51,
@@ -54,15 +54,15 @@ def test_slice_attribution_single_bunch(test_context):
     i_slice_expected = [-1, -1, -1, 0, 0, 0, 1, 2, 2, -1, -1, -1, -1, -999]
     i_bunch_expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -9999]
     i_slice_particles = p.particle_id * 0 - 999
-    i_bunch_particles = p.particle_id * 0 - 9999
-    slicer.slice(particles=p, i_bunch_particles=i_bunch_particles,
+    i_slot_particles = p.particle_id * 0 - 9999
+    slicer.slice(particles=p, i_slot_particles=i_slot_particles,
                  i_slice_particles=i_slice_particles)
 
     xo.assert_allclose(np.array(i_slice_expected), i_slice_particles, atol=0, rtol=0)
-    xo.assert_allclose(i_bunch_particles, i_bunch_expected,  atol=0, rtol=0)
+    xo.assert_allclose(i_slot_particles, i_bunch_expected,  atol=0, rtol=0)
 
     expected_num_particles = np.array([40, 20, 50])
-    xo.assert_allclose(slicer.num_particles[0, :], expected_num_particles,
+    xo.assert_allclose(slicer.num_particles, expected_num_particles,
                        atol=1e-12, rtol=0)
 
 
@@ -97,7 +97,7 @@ def test_slice_attribution_multi_bunch(test_context):
 
     p = xt.Particles.merge([p1, p2, p3, p4])
 
-    i_bunch_particles = p.particle_id * 0 - 999
+    i_slot_particles = p.particle_id * 0 - 999
     i_slice_particles = p.particle_id * 0 - 999
 
     slicer = xf.UniformBinSlicer(zeta_range=(-1, 1), num_slices=3,
@@ -106,7 +106,7 @@ def test_slice_attribution_multi_bunch(test_context):
                                  _context=test_context)
     slicer.slice(particles=p,
                  i_slice_particles=i_slice_particles,
-                 i_bunch_particles=i_bunch_particles)
+                 i_slot_particles=i_slot_particles)
 
     # when we merge the particles the ones with state zero end up at the end so
     # the -999 are now at the end of the array
@@ -128,8 +128,8 @@ def test_slice_attribution_multi_bunch(test_context):
         [40000, 20000, 50000],
     ])
 
+    xo.assert_allclose(i_slot_particles, i_bunch_expected_mb, rtol=0, atol=0)
     xo.assert_allclose(i_slice_particles, i_slice_expected_mb, rtol=0, atol=0)
-    xo.assert_allclose(i_bunch_particles, i_bunch_expected_mb, rtol=0, atol=0)
     xo.assert_allclose(slicer.num_particles, expected_num_particles_mb,
                        atol=1e-12, rtol=0)
 
@@ -175,51 +175,51 @@ def test_slicer_moments_single_bunch(test_context):
         xo.assert_allclose(sl.zeta_centers, np.array([-2 / 3, 0, 2 / 3]),
                            rtol=0,
                            atol=1e-12)
-        xo.assert_allclose(sl.num_particles[0, :], [0, 0, p.weight.sum()], rtol=0,
+        xo.assert_allclose(sl.num_particles, [0, 0, p.weight.sum()], rtol=0,
                            atol=1e-12)
-        xo.assert_allclose(sl.sum('x')[0, :], [0, 0, (p.x * p.weight).sum()], rtol=0,
+        xo.assert_allclose(sl.sum('x'), [0, 0, (p.x * p.weight).sum()], rtol=0,
                            atol=1e-12)
-        xo.assert_allclose(sl.sum('y')[0, :], [0, 0, (p.y * p.weight).sum()], rtol=0,
+        xo.assert_allclose(sl.sum('y'), [0, 0, (p.y * p.weight).sum()], rtol=0,
                            atol=1e-12)
-        xo.assert_allclose(sl.sum('zeta')[0, :], [0, 0, (p.zeta * p.weight).sum()],
+        xo.assert_allclose(sl.sum('zeta'), [0, 0, (p.zeta * p.weight).sum()],
                            rtol=0, atol=1e-12)
-        xo.assert_allclose(sl.sum('xx')[0, :], [0, 0, (p.x ** 2 * p.weight).sum()],
+        xo.assert_allclose(sl.sum('xx'), [0, 0, (p.x ** 2 * p.weight).sum()],
                            rtol=0,
                            atol=1e-12)
-        xo.assert_allclose(sl.sum('yy')[0, :], [0, 0, (p.y ** 2 * p.weight).sum()],
+        xo.assert_allclose(sl.sum('yy'), [0, 0, (p.y ** 2 * p.weight).sum()],
                            rtol=0,
                            atol=1e-12)
-        xo.assert_allclose(sl.sum('zetazeta')[0, :],
+        xo.assert_allclose(sl.sum('zetazeta'),
                            [0, 0, (p.zeta ** 2 * p.weight).sum()],
                            rtol=0, atol=1e-12)
-        xo.assert_allclose(sl.sum('xy')[0, :], [0, 0, (p.x * p.y * p.weight).sum()],
+        xo.assert_allclose(sl.sum('xy'), [0, 0, (p.x * p.y * p.weight).sum()],
                            rtol=0, atol=1e-12)
-        xo.assert_allclose(sl.sum('xzeta')[0, :],
+        xo.assert_allclose(sl.sum('xzeta'),
                            [0, 0, (p.x * p.zeta * p.weight).sum()],
                            rtol=0, atol=1e-12)
-        xo.assert_allclose(sl.mean('x')[0, :],
+        xo.assert_allclose(sl.mean('x'),
                            [0, 0, (p.x * p.weight).sum() / p.weight.sum()],
                            rtol=0,
                            atol=1e-12)
-        xo.assert_allclose(sl.mean('y')[0, :],
+        xo.assert_allclose(sl.mean('y'),
                            [0, 0, (p.y * p.weight).sum() / p.weight.sum()],
                            rtol=0,
                            atol=1e-12)
-        xo.assert_allclose(sl.mean('xx')[0, :],
+        xo.assert_allclose(sl.mean('xx'),
                            [0, 0, (p.x ** 2 * p.weight).sum() / p.weight.sum()],
                            rtol=0, atol=1e-12)
-        xo.assert_allclose(sl.mean('yy')[0, :],
+        xo.assert_allclose(sl.mean('yy'),
                            [0, 0, (p.y ** 2 * p.weight).sum() / p.weight.sum()],
                            rtol=0, atol=1e-12)
-        xo.assert_allclose(sl.mean('zetazeta')[0, :],
+        xo.assert_allclose(sl.mean('zetazeta'),
                            [0, 0,
                             (p.zeta ** 2 * p.weight).sum() / p.weight.sum()],
                            rtol=0, atol=1e-12)
-        xo.assert_allclose(sl.mean('xy')[0, :],
+        xo.assert_allclose(sl.mean('xy'),
                            [0, 0,
                             (p.x * p.y * p.weight).sum() / p.weight.sum()],
                            rtol=0, atol=1e-12)
-        xo.assert_allclose(sl.mean('xzeta')[0, :],
+        xo.assert_allclose(sl.mean('xzeta'),
                            [0, 0,
                             (p.x * p.zeta * p.weight).sum() / p.weight.sum()],
                            rtol=0, atol=1e-12)
@@ -296,50 +296,50 @@ def test_slicer_moments_single_bunch(test_context):
             xo.assert_allclose(sl.zeta_centers, np.array([-2 / 3, 0, 2 / 3]),
                                rtol=0,
                                atol=1e-12)
-            xo.assert_allclose(sl.num_particles[0, :], [0, 0, p.weight.sum()], rtol=0,
+            xo.assert_allclose(sl.num_particles, [0, 0, p.weight.sum()], rtol=0,
                                atol=1e-12)
-            xo.assert_allclose(sl.sum(c1_name)[0], [0, 0, (c1 * p.weight).sum()],
+            xo.assert_allclose(sl.sum(c1_name), [0, 0, (c1 * p.weight).sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.sum(c2_name)[0], [0, 0, (c2 * p.weight).sum()],
+            xo.assert_allclose(sl.sum(c2_name), [0, 0, (c2 * p.weight).sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.sum('zeta')[0],
+            xo.assert_allclose(sl.sum('zeta'),
                                [0, 0, (p.zeta * p.weight).sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.sum(c1_name + c1_name)[0],
+            xo.assert_allclose(sl.sum(c1_name + c1_name),
                                [0, 0, (c1 ** 2 * p.weight).sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.sum(c2_name + c2_name)[0],
+            xo.assert_allclose(sl.sum(c2_name + c2_name),
                                [0, 0, (c2 ** 2 * p.weight).sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.sum(c1_name + c2_name)[0],
+            xo.assert_allclose(sl.sum(c1_name + c2_name),
                                [0, 0, (c1 * c2 * p.weight).sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.sum('zetazeta')[0],
+            xo.assert_allclose(sl.sum('zetazeta'),
                                [0, 0, (p.zeta ** 2 * p.weight).sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.sum(c1_name + 'zeta')[0],
+            xo.assert_allclose(sl.sum(c1_name + 'zeta'),
                                [0, 0, (c1 * p.zeta * p.weight).sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.mean(c1_name)[0],
+            xo.assert_allclose(sl.mean(c1_name),
                                [0, 0, (c1 * p.weight).sum() / p.weight.sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.mean(c2_name)[0],
+            xo.assert_allclose(sl.mean(c2_name),
                                [0, 0, (c2 * p.weight).sum() / p.weight.sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.mean(c1_name + c1_name)[0],
+            xo.assert_allclose(sl.mean(c1_name + c1_name),
                                [0, 0,
                                 (c1 ** 2 * p.weight).sum() / p.weight.sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.mean(c2_name + c2_name)[0],
+            xo.assert_allclose(sl.mean(c2_name + c2_name),
                                [0, 0,
                                 (c2 ** 2 * p.weight).sum() / p.weight.sum()],
                                rtol=0, atol=1e-12)
-            xo.assert_allclose(sl.mean(c1_name + c2_name)[0],
+            xo.assert_allclose(sl.mean(c1_name + c2_name),
                                [0, 0,
                                 (c1 * c2 * p.weight).sum() / p.weight.sum()],
                                rtol=0, atol=1e-12)
             xo.assert_allclose(
-                sl.mean(c1_name + 'zeta')[0],
+                sl.mean(c1_name + 'zeta'),
                 [0, 0, (c1 * p.zeta * p.weight).sum() / p.weight.sum()],
                 rtol=0, atol=1e-12)
             xo.assert_allclose(

{xfields-0.20.2 → xfields-0.20.3}/xfields/__init__.py

@@ -24,9 +24,6 @@ from .beam_elements.beambeam3d import ConfigForUpdateBeamBeamBiGaussian3D
 from .beam_elements.temp_slicer import TempSlicer
 from .beam_elements.electroncloud import ElectronCloud
 from .beam_elements.electronlens_interpolated import ElectronLensInterpolated
-from .beam_elements.wakefield import WakeComponent, ResonatorWake
-from .beam_elements.wakefield import Wakefield
-from .beam_elements.transverse_damper import TransverseDamper
 
 from .general import _pkg_root
 from .config_tools import replace_spacecharge_with_quasi_frozen

xfields-0.20.3/xfields/_version.py

@@ -0,0 +1 @@
+__version__ = "0.20.3"

{xfields-0.20.2 → xfields-0.20.3}/xfields/beam_elements/beambeam2d.py

@@ -240,11 +240,11 @@ class BeamBeamBiGaussian2D(xt.BeamElement):
                                                  particles.at_turn[0],
                                                  internal_tag=0)
 
-            if self.config_for_update.pipeline_manager.is_ready_to_recieve(self.config_for_update.element_name,
+            if self.config_for_update.pipeline_manager.is_ready_to_receive(self.config_for_update.element_name,
                                     self.config_for_update.partner_particles_name,
                                     particles.name,
                                     internal_tag=0):
-                self.config_for_update.pipeline_manager.recieve_message(self.partner_moments,
+                self.config_for_update.pipeline_manager.receive_message(self.partner_moments,
                                     self.config_for_update.element_name,
                                     self.config_for_update.partner_particles_name,
                                     particles.name,

{xfields-0.20.2 → xfields-0.20.3}/xfields/beam_elements/beambeam3d.py

@@ -782,11 +782,11 @@ class BeamBeamBiGaussian3D(xt.BeamElement):
                                                      self.config_for_update.partner_particles_name,
                                                      at_turn,
                                                      internal_tag=self.config_for_update._i_step)
-                if self.config_for_update.pipeline_manager.is_ready_to_recieve(self.config_for_update.element_name,
+                if self.config_for_update.pipeline_manager.is_ready_to_receive(self.config_for_update.element_name,
                                         self.config_for_update.partner_particles_name,
                                         particles.name,
                                         internal_tag=self.config_for_update._i_step):
-                    self.config_for_update.pipeline_manager.recieve_message(self.partner_moments,
+                    self.config_for_update.pipeline_manager.receive_message(self.partner_moments,
                                         self.config_for_update.element_name,
                                         self.config_for_update.partner_particles_name,
                                         particles.name,

{xfields-0.20.2 → xfields-0.20.3}/xfields/beam_elements/element_with_slicer.py

@@ -24,7 +24,7 @@ class ElementWithSlicer:
         of the array is equal to the number of slots in the machine and each
         element of the array holds a one if the slot is filled or a zero
         otherwise.
-    bunch_numbers: np.ndarray
+    bunch_selection: np.ndarray
         List of the bunches indicating which slots from the filling scheme are
         used (not all the bunches are used when using multi-processing)
     num_turns : int
@@ -44,13 +44,16 @@ class ElementWithSlicer:
                  num_slices=None,  # Per bunch, this is N_1 in the paper
                  bunch_spacing_zeta=None,  # This is P in the paper
                  filling_scheme=None,
-                 bunch_numbers=None,
+                 bunch_selection=None,
                  num_turns=1,
                  circumference=None,
-                 _flatten=False,
                  with_compressed_profile=False):
 
         self.with_compressed_profile = with_compressed_profile
+        self.pipeline_manager = None
+
+        if slicer_moments is None:
+            slicer_moments = ['num_particles']
 
         self.source_moments = slicer_moments.copy()
 
@@ -61,7 +64,7 @@ class ElementWithSlicer:
         self.init_slicer(zeta_range=zeta_range,
                          num_slices=num_slices,
                          filling_scheme=filling_scheme,
-                         bunch_numbers=bunch_numbers,
+                         bunch_selection=bunch_selection,
                          bunch_spacing_zeta=bunch_spacing_zeta,
                          slicer_moments=slicer_moments)
 
@@ -75,7 +78,7 @@ class ElementWithSlicer:
                 circumference=circumference)
 
     def init_slicer(self, zeta_range, num_slices, filling_scheme,
-                    bunch_numbers, bunch_spacing_zeta, slicer_moments):
+                    bunch_selection, bunch_spacing_zeta, slicer_moments):
         if zeta_range is not None:
             if 'num_particles' in slicer_moments:
                 slicer_moments.remove('num_particles')
@@ -83,7 +86,7 @@ class ElementWithSlicer:
                 zeta_range=zeta_range,
                 num_slices=num_slices,
                 filling_scheme=filling_scheme,
-                bunch_numbers=bunch_numbers,
+                bunch_selection=bunch_selection,
                 bunch_spacing_zeta=bunch_spacing_zeta,
                 moments=slicer_moments
             )
@@ -100,19 +103,23 @@ class ElementWithSlicer:
             num_turns=1,
             circumference=None):
 
+        if filling_scheme is not None:
+            i_last_bunch = np.where(filling_scheme)[0][-1]
+            num_periods = i_last_bunch + 1
+        else:
+            num_periods = 1
         self.moments_data = CompressedProfile(
                 moments=self.source_moments + ['result'],
                 zeta_range=zeta_range,
                 num_slices=num_slices,
                 bunch_spacing_zeta=bunch_spacing_zeta,
-                num_periods=(len(filling_scheme) if filling_scheme is not None
-                                                 else 1),
+                num_periods=num_periods,
                 num_turns=num_turns,
                 circumference=circumference)
 
-    def init_pipeline(self, pipeline_manager, element_name, partners_names):
+    def init_pipeline(self, pipeline_manager, element_name, partner_names):
         self.pipeline_manager = pipeline_manager
-        self.partners_names = partners_names
+        self.partner_names = partner_names
         self.name = element_name
 
         self._send_buffer = self.slicer._to_npbuffer()
@@ -137,15 +144,15 @@ class ElementWithSlicer:
     def _slice_and_store(self, particles, _slice_result=None):
         if _slice_result is not None:
             self.i_slice_particles = _slice_result['i_slice_particles']
-            self.i_bunch_particles = _slice_result['i_bunch_particles']
+            self.i_slot_particles = _slice_result['i_slot_particles']
             self.slicer = _slice_result['slicer']
         else:
             # Measure slice moments and get slice indeces
             self.i_slice_particles = particles.particle_id * 0 + -999
-            self.i_bunch_particles = particles.particle_id * 0 + -9999
+            self.i_slot_particles = particles.particle_id * 0 + -9999
             self.slicer.slice(particles,
                               i_slice_particles=self.i_slice_particles,
-                              i_bunch_particles=self.i_bunch_particles)
+                              i_slot_particles=self.i_slot_particles)
 
     def _add_slicer_moments_to_moments_data(self, slicer):
         if not self.with_compressed_profile:
@@ -158,12 +165,13 @@ class ElementWithSlicer:
                 continue
             means[mm] = slicer.mean(mm)
 
-        for i_bunch_in_slicer, bunch_number in enumerate(slicer.bunch_numbers):
+        for i_bunch_in_slicer, bunch_number in enumerate(slicer.bunch_selection):
             moments_bunch = {}
             for nn in means.keys():
-                moments_bunch[nn] = means[nn][i_bunch_in_slicer, :]
-            moments_bunch['num_particles'] = (
-                slicer.num_particles[i_bunch_in_slicer, :])
+                moments_bunch[nn] = np.atleast_2d(means[nn])[i_bunch_in_slicer, :]
+
+            moments_bunch['num_particles'] = np.atleast_2d(slicer.num_particles)[i_bunch_in_slicer, :]
+
             self.moments_data.set_moments(
                 moments=moments_bunch,
                 i_turn=0,
@@ -192,7 +200,7 @@ class ElementWithSlicer:
             self.other_bunch_slicers = []
             is_ready_to_send = True
 
-            for i_partner, partner_name in enumerate(self.partners_names):
+            for partner_name in self.partner_names:
                 if not self.pipeline_manager.is_ready_to_send(
                         self.name,
                         particles.name,
@@ -207,12 +215,12 @@ class ElementWithSlicer:
                 self._update_moments_for_new_turn(particles,
                                                   _slice_result=_slice_result)
                 self._slicer_to_buffer(self.slicer)
-                for i_partner, partner_name in enumerate(self.partners_names):
+                for partner_name in self.partner_names:
                     self.pipeline_manager.send_message(
                         self._send_buffer_length,
                         element_name=self.name,
                         sender_name=particles.name,
-                        reciever_name=partner_name,
+                        receiver_name=partner_name,
                         turn=particles.at_turn[0],
                         internal_tag=0
                     )
@@ -220,26 +228,27 @@ class ElementWithSlicer:
                         self._send_buffer,
                         element_name=self.name,
                         sender_name=particles.name,
-                        reciever_name=partner_name,
+                        receiver_name=partner_name,
                         turn=particles.at_turn[0],
                         internal_tag=1)
 
-            for i_partner, partner_name in enumerate(self.partners_names):
-                if not self.pipeline_manager.is_ready_to_recieve(
-                        self.name, partner_name,
-                        particles.name, internal_tag=0):
+            for partner_name in self.partner_names:
+                if not self.pipeline_manager.is_ready_to_receive(
+                                        self.name, partner_name,
+                                        particles.name, internal_tag=0):
                     return xt.PipelineStatus(on_hold=True)
 
         if self.pipeline_manager is not None:
-            for i_partner, partner_name in enumerate(self.partners_names):
-                self.pipeline_manager.recieve_message(
+            for partner_name in self.partner_names:
+                self.pipeline_manager.receive_message(
                     self._recv_buffer_length_buffer,
                     self.name,
                     partner_name,
                     particles.name,
                     internal_tag=0)
+
                 self._ensure_recv_buffer_size()
-                self.pipeline_manager.recieve_message(self._recv_buffer,
+                self.pipeline_manager.receive_message(self._recv_buffer,
                                                       self.name,
                                                       partner_name,
                                                       particles.name,
@@ -257,5 +266,5 @@ class ElementWithSlicer:
 
         if not self.with_compressed_profile:
             self._slice_result = {'i_slice_particles': self.i_slice_particles,
-                                  'i_bunch_particles': self.i_bunch_particles,
+                                  'i_slot_particles': self.i_slot_particles,
                                   'slicer': self.slicer}

xfields-0.20.3/xfields/beam_elements/waketracker/__init__.py

@@ -0,0 +1 @@
+from .waketracker import WakeTracker