topology_store.hpp

Go to the documentation of this file.

 
#ifndef PECLET_VORO_TOPOLOGY_STORE_HPP
#define PECLET_VORO_TOPOLOGY_STORE_HPP
 
#include <Kokkos_Core.hpp>
#include <string>
 
#include "peclet/core/common/view.hpp"
 
namespace peclet::voro {
 
template <int MAXP, int MAXT>
struct TopologyStore {
  using MemSpace = peclet::core::MemSpace;
  int N = 0;
  Kokkos::View<int*, MemSpace> np;        // N
  Kokkos::View<int*, MemSpace> nt;        // N
  Kokkos::View<int*, MemSpace> pnbr;      // N*MAXP : neighbour seed id per plane (<0 = box)
  Kokkos::View<unsigned*, MemSpace> tri;  // N*MAXT : t0 | t1<<8 | t2<<16 | alive<<24
  Kokkos::View<unsigned char*, MemSpace>
      poke4;  // N*MAXT*4 : per-triangle local-cert plane set (3 edge-
              // opposite + 4th-face), computed by ConvexCell::computePoke4() at
              // gather/rebuild and read directly by isLocallyConvex each step.
              // Allocated via allocPoke4(); written/read OUTSIDE save()/load()
              // (the gather computes it; the cert reads its pointer).
 
  void alloc(int n) {
    using Kokkos::view_alloc;
    using Kokkos::WithoutInitializing;
    N = n;
    np = Kokkos::View<int*, MemSpace>("topo.np", n);
    nt = Kokkos::View<int*, MemSpace>("topo.nt", n);
    pnbr = Kokkos::View<int*, MemSpace>(view_alloc(std::string("topo.pnbr"), WithoutInitializing),
                                        (size_t)n * MAXP);
    tri = Kokkos::View<unsigned*, MemSpace>(
        view_alloc(std::string("topo.tri"), WithoutInitializing), (size_t)n * MAXT);
  }
 
  void allocPoke4() {
    poke4 = Kokkos::View<unsigned char*, MemSpace>(
        Kokkos::view_alloc(std::string("topo.poke4"), Kokkos::WithoutInitializing),
        (size_t)N * MAXT * 4);
  }
 
  template <class Cell>
  KOKKOS_INLINE_FUNCTION void save(int i, const Cell& c) const {
    np(i) = c.np;
    nt(i) = c.nt;
    for (int k = 0; k < c.np; ++k)
      pnbr((size_t)i * MAXP + k) = c.pnbr[k];
    for (int t = 0; t < c.nt; ++t)
      tri((size_t)i * MAXT + t) = (unsigned)c.t0[t] | ((unsigned)c.t1[t] << 8) |
                                  ((unsigned)c.t2[t] << 16) | ((c.alive[t] ? 1u : 0u) << 24);
    // NOTE: the local-cert `poke4` table is NOT part of the topology snapshot — it is computed by
    // the caller (ConvexCell::computePoke4) directly into `poke4` at gather/rebuild, and read by
    // the cert.
  }
 
  template <class Cell, class Real>
  KOKKOS_INLINE_FUNCTION void load(int i, Cell& c, Real L0, Real L1, Real L2) const {
    c.initBoxPlanes(L0, L1, L2);
    const int npi = np(i), nti = nt(i);
    c.np = npi;
    c.nt = nti;
    c.overflow = false;
    for (int k = 6; k < npi; ++k)
      c.pnbr[k] = pnbr((size_t)i * MAXP + k);
    for (int t = 0; t < nti; ++t) {
      const unsigned w = tri((size_t)i * MAXT + t);
      c.t0[t] = (unsigned char)(w & 0xffu);
      c.t1[t] = (unsigned char)((w >> 8) & 0xffu);
      c.t2[t] = (unsigned char)((w >> 16) & 0xffu);
      c.alive[t] = ((w >> 24) & 1u) != 0u;
    }
    // `poke4` is read by the certificate directly from this store (a pointer), not loaded into the
    // cell; `adj` (if the cell is TrackAdj) is rebuilt by the caller when it needs it
    // (rebuildAdjAll / the gather).
  }
};
 
}  // namespace peclet::voro
 
#endif  // PECLET_VORO_TOPOLOGY_STORE_HPP