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
// RDF Pair Distance Histogram — f64 precision
//
// **Physics**: Radial distribution function g(r)
// **Algorithm**: All-pairs distance with PBC, bin into histogram
// **Use Case**: Structure analysis, validation vs Sarkas
//
// **f64 precision**: f64 positions, u32 histogram bins
//
// Note: Uses atomicAdd for histogram — requires workgroup synchronization
//
// Bindings:
//   0: positions   [N*3] f64, read
//   1: histogram   [n_bins] atomic<u32>, read-write
//   2: params      uniform

@group(0) @binding(0) var<storage, read> positions: array<f64>;
@group(0) @binding(1) var<storage, read_write> histogram: array<atomic<u32>>;
@group(0) @binding(2) var<uniform> params: Params;

struct Params {
    n_particles: u32,
    n_bins: u32,
    dr: f64,        // Bin width
    box_x: f64,
    box_y: f64,
    box_z: f64,
}

fn pbc_delta(delta: f64, box_size: f64) -> f64 {
    return delta - box_size * round(delta / box_size);
}

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    let i = gid.x;
    let n = params.n_particles;
    let n_bins = params.n_bins;
    let dr = params.dr;
    let box_x = params.box_x;
    let box_y = params.box_y;
    let box_z = params.box_z;

    if (i >= n) { return; }

    let xi = positions[i * 3u];
    let yi = positions[i * 3u + 1u];
    let zi = positions[i * 3u + 2u];

    // Only count pairs where j > i to avoid double-counting
    for (var j = i + 1u; j < n; j = j + 1u) {
        let dx = pbc_delta(positions[j * 3u]      - xi, box_x);
        let dy = pbc_delta(positions[j * 3u + 1u] - yi, box_y);
        let dz = pbc_delta(positions[j * 3u + 2u] - zi, box_z);

        let r = sqrt(dx * dx + dy * dy + dz * dz);
        let bin = u32(r / dr);

        if (bin < n_bins) {
            atomicAdd(&histogram[bin], 1u);
        }
    }
}

// Normalize histogram to g(r)
// g(r) = histogram[bin] / (N_pairs * V_shell * rho)
// where V_shell = (4/3)*π*((r+dr)³ - r³), rho = N/V
@group(0) @binding(3) var<storage, read_write> g_r_output: array<f64>;

@compute @workgroup_size(256)
fn normalize(@builtin(global_invocation_id) gid: vec3<u32>) {
    let bin = gid.x;
    if (bin >= params.n_bins) { return; }

    let n = params.n_particles;
    let volume = params.box_x * params.box_y * params.box_z;
    let rho = f64(n) / volume;
    let n_pairs = f64(n * (n - 1u)) / 2.0;

    let r_lo = f64(bin) * params.dr;
    let r_hi = f64(bin + 1u) * params.dr;
    let v_shell = (4.0 / 3.0) * 3.14159265358979323846 * (r_hi * r_hi * r_hi - r_lo * r_lo * r_lo);

    let expected = rho * v_shell * f64(n - 1u) / 2.0;
    let count = f64(atomicLoad(&histogram[bin]));

    var g_r = count - count;
    if (expected > 0.0) {
        g_r = count / expected;
    }
    g_r_output[bin] = g_r;
}