cuwave 0.1.0__tar.gz → 0.2.0__tar.gz

{cuwave-0.1.0 → cuwave-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cuwave
-Version: 0.1.0
+Version: 0.2.0
 Summary: GPU finite-difference wave solver with differentiable adjoints
 Author-email: Leon Herrmann <herrmann.leon@pm.me>
 License-Expression: MIT
@@ -93,31 +93,11 @@ Additional benefits of **CuWave** are
 
 ## Install
 
-Dependencies are kept **lightweight**. Only CuPy is required beyond standard Python library.
-
 ```bash
-pip install cupy-cuda12x        # or cupy-cuda11x, to match your CUDA
-pip install cuwave               # or `pip install -e .` from a checkout
+pip install cuwave
 ```
 
-CuPy must be installed separately because the wheel depends on your CUDA toolkit;
-all remaining dependencies are declared in `pyproject.toml`.
-
-PyTorch is optional for the regularization via neural optimization; see [pytorch](https://pytorch.org/get-started/locally/) for the installation. Otherwise it is not needed.
-
-> [!NOTE]
-> Match PyTorch's CUDA version to CuPy's, or the two runtimes clash at the first kernel launch. 
-> With `cupy-cuda12x`:
-> ```bash
-> pip install torch --index-url https://download.pytorch.org/whl/cu128
-> ```
-
-The tests under `tests/` are `unittest` classes, but `pytest` is the recommended runner:
-
-```bash
-pip install pytest
-python -m pytest tests/ -q  # ~20 s on a GPU, ~3 s without: CUDA and PyTorch tests skip when unavailable
-```
+Requires an NVIDIA GPU and [CuPy](https://docs.cupy.dev/en/stable/install.html) matching your CUDA toolkit (e.g. `pip install cupy-cuda12x`), which is not pulled in automatically. For the full installation, including the optional PyTorch and running the tests, see [docs/install.md](https://github.com/cmpmech/cuwave/blob/main/docs/install.md).
 
 ## References
 

{cuwave-0.1.0 → cuwave-0.2.0}/README.md

@@ -67,31 +67,11 @@ Additional benefits of **CuWave** are
 
 ## Install
 
-Dependencies are kept **lightweight**. Only CuPy is required beyond standard Python library.
-
 ```bash
-pip install cupy-cuda12x        # or cupy-cuda11x, to match your CUDA
-pip install cuwave               # or `pip install -e .` from a checkout
+pip install cuwave
 ```
 
-CuPy must be installed separately because the wheel depends on your CUDA toolkit;
-all remaining dependencies are declared in `pyproject.toml`.
-
-PyTorch is optional for the regularization via neural optimization; see [pytorch](https://pytorch.org/get-started/locally/) for the installation. Otherwise it is not needed.
-
-> [!NOTE]
-> Match PyTorch's CUDA version to CuPy's, or the two runtimes clash at the first kernel launch. 
-> With `cupy-cuda12x`:
-> ```bash
-> pip install torch --index-url https://download.pytorch.org/whl/cu128
-> ```
-
-The tests under `tests/` are `unittest` classes, but `pytest` is the recommended runner:
-
-```bash
-pip install pytest
-python -m pytest tests/ -q  # ~20 s on a GPU, ~3 s without: CUDA and PyTorch tests skip when unavailable
-```
+Requires an NVIDIA GPU and [CuPy](https://docs.cupy.dev/en/stable/install.html) matching your CUDA toolkit (e.g. `pip install cupy-cuda12x`), which is not pulled in automatically. For the full installation, including the optional PyTorch and running the tests, see [docs/install.md](https://github.com/cmpmech/cuwave/blob/main/docs/install.md).
 
 ## References
 

{cuwave-0.1.0 → cuwave-0.2.0}/cuwave/anisotropic.py

@@ -25,7 +25,7 @@ import numpy.typing as npt
 
 from .boundary import Clamped, Traction, faces_with
 from .elastic import voigt
-from .wave import PAIRS, Simulation, apply_cell_weights, grid_block
+from .wave import PAIRS, Simulation, apply_cell_weights, axis_geometry, grid_block
 
 KERNEL_PATH = Path(__file__).parent / "kernels" / "anisotropic.cu"
 SENSITIVITY_PATH = Path(__file__).parent / "kernels" / "anisotropic_sensitivity.cu"
@@ -253,13 +253,6 @@ class AnisotropicElasticWave(Simulation):
         """Source scaling, unscaled since rho0 is already folded into the lumped inertia."""
         return 1.0
 
-    def axis_geometry(self) -> list:
-        """Extents and previous-axis strides, the step kernel's tail without the factors."""
-        geom = [self.Nx[0]]
-        for d in range(1, self.ndim):
-            geom += [self.Nx[d], self.strides[d - 1]]
-        return geom
-
     def gradient_fields(self, mat: dict) -> dict[str, cpt.NDArray]:
         """Nodal accumulators plus the cell one the stiffness density lands in first."""
         grads = {
@@ -285,7 +278,7 @@ class AnisotropicElasticWave(Simulation):
                 grads["material"],
                 grads["design"],
                 self.dtype(1.0 / 2.0**self.ndim),
-                *self.axis_geometry(),
+                *axis_geometry(self),
             ],
         )
         return {"mass": grads["mass"], "stiff": grads["stiff"]}
@@ -302,7 +295,7 @@ class AnisotropicElasticWave(Simulation):
             mat["stencil"],
             mass_factor,
             np.int32(self.comp_stride),
-            *self.axis_geometry(),
+            *axis_geometry(self),
         ]
 
         def gradient_step(u0, u1, u2, l1):
@@ -323,7 +316,7 @@ class AnisotropicElasticWave(Simulation):
             self.dtype(sign * self.density * volume / (2.0 * self.dt) ** 2),
             self.dtype(-sign),
             np.int32(self.comp_stride),
-            *self.axis_geometry(),
+            *axis_geometry(self),
         ]
 
         def frechet_step(u0, u1, u2):

{cuwave-0.1.0 → cuwave-0.2.0}/cuwave/elastic.py

@@ -26,13 +26,12 @@ from .wave import (
     Simulation,
     apply_cell_weights,
     axis_geometry,
-    component_weights,
     grid_block,
     pair_average,
     pair_average_adjoint,
-    pair_weights,
     point_average,
     point_average_adjoint,
+    wall_weights,
 )
 
 KERNEL_PATH = Path(__file__).parent / "kernels" / "elastic.cu"
@@ -160,7 +159,7 @@ class ElasticWave(Simulation):
         for c in range(self.ncomp):
             mass = (
                 self.density
-                * component_weights(self, c)
+                * wall_weights(self, (c,))
                 * point_average(self, gamma, c)
             )
             minv[c] = 1.0 / cp.maximum(mass, cp.finfo(self.dtype).tiny)
@@ -178,7 +177,7 @@ class ElasticWave(Simulation):
         if self.ndim > 1:
             gshear = cp.zeros((self.npairs, *self.Nx_padded), dtype=self.dtype)
             for p, axes in enumerate(PAIRS[self.ndim][self.ndim :]):
-                gshear[p] = pair_weights(self, axes) * pair_average(self, gamma, axes)
+                gshear[p] = wall_weights(self, axes) * pair_average(self, gamma, axes)
             mat["gshear"] = cp.ascontiguousarray(gshear)
         if self.damping is not None:
             mat["damping"] = self.damping
@@ -269,12 +268,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] * component_weights(self, c) * self.density
+            density = grads["mass"][c] * wall_weights(self, (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())
         for p, axes in enumerate(PAIRS[self.ndim][self.ndim :]):
-            density = grads["shear"][p] * pair_weights(self, axes)
+            density = grads["shear"][p] * wall_weights(self, axes)
             g_stiff += pair_average_adjoint(self, density, gamma, axes)
         return {"mass": g_mass, "stiff": g_stiff}
 

{cuwave-0.1.0 → cuwave-0.2.0}/cuwave/kernels/scalar.cu

@@ -2,6 +2,7 @@
 // Compile-time configuration this file responds to:
 //   NDIM = 1 | 2 | 3
 //   USE_DAMPING
+//   USE_DOMAIN
 
 // spatial finite difference stencil for Laplacian
 __device__ __forceinline__ real_t flux_divergence_axis(
@@ -25,6 +26,81 @@ __device__ __forceinline__ real_t flux_divergence_axis(
   return factor * (Dp * gp - Dm * gm); // outer grad (incl. inner grad)
 }
 
+// ----------------------------------- domain helpers
+#ifdef USE_DOMAIN
+#define DIRICHLET 7 // the radius code of a cell open onto a node held at zero
+
+// the same with each cell at its own radius, zero for a cell leaving the domain
+__device__ __forceinline__ real_t flux_divergence_cells(
+    const real_t *__restrict__ u1, const real_t *__restrict__ stiff,
+    const int idx, const int s, const real_t uc, const real_t sc,
+    const real_t factor, const int rp, const int rm) {
+  real_t Dp = 0, Dm = 0; // a closed cell carries no flux
+  if (rp == DIRICHLET)
+    Dp = -uc * sc; // onto a zero halfway across, at the node's own stiffness
+  else if (rp) {
+    const real_t sp = stiff[idx + s];
+    Dp = OP_W(rp, 1) * (u1[idx + s] - uc);
+#pragma unroll
+    for (int k = 2; k <= STENCIL_RADIUS; ++k)
+      if (k <= rp)
+        Dp += OP_W(rp, k) * (u1[idx + k * s] - u1[idx - (k - 1) * s]);
+    Dp *= sc * sp / (sc + sp); // harmonic mean
+  }
+  if (rm == DIRICHLET)
+    Dm = uc * sc;
+  else if (rm) {
+    const real_t sm = stiff[idx - s];
+    Dm = OP_W(rm, 1) * (uc - u1[idx - s]);
+#pragma unroll
+    for (int k = 2; k <= STENCIL_RADIUS; ++k)
+      if (k <= rm)
+        Dm += OP_W(rm, k) * (u1[idx + (k - 1) * s] - u1[idx - k * s]);
+    Dm *= sc * sm / (sc + sm); // harmonic mean
+  }
+  return factor * (Dp - Dm);
+}
+#endif
+
+#ifdef USE_DOMAIN
+#define BLOCK_X (tile & 1023) // one block per domain tile, 10 bits an axis
+#define BLOCK_Y ((tile >> 10) & 1023)
+#define BLOCK_Z ((tile >> 20) & 1023)
+#else
+#define BLOCK_X blockIdx.x
+#define BLOCK_Y blockIdx.y
+#define BLOCK_Z blockIdx.z
+#endif
+
+#ifdef USE_DOMAIN
+#define CELLS(s, f, d)                                                         \
+  flux_divergence_cells(u1, stiff, idx, s, uc, sc, f, (code >> 6 * (d)) & 7,   \
+                        (code >> (6 * (d) + 3)) & 7)
+
+// out of line, so the rare wall node costs the deep ones no registers
+__device__ __noinline__ real_t
+wall_laplacian(const real_t *__restrict__ u1, const real_t *__restrict__ stiff,
+               const int idx, const real_t uc, const real_t sc, const int code,
+               const real_t f0
+#if NDIM >= 2
+               ,
+               const real_t f1, const int s0
+#endif
+#if NDIM >= 3
+               ,
+               const real_t f2, const int s1
+#endif
+) {
+#if NDIM == 1
+  return CELLS(1, f0, 0);
+#elif NDIM == 2
+  return CELLS(s0, f0, 0) + CELLS(1, f1, 1);
+#elif NDIM == 3
+  return CELLS(s0, f0, 0) + CELLS(s1, f1, 1) + CELLS(1, f2, 2);
+#endif
+}
+#endif
+
 // ----------------------------- boundary condition helper
 #if NDIM == 1
 #define BC_PARAMS const int N0
@@ -80,6 +156,9 @@ fd_kernel(const real_t *__restrict__ u0, const real_t *__restrict__ u1,
           const real_t *__restrict__ minv, const int derive_inertia,
 #ifdef USE_DAMPING
           const real_t *__restrict__ damping, const real_t dt,
+#endif
+#ifdef USE_DOMAIN
+          const int *__restrict__ cells, const int *__restrict__ tiles,
 #endif
           const real_t f0, const int N0
 #if NDIM >= 2
@@ -91,23 +170,26 @@ fd_kernel(const real_t *__restrict__ u0, const real_t *__restrict__ u1,
           const real_t f2, const int N2, const int s1
 #endif
 ) {
+#ifdef USE_DOMAIN
+  const int tile = tiles[blockIdx.x];
+#endif
 #if NDIM == 1
-  const int a0 = blockIdx.x * blockDim.x + threadIdx.x;
+  const int a0 = BLOCK_X * blockDim.x + threadIdx.x;
   if (!(a0 > 0 && a0 < N0 - 1))
     return;
   const int idx = a0;
   const int r0 = CLOSURE(a0, N0);
 #elif NDIM == 2
-  const int a1 = blockIdx.x * blockDim.x + threadIdx.x;
-  const int a0 = blockIdx.y * blockDim.y + threadIdx.y;
+  const int a1 = BLOCK_X * blockDim.x + threadIdx.x;
+  const int a0 = BLOCK_Y * blockDim.y + threadIdx.y;
   if (!(a0 > 0 && a0 < N0 - 1 && a1 > 0 && a1 < N1 - 1))
     return;
   const int idx = a0 * s0 + a1;
   const int r0 = CLOSURE(a0, N0), r1 = CLOSURE(a1, N1);
 #elif NDIM == 3
-  const int a2 = blockIdx.x * blockDim.x + threadIdx.x;
-  const int a1 = blockIdx.y * blockDim.y + threadIdx.y;
-  const int a0 = blockIdx.z * blockDim.z + threadIdx.z;
+  const int a2 = BLOCK_X * blockDim.x + threadIdx.x;
+  const int a1 = BLOCK_Y * blockDim.y + threadIdx.y;
+  const int a0 = BLOCK_Z * blockDim.z + threadIdx.z;
   if (!(a0 > 0 && a0 < N0 - 1 && a1 > 0 && a1 < N1 - 1 && a2 > 0 &&
         a2 < N2 - 1))
     return;
@@ -117,7 +199,6 @@ fd_kernel(const real_t *__restrict__ u0, const real_t *__restrict__ u1,
 
   const real_t uc = u1[idx];    // load once
   const real_t sc = stiff[idx]; // load once
-
 #if NDIM == 1
   real_t laplacian = flux_divergence_axis(u1, stiff, idx, 1, uc, sc, f0, r0);
 #elif NDIM == 2
@@ -128,6 +209,25 @@ fd_kernel(const real_t *__restrict__ u0, const real_t *__restrict__ u1,
                      flux_divergence_axis(u1, stiff, idx, s1, uc, sc, f1, r1) +
                      flux_divergence_axis(u1, stiff, idx, 1, uc, sc, f2, r2);
 #endif
+#ifdef USE_DOMAIN
+  // bit 30 marks a tile touching the wall, so the branch is uniform per block
+  if (tile >> 30) {
+    const int code = cells[idx]; // 0 outside, bit 30 deep, else the cell radii
+    if (!code)
+      return; // outside the domain nothing is stepped
+#if NDIM == 1
+    if (!(code >> 30))
+      laplacian = wall_laplacian(u1, stiff, idx, uc, sc, code, f0);
+#elif NDIM == 2
+    if (!(code >> 30))
+      laplacian = wall_laplacian(u1, stiff, idx, uc, sc, code, f0, f1, s0);
+#elif NDIM == 3
+    if (!(code >> 30))
+      laplacian =
+          wall_laplacian(u1, stiff, idx, uc, sc, code, f0, f1, s0, f2, s1);
+#endif
+  }
+#endif
 
   const real_t mi = derive_inertia ? 1.f / sc : minv[idx];
 #ifdef USE_DAMPING

{cuwave-0.1.0 → cuwave-0.2.0}/cuwave/maxwell.py

@@ -27,13 +27,12 @@ from .wave import (
     Simulation,
     apply_cell_weights,
     axis_geometry,
-    component_weights,
     grid_block,
     pair_average,
     pair_average_adjoint,
-    pair_weights,
     point_average,
     point_average_adjoint,
+    wall_weights,
 )
 
 KERNEL_PATH = Path(__file__).parent / "kernels" / "maxwell.cu"
@@ -217,7 +216,7 @@ class MaxwellWave(Simulation):
         permittivity = cp.ascontiguousarray(permittivity, dtype=self.dtype)
         minv = cp.zeros((self.ncomp, *self.Nx_padded), dtype=self.dtype)
         for c in range(self.ncomp):
-            mass = component_weights(self, c) * point_average(self, permittivity, c)
+            mass = wall_weights(self, (c,)) * point_average(self, permittivity, c)
             minv[c] = 1.0 / cp.maximum(mass, cp.finfo(self.dtype).tiny)
         # a conductor holds the tangential field, which is what a zeroed inertia does
         for face in faces_with(self, Conductor):
@@ -231,7 +230,7 @@ class MaxwellWave(Simulation):
             nu = cp.ascontiguousarray(nu, dtype=self.dtype)
             pairs = cp.zeros((self.npairs, *self.Nx_padded), dtype=self.dtype)
             for p, axes in enumerate(PAIRS[self.ndim][self.ndim :]):
-                pairs[p] = pair_weights(self, axes) * pair_average(self, nu, axes)
+                pairs[p] = wall_weights(self, axes) * pair_average(self, nu, axes)
             mat["nu_pair"] = cp.ascontiguousarray(pairs)
             mat["nu"] = nu
         if self.damping is not None:
@@ -310,13 +309,13 @@ class MaxwellWave(Simulation):
         """Chain the point densities through the averages onto the nodal design fields."""
         g_mass = cp.zeros(self.Nx_padded, dtype=self.dtype)
         for c in range(self.ncomp):
-            density = grads["mass"][c] * component_weights(self, c)
+            density = grads["mass"][c] * wall_weights(self, (c,))
             g_mass += point_average_adjoint(self, density, c)
         # a non-magnetic medium has no stiffness design dependence: zeros say so
         g_stiff = cp.zeros(self.Nx_padded, dtype=self.dtype)
         if self.magnetic:
             for p, axes in enumerate(PAIRS[self.ndim][self.ndim :]):
-                density = grads["nu"][p] * pair_weights(self, axes)
+                density = grads["nu"][p] * wall_weights(self, axes)
                 g_stiff += pair_average_adjoint(self, density, grads["design"], axes)
         return {"mass": g_mass, "stiff": g_stiff}
 

{cuwave-0.1.0 → cuwave-0.2.0}/cuwave/scalar.py

@@ -21,6 +21,7 @@ from .boundary import Neumann
 from .wave import (
     Simulation,
     apply_cell_weights,
+    axis_geometry,
     grid_block,
     mirror_ghosts,
     sensor_cell_weights,
@@ -40,6 +41,7 @@ class PressureWave(Simulation):
     default_boundary = Neumann
 
     derive_inertia = False  # set where m == k (rho scaling): minv derived from stiff
+    accepts_domain = True
 
     def build_materials(self, indicator: cpt.NDArray) -> dict:
         """Turn `indicator` into the kernel's material dict, `damping` included."""
@@ -92,14 +94,8 @@ class PressureWave(Simulation):
         grid, block = grid_block(self)
         # the operator without the dt^2 the step folds into it: L, not dt^2 L
         factors = [self.dtype(float(f) / self.dt**2) for f in self.step_factors()]
-        geom = [factors[0], self.Nx[0]]
-        for d in range(1, self.ndim):
-            geom += [factors[d], self.Nx[d], self.strides[d - 1]]
-        args = [grads["mass"], grads["stiff"], None, None, None, None] + [
-            mat["stiff"],
-            self.dtype(1.0 / self.dt**2),
-            *geom,
-        ]
+        args = [grads["mass"], grads["stiff"], None, None, None, None, mat["stiff"]]
+        args += [self.dtype(1.0 / self.dt**2), *axis_geometry(self, factors)]
 
         def gradient_step(u0, u1, u2, l1):
             args[2], args[3], args[4], args[5] = u0, u1, u2, l1
@@ -115,13 +111,9 @@ class PressureWave(Simulation):
         frechet_kernel = kernels.get_function("frechet_kernel")
         grid, block = grid_block(self)
         # the stiffness density enters negated, so the epilogue scales both alike
-        geom = [self.dtype(sign / (2.0 * self.dt) ** 2)]
-        for d in range(self.ndim):
-            geom.append(self.dtype(-sign / (2.0 * self.dx[d]) ** 2))
-            geom.append(self.Nx[d])
-            if d:
-                geom.append(self.strides[d - 1])
-        args = [accs["mass"], accs["stiff"], None, None, None] + geom
+        factors = [self.dtype(-sign / (2.0 * d) ** 2) for d in self.dx]
+        args = [accs["mass"], accs["stiff"], None, None, None]
+        args += [self.dtype(sign / (2.0 * self.dt) ** 2), *axis_geometry(self, factors)]
 
         def frechet_step(u0, u1, u2):
             args[2], args[3], args[4] = u0, u1, u2