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 Mermin dielectric function ε(k,ω) on GPU.
// Each thread evaluates one ω point through the full chain:
//   plasma_W → χ₀ → ε_Vlasov → ε_Mermin → Im[1/ε] → S(k,ω)
//
// NUMERICAL STABILITY: For |z| ≥ 4, W(z) is computed directly via its
// asymptotic expansion, avoiding catastrophic cancellation in 1 + z·Z(z)
// where z·Z(z) ≈ -1 for large z. See gpu_dielectric.rs for details.
//
// PRECISION: All f64 constants use the (zero + literal) pattern to avoid
// f32 truncation (see math_f64.wgsl gotcha #2).
// Prepend: complex_f64.wgsl (with exp_f64/sin_f64/cos_f64 polyfills)

struct DielectricParams {
    n_points: u32,
    use_completed: u32,
    k: f64,
    nu: f64,
    k_debye: f64,
    v_th: f64,
    omega_p: f64,
    temperature: f64,
    density: f64,
}

@group(0) @binding(0) var<uniform> params: DielectricParams;
@group(0) @binding(1) var<storage, read> omegas: array<f64>;
@group(0) @binding(2) var<storage, read_write> loss_out: array<f64>;
@group(0) @binding(3) var<storage, read_write> dsf_out: array<f64>;

// W(z) = 1 + z·Z(z) — the Vlasov susceptibility kernel.
//
// Two branches to maintain f64 parity across CPU/GPU:
//
// |z| < 4: Power series for Z(z), then W = 1 + z·Z.
//          Cancellation is at most ~15× (|2z²Σ| < 0.97), safe for f64.
//
// |z| ≥ 4: Direct asymptotic expansion of W(z):
//          W(z) = i·z·√π·exp(-z²) - 1/(2z²) · Σ (2n+1)!! / (2z²)^n
//          No subtraction of near-equal values — naturally produces small W.
//          Converges rapidly: ratio test gives |a_{n+1}/a_n| = (2n+3)/(2z²).
//          For z=4, ratio = 0.19 at n=0 (excellent convergence).
fn plasma_w(z: Complex64) -> Complex64 {
    let zero = z.re - z.re;
    let z_abs = c64_abs(z);

    if z_abs < zero + 4.0 {
        // ── Small-z: power series for Z(z) ──
        // Z(z) = i√π exp(-z²) - 2z Σ_{n=0}^∞ (-2z²)^n / (2n+1)!!
        let z2 = c64_mul(z, z);
        let neg2z2 = c64_scale(z2, zero - 2.0);
        var term = c64_one();
        var total = term;
        for (var n = 1u; n < 80u; n++) {
            let denom = zero + f64(2u * n + 1u);
            term = c64_scale(c64_mul(term, neg2z2), (zero + 1.0) / denom);
            total = c64_add(total, term);
            if c64_abs(term) < (zero + 1e-16) * (c64_abs(total) + (zero + 1e-30)) {
                break;
            }
        }
        let exp_neg_z2 = c64_exp(c64_scale(z2, zero - 1.0));
        let sqrt_pi = zero + 1.7724538509055159;
        let imag_part = c64_scale(exp_neg_z2, sqrt_pi);
        // Z = i·√π·exp(-z²) - 2z·total
        let z_val = c64_sub(c64_new(-imag_part.im, imag_part.re),
                            c64_scale(c64_mul(z, total), zero + 2.0));
        // W = 1 + z·Z
        return c64_add(c64_one(), c64_mul(z, z_val));
    } else {
        // ── Large-z: direct asymptotic of W(z) ──
        // W(z) = i·z·√π·exp(-z²) + W_asymp
        // W_asymp = -1/(2z²) · (1 + 3/(2z²) + 15/(4z⁴) + 105/(8z⁶) + ...)
        //         = -inv2z2 · Σ_{n=0}^∞ (2n+1)!! · inv2z2^n
        //
        // Recurrence: a_0 = 1, a_{n+1} = a_n · (2n+3) · inv2z2
        let z2 = c64_mul(z, z);
        let inv_2z2 = c64_inv(c64_scale(z2, zero + 2.0));

        var coeff = c64_one();
        var total = coeff;
        for (var n = 0u; n < 30u; n++) {
            let factor = zero + f64(2u * n + 3u);
            coeff = c64_scale(c64_mul(coeff, inv_2z2), factor);
            total = c64_add(total, coeff);
            if c64_abs(coeff) < (zero + 1e-15) * (c64_abs(total) + (zero + 1e-30)) {
                break;
            }
        }
        // W_asymp = -inv2z2 · total
        let w_asymp = c64_scale(c64_mul(inv_2z2, total), zero - 1.0);

        // Exponential contribution: i·z·√π·exp(-z²)
        let exp_neg_z2 = c64_exp(c64_scale(z2, zero - 1.0));
        let sqrt_pi = zero + 1.7724538509055159;
        let zexp = c64_scale(c64_mul(z, exp_neg_z2), sqrt_pi);
        // i · zexp = (-zexp.im, zexp.re)
        let i_zexp = c64_new(-zexp.im, zexp.re);

        // sigma correction for Im(z) < 0 (Landau prescription)
        var sigma = zero + 1.0;
        if z.im < zero { sigma = zero + 2.0; }
        let w_exp = c64_scale(i_zexp, sigma);

        return c64_add(w_asymp, w_exp);
    }
}

fn chi0_classical(k_val: f64, omega: Complex64) -> Complex64 {
    let zero = k_val - k_val;
    let sqrt_2 = zero + 1.4142135623730951;
    let z = c64_scale(omega, (zero + 1.0) / (sqrt_2 * k_val * params.v_th));
    let w = plasma_w(z);
    let factor = -(params.k_debye * params.k_debye) / (k_val * k_val);
    return c64_scale(w, factor);
}

fn eps_vlasov(k_val: f64, omega: Complex64) -> Complex64 {
    return c64_sub(c64_one(), chi0_classical(k_val, omega));
}

fn eps_mermin(k_val: f64, omega_val: f64, nu_val: f64) -> Complex64 {
    return eps_mermin_core(k_val, omega_val, nu_val, false);
}

fn eps_completed_mermin(k_val: f64, omega_val: f64, nu_val: f64) -> Complex64 {
    return eps_mermin_core(k_val, omega_val, nu_val, true);
}

// Shared core for standard and completed (momentum-conserving) Mermin.
// When momentum_conserving is true, the denominator includes the Chuna &
// Murillo (2024) correction: D = 1 + (iν/ω) × R × (1 - G_p)
// where G_p = R × ω(ω+iν)/(k²v_th²).
fn eps_mermin_core(k_val: f64, omega_val: f64, nu_val: f64, momentum_conserving: bool) -> Complex64 {
    let zero = k_val - k_val;
    if abs(omega_val) < zero + 1e-15 {
        return eps_vlasov(k_val, c64_zero());
    }

    let omega_c = c64_new(omega_val, zero);
    let omega_shifted = c64_new(omega_val, nu_val);
    let eps_shifted = eps_vlasov(k_val, omega_shifted);
    let eps_static = eps_vlasov(k_val, c64_zero());

    let numer = c64_mul(c64_mul(omega_shifted, c64_inv(omega_c)),
                        c64_sub(eps_shifted, c64_one()));

    // R = (ε_shifted - 1) / (ε_static - 1)
    let r = c64_mul(c64_sub(eps_shifted, c64_one()),
                    c64_inv(c64_sub(eps_static, c64_one())));

    let i_nu_over_omega = c64_mul(c64_new(zero, zero + 1.0),
                                  c64_scale(c64_inv(omega_c), nu_val));

    var denom: Complex64;
    if momentum_conserving {
        let k2_vth2 = k_val * k_val * params.v_th * params.v_th;
        let omega_product = c64_mul(omega_c, omega_shifted);
        let g_p = c64_scale(c64_mul(r, omega_product), (zero + 1.0) / k2_vth2);
        let correction = c64_sub(c64_one(), g_p);
        denom = c64_add(c64_one(), c64_mul(i_nu_over_omega, c64_mul(r, correction)));
    } else {
        denom = c64_add(c64_one(), c64_mul(i_nu_over_omega, r));
    }

    return c64_add(c64_one(), c64_mul(numer, c64_inv(denom)));
}

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) nwg: vec3<u32>) {
    let idx = gid.x + gid.y * nwg.x * 64u;
    if idx >= params.n_points { return; }

    let zero = params.k - params.k;
    let omega = omegas[idx];
    var eps: Complex64;
    if params.use_completed != 0u {
        eps = eps_completed_mermin(params.k, omega, params.nu);
    } else {
        eps = eps_mermin(params.k, omega, params.nu);
    }
    let inv_eps = c64_inv(eps);

    loss_out[idx] = inv_eps.im;

    let pi = zero + 3.14159265358979323846;
    let prefactor = params.temperature * params.k * params.k / (pi * params.density);
    if abs(omega) < zero + 1e-15 {
        dsf_out[idx] = zero;
    } else {
        dsf_out[idx] = prefactor * (-inv_eps.im) / omega;
    }
}