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
// batched_hfb_density_f64.wgsl — BCS pairing + density construction for spherical HFB
//
// hotSpring absorption: nuclear physics GPU-resident SCF.
//
// Three entry points (kernels):
//   1. bcs_occupations — Compute BCS v² from eigenvalues and gap parameter
//   2. compute_density — Sum ρ(r) = Σ_k deg_k · v²_k · |φ_k(r)|² / (4π)
//   3. mix_density     — Linear density mixing for SCF convergence
//
// Physics:
//   v²_k = 0.5 * (1 - (ε_k - λ) / sqrt((ε_k - λ)² + Δ²))
//   ρ(r) = Σ_k (2j_k + 1) · v²_k · |φ_k(r)|² / (4πr²)
//
// Bindings:
//   0: params       uniform { n_states, n_grid, n_batch, mix_alpha: f64, delta: f64, lambda: f64 }
//   1: eigenvalues  [n_batch × n_states] f64
//   2: degeneracies [n_states] f64 — (2j+1) for each state
//   3: wf           [n_batch × n_states × n_grid] f64 — radial wavefunctions
//   4: v2_out       [n_batch × n_states] f64 — output BCS occupation probabilities
//   5: rho_out      [n_batch × n_grid] f64 — output density
//   6: rho_prev     [n_batch × n_grid] f64 — previous density (for mixing)
//   7: r_grid       [n_grid] f64

// f64 enabled by compile_shader_f64() preamble injection

struct DensityParams {
    n_states:  u32,
    n_grid:    u32,
    n_batch:   u32,
    _pad:      u32,
    mix_alpha: f64,
    delta:     f64,
    lambda:    f64,
}

@group(0) @binding(0) var<uniform>             params: DensityParams;
@group(0) @binding(1) var<storage, read>       eigenvalues: array<f64>;
@group(0) @binding(2) var<storage, read>       degeneracies: array<f64>;
@group(0) @binding(3) var<storage, read>       wf: array<f64>;
@group(0) @binding(4) var<storage, read_write> v2_out: array<f64>;
@group(0) @binding(5) var<storage, read_write> rho_out: array<f64>;
@group(0) @binding(6) var<storage, read>       rho_prev: array<f64>;
@group(0) @binding(7) var<storage, read>       r_grid: array<f64>;

@compute @workgroup_size(256)
fn bcs_occupations(@builtin(global_invocation_id) gid: vec3<u32>) {
    let idx = gid.x;
    let ns = params.n_states;
    let total = params.n_batch * ns;
    if (idx >= total) { return; }

    let zero = params.delta - params.delta;
    let half = zero + 0.5;
    let one = zero + 1.0;

    let eps = eigenvalues[idx];
    let xi = eps - params.lambda;
    let d2 = params.delta * params.delta;
    let denom = sqrt(xi * xi + d2);

    var v2 = half;
    if (denom > zero + 1e-30) {
        v2 = half * (one - xi / denom);
    }

    v2_out[idx] = clamp(v2, zero, one);
}

@compute @workgroup_size(256)
fn compute_density(@builtin(global_invocation_id) gid: vec3<u32>) {
    let idx = gid.x;
    let ng = params.n_grid;
    let total = params.n_batch * ng;
    if (idx >= total) { return; }

    let batch = idx / ng;
    let ir = idx % ng;
    let ns = params.n_states;

    let zero = r_grid[0] - r_grid[0];
    let four_pi = zero + 12.566370614359172;
    let r = r_grid[ir];
    let r2 = r * r;

    var rho = zero;
    for (var k = 0u; k < ns; k = k + 1u) {
        let v2 = v2_out[batch * ns + k];
        let phi = wf[batch * ns * ng + k * ng + ir];
        let deg = degeneracies[k];
        rho = rho + deg * v2 * phi * phi;
    }

    // Divide by 4πr² (spherical shell normalization)
    if (r2 > zero + 1e-30) {
        rho = rho / (four_pi * r2);
    }

    rho_out[idx] = rho;
}

@compute @workgroup_size(256)
fn mix_density(@builtin(global_invocation_id) gid: vec3<u32>) {
    let idx = gid.x;
    let total = params.n_batch * params.n_grid;
    if (idx >= total) { return; }

    let zero = params.mix_alpha - params.mix_alpha;
    let one = zero + 1.0;
    let alpha = params.mix_alpha;

    rho_out[idx] = alpha * rho_out[idx] + (one - alpha) * rho_prev[idx];
}