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
// B-spline evaluation for PPPM charge assignment (f64)
//
// **Physics**: Cardinal B-splines M_p(x) for smooth particle-mesh interpolation
// **Formula**: M_p(x) = 1/(p-1)! * Σ_{k=0}^{p} (-1)^k * C(p,k) * max(0, x-k)^{p-1}
// **Precision**: Full f64 via math_f64.wgsl preamble
// **Use Case**: PPPM charge spreading and force interpolation
//
// Requires: math_f64.wgsl preamble
//
// Bindings:
//   0: positions  [N*3] f64, read     — particle positions (x,y,z)
//   1: coeffs     [N*order*3] f64, write — B-spline coefficients per particle/dim
//   2: derivs     [N*order*3] f64, write — B-spline derivatives per particle/dim
//   3: base_idx   [N*3] i32, write    — base mesh indices per particle
//   4: params     [16] f64, read      — simulation parameters

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

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

// Binomial coefficient C(n, k)
fn binomial(n: u32, k: u32) -> f64 {
    if (k > n) { return f64_const(positions[0], 0.0); }
    if (k == 0u || k == n) { return f64_const(positions[0], 1.0); }
    
    var result = f64_const(positions[0], 1.0);
    var ki = k;
    if (ki > n - ki) { ki = n - ki; }
    
    for (var i = 0u; i < ki; i = i + 1u) {
        result = result * f64(n - i) / f64(i + 1u);
    }
    return result;
}

// Factorial
fn factorial(n: u32) -> f64 {
    var result = f64_const(positions[0], 1.0);
    for (var i = 2u; i <= n; i = i + 1u) {
        result = result * f64(i);
    }
    return result;
}

// Cardinal B-spline M_p(x) using explicit formula
// M_p(x) = 1/(p-1)! * Σ_{k=0}^{p} (-1)^k * C(p,k) * max(0, x-k)^{p-1}
fn bspline_value(order: u32, x: f64) -> f64 {
    let zero = f64_const(x, 0.0);
    let one = f64_const(x, 1.0);
    
    if (order == 0u) { return zero; }
    if (order == 1u) {
        if (x >= zero && x < one) { return one; }
        return zero;
    }
    
    let order_f = f64(order);
    if (x <= zero || x >= order_f) { return zero; }
    
    let pm1 = order - 1u;
    let inv_fact = one / factorial(pm1);
    
    var sum = zero;
    for (var k = 0u; k <= order; k = k + 1u) {
        let xmk = x - f64(k);
        if (xmk > zero) {
            var sign = one;
            if ((k & 1u) == 1u) { sign = -one; }
            let binom = binomial(order, k);
            sum = sum + sign * binom * pow_f64(xmk, f64(pm1));
        }
    }
    
    return sum * inv_fact;
}

// B-spline derivative dM_p(x)/dx = M_{p-1}(x) - M_{p-1}(x-1)
fn bspline_deriv_value(order: u32, x: f64) -> f64 {
    if (order <= 1u) {
        return f64_const(x, 0.0);
    }
    return bspline_value(order - 1u, x) - bspline_value(order - 1u, x - f64_const(x, 1.0));
}

@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 mesh_kx = u32(params[2]);
    let mesh_ky = u32(params[3]);
    let mesh_kz = u32(params[4]);
    let box_x = params[5];
    let box_y = params[6];
    let box_z = params[7];
    
    // Particle position
    let px = positions[i * 3u];
    let py = positions[i * 3u + 1u];
    let pz = positions[i * 3u + 2u];
    
    // Convert to mesh coordinates
    let ux = px / box_x * f64(mesh_kx);
    let uy = py / box_y * f64(mesh_ky);
    let uz = pz / box_z * f64(mesh_kz);
    
    // Base indices: floor(u) - (order - 1)
    let base_x = i32(floor_f64(ux)) - i32(order) + 1;
    let base_y = i32(floor_f64(uy)) - i32(order) + 1;
    let base_z = i32(floor_f64(uz)) - i32(order) + 1;
    
    // Store base indices
    base_idx[i * 3u] = base_x;
    base_idx[i * 3u + 1u] = base_y;
    base_idx[i * 3u + 2u] = base_z;
    
    // Compute coefficients for each dimension
    // Output layout: coeffs[i * order * 3 + dim * order + k]
    let stride = order * 3u;
    
    for (var k = 0u; k < order; k = k + 1u) {
        // X dimension
        let arg_x = ux - f64(base_x + i32(k));
        coeffs[i * stride + k] = bspline_value(order, arg_x);
        derivs[i * stride + k] = bspline_deriv_value(order, arg_x);
        
        // Y dimension
        let arg_y = uy - f64(base_y + i32(k));
        coeffs[i * stride + order + k] = bspline_value(order, arg_y);
        derivs[i * stride + order + k] = bspline_deriv_value(order, arg_y);
        
        // Z dimension
        let arg_z = uz - f64(base_z + i32(k));
        coeffs[i * stride + 2u * order + k] = bspline_value(order, arg_z);
        derivs[i * stride + 2u * order + k] = bspline_deriv_value(order, arg_z);
    }
}