cuwave 0.1.0__py3-none-any.whl

cuwave/kernels/maxwell_sensitivity.cu

@@ -0,0 +1,139 @@
+// Prepended by wave.compile_kernels: stencils.preamble, then common.cuh.
+// Compile-time configuration this file responds to:
+//   NDIM = 2 | 3
+//   USE_MAGNETIC
+
+#if NDIM == 1
+#error "a single in-plane component has no curl; use maxwell.ElectricWave"
+#endif
+
+#if NDIM == 2
+#define AXIS_PARAMS                                                            \
+  const real_t f0, const int N0, const real_t f1, const int N1, const int s0
+#define INTERIOR_OR_RETURN                                                     \
+  const int a1 = blockIdx.x * blockDim.x + threadIdx.x;                        \
+  const int a0 = blockIdx.y * blockDim.y + threadIdx.y;                        \
+  if (!(a0 > 0 && a0 < N0 - 1 && a1 > 0 && a1 < N1 - 1))                       \
+    return;                                                                    \
+  const int idx = a0 * s0 + a1
+#define AXIS_GEOM                                                              \
+  const int A[2] = {a0, a1}, S[2] = {s0, 1}, NN[2] = {N0, N1}
+#define AXIS_FACTORS const real_t F[2] = {f0, f1}
+#elif NDIM == 3
+#define AXIS_PARAMS                                                            \
+  const real_t f0, const int N0, const real_t f1, const int N1, const int s0,  \
+      const real_t f2, const int N2, const int s1
+#define INTERIOR_OR_RETURN                                                     \
+  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;                        \
+  if (!(a0 > 0 && a0 < N0 - 1 && a1 > 0 && a1 < N1 - 1 && a2 > 0 &&            \
+        a2 < N2 - 1))                                                          \
+    return;                                                                    \
+  const int idx = a0 * s0 + a1 * s1 + a2
+#define AXIS_GEOM                                                              \
+  const int A[3] = {a0, a1, a2}, S[3] = {s0, s1, 1}, NN[3] = {N0, N1, N2}
+#define AXIS_FACTORS const real_t F[3] = {f0, f1, f2}
+#endif
+
+#ifdef USE_MAGNETIC
+// ------------------------------------ curl helpers
+// byte-identical to maxwell.cu: each file is its own compilation unit
+__device__ __forceinline__ real_t
+curl_component(const real_t *__restrict__ u, const int idx, const int cs,
+               const int k, const int l, const int *A, const int *S,
+               const int *NN, const real_t *F) {
+  const int r1 = rad_half(A[l], NN[l]); // d u_k / d x_l
+  const int r2 = rad_half(A[k], NN[k]); // d u_l / d x_k
+  real_t b = (real_t)0;
+#pragma unroll
+  for (int j = 1; j <= STENCIL_RADIUS; ++j) {
+    if (j <= r1)
+      b -= F[l] * SG_W(r1, j) *
+           (u[k * cs + idx + j * S[l]] - u[k * cs + idx - (j - 1) * S[l]]);
+    if (j <= r2)
+      b += F[k] * SG_W(r2, j) *
+           (u[l * cs + idx + j * S[k]] - u[l * cs + idx - (j - 1) * S[k]]);
+  }
+  return b;
+}
+#endif
+
+// -------------------------------------- kernels
+extern "C" {
+
+// ------------------------------------------------------------------------------------
+__global__ void gradient_kernel(real_t *__restrict__ g_mass,
+#ifdef USE_MAGNETIC
+                                real_t *__restrict__ g_nu,
+#endif
+                                const real_t *__restrict__ u0,
+                                const real_t *__restrict__ u1,
+                                const real_t *__restrict__ u2,
+                                const real_t *__restrict__ l1, const real_t mf,
+                                const int cs, AXIS_PARAMS) {
+  INTERIOR_OR_RETURN;
+  AXIS_GEOM;
+
+  // dJ/dpermittivity on the component points: no neighbour and no material load
+#pragma unroll
+  for (int c = 0; c < NDIM; ++c) {
+    if (A[c] > NN[c] - 3)
+      continue;
+    const int n = c * cs + idx;
+    g_mass[n] -= mf * l1[n] * (u2[n] - 2.f * u1[n] + u0[n]);
+  }
+
+#ifdef USE_MAGNETIC
+  AXIS_FACTORS;
+  // dJ/d(1/mu) on the pair points: forward curl against adjoint curl
+#pragma unroll
+  for (int k = 0; k < NDIM - 1; ++k)
+#pragma unroll
+    for (int l = k + 1; l < NDIM; ++l) {
+      if (A[k] > NN[k] - 3 || A[l] > NN[l] - 3)
+        continue;
+      const int p = PAIR_ROW(k, l) - NDIM;
+      g_nu[p * cs + idx] -= curl_component(l1, idx, cs, k, l, A, S, NN, F) *
+                            curl_component(u1, idx, cs, k, l, A, S, NN, F);
+    }
+#endif
+}
+
+// ------------------------------------------------------------------------------------
+__global__ void frechet_kernel(real_t *__restrict__ acc_mass,
+#ifdef USE_MAGNETIC
+                               real_t *__restrict__ acc_nu,
+#endif
+                               const real_t *__restrict__ u0,
+                               const real_t *__restrict__ u1,
+                               const real_t *__restrict__ u2, const real_t ft,
+                               const real_t fs, const int cs, AXIS_PARAMS) {
+  INTERIOR_OR_RETURN;
+  AXIS_GEOM;
+
+#pragma unroll
+  for (int c = 0; c < NDIM; ++c) {
+    if (A[c] > NN[c] - 3)
+      continue;
+    const int n = c * cs + idx;
+    const real_t dudt = u2[n] - u0[n];
+    acc_mass[n] += ft * dudt * dudt;
+  }
+
+#ifdef USE_MAGNETIC
+  AXIS_FACTORS;
+#pragma unroll
+  for (int k = 0; k < NDIM - 1; ++k)
+#pragma unroll
+    for (int l = k + 1; l < NDIM; ++l) {
+      if (A[k] > NN[k] - 3 || A[l] > NN[l] - 3)
+        continue;
+      const int p = PAIR_ROW(k, l) - NDIM;
+      const real_t b = curl_component(u1, idx, cs, k, l, A, S, NN, F);
+      acc_nu[p * cs + idx] += fs * b * b;
+    }
+#endif
+}
+
+} // extern "C"

cuwave/kernels/scalar.cu

@@ -0,0 +1,164 @@
+// Prepended by wave.compile_kernels: stencils.preamble, then common.cuh.
+// Compile-time configuration this file responds to:
+//   NDIM = 1 | 2 | 3
+//   USE_DAMPING
+
+// spatial finite difference stencil for Laplacian
+__device__ __forceinline__ real_t flux_divergence_axis(
+    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 r) {
+  const real_t sp = stiff[idx + s];            // plus of sc
+  const real_t sm = stiff[idx - s];            // minus of sc
+  const real_t gp = sc * sp / (sc + sp);       // harmonic mean
+  const real_t gm = sc * sm / (sc + sm);       // harmonic mean
+  real_t Dp = OP_W(r, 1) * (u1[idx + s] - uc); // initialization: inner grad
+  real_t Dm = OP_W(r, 1) * (uc - u1[idx - s]); // initialization: inner grad
+#pragma unroll
+  for (int k = 2; k <= STENCIL_RADIUS; ++k)
+    if (k <= r) {
+      Dp +=
+          OP_W(r, k) * (u1[idx + k * s] - u1[idx - (k - 1) * s]); // inner grad
+      Dm +=
+          OP_W(r, k) * (u1[idx + (k - 1) * s] - u1[idx - k * s]); // inner grad
+    }
+  return factor * (Dp * gp - Dm * gm); // outer grad (incl. inner grad)
+}
+
+// ----------------------------- boundary condition helper
+#if NDIM == 1
+#define BC_PARAMS const int N0
+#define BC_GEOM const int n[1] = {N0}, s[1] = {1}
+#elif NDIM == 2
+#define BC_PARAMS const int N0, const int N1, const int s0
+#define BC_GEOM const int n[2] = {N0, N1}, s[2] = {s0, 1}
+#elif NDIM == 3
+#define BC_PARAMS                                                              \
+  const int N0, const int N1, const int s0, const int N2, const int s1
+#define BC_GEOM const int n[3] = {N0, N1, N2}, s[3] = {s0, s1, 1}
+#endif
+
+__device__ __forceinline__ bool bc_ghost(int t, const int faces, const int *n,
+                                         const int *s, int &ghost,
+                                         int &normal) {
+#pragma unroll
+  for (int d = 0; d < NDIM; ++d) {
+    int face = 1; // nodes on one ghost face of axis d
+#pragma unroll
+    for (int k = 0; k < NDIM; ++k)
+      if (k != d)
+        face *= n[k] - 2;
+
+    const int lo = (faces >> (2 * d)) & 1, hi = (faces >> (2 * d + 1)) & 1;
+    if (t < (lo + hi) * face) {
+      const int high =
+          (lo && t < face) ? 0 : 1; // low ghost (0) or high (n[d] - 1)
+      int r = t - (high ? lo * face : 0);
+      int off = 0; // position within the face, axis d excluded
+#pragma unroll
+      for (int k = NDIM - 1; k >= 0; --k)
+        if (k != d) {
+          off += (r % (n[k] - 2) + 1) * s[k];
+          r /= n[k] - 2;
+        }
+      ghost = off + (high ? n[d] - 1 : 0) * s[d];
+      normal = high ? -s[d] : s[d];
+      return true;
+    }
+    t -= (lo + hi) * face;
+  }
+  return false;
+}
+
+// -------------------------------------- kernels
+extern "C" {
+
+// ------------------------------------------------------------------------------------
+__global__ void
+fd_kernel(const real_t *__restrict__ u0, const real_t *__restrict__ u1,
+          real_t *__restrict__ u2, const real_t *__restrict__ stiff,
+          const real_t *__restrict__ minv, const int derive_inertia,
+#ifdef USE_DAMPING
+          const real_t *__restrict__ damping, const real_t dt,
+#endif
+          const real_t f0, const int N0
+#if NDIM >= 2
+          ,
+          const real_t f1, const int N1, const int s0
+#endif
+#if NDIM >= 3
+          ,
+          const real_t f2, const int N2, const int s1
+#endif
+) {
+#if NDIM == 1
+  const int a0 = blockIdx.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;
+  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;
+  if (!(a0 > 0 && a0 < N0 - 1 && a1 > 0 && a1 < N1 - 1 && a2 > 0 &&
+        a2 < N2 - 1))
+    return;
+  const int idx = a0 * s0 + a1 * s1 + a2;
+  const int r0 = CLOSURE(a0, N0), r1 = CLOSURE(a1, N1), r2 = CLOSURE(a2, N2);
+#endif
+
+  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
+  real_t laplacian = flux_divergence_axis(u1, stiff, idx, s0, uc, sc, f0, r0) +
+                     flux_divergence_axis(u1, stiff, idx, 1, uc, sc, f1, r1);
+#elif NDIM == 3
+  real_t laplacian = flux_divergence_axis(u1, stiff, idx, s0, uc, sc, f0, r0) +
+                     flux_divergence_axis(u1, stiff, idx, s1, uc, sc, f1, r1) +
+                     flux_divergence_axis(u1, stiff, idx, 1, uc, sc, f2, r2);
+#endif
+
+  const real_t mi = derive_inertia ? 1.f / sc : minv[idx];
+#ifdef USE_DAMPING
+  const real_t beta = 0.5f * mi * damping[idx] * dt;
+  u2[idx] = (2.f * uc - u0[idx] * (1.f - beta) + mi * laplacian) / (1.f + beta);
+#else
+  u2[idx] = -u0[idx] + 2.f * uc + mi * laplacian;
+#endif
+}
+
+// ------------------------------------------------------------------------------------
+__global__ void homogeneous_neumann_kernel(real_t *__restrict__ u,
+                                           const int faces, BC_PARAMS) {
+  BC_GEOM;
+  int ghost, normal;
+  if (!bc_ghost(blockIdx.x * blockDim.x + threadIdx.x, faces, n, s, ghost,
+                normal))
+    return;
+  u[ghost] = u[ghost + 2 * normal];
+}
+
+// ------------------------------------------------------------------------------------
+__global__ void homogeneous_dirichlet_kernel(real_t *__restrict__ u,
+                                             const int faces, BC_PARAMS) {
+  BC_GEOM;
+  int ghost, normal;
+  if (!bc_ghost(blockIdx.x * blockDim.x + threadIdx.x, faces, n, s, ghost,
+                normal))
+    return;
+  u[ghost] = -u[ghost + 2 * normal];
+}
+
+
+} // extern "C"

cuwave/kernels/scalar_sensitivity.cu

@@ -0,0 +1,140 @@
+// Prepended by wave.compile_kernels: stencils.preamble, then common.cuh.
+// Compile-time configuration this file responds to:
+//   NDIM = 1 | 2 | 3
+
+// ------------------------------- interior guard macros
+#if NDIM == 1
+#define INTERIOR_OR_RETURN                                                     \
+  const int a0 = blockIdx.x * blockDim.x + threadIdx.x;                        \
+  if (!(a0 > 0 && a0 < N0 - 1))                                                \
+    return;                                                                    \
+  const int idx = a0
+#define AXIS_RADII const int r0 = CLOSURE(a0, N0)
+#define AXIS_OFFSETS const int o0 = 1
+#elif NDIM == 2
+#define INTERIOR_OR_RETURN                                                     \
+  const int a1 = blockIdx.x * blockDim.x + threadIdx.x;                        \
+  const int a0 = blockIdx.y * blockDim.y + threadIdx.y;                        \
+  if (!(a0 > 0 && a0 < N0 - 1 && a1 > 0 && a1 < N1 - 1))                       \
+    return;                                                                    \
+  const int idx = a0 * s0 + a1
+#define AXIS_RADII const int r0 = CLOSURE(a0, N0), r1 = CLOSURE(a1, N1)
+#define AXIS_OFFSETS const int o0 = s0, o1 = 1
+#elif NDIM == 3
+#define INTERIOR_OR_RETURN                                                     \
+  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;                        \
+  if (!(a0 > 0 && a0 < N0 - 1 && a1 > 0 && a1 < N1 - 1 && a2 > 0 &&            \
+        a2 < N2 - 1))                                                          \
+    return;                                                                    \
+  const int idx = a0 * s0 + a1 * s1 + a2
+#define AXIS_RADII                                                             \
+  const int r0 = CLOSURE(a0, N0), r1 = CLOSURE(a1, N1), r2 = CLOSURE(a2, N2)
+#define AXIS_OFFSETS const int o0 = s0, o1 = s1, o2 = 1
+#endif
+
+// ---------------------------------- gradient helpers
+__device__ __forceinline__ real_t stiffness_gradient_axis(
+    const real_t *__restrict__ u1, const real_t *__restrict__ l1,
+    const real_t *__restrict__ stiff, const int idx, const int s,
+    const real_t uc, const real_t lc, const real_t sc, const real_t factor,
+    const int r) {
+  const real_t sp = stiff[idx + s];                     // plus of sc
+  const real_t sm = stiff[idx - s];                     // minus of sc
+  const real_t dgp = sp * sp / ((sc + sp) * (sc + sp)); // d(harmonic mean)/dsc
+  const real_t dgm = sm * sm / ((sc + sm) * (sc + sm)); // d(harmonic mean)/dsc
+  real_t Dp = OP_W(r, 1) * (u1[idx + s] - uc);          // inner grad
+  real_t Dm = OP_W(r, 1) * (uc - u1[idx - s]);          // inner grad
+#pragma unroll
+  for (int k = 2; k <= STENCIL_RADIUS; ++k)
+    if (k <= r) {
+      Dp += OP_W(r, k) * (u1[idx + k * s] - u1[idx - (k - 1) * s]);
+      Dm += OP_W(r, k) * (u1[idx + (k - 1) * s] - u1[idx - k * s]);
+    }
+  return factor * (dgp * Dp * (l1[idx + s] - lc) +
+                   dgm * Dm * (lc - l1[idx - s])); // both cells of the node
+}
+
+// -------------------------------------- kernels
+extern "C" {
+
+// ------------------------------------------------------------------------------------
+__global__ void
+gradient_kernel(real_t *__restrict__ g_mass, real_t *__restrict__ g_stiff,
+                const real_t *__restrict__ u0, const real_t *__restrict__ u1,
+                const real_t *__restrict__ u2, const real_t *__restrict__ l1,
+                const real_t *__restrict__ stiff, const real_t inv_dt2,
+                const real_t F0, const int N0
+#if NDIM >= 2
+                ,
+                const real_t F1, const int N1, const int s0
+#endif
+#if NDIM >= 3
+                ,
+                const real_t F2, const int N2, const int s1
+#endif
+) {
+  INTERIOR_OR_RETURN;
+  AXIS_RADII;
+
+  const real_t uc = u1[idx];
+  const real_t lc = l1[idx];
+
+  // dJ/dmass: no neighbour and no material load
+  g_mass[idx] -= inv_dt2 * lc * (u2[idx] - 2.f * uc + u0[idx]);
+
+  // dJ/dstiff: scalar.cu's harmonic cell mean differentiated in place
+  const real_t sc = stiff[idx];
+#if NDIM == 1
+  const real_t g =
+      stiffness_gradient_axis(u1, l1, stiff, idx, 1, uc, lc, sc, F0, r0);
+#elif NDIM == 2
+  const real_t g =
+      stiffness_gradient_axis(u1, l1, stiff, idx, s0, uc, lc, sc, F0, r0) +
+      stiffness_gradient_axis(u1, l1, stiff, idx, 1, uc, lc, sc, F1, r1);
+#elif NDIM == 3
+  const real_t g =
+      stiffness_gradient_axis(u1, l1, stiff, idx, s0, uc, lc, sc, F0, r0) +
+      stiffness_gradient_axis(u1, l1, stiff, idx, s1, uc, lc, sc, F1, r1) +
+      stiffness_gradient_axis(u1, l1, stiff, idx, 1, uc, lc, sc, F2, r2);
+#endif
+  g_stiff[idx] -= g;
+}
+
+// ------------------------------------------------------------------------------------
+__global__ void frechet_kernel(real_t *__restrict__ acc_mass,
+                               real_t *__restrict__ acc_stiff,
+                               const real_t *__restrict__ u0,
+                               const real_t *__restrict__ u1,
+                               const real_t *__restrict__ u2, const real_t ft,
+                               const real_t f0, const int N0
+#if NDIM >= 2
+                               ,
+                               const real_t f1, const int N1, const int s0
+#endif
+#if NDIM >= 3
+                               ,
+                               const real_t f2, const int N2, const int s1
+#endif
+) {
+  INTERIOR_OR_RETURN;
+  AXIS_OFFSETS;
+
+  const real_t dudt = u2[idx] - u0[idx];
+  acc_mass[idx] += ft * dudt * dudt;
+
+  const real_t g0 = u1[idx + o0] - u1[idx - o0];
+  real_t sum = f0 * g0 * g0;
+#if NDIM >= 2
+  const real_t g1 = u1[idx + o1] - u1[idx - o1];
+  sum += f1 * g1 * g1;
+#endif
+#if NDIM >= 3
+  const real_t g2 = u1[idx + o2] - u1[idx - o2];
+  sum += f2 * g2 * g2;
+#endif
+  acc_stiff[idx] += sum;
+}
+
+} // extern "C"