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
// Force interpolation kernel for PPPM (f64)
//
// **Physics**: Interpolates potential gradient from mesh to particle positions
// **Formula**: F_i = -q_i * ∇φ(r_i) where gradient uses B-spline derivatives
// **Precision**: Full f64 via math_f64.wgsl preamble
// **Use Case**: PPPM final step - mesh to particle forces
//
// Requires: math_f64.wgsl preamble, B-spline coefficients and derivatives
//
// Bindings:
//   0: charges     [N] f64, read        — particle charges
//   1: coeffs      [N*order*3] f64, read — B-spline coefficients
//   2: derivs      [N*order*3] f64, read — B-spline derivatives
//   3: base_idx    [N*3] i32, read      — base mesh indices
//   4: potential   [Kx*Ky*Kz] f64, read — potential mesh φ(n)
//   5: forces      [N*3] f64, write     — output forces (fx, fy, fz)
//   6: params      [16] f64, read       — simulation parameters

@group(0) @binding(0) var<storage, read> charges: array<f64>;
@group(0) @binding(1) var<storage, read> coeffs: array<f64>;
@group(0) @binding(2) var<storage, read> derivs: array<f64>;
@group(0) @binding(3) var<storage, read> base_idx: array<i32>;
@group(0) @binding(4) var<storage, read> potential: array<f64>;
@group(0) @binding(5) var<storage, read_write> forces: array<f64>;
@group(0) @binding(6) var<storage, read> params: array<f64>;

// params layout:
//   [0] = n_particles
//   [1] = order
//   [2] = mesh_kx, [3] = mesh_ky, [4] = mesh_kz
//   [5] = box_x, [6] = box_y, [7] = box_z

// Wrap index to [0, K) with periodic boundary
fn wrap_idx(idx: i32, k: u32) -> u32 {
    var wrapped = idx % i32(k);
    if (wrapped < 0) { wrapped = wrapped + i32(k); }
    return u32(wrapped);
}

// 3D mesh index to linear index
fn mesh_index(ix: u32, iy: u32, iz: u32, kx: u32, ky: u32, kz: u32) -> u32 {
    return ix * ky * kz + iy * kz + iz;
}

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    let i = gid.x;
    let n = u32(params[0]);
    if (i >= n) { return; }
    
    let order = u32(params[1]);
    let kx = u32(params[2]);
    let ky = u32(params[3]);
    let kz = u32(params[4]);
    let box_x = params[5];
    let box_y = params[6];
    let box_z = params[7];
    
    let q = charges[i];
    let stride = order * 3u;
    
    // Mesh spacing (for gradient scaling)
    let hx = box_x / f64(kx);
    let hy = box_y / f64(ky);
    let hz = box_z / f64(kz);
    
    // Base indices
    let bx = base_idx[i * 3u];
    let by = base_idx[i * 3u + 1u];
    let bz = base_idx[i * 3u + 2u];
    
    // Accumulate gradient components
    let zero = charges[0] - charges[0];  // f64 zero
    var grad_x = zero;
    var grad_y = zero;
    var grad_z = zero;
    
    // Triple loop over B-spline support
    for (var jx = 0u; jx < order; jx = jx + 1u) {
        let wx = coeffs[i * stride + jx];
        let dwx = derivs[i * stride + jx];
        let ix = wrap_idx(bx + i32(jx), kx);
        
        for (var jy = 0u; jy < order; jy = jy + 1u) {
            let wy = coeffs[i * stride + order + jy];
            let dwy = derivs[i * stride + order + jy];
            let iy = wrap_idx(by + i32(jy), ky);
            
            for (var jz = 0u; jz < order; jz = jz + 1u) {
                let wz = coeffs[i * stride + 2u * order + jz];
                let dwz = derivs[i * stride + 2u * order + jz];
                let iz = wrap_idx(bz + i32(jz), kz);
                
                // Get potential at this mesh point
                let midx = mesh_index(ix, iy, iz, kx, ky, kz);
                let phi = potential[midx];
                
                // Gradient components: ∂φ/∂x ≈ Σ φ(n) * dW_x/dx * W_y * W_z
                // Scale: dW/dx = dW/du * du/dx = dW/du * K/L
                grad_x = grad_x + phi * dwx * wy * wz * f64(kx) / box_x;
                grad_y = grad_y + phi * wx * dwy * wz * f64(ky) / box_y;
                grad_z = grad_z + phi * wx * wy * dwz * f64(kz) / box_z;
            }
        }
    }
    
    // Force = -q * ∇φ
    forces[i * 3u]      = -q * grad_x;
    forces[i * 3u + 1u] = -q * grad_y;
    forces[i * 3u + 2u] = -q * grad_z;
}