cuwave 0.7.1__tar.gz → 0.7.2__tar.gz

{cuwave-0.7.1 → cuwave-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cuwave
-Version: 0.7.1
+Version: 0.7.2
 Summary: GPU finite-difference wave solver with differentiable adjoints
 Author-email: Leon Herrmann <herrmann.leon@pm.me>
 License-Expression: MIT

{cuwave-0.7.1 → cuwave-0.7.2}/cuwave/boundary.py

@@ -92,6 +92,18 @@ def face_mask(sim: Simulation, condition: BoundaryCondition) -> np.int32:
     return np.int32(sum(1 << f for f in faces_with(sim, condition)))
 
 
+def require_off_held_walls(sim: Simulation, position: cpt.NDArray[cp.int32]) -> None:
+    """Raise if a source at `position` sits on the wall node of a `Dirichlet` face, which the step holds at zero."""
+    rows = position[-sim.ndim :]
+    for face in faces_with(sim, Dirichlet):
+        d, side = divmod(face, 2)
+        wall = sim.Nx[d] - 2 if side else 1
+        if bool(cp.any(rows[d] == wall)):
+            raise ValueError(
+                f"a source on the wall node {wall} of Dirichlet face {face}, held at zero"
+            )
+
+
 def canonical_boundary(
     boundary: BoundaryCondition | Sequence | None,
     ndim: int,

{cuwave-0.7.1 → cuwave-0.7.2}/cuwave/decomposition.py

@@ -20,7 +20,7 @@ import cupy as cp
 import cupy.typing as cpt
 import numpy as np
 
-from .boundary import _canonical_faces, pml_widths
+from .boundary import _canonical_faces, pml_widths, require_off_held_walls
 
 if TYPE_CHECKING:
     from .wave import Simulation
@@ -295,6 +295,8 @@ def decomposable(function: Callable) -> Callable:
     def run(*args, **kwargs):
         bound = signature.bind(*args, **kwargs)
         sim = bound.arguments["sim"]
+        # checked whole, since a subdomain's walls at the cuts are halo rows
+        require_off_held_walls(sim, bound.arguments["source"].position)
         if sim.devices is None:
             return function(*args, **kwargs)
         if bound.arguments.get("record_every") is not None:

{cuwave-0.7.1 → cuwave-0.7.2}/cuwave/elastic.py

@@ -6,7 +6,8 @@ axes. Each is a pure per-axis staggered difference, which is what carries the cr
 terms a per-axis flux cannot and keeps the cost linear in the stencil radius, where the
 cell gather of `AnisotropicElasticWave` pays `(2r)**(2 ndim)`. The operator is
 `-B^T C B` with the material sampled on the stress points, so it stays the exact
-transpose at every order.
+transpose at every order. Its walls are the closures of a staggered SBP pair, whose norms
+weigh the stress and component points, so the walls keep the interior order.
 """
 
 from __future__ import annotations
@@ -23,13 +24,13 @@ import numpy as np
 import numpy.typing as npt
 
 from .boundary import Clamped, Traction, face_mask, faces_with
+from .stencils import CLOSURES, closure_band, closure_norms, closure_reach
 from .wave import (
     PAIRS,
     Blocked,
     LaunchSlots,
     Simulation,
     Source,
-    apply_cell_weights,
     axis_geometry,
     blocked_launches,
     compile_kernels,
@@ -41,7 +42,6 @@ from .wave import (
     point_average_adjoint,
     tile_counts,
     tile_lists,
-    wall_weights,
 )
 
 KERNEL_PATH = Path(__file__).parent / "kernels" / "elastic.cu"
@@ -138,6 +138,19 @@ def zener(relaxation: Relaxation, dt: float) -> Zener:
     return Zener(rates, weights, float(np.real(1.0 / np.sqrt(modulus)) ** 2))
 
 
+def _band_free_origin(n: int, tile: int, core: int, halo: int, band: int) -> int | None:
+    """The latest first core start, 1 or before, that puts no blocked tile's edge inside a wall's closure band."""
+    for origin in range(1, 1 - core, -1):
+        count = -(-(n - 1 - origin) // core)
+        firsts = [origin + b * core - halo for b in range(1, count)]
+        lasts = [first + tile - 1 for first in [origin - halo, *firsts][:-1]]
+        if all(f <= 1 or f > band for f in firsts) and all(
+            e >= n - 2 or e < n - 2 - band for e in lasts
+        ):
+            return origin
+    return None
+
+
 # ------------------------------- discretization setup --------------------------------
 @dataclass
 class ElasticWave(Simulation):
@@ -206,6 +219,16 @@ class ElasticWave(Simulation):
                 if condition not in (Traction, Clamped):
                     raise ValueError(f"elastic faces are Traction or Clamped: {pair}")
 
+        # the order the walls close at, and room for both closures
+        if self.space_order not in CLOSURES:
+            raise ValueError(f"the walls close up to order 8: {self.space_order}")
+        least = 2 * closure_band(self.space_order, self.stencil) + 3
+        if min(self.Nx) < least:
+            raise ValueError(
+                f"Nx {self.Nx} at order {self.space_order} needs {least} nodes an "
+                f"axis for both closures"
+            )
+
         # the relaxation, fitted to the step's dt
         if self.relaxation is not None:
             if self.pml is not None:
@@ -255,14 +278,32 @@ class ElasticWave(Simulation):
         return 1.0 if self.zener is None else self.zener.unrelaxed
 
     def inverse_inertia(self, indicator: cpt.NDArray) -> cpt.NDArray:
-        """Nodal `1 / (gamma rho0 W)`, what a sponge scales its damping by."""
-        mass = (
-            indicator
-            * self.density
-            * apply_cell_weights(self, cp.ones(self.Nx_padded, dtype=self.dtype))
-        )
+        """Nodal `1 / (gamma rho0)`, the inertia the update damps by and a sponge scales its damping by."""
+        mass = indicator * self.density
         return 1.0 / cp.maximum(mass, cp.finfo(self.dtype).tiny)
 
+    def point_weights(self, half: tuple[int, ...]) -> cpt.NDArray:
+        """The norm W of the points on the half grid of the axes `half` and on the nodes of the rest."""
+        w = cp.ones(self.Nx_padded, dtype=self.dtype)
+        for d, line in enumerate(self._norm_lines(half)):
+            shape = [1] * self.ndim
+            shape[d] = -1
+            w *= cp.asarray(line.reshape(shape), dtype=self.dtype)
+        return w
+
+    def _norm_lines(self, half: tuple[int, ...]) -> list[npt.NDArray[np.float64]]:
+        """Per axis the closure norms along its padded extent, 1 on the ghosts and past the walls."""
+        lines = []
+        for d, n in enumerate(self.Nx):
+            node, half_points = closure_norms(self.space_order, int(n) - 3)
+            line = np.ones(self.Nx_padded[d])
+            if d in half:
+                line[1 : n - 2] = half_points
+            else:
+                line[1 : n - 1] = node
+            lines.append(line)
+        return lines
+
     def build_materials(self, indicator: cpt.NDArray) -> dict:
         """The design field alone: the kernels average it onto the stress and component points."""
         mat = {"gamma": cp.ascontiguousarray(indicator, dtype=self.dtype)}
@@ -273,17 +314,17 @@ class ElasticWave(Simulation):
     def point_inverse_inertia(
         self, gamma: cpt.NDArray, lin_index: cpt.NDArray[cp.int32]
     ) -> cpt.NDArray:
-        """`1 / (rho0 W mean gamma)` on the component points `lin_index`, as `point_minv` forms it."""
+        """`1 / (rho0 W mean gamma)` on the component points `lin_index`, the inverse mass a point load divides by.
+
+        The kernels' `point_minv` leaves the norm W out, which the summation by parts
+        cancels against the stresses' (`_point_norms`), so it is this times W.
+        """
         component, node = lin_index // self.comp_stride, lin_index % self.comp_stride
         rows = [node // s % n for s, n in zip(self.strides, self.Nx_padded)]
         step = cp.asarray(self.strides, dtype=lin_index.dtype)[component]
         flat = gamma.ravel()
         mean = 0.5 * (flat[node] + flat[node + step])
-        weight = cp.ones(lin_index.shape, dtype=self.dtype)
-        for d, a in enumerate(rows):
-            for index in (1, self.Nx[d] - 2):
-                weight = cp.where((a == index) & (component != d), 0.5 * weight, weight)
-        mass = self.density * weight * mean
+        mass = self.density * self._point_norms(lin_index) * mean
         minv = 1.0 / cp.maximum(mass, cp.finfo(self.dtype).tiny)
         for face in faces_with(self, Clamped):
             d = face // 2
@@ -291,6 +332,17 @@ class ElasticWave(Simulation):
             minv = cp.where((rows[d] == wall) & (component != d), 0.0, minv)
         return minv.astype(self.dtype)
 
+    def _point_norms(self, lin_index: cpt.NDArray[cp.int32]) -> cpt.NDArray:
+        """The norm W on the component points `lin_index`: the half points' along its own axis."""
+        component, node = np.divmod(lin_index.get(), self.comp_stride)
+        nodal = self._norm_lines(())
+        half = self._norm_lines(tuple(range(self.ndim)))
+        weight = np.ones(len(node))
+        for d in range(self.ndim):
+            a = node // self.strides[d] % self.Nx_padded[d]
+            weight *= np.where(component == d, half[d][a], nodal[d][a])
+        return cp.asarray(weight, dtype=self.dtype)
+
     def define_step(self, kernels: cp.RawModule, mat: dict) -> Callable:
         """Closure launching the stress kernel and then the update over (u0, u1, u2)."""
         return self._define_pair(kernels, mat, adjoint=False)
@@ -341,6 +393,7 @@ class ElasticWave(Simulation):
         ring = math.prod(t + self.space_order for t in tile)
         return (
             self.ndim >= 2
+            and min(tile) > closure_reach(self.space_order, self.stencil)
             and self.pml is None
             and self.relaxation is None
             and fields > device["L2CacheSize"]
@@ -483,7 +536,15 @@ class ElasticWave(Simulation):
         tile, rows, steps = block
         halo = steps * reach
         core = [t - 2 * halo for t in tile]
-        cores = tile_counts(self.Nx, tile, halo)
+
+        # the first cores moved until no tile edge cuts a wall's closure band
+        band = closure_band(self.space_order, self.stencil)
+        origin = [
+            _band_free_origin(*axis, halo, band) for axis in zip(self.Nx, tile, core)
+        ]
+        if None in origin:
+            return None
+        cores = tile_counts(self.Nx, tile, halo, origin=origin)
 
         # sources on points the step moves, sensors in the interior, none twice
         sources = flatten_indices(self, source.position)
@@ -509,12 +570,12 @@ class ElasticWave(Simulation):
 
         # a tile's sources wherever its nodes reach, its sensors where its core does
         hits = [
-            covering_hits(points[0], tile, core, halo, cores),
-            owner_hits(points[1], points[1], core),
+            covering_hits(points[0], tile, core, halo, cores, origin=origin),
+            owner_hits(points[1], points[1], core, origin=origin),
         ]
         lists = []
         for hit, layer in zip(hits, layers):
-            lists += tile_lists(hit, tile, core, halo, cores, layer)
+            lists += tile_lists(hit, tile, core, halo, cores, layer, origin=origin)
 
         # the kernel and its arguments, the pointers swapped per launch
         flags = (f"-DSTEPS={steps}", f"-DTILE0={tile[0]}", f"-DTILE1={tile[1]}")
@@ -534,7 +595,7 @@ class ElasticWave(Simulation):
         slots = LaunchSlots(len(args) - 10, len(args) - 7, len(args) - 1, None)
         args += [face_mask(self, Clamped), np.int32(self.comp_stride)]
         args += [self.dtype(1.0 / d) for d in self.dx]
-        args += axis_geometry(self, self.step_factors())
+        args += [*axis_geometry(self, self.step_factors()), *map(np.int32, origin)]
         launches = [(kernel, tuple(cores[::-1]), None)]
         return blocked_launches(steps, launches, (tile[1], rows), shared, args, slots)
 
@@ -614,9 +675,10 @@ class ElasticWave(Simulation):
         minv = self.point_inverse_inertia(mat["gamma"], lin_index)
         weight = minv * volume
         if self.damping is not None:
+            # the kernel's beta, whose inertia leaves the norm out
             node = lin_index % np.int32(self.comp_stride)
-            beta = 0.5 * minv * mat["damping"].ravel()[node] * self.dt
-            weight = weight / (1.0 + beta)
+            beta = 0.5 * minv * self._point_norms(lin_index)
+            weight = weight / (1.0 + beta * mat["damping"].ravel()[node] * self.dt)
         return (self.dtype(self.dt**2 * self.source_factor()) * weight).astype(
             self.dtype
         )
@@ -655,12 +717,12 @@ class ElasticWave(Simulation):
         gamma = grads["design"]
         g_mass = cp.zeros(self.Nx_padded, dtype=self.dtype)
         for c in range(self.ncomp):
-            density = grads["mass"][c] * wall_weights(self, (c,)) * self.density
+            density = grads["mass"][c] * self.point_weights((c,)) * self.density
             g_mass += point_average_adjoint(self, density, c)
         # the normal density sits on the nodes, so its chain rule is the weight alone
-        g_stiff = apply_cell_weights(self, grads["normal"].copy())
+        g_stiff = grads["normal"] * self.point_weights(())
         for p, axes in enumerate(PAIRS[self.ndim][self.ndim :]):
-            density = grads["shear"][p] * wall_weights(self, axes)
+            density = grads["shear"][p] * self.point_weights(axes)
             g_stiff += pair_average_adjoint(self, density, gamma, axes)
         return {"mass": g_mass, "stiff": g_stiff}
 

{cuwave-0.7.1 → cuwave-0.7.2}/cuwave/kernels/common.cuh

@@ -5,6 +5,8 @@
 //   STENCIL_RADIUS
 //   OP_COEFFS
 //   STAG_COEFFS
+//   NODE_CLOSURE, HALF_CLOSURE, NODE_SPAN, HALF_SPAN, NODE_ROWS_C, HALF_ROWS_C
+//   DIRICHLET_FACES (default 0)
 
 #ifdef USE_FLOAT
 typedef float real_t;
@@ -12,8 +14,8 @@ typedef float real_t;
 #define FMA_RN __fmaf_rn
 #else
 typedef double real_t;
-#define MUL_RN(a, b) ((a) * (b)) // left to nvcc, as only float32 blocks steps
-#define FMA_RN(a, b, c) ((a) * (b) + (c))
+#define MUL_RN __dmul_rn // pinned too, so code around it rounds nothing anew
+#define FMA_RN __fma_rn
 #endif
 
 // ----------------------------- finite difference helpers
@@ -23,18 +25,105 @@ typedef double real_t;
 
 #if STENCIL_RADIUS == 1
 #define OP_W(r, k) ((real_t)1)
-#define CLOSURE(a, N) 1
 #define SG_W(r, k) ((real_t)1)
 #else
 // cache
 __constant__ real_t OP_C[STENCIL_RADIUS][STENCIL_RADIUS] = OP_COEFFS;
 #define OP_W(r, k) OP_C[(r) - 1][(k) - 1] // 1-indexed adjustment
-// grade radius down towards wall so the stencil never reaches past ghost nodes
-#define CLOSURE(a, N) min(STENCIL_RADIUS, min(a, (N) - 1 - (a)))
 __constant__ real_t SG_C[STENCIL_RADIUS][STENCIL_RADIUS] = STAG_COEFFS;
 #define SG_W(r, k) SG_C[(r) - 1][(k) - 1] // 1-indexed adjustment
 #endif
 
+// ---------------------------------- mirrored taps
+#ifndef DIRICHLET_FACES
+#define DIRICHLET_FACES 0
+#endif
+
+// whether node a is the wall node of a face of `odd` (bit 0 low, bit 1 high)
+__device__ __forceinline__ bool held_wall(const int a, const int N,
+                                          const int odd) {
+  return (odd & 1 && a == 1) || (odd & 2 && a == N - 2);
+}
+
+// node b of an axis of N nodes, past the stored ghost its mirror about the
+// wall node, odd past a face of `odd`
+__device__ __forceinline__ int mirror_node(const int b, const int N,
+                                           const int odd, int &sign) {
+  sign = (b < 0 && odd & 1) || (b > N - 1 && odd & 2) ? -1 : 1;
+  return b < 0 ? 2 - b : b > N - 1 ? 2 * (N - 2) - b : b;
+}
+
+// a value read off a mirror with its sign
+__device__ __forceinline__ real_t signed_value(const real_t v, const int sign) {
+  return sign > 0 ? v : sign < 0 ? -v : (real_t)0;
+}
+
+// u at node a + j of the line through idx, read through mirror_node
+__device__ __forceinline__ real_t mirrored(const real_t *__restrict__ u,
+                                           const int idx, const int s,
+                                           const int a, const int N,
+                                           const int odd, const int j) {
+  int sign;
+  const int b = mirror_node(a + j, N, odd, sign);
+  return signed_value(u[idx + (b - a) * s], sign);
+}
+
+// node b past the wall node its image, for a field no refill keeps beyond it:
+// odd across a face of `odd`
+__device__ __forceinline__ int node_image(const int b, const int N,
+                                          const int odd, int &sign) {
+  sign = (b < 1 && odd & 1) || (b > N - 2 && odd & 2) ? -1 : 1;
+  return b < 1 ? 2 - b : b > N - 2 ? 2 * (N - 2) - b : b;
+}
+
+// half point b, half a node up from node b, past the wall its image
+__device__ __forceinline__ int half_image(const int b, const int N,
+                                          const int odd, int &sign) {
+  sign = (b < 1 && odd & 1) || (b > N - 3 && odd & 2) ? -1 : 1;
+  return b < 1 ? 1 - b : b > N - 3 ? 2 * N - 5 - b : b;
+}
+
+// a node-centred field at a + j of the line through idx, through node_image
+__device__ __forceinline__ real_t node_imaged(const real_t *__restrict__ u,
+                                              const int idx, const int s,
+                                              const int a, const int N,
+                                              const int odd, const int j) {
+  int sign;
+  const int b = node_image(a + j, N, odd, sign);
+  return signed_value(u[idx + (b - a) * s], sign);
+}
+
+// a half-point field at a + j of the line through idx, through half_image
+__device__ __forceinline__ real_t half_imaged(const real_t *__restrict__ u,
+                                              const int idx, const int s,
+                                              const int a, const int N,
+                                              const int odd, const int j) {
+  int sign;
+  const int b = half_image(a + j, N, odd, sign);
+  return signed_value(u[idx + (b - a) * s], sign);
+}
+
+// t[j - first] = a field at a + j, j = first .. first + 2R - 1, read in place
+// where every tap lies on stored points `lo .. hi`, else through its image
+template <bool HALF>
+__device__ __forceinline__ void staged_taps(real_t *t,
+                                            const real_t *__restrict__ u,
+                                            const int idx, const int s,
+                                            const int a, const int N,
+                                            const int odd, const int first,
+                                            const int lo, const int hi) {
+  if (a + first >= lo && a + first + 2 * STENCIL_RADIUS - 1 <= hi) {
+#pragma unroll
+    for (int j = 0; j < 2 * STENCIL_RADIUS; ++j)
+      t[j] = u[idx + (first + j) * s];
+  } else {
+#pragma unroll
+    for (int j = 0; j < 2 * STENCIL_RADIUS; ++j)
+      t[j] = HALF ? half_imaged(u, idx, s, a, N, odd, first + j)
+                  : node_imaged(u, idx, s, a, N, odd, first + j);
+  }
+}
+
 // --------------------------------- staggered lattice
 #define NPAIRS (NDIM * (NDIM - 1) / 2)
 #define NVOIGT (NDIM + NPAIRS)
@@ -44,11 +133,6 @@ __constant__ real_t SG_C[STENCIL_RADIUS][STENCIL_RADIUS] = STAG_COEFFS;
 #define PAIR_ROW(k, l) 2
 #endif
 
-// radius of the node-centred derivative of a staggered field, zero on the wall
-__device__ __forceinline__ int rad_node(const int a, const int N) {
-  return min(STENCIL_RADIUS, min(a - 1, N - 2 - a));
-}
-
 // radius of a half-point derivative, whose taps may sit on the wall
 __device__ __forceinline__ int rad_half(const int a, const int N) {
   return min(STENCIL_RADIUS, min(a, N - 2 - a));
@@ -65,6 +149,154 @@ __device__ __forceinline__ bool clamped_face(const int clamped, const int d,
   return (clamped >> (2 * d + side)) & 1;
 }
 
+// ---------------------------------- staggered closure
+#ifdef NODE_CLOSURE
+// the low wall's rows of the staggered SBP pair, row 0 the wall's; the high
+// wall reads them mirrored and negated
+__device__ const real_t NODE_ROWS[NODE_CLOSURE][NODE_SPAN] = NODE_ROWS_C;
+__device__ const real_t HALF_ROWS[HALF_CLOSURE][HALF_SPAN] = HALF_ROWS_C;
+#define CLOSURE_BAND                                                           \
+  (NODE_CLOSURE > HALF_CLOSURE ? NODE_CLOSURE : HALF_CLOSURE)
+
+// the axes along which a node lies past both walls' closure bands, a bit each
+__device__ __forceinline__ int deep_axes(const int *A, const int *NN) {
+  int deep = 0;
+#pragma unroll
+  for (int d = 0; d < NDIM; ++d)
+    deep |= (A[d] > CLOSURE_BAND && A[d] < NN[d] - 2 - CLOSURE_BAND) << d;
+  return deep;
+}
+
+// every axis deep, or every one but the fast axis
+#define DEEP_ALL ((1 << NDIM) - 1)
+#define DEEP_SLOW (DEEP_ALL >> 1)
+
+// the deep axes the warp's active lanes share, as DEEP_ALL, DEEP_SLOW or none,
+// so the warp runs one path
+__device__ __forceinline__ int warp_deep(const int *A, const int *NN) {
+  const unsigned lanes = __activemask();
+  const int deep = deep_axes(A, NN);
+  if (__all_sync(lanes, deep == DEEP_ALL))
+    return DEEP_ALL;
+  return __all_sync(lanes, (deep & DEEP_SLOW) == DEEP_SLOW) ? DEEP_SLOW : 0;
+}
+
+// f with the template mask of the deep axes a warp_deep result names
+#define BY_DEEP(deep, f, ...)                                                  \
+  ((deep) == DEEP_ALL    ? f<DEEP_ALL>(__VA_ARGS__)                            \
+   : (deep) == DEEP_SLOW ? f<DEEP_SLOW>(__VA_ARGS__)                           \
+                         : f(__VA_ARGS__))
+
+// a line through a field: u(j) the value j points along the axis from idx
+struct Line {
+  const real_t *__restrict__ p;
+  int idx, s;
+  __device__ real_t operator()(const int j) const { return p[idx + j * s]; }
+};
+
+// the closure rows off either wall
+template <class L>
+__device__ __forceinline__ real_t node_rows(const L &u, const int lo,
+                                           const int hi) {
+  real_t acc = (real_t)0;
+  if (lo < NODE_CLOSURE) {
+#pragma unroll
+    for (int m = 0; m < NODE_SPAN; ++m)
+      acc += NODE_ROWS[lo][m] * u(m - lo);
+  } else {
+#pragma unroll
+    for (int m = 0; m < NODE_SPAN; ++m)
+      acc -= NODE_ROWS[hi][m] * u(hi - 1 - m);
+  }
+  return acc;
+}
+
+template <class L>
+__device__ __forceinline__ real_t half_rows(const L &u, const int lo,
+                                           const int hi) {
+  real_t acc = (real_t)0;
+  if (lo < HALF_CLOSURE) {
+#pragma unroll
+    for (int i = 0; i < HALF_SPAN; ++i)
+      acc += HALF_ROWS[lo][i] * u(i - lo);
+  } else {
+#pragma unroll
+    for (int i = 0; i < HALF_SPAN; ++i)
+      acc -= HALF_ROWS[hi][i] * u(hi + 1 - i);
+  }
+  return acc;
+}
+
+// d/dx at node a of a half-point field along a line; past a wall it reads the
+// half-grid wall point as zero; deep (a constant where it is set) skips the
+// closure rows
+template <class L>
+__device__ __forceinline__ real_t node_derivative(const L &u, const int a,
+                                                  const int N,
+                                                  const bool deep = false) {
+  const int lo = a - 1, hi = N - 2 - a;
+  if (!deep && (lo < NODE_CLOSURE || hi < NODE_CLOSURE))
+    return node_rows(u, lo, hi);
+  real_t acc = (real_t)0;
+#pragma unroll
+  for (int k = 1; k <= STENCIL_RADIUS; ++k)
+    acc += SG_W(STENCIL_RADIUS, k) * (u(k - 1) - u(-k));
+  return acc;
+}
+
+// d/dx at the half point a (a + 1/2) of a nodal field along a line
+template <class L>
+__device__ __forceinline__ real_t half_derivative(const L &u, const int a,
+                                                  const int N,
+                                                  const bool deep = false) {
+  const int lo = a - 1, hi = N - 3 - a;
+  if (!deep && (lo < HALF_CLOSURE || hi < HALF_CLOSURE))
+    return half_rows(u, lo, hi);
+  real_t acc = (real_t)0;
+#pragma unroll
+  for (int k = 1; k <= STENCIL_RADIUS; ++k)
+    acc += SG_W(STENCIL_RADIUS, k) * (u(k) - u(1 - k));
+  return acc;
+}
+
+// the divergence of a nodal stress at the half point a: half_derivative's rows,
+// which are minus node_derivative's transpose in the norms, so the norms cancel
+// against the inertia's; inside, the taps in the order the deep path rounds
+template <class L>
+__device__ __forceinline__ real_t node_divergence(const L &sg, const int a,
+                                                  const int N,
+                                                  const bool deep = false) {
+  const int lo = a - 1, hi = N - 3 - a;
+  if (!deep && (lo < HALF_CLOSURE || hi < HALF_CLOSURE))
+    return half_rows(sg, lo, hi);
+  real_t acc = (real_t)0;
+#pragma unroll
+  for (int k = 1; k <= STENCIL_RADIUS; ++k) {
+    acc += SG_W(STENCIL_RADIUS, k) * sg(k);
+    acc -= SG_W(STENCIL_RADIUS, k) * sg(1 - k);
+  }
+  return acc;
+}
+
+// the divergence of a half-point stress at node a: node_derivative's rows, the
+// stress at the wall point never read
+template <class L>
+__device__ __forceinline__ real_t half_divergence(const L &sg, const int a,
+                                                  const int N,
+                                                  const bool deep = false) {
+  const int lo = a - 1, hi = N - 2 - a;
+  if (!deep && (lo < NODE_CLOSURE || hi < NODE_CLOSURE))
+    return node_rows(sg, lo, hi);
+  real_t acc = (real_t)0;
+#pragma unroll
+  for (int k = 1; k <= STENCIL_RADIUS; ++k) {
+    acc += SG_W(STENCIL_RADIUS, k) * sg(k - 1);
+    acc -= SG_W(STENCIL_RADIUS, k) * sg(-k);
+  }
+  return acc;
+}
+#endif
+
 // --------------------------------------- pml slabs
 #if NDIM == 1
 #define PML_PARAMS const int N0
@@ -140,6 +372,20 @@ __device__ __forceinline__ int slab_index(const int a, const int off,
   return d < NDIM - 1 ? row * plane + off : off * (lo + hi) + row;
 }
 
+// whether the node at idx is the wall node of a face DIRICHLET_FACES names
+__device__ __forceinline__ bool held_node(const int idx, const int *n,
+                                          const int *s) {
+  bool held = false;
+  int rest = idx;
+#pragma unroll
+  for (int e = 0; e < NDIM; ++e) {
+    const int ae = rest / s[e];
+    rest -= ae * s[e];
+    held |= held_wall(ae, n[e], DIRICHLET_FACES >> 2 * e);
+  }
+  return held;
+}
+
 // ------------------------------- pml memory accessors
 // component k of a field j nodes along the axis from a node
 struct Field {