primal-barracuda 0.4.0

barraCuda — BARrier-free Rust Abstracted Cross-platform Unified Dimensional Algebra. Vendor-agnostic GPU compute via WGSL.
Documentation
// SPDX-License-Identifier: AGPL-3.0-or-later
// Green's function application for PPPM k-space (f64)
//
// **Physics**: Applies Green's function in k-space: φ(k) = G(k) * ρ(k)
// **Formula**: G(k) = 4π/k² × exp(-k²/(4α²)) × influence(k)
// **Precision**: Full f64 using native builtins where available
// **Use Case**: PPPM k-space step after FFT
//
// **Performance (Feb 15 2026 hotSpring finding)**:
// Native exp(f64): 2.2× faster than math_f64 software exp_f64
//
// Requires: math_f64.wgsl preamble (for complex ops if needed)
//
// Complex multiplication: (a + bi)(c + di) = (ac - bd) + (ad + bc)i
//
// Bindings:
//   0: rho_k_re    [Kx*Ky*Kz] f64, read  — charge density FFT real part
//   1: rho_k_im    [Kx*Ky*Kz] f64, read  — charge density FFT imag part
//   2: phi_k_re    [Kx*Ky*Kz] f64, write — potential FFT real part
//   3: phi_k_im    [Kx*Ky*Kz] f64, write — potential FFT imag part
//   4: greens      [Kx*Ky*Kz] f64, read  — precomputed G(k) values (real)
//   5: params      [16] f64, read        — simulation parameters

@group(0) @binding(0) var<storage, read> rho_k_re: array<f64>;
@group(0) @binding(1) var<storage, read> rho_k_im: array<f64>;
@group(0) @binding(2) var<storage, read_write> phi_k_re: array<f64>;
@group(0) @binding(3) var<storage, read_write> phi_k_im: array<f64>;
@group(0) @binding(4) var<storage, read> greens: array<f64>;
@group(0) @binding(5) var<storage, read> params: array<f64>;

// params layout:
//   [0] = total mesh size (Kx * Ky * Kz)

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    let idx = gid.x;
    let total = u32(params[0]);
    if (idx >= total) { return; }
    
    // G(k) is purely real for symmetric systems
    let g = greens[idx];
    let rho_re = rho_k_re[idx];
    let rho_im = rho_k_im[idx];
    
    // φ(k) = G(k) * ρ(k)
    // Since G is real: φ_re = G * ρ_re, φ_im = G * ρ_im
    phi_k_re[idx] = g * rho_re;
    phi_k_im[idx] = g * rho_im;
}

// Alternative entry point: compute G(k) on-the-fly instead of precomputed
// This is slower but uses less memory
@compute @workgroup_size(64)
fn apply_greens_inline(@builtin(global_invocation_id) gid: vec3<u32>) {
    let idx = gid.x;
    let total = u32(params[0]);
    if (idx >= total) { return; }
    
    // Additional params for inline G computation:
    //   [1] = kx, [2] = ky, [3] = kz (mesh dims)
    //   [4] = box_x, [5] = box_y, [6] = box_z
    //   [7] = alpha (Ewald parameter)
    //   [8] = order (B-spline order)
    let kx = u32(params[1]);
    let ky = u32(params[2]);
    let kz = u32(params[3]);
    let box_x = params[4];
    let box_y = params[5];
    let box_z = params[6];
    let alpha = params[7];
    let order = u32(params[8]);
    
    // Convert linear index to 3D
    let iz = idx % kz;
    let iy = (idx / kz) % ky;
    let ix = idx / (ky * kz);
    
    let zero = rho_k_re[0] - rho_k_re[0];
    let one = zero + 1.0;
    let pi = zero + 3.14159265358979323846;
    let two_pi = pi * (zero + 2.0);
    
    // Compute k-vector components with Nyquist handling
    var kx_f = f64(ix);
    var ky_f = f64(iy);
    var kz_f = f64(iz);
    if (ix > kx / 2u) { kx_f = kx_f - f64(kx); }
    if (iy > ky / 2u) { ky_f = ky_f - f64(ky); }
    if (iz > kz / 2u) { kz_f = kz_f - f64(kz); }
    
    // k = 2π * n / L
    let kvec_x = two_pi * kx_f / box_x;
    let kvec_y = two_pi * ky_f / box_y;
    let kvec_z = two_pi * kz_f / box_z;
    let k_sq = kvec_x * kvec_x + kvec_y * kvec_y + kvec_z * kvec_z;
    
    // Handle k = 0 (DC component)
    var g = zero;
    if (k_sq > zero + 1e-30) {
        // Coulomb: 4π/k²
        let coulomb = (zero + 4.0) * pi / k_sq;
        
        // Ewald damping: exp(-k²/(4α²)) - native f64 builtin
        let ewald = exp(-k_sq / ((zero + 4.0) * alpha * alpha));
        
        // Simplified G (without influence function for this kernel)
        g = coulomb * ewald;
    }
    
    let rho_re = rho_k_re[idx];
    let rho_im = rho_k_im[idx];
    
    phi_k_re[idx] = g * rho_re;
    phi_k_im[idx] = g * rho_im;
}