peclet-core 1.2.0__tar.gz → 1.3.0__tar.gz

{peclet_core-1.2.0 → peclet_core-1.3.0}/CITATION.cff

@@ -16,8 +16,8 @@ authors:
     orcid: "https://orcid.org/0000-0001-6099-3583"
     email: e.a.j.f.peters@tue.nl
     affiliation: "Eindhoven University of Technology"
-version: 1.2.0
-date-released: 2026-09-24
+version: 1.3.0
+date-released: 2026-09-26
 license: MIT
 doi: 10.5281/zenodo.21132435
 identifiers:

{peclet_core-1.2.0 → peclet_core-1.3.0}/CLAUDE.md

@@ -31,13 +31,13 @@ judgement call in the moment.
 ```bash
 # CPU library + tests (no device dependency):
 cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j
-ctest --test-dir build --output-on-failure -LE bench   # 72 ctests (73 with `bench`): decomposition, MPI halo, particle migration, MG stages, diffusion, geometry
+ctest --test-dir build --output-on-failure -LE bench   # 76 ctests (77 with `bench`): decomposition, MPI halo, particle migration, MG stages, diffusion, geometry
 
 # Portable Kokkos device halo (CUDA / HIP / OpenMP) -- opt-in, find_package(Kokkos):
 export PATH=/usr/local/cuda-13.2/bin:$PATH    # if the Kokkos install targets the CUDA backend
 cmake -S . -B build_kokkos -DPECLET_CORE_ENABLE_KOKKOS=ON \
   -DCMAKE_PREFIX_PATH=../extern/install/nvidia-cuda
-cmake --build build_kokkos -j && ctest --test-dir build_kokkos --output-on-failure -LE bench  # 87 ctests (88 with `bench`): + device halo / geometry / solver, np=1,2,4,8
+cmake --build build_kokkos -j && ctest --test-dir build_kokkos --output-on-failure -LE bench  # 91 ctests (92 with `bench`): + device halo / geometry / solver, np=1,2,4,8
 mpirun -np 4 ./build/benchmarks/bench_halo 48 1 300
 
 # Python modules + their ctests (test_mpi.py np=1,2,4,8; state_hash; ndarray interop). Release is
@@ -158,6 +158,14 @@ Header-only under `include/peclet/core/`:
   particle proximity; `forward` (owner→ghost), `reverse` (ghost→owner, accumulate) and
   `forwardPositions` (periodic image shift) are the cheap per-step exchanges. The standard distributed
   particle schemes (frozen/replicate, Newton-on, force-accumulate) are compositions of these.
+  `build(pos, rcut, includePeriodicSelf = false, allImages = false)`: by default each particle goes
+  to each other rank ONCE, at the image nearest that rank's block — on a periodic axis the ORB left
+  undecomposed that is always the unshifted image, so a wrapped image inside `rcut` is dropped and a
+  pair crossing a rank face while wrapping that axis is seen by neither owner. `allImages = true`
+  (opt-in, 1.3.0; dem's distributed step, `../dem/docs/contact_solve_framework.md` §5.3)
+  sends every image within `rcut`, one send entry per image, so an owned index may repeat in one
+  rank's `sendIdx` and a ghost is identified by (owner id, shift); forward/reverse work per entry.
+  Off is byte-identical to the one-image rule. Gate: `test_particle_halo_images_mpi` (np 1–8).
 - `halo/particle_halo.hpp` — `ParticleHalo<Dim>`: the Kokkos GPU-resident driver for
   `ParticleHaloTopology` (on-device forward gather + reverse atomic-accumulate; host-staged or
   GPU-aware MPI). Built from `ParticleHaloTopology::flatten()`; consumed by dem's distributed step.

{peclet_core-1.2.0 → peclet_core-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: peclet-core
-Version: 1.2.0
+Version: 1.3.0
 Summary: peclet.core — compatibility shell: peclet.core.geom is now peclet.geom, peclet.core.mpi is now peclet.halo
 Project-URL: Homepage, https://github.com/computational-chemical-engineering/peclet
 Project-URL: Documentation, https://computational-chemical-engineering.github.io/peclet/

{peclet_core-1.2.0 → peclet_core-1.3.0}/docs/Doxyfile

@@ -5,7 +5,7 @@
 
 DOXYFILE_ENCODING      = UTF-8
 PROJECT_NAME           = "core"
-PROJECT_NUMBER         = 1.2.0
+PROJECT_NUMBER         = 1.3.0
 PROJECT_BRIEF          = "Shared MPI block decomposition, asynchronous ghost-layer exchange, SDF geometry, load balancing (header-only C++20)"
 OUTPUT_DIRECTORY       = docs
 HTML_OUTPUT            = html

{peclet_core-1.2.0 → peclet_core-1.3.0}/include/peclet/core/halo/particle_halo_topology.hpp

@@ -21,6 +21,7 @@
 #ifndef PECLET_CORE_HALO_PARTICLE_HALO_TOPOLOGY_HPP
 #define PECLET_CORE_HALO_PARTICLE_HALO_TOPOLOGY_HPP
 
+#include <algorithm>
 #include <cstring>
 #include <map>
 #include <vector>
@@ -49,7 +50,20 @@ class ParticleHaloTopology {
   /// byte-identical to the cross-rank-only behaviour (no self-ghosts, no MPI self-messages).
   /// Self-ghosts occupy the ghost slots AFTER the received ones ([numReceived, numGhost)) and are
   /// filled locally (no MPI).
-  void build(const std::vector<Vec<Dim>>& pos, double rcut, bool includePeriodicSelf = false) {
+  ///
+  /// `allImages` changes what the CROSS-RANK exchange sends. Off (the default), each owned particle
+  /// goes to each other rank at most once, at the single periodic image nearest that rank's block
+  /// (`withinRcutOfBlock`). On a periodic axis the ORB leaves undecomposed, that nearest image is
+  /// always the unshifted one (its gap on the axis is 0), so a wrapped image inside `rcut` is never
+  /// sent. On, EVERY periodic image of the particle within `rcut` of rank r's block is sent
+  /// (`imagesWithinRcutOfBlock` with the identity allowed), one send entry per image: the same
+  /// owned index may then appear several times in one rank's send list, each with its own shift,
+  /// and a receiver identifies a ghost by (owner id, shift). Every exchange works per entry, so
+  /// forwardPositions places each image, and reverse sums every image's contribution onto the
+  /// owner. The shift of an allImages entry is exactly 0 or +-L per axis. Off => byte-identical to
+  /// the one-image behaviour.
+  void build(const std::vector<Vec<Dim>>& pos, double rcut, bool includePeriodicSelf = false,
+             bool allImages = false) {
     numOwned_ = pos.size();
     int nranks = 0;
     MPI_Comm_size(mig_->comm(), &nranks);
@@ -59,10 +73,35 @@ class ParticleHaloTopology {
     std::map<int, std::vector<Index>> sendMap;
     std::map<int, std::vector<Vec<Dim>>> shiftMap;
     Vec<Dim> img;
+    std::vector<Vec<Dim>> imgShifts;
+    // Candidate ranks (ascending): those whose block comes within rcut of the bounding box of my
+    // particles, images included (boxWithinRcutOfBlock). A superset of every rank any particle can
+    // qualify for, so the send lists -- entries and order -- are those of the all-ranks loop; the
+    // per-particle work drops from O(numRanks) to O(neighbours).
+    std::vector<int> cand;
+    if (!pos.empty()) {
+      Vec<Dim> bmin = pos[0], bmax = pos[0];
+      for (const auto& x : pos)
+        for (int d = 0; d < Dim; ++d) {
+          bmin[d] = std::min(bmin[d], x[d]);
+          bmax[d] = std::max(bmax[d], x[d]);
+        }
+      for (int r = 0; r < nranks; ++r)
+        if (r != me && mig_->boxWithinRcutOfBlock(bmin, bmax, r, rcut))
+          cand.push_back(r);
+    }
     for (std::size_t i = 0; i < pos.size(); ++i) {
-      for (int r = 0; r < nranks; ++r) {
-        if (r == me)
+      for (const int r : cand) {
+        if (allImages) {
+          // Every qualifying image, one send entry each (the identity included).
+          imgShifts.clear();
+          mig_->imagesWithinRcutOfBlock(pos[i], r, rcut, /*allowIdentity=*/true, imgShifts);
+          for (const auto& sh : imgShifts) {
+            sendMap[r].push_back(static_cast<Index>(i));
+            shiftMap[r].push_back(sh);
+          }
           continue;
+        }
         if (!mig_->withinRcutOfBlock(pos[i], r, rcut, img))
           continue;
         Vec<Dim> shift;
@@ -74,11 +113,13 @@ class ParticleHaloTopology {
     }
     sendRanks_.clear();
     sendIdx_.clear();
+    sendShift_.clear();
     sendRankPos_.clear();
     for (auto& [r, idx] : sendMap) {
       sendRankPos_[r] = sendRanks_.size();
       sendRanks_.push_back(r);
       sendIdx_.push_back(std::move(idx));
+      sendShift_.push_back(shiftMap[r]);  // the image each entry is sent as (parallel to sendIdx_)
     }
 
     // Exchange the shift vectors (one NBX round) to size the ghost array + matched recv lists.
@@ -242,26 +283,33 @@ class ParticleHaloTopology {
   // pack). recvOffsets index the contiguous [0,numGhost) ghost array (in recvRanks order); shift is
   // per-ghost (for position forwards). Rebuild after each build().
   struct FlatTopo {
-    std::vector<int> sendRanks;      // neighbour ranks I send owned copies to
-    std::vector<Index> sendIdx;      // concatenated owned indices to send (all ranks)
-    std::vector<int> sendCounts;     // per send rank
-    std::vector<int> sendOffsets;    // prefix sum into sendIdx (size sendRanks+1)
-    std::vector<int> recvRanks;      // neighbour ranks I receive ghosts from
-    std::vector<int> recvCounts;     // per recv rank
-    std::vector<Index> recvOffsets;  // per recv rank: start in the [0,numReceived) ghost array
-    std::vector<Vec<Dim>> shift;     // per ghost: periodic image offset (add to forwarded position)
-    std::vector<Index> selfIdx;      // owned index of each LOCAL periodic self-ghost (size numSelf)
-    Index numReceived = 0;           // ghost slots [0,numReceived) are cross-rank (MPI), the rest
+    std::vector<int> sendRanks;       // neighbour ranks I send owned copies to
+    std::vector<Index> sendIdx;       // concatenated owned indices to send (all ranks); with
+                                      // allImages an index may repeat within one rank's slice
+                                      // (one entry per periodic image)
+    std::vector<Vec<Dim>> sendShift;  // parallel to sendIdx: the periodic image offset the entry is
+                                      // sent with (the receiver's ghost shift for that entry)
+    std::vector<int> sendCounts;      // per send rank
+    std::vector<int> sendOffsets;     // prefix sum into sendIdx (size sendRanks+1)
+    std::vector<int> recvRanks;       // neighbour ranks I receive ghosts from
+    std::vector<int> recvCounts;      // per recv rank
+    std::vector<Index> recvOffsets;   // per recv rank: start in the [0,numReceived) ghost array
+    std::vector<Vec<Dim>> shift;  // per ghost: periodic image offset (add to forwarded position)
+    std::vector<Index> selfIdx;   // owned index of each LOCAL periodic self-ghost (size numSelf)
+    Index numReceived = 0;        // ghost slots [0,numReceived) are cross-rank (MPI), the rest
                             // [numReceived, numGhost) are local self-ghosts gathered from selfIdx
   };
   FlatTopo flatten() const {
     FlatTopo t;
     t.sendRanks = sendRanks_;
     t.sendOffsets.push_back(0);
-    for (const auto& idx : sendIdx_) {
+    for (std::size_t k = 0; k < sendIdx_.size(); ++k) {
+      const auto& idx = sendIdx_[k];
       t.sendCounts.push_back(static_cast<int>(idx.size()));
       for (Index id : idx)
         t.sendIdx.push_back(id);
+      for (const auto& sh : sendShift_[k])
+        t.sendShift.push_back(sh);
       t.sendOffsets.push_back(static_cast<int>(t.sendIdx.size()));
     }
     t.recvRanks = recvRanks_;
@@ -281,6 +329,7 @@ class ParticleHaloTopology {
   // Owner side: particles I send as ghosts to each neighbour rank.
   std::vector<int> sendRanks_;
   std::vector<std::vector<Index>> sendIdx_;
+  std::vector<std::vector<Vec<Dim>>> sendShift_;  // parallel to sendIdx_: each entry's image offset
   std::map<int, std::size_t> sendRankPos_;
 
   // Ghost side: ghosts I receive from each neighbour rank (contiguous slots, in recvRanks_ order).

{peclet_core-1.2.0 → peclet_core-1.3.0}/include/peclet/core/halo/particle_migrator.hpp

@@ -199,6 +199,32 @@ class ParticleMigrator {
   /// periodic face (an undecomposed periodic axis, or np=1). `allowIdentity=false` drops the
   /// un-shifted image, so r==self yields only the periodic self-wrap copies (a particle is never
   /// its own ghost).
+  /// True iff some point of the box [bmin, bmax] (a periodic image of it included) lies within
+  /// `rcut` of rank r's block. A point of the box has, per axis and per image, a gap no smaller
+  /// than the box's, so false proves that NO point of the box qualifies for r -- a candidate filter
+  /// that is a superset of every per-particle test (withinRcutOfBlock, imagesWithinRcutOfBlock).
+  bool boxWithinRcutOfBlock(const Vec<Dim>& bmin, const Vec<Dim>& bmax, int r, double rcut) const {
+    const auto& o = dec_->origins()[r];
+    const auto& s = dec_->sizes()[r];
+    const IVec<Dim>& gsize = dec_->globalSize();
+    double d2 = 0.0;
+    for (int d = 0; d < Dim; ++d) {
+      const double lo = map_.origin[d] + o[d] * map_.cellSize[d];
+      const double hi = map_.origin[d] + (o[d] + s[d]) * map_.cellSize[d];
+      auto gap = [&](double shift) {
+        const double a = bmin[d] + shift, b = bmax[d] + shift;
+        return std::max(0.0, std::max(lo - b, a - hi));
+      };
+      double g = gap(0.0);
+      if (map_.periodic[d]) {
+        const double L = map_.cellSize[d] * static_cast<double>(gsize[d]);
+        g = std::min(g, std::min(gap(-L), gap(L)));
+      }
+      d2 += g * g;
+    }
+    return d2 < rcut * rcut;
+  }
+
   void imagesWithinRcutOfBlock(const Vec<Dim>& x, int r, double rcut, bool allowIdentity,
                                std::vector<Vec<Dim>>& outShifts) const {
     const auto& o = dec_->origins()[r];
@@ -218,24 +244,45 @@ class ParticleMigrator {
         nc[d] = 3;
       }
     }
+    // Per-axis prefilter (exact): an image qualifies only if its total squared gap is below rc2,
+    // so every one of its per-axis gaps is -- keep, per axis and in candidate order, the shifts
+    // whose own gap passes, then enumerate their product in the same nesting (axis 0 fastest) as
+    // the full 3^Dim walk. Same set, same order, typically one candidate per axis instead of 27
+    // combinations (this runs for every owned particle x every rank at every topology build).
+    const double rc2 = rcut * rcut;
+    int keep[Dim][3];
+    double keepGap2[Dim][3];
+    int nk[Dim];
+    for (int d = 0; d < Dim; ++d) {
+      nk[d] = 0;
+      for (int k = 0; k < nc[d]; ++k) {
+        const double p = x[d] + cand[d][k];
+        const double gap = (p < lo[d]) ? (lo[d] - p) : (p > hi[d]) ? (p - hi[d]) : 0.0;
+        if (gap * gap < rc2) {
+          keep[d][nk[d]] = k;
+          keepGap2[d][nk[d]] = gap * gap;
+          ++nk[d];
+        }
+      }
+      if (nk[d] == 0)
+        return;
+    }
     int total = 1;
     for (int d = 0; d < Dim; ++d)
-      total *= nc[d];
-    const double rc2 = rcut * rcut;
+      total *= nk[d];
     for (int idx = 0; idx < total; ++idx) {
       Vec<Dim> shift{};
       int t = idx;
       bool identity = true;
       double d2 = 0.0;
       for (int d = 0; d < Dim; ++d) {
-        const int k = t % nc[d];
-        t /= nc[d];
+        const int j = t % nk[d];
+        t /= nk[d];
+        const int k = keep[d][j];
         shift[d] = cand[d][k];
         if (k != 0)
           identity = false;
-        const double p = x[d] + shift[d];
-        const double gap = (p < lo[d]) ? (lo[d] - p) : (p > hi[d]) ? (p - hi[d]) : 0.0;
-        d2 += gap * gap;
+        d2 += keepGap2[d][j];
       }
       if (d2 < rc2 && (allowIdentity || !identity))
         outShifts.push_back(shift);

{peclet_core-1.2.0 → peclet_core-1.3.0}/packaging/pyproject-core.toml

@@ -19,7 +19,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "peclet-core"
-version = "1.2.0"
+version = "1.3.0"
 description = "peclet.core — compatibility shell: peclet.core.geom is now peclet.geom, peclet.core.mpi is now peclet.halo"
 readme = "README.md"
 requires-python = ">=3.10"

{peclet_core-1.2.0 → peclet_core-1.3.0}/pyproject.toml

@@ -19,7 +19,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "peclet-core"
-version = "1.2.0"
+version = "1.3.0"
 description = "peclet.core — compatibility shell: peclet.core.geom is now peclet.geom, peclet.core.mpi is now peclet.halo"
 readme = "README.md"
 requires-python = ">=3.10"

{peclet_core-1.2.0 → peclet_core-1.3.0}/tests/CMakeLists.txt

@@ -227,6 +227,13 @@ if(MPI_FOUND)
   target_link_libraries(test_particle_halo_mpi PRIVATE peclet_halo)
   target_include_directories(test_particle_halo_mpi PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
+  # ParticleHaloTopology::build(..., allImages = true) on a slab whose periodic z axis the ORB never
+  # splits (np 1..8): every periodic image within rcut is sent, keyed (id, image), against a
+  # brute-force image-count oracle; reverse sums every image; the default stays the one-image rule.
+  add_executable(test_particle_halo_images_mpi test_particle_halo_images_mpi.cpp)
+  target_link_libraries(test_particle_halo_images_mpi PRIVATE peclet_halo)
+  target_include_directories(test_particle_halo_images_mpi PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
   # The device particle-migrator view: needs Kokkos + MPI. peclet_halo carries both when
   # PECLET_CORE_ENABLE_KOKKOS is on (same target the Kokkos grid-halo test links).
   if(PECLET_CORE_ENABLE_KOKKOS)
@@ -250,6 +257,7 @@ if(MPI_FOUND)
     peclet_core_add_mpi_test(diffusion_sdf_np${np} test_diffusion_sdf ${np})
     peclet_core_add_mpi_test(ghost_particles_np${np} test_ghost_particles_mpi ${np})
     peclet_core_add_mpi_test(particle_halo_np${np} test_particle_halo_mpi ${np})
+    peclet_core_add_mpi_test(particle_halo_images_np${np} test_particle_halo_images_mpi ${np})
   endforeach()
 
   # Portable GPU-resident halo : device result must match the CPU path, on whatever backend

{peclet_core-1.2.0 → peclet_core-1.3.0}/tests/test_particle_halo_exchange.cpp

@@ -5,8 +5,12 @@
 // to match the CPU result bit-for-bit:
 //   forward(id)        -> each ghost carries its owner's id,
 //   reverse(ones, sum) -> each owned particle accumulates a count of how many ranks ghost it.
+// Run twice: the default topology, and build(..., allImages = true), where one owned particle may
+// sit several times in one rank's send list (one entry per periodic image) and the device reverse
+// must still sum every image's contribution (atomic add over repeated sendIdx entries).
 #include <mpi.h>
 
+#include <algorithm>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
@@ -78,56 +82,77 @@ int main(int argc, char** argv) {
       ownId[i] = (double)id;
     }
 
-    ParticleHaloTopology<3> halo;
-    halo.init(mig);
-    halo.build(pos, rcut);
-    const std::size_t G = halo.numGhost();
+    long long repeated = 0;
+    auto run = [&](bool allImages) {
+      ParticleHaloTopology<3> halo;
+      halo.init(mig);
+      halo.build(pos, rcut, /*includePeriodicSelf=*/allImages, allImages);
+      const std::size_t G = halo.numGhost();
+      if (allImages) {  // count repeated owned indices within one rank's send slice
+        const auto t = halo.flatten();
+        for (std::size_t k = 0; k < t.sendRanks.size(); ++k) {
+          std::vector<Index> sl(t.sendIdx.begin() + t.sendOffsets[k],
+                                t.sendIdx.begin() + t.sendOffsets[k + 1]);
+          std::sort(sl.begin(), sl.end());
+          for (std::size_t j = 1; j < sl.size(); ++j)
+            repeated += (sl[j] == sl[j - 1]) ? 1 : 0;
+        }
+      }
 
-    // --- CPU reference exchanges ---
-    std::vector<double> ghCpu(G), ownCntCpu(Nown, 0.0), ones(G, 1.0);
-    halo.forward(ownId.data(), ghCpu.data());
-    halo.reverse(ones.data(), ownCntCpu.data());
+      // --- CPU reference exchanges ---
+      std::vector<double> ghCpu(G), ownCntCpu(Nown, 0.0), ones(G, 1.0);
+      halo.forward(ownId.data(), ghCpu.data());
+      halo.reverse(ones.data(), ownCntCpu.data());
 
-    // --- device exchanges ---
-    ParticleHalo<3> dhalo;
-    dhalo.init(halo);
+      // --- device exchanges ---
+      ParticleHalo<3> dhalo;
+      dhalo.init(halo);
 
-    View<double> dOwn(Kokkos::view_alloc("own", Kokkos::WithoutInitializing), Nown);
-    View<double> dGhost(Kokkos::view_alloc("ghost", Kokkos::WithoutInitializing), G);
-    {
-      auto hOwn = Kokkos::create_mirror_view(dOwn);
-      for (std::size_t i = 0; i < Nown; ++i)
-        hOwn(i) = ownId[i];
-      Kokkos::deep_copy(dOwn, hOwn);
-    }
-    dhalo.forward(dOwn, dGhost);
-    std::vector<double> ghDev(G);
-    {
-      auto hGhost = Kokkos::create_mirror_view(dGhost);
-      Kokkos::deep_copy(hGhost, dGhost);
-      for (std::size_t i = 0; i < G; ++i)
-        ghDev[i] = hGhost(i);
-    }
+      View<double> dOwn(Kokkos::view_alloc("own", Kokkos::WithoutInitializing), Nown);
+      View<double> dGhost(Kokkos::view_alloc("ghost", Kokkos::WithoutInitializing), G);
+      {
+        auto hOwn = Kokkos::create_mirror_view(dOwn);
+        for (std::size_t i = 0; i < Nown; ++i)
+          hOwn(i) = ownId[i];
+        Kokkos::deep_copy(dOwn, hOwn);
+      }
+      dhalo.forward(dOwn, dGhost);
+      std::vector<double> ghDev(G);
+      {
+        auto hGhost = Kokkos::create_mirror_view(dGhost);
+        Kokkos::deep_copy(hGhost, dGhost);
+        for (std::size_t i = 0; i < G; ++i)
+          ghDev[i] = hGhost(i);
+      }
 
-    View<double> dGones(Kokkos::view_alloc("gones", Kokkos::WithoutInitializing), G);
-    View<double> dOwnCnt("owncnt", Nown);  // zero-initialised
-    Kokkos::deep_copy(dGones, 1.0);
-    dhalo.reverse(dGones, dOwnCnt);
-    std::vector<double> ownCntDev(Nown);
-    {
-      auto hCnt = Kokkos::create_mirror_view(dOwnCnt);
-      Kokkos::deep_copy(hCnt, dOwnCnt);
-      for (std::size_t i = 0; i < Nown; ++i)
-        ownCntDev[i] = hCnt(i);
-    }
+      View<double> dGones(Kokkos::view_alloc("gones", Kokkos::WithoutInitializing), G);
+      View<double> dOwnCnt("owncnt", Nown);  // zero-initialised
+      Kokkos::deep_copy(dGones, 1.0);
+      dhalo.reverse(dGones, dOwnCnt);
+      std::vector<double> ownCntDev(Nown);
+      {
+        auto hCnt = Kokkos::create_mirror_view(dOwnCnt);
+        Kokkos::deep_copy(hCnt, dOwnCnt);
+        for (std::size_t i = 0; i < Nown; ++i)
+          ownCntDev[i] = hCnt(i);
+      }
 
-    // --- device must match CPU bit-for-bit ---
-    for (std::size_t i = 0; i < G; ++i)
-      if (ghDev[i] != ghCpu[i])
-        ++fail;
-    for (std::size_t i = 0; i < Nown; ++i)
-      if (ownCntDev[i] != ownCntCpu[i])
-        ++fail;
+      // --- device must match CPU bit-for-bit ---
+      for (std::size_t i = 0; i < G; ++i)
+        if (ghDev[i] != ghCpu[i])
+          ++fail;
+      for (std::size_t i = 0; i < Nown; ++i)
+        if (ownCntDev[i] != ownCntCpu[i])
+          ++fail;
+    };
+    run(false);
+    run(true);
+    // The allImages pass must actually exercise repeated send entries where a periodic axis is
+    // undecomposed (np 2 and 4 of this ORB; np 1 has no cross-rank exchange).
+    long long repeatedAll = 0;
+    MPI_Allreduce(&repeated, &repeatedAll, 1, MPI_LONG_LONG, MPI_SUM, MPI_COMM_WORLD);
+    if (size >= 2 && repeatedAll == 0)
+      ++fail;
   }
 
   int total = 0;