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
// deformed_bcs_f64.wgsl — BCS pairing for axially-deformed nuclei
//
// hotSpring absorption: same BCS physics as spherical but with deformed
// single-particle energies and level degeneracies.
//
// Three entry points:
//   bcs_occupations: v²_i, u²_i from (ε_i, λ, Δ)
//   particle_number: N = Σ (2j_i+1) · v²_i  (for bisection solver)
//   gap_equation:    Δ = G/2 · Σ (2j_i+1) · u_i · v_i
//
// Bindings:
//   0: params       uniform { n_states, _pad, lambda, delta, G, target_N: f64 }
//   1: sp_energies  [n_states] f64
//   2: degeneracy   [n_states] f64 — (2j_i + 1) per deformed level
//   3: v_sq         [n_states] f64 — output: v²_i
//   4: u_sq         [n_states] f64 — output: u²_i
//   5: result       [2] f64 — result[0] = particle count, result[1] = gap

// f64 enabled by compile_shader_f64() preamble injection

struct BcsParams {
    n_states: u32,
    _pad:     u32,
    lambda:   f64,
    delta:    f64,
    G:        f64,
    target_N: f64,
}

@group(0) @binding(0) var<uniform>             params: BcsParams;
@group(0) @binding(1) var<storage, read>       sp_energies: array<f64>;
@group(0) @binding(2) var<storage, read>       degeneracy: array<f64>;
@group(0) @binding(3) var<storage, read_write> v_sq: array<f64>;
@group(0) @binding(4) var<storage, read_write> u_sq: array<f64>;
@group(0) @binding(5) var<storage, read_write> result: array<f64>;

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

    let zero = params.lambda - params.lambda;
    let half = zero + 0.5;
    let eps = sp_energies[gid.x];
    let xi = eps - params.lambda;
    let e_qp = sqrt(xi * xi + params.delta * params.delta);

    let v2 = half * ((zero + 1.0) - xi / e_qp);
    let u2 = half * ((zero + 1.0) + xi / e_qp);

    v_sq[gid.x] = v2;
    u_sq[gid.x] = u2;
}

var<workgroup> shared_n: array<f64, 256>;
var<workgroup> shared_gap: array<f64, 256>;

@compute @workgroup_size(256)
fn particle_number_and_gap(@builtin(global_invocation_id) gid: vec3<u32>,
                           @builtin(local_invocation_id) lid: vec3<u32>) {
    let zero = params.lambda - params.lambda;
    var n_val = zero;
    var gap_val = zero;

    if (gid.x < params.n_states) {
        let degen = degeneracy[gid.x];
        n_val = degen * v_sq[gid.x];
        gap_val = degen * sqrt(v_sq[gid.x] * u_sq[gid.x]);
    }

    shared_n[lid.x] = n_val;
    shared_gap[lid.x] = gap_val;
    workgroupBarrier();

    var stride = 128u;
    while (stride > 0u) {
        if (lid.x < stride) {
            shared_n[lid.x] = shared_n[lid.x] + shared_n[lid.x + stride];
            shared_gap[lid.x] = shared_gap[lid.x] + shared_gap[lid.x + stride];
        }
        workgroupBarrier();
        stride = stride >> 1u;
    }

    if (lid.x == 0u) {
        result[0] = shared_n[0];
        result[1] = params.G * (zero + 0.5) * shared_gap[0];
    }
}