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_f64.wgsl — Interpolate forces from mesh to particles (PPPM)
//
// **Physics**: F_i = -q_i * E(r_i). E = ∇φ is stored on mesh (Ex, Ey, Ez).
// Interpolate E at particle position: E(r) = Σ_m E(m) * W(r - m) using B-spline W.
// Force = -q * E_interp.
//
// **Algorithm**: Each thread handles one particle. Sample Ex, Ey, Ez at order³
// mesh points, weight by B-spline M_4, trilinear-style sum. Force = -q * (Ex, Ey, Ez).
//
// **Precision**: f64 via bitcast<f64>(vec2<u32>)
// **Workgroup**: @compute @workgroup_size(256)
//
// Bindings:
//   0: mesh_grad  array<vec2<u32>>  read — potential gradient [Ex_grid | Ey_grid | Ez_grid]
//      Layout: Ex[gx*gy*gz], Ey[gx*gy*gz], Ez[gx*gy*gz] — 3 * gx*gy*gz f64s
//   1: frac_coords array<vec2<u32>>  read — [u,v,w] per particle
//   2: charges    array<vec2<u32>>  read — particle charges
//   3: forces     array<vec2<u32>>  read_write — [fx,fy,fz] per particle
//
// Params: { n_particles, grid_x, grid_y, grid_z, order }
//
// Reference: Hockney & Eastwood; PPPM force interpolation

@group(0) @binding(0) var<storage, read> mesh_grad: array<vec2<u32>>;
@group(0) @binding(1) var<storage, read> frac_coords: array<vec2<u32>>;
@group(0) @binding(2) var<storage, read> charges: array<vec2<u32>>;
@group(0) @binding(3) var<storage, read_write> forces: array<vec2<u32>>;
@group(0) @binding(4) var<uniform> params: Params;

struct Params {
    n_particles: u32,
    grid_x: u32,
    grid_y: u32,
    grid_z: u32,
    order: u32,
}

fn wrap_idx(idx: i32, k: u32) -> u32 {
    var w = idx % i32(k);
    if (w < 0) { w = w + i32(k); }
    return u32(w);
}

fn mesh_index(ix: u32, iy: u32, iz: u32, gx: u32, gy: u32, gz: u32) -> u32 {
    return ix * gy * gz + iy * gz + iz;
}

// M_4 cardinal B-spline for interpolation
fn M4(u: f64) -> f64 {
    let z = 0.0;
    if (u <= z || u >= 4.0) { return z; }
    let u2 = u * u;
    let u3 = u2 * u;
    if (u < 1.0) { return u3 / 6.0; }
    if (u < 2.0) { return (-3.0*u3 + 12.0*u2 - 12.0*u + 4.0) / 6.0; }
    if (u < 3.0) { return (3.0*u3 - 24.0*u2 + 60.0*u - 44.0) / 6.0; }
    return (4.0 - u) * (4.0 - u) * (4.0 - u) / 6.0;
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let i = global_id.x;
    let n = params.n_particles;
    let gx = params.grid_x;
    let gy = params.grid_y;
    let gz = params.grid_z;
    let order = params.order;
    if (i >= n) {
        return;
    }

    let q = bitcast<f64>(charges[i]);
    let base = i * 3u;
    let ux = bitcast<f64>(frac_coords[base]);
    let uy = bitcast<f64>(frac_coords[base + 1u]);
    let uz = bitcast<f64>(frac_coords[base + 2u]);

    let base_x = i32(floor(ux)) - i32(order) + 1;
    let base_y = i32(floor(uy)) - i32(order) + 1;
    let base_z = i32(floor(uz)) - i32(order) + 1;

    let grid_size = gx * gy * gz;
    let zero = q - q;

    var grad_x = zero;
    var grad_y = zero;
    var grad_z = zero;

    // Interpolate E using B-spline weights
    for (var jx = 0u; jx < order; jx = jx + 1u) {
        let arg_x = ux - f64(base_x + i32(jx));
        let wx = M4(arg_x);
        let ix = wrap_idx(base_x + i32(jx), gx);

        for (var jy = 0u; jy < order; jy = jy + 1u) {
            let arg_y = uy - f64(base_y + i32(jy));
            let wy = M4(arg_y);
            let iy = wrap_idx(base_y + i32(jy), gy);

            for (var jz = 0u; jz < order; jz = jz + 1u) {
                let arg_z = uz - f64(base_z + i32(jz));
                let wz = M4(arg_z);
                let iz = wrap_idx(base_z + i32(jz), gz);

                let midx = mesh_index(ix, iy, iz, gx, gy, gz);
                let ex = bitcast<f64>(mesh_grad[midx]);
                let ey = bitcast<f64>(mesh_grad[grid_size + midx]);
                let ez = bitcast<f64>(mesh_grad[2u * grid_size + midx]);

                let w = wx * wy * wz;
                grad_x = grad_x + ex * w;
                grad_y = grad_y + ey * w;
                grad_z = grad_z + ez * w;
            }
        }
    }

    // Force = -q * ∇φ (box-normalized gradient)
    forces[base] = bitcast<vec2<u32>>(-q * grad_x);
    forces[base + 1u] = bitcast<vec2<u32>>(-q * grad_y);
    forces[base + 2u] = bitcast<vec2<u32>>(-q * grad_z);
}