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
// 1D Euler fluid solver with HLL approximate Riemann solver.
//
// GPU-accelerated spatial mesh update for the kinetic-fluid coupling pipeline.
// Each thread computes the flux at one cell interface and applies the
// conservative update for the adjacent cell.
//
// Two-pass approach:
// Pass 1 (flux): Compute HLL flux at each interface i+1/2.
// Pass 2 (update): Apply conservative update U^{n+1} = U^n - (dt/dx)(F_{i+1/2} - F_{i-1/2}).

struct EulerParams {
    nx: u32,
    _pad: u32,
    dt: f64,
    dx: f64,
    gamma: f64,
}

@group(0) @binding(0) var<uniform> params: EulerParams;
// Conserved variables: [rho_0, rho_1, ..., rhou_0, rhou_1, ..., E_0, E_1, ...]
@group(0) @binding(1) var<storage, read_write> cons: array<f64>;
// HLL fluxes at interfaces: [F_rho_0, F_rho_1, ..., F_mom_0, ..., F_ene_0, ...]
@group(0) @binding(2) var<storage, read_write> flux: array<f64>;

fn cons_to_prim(rho: f64, rhou: f64, e: f64) -> vec3<f64> {
    let zero = params.dx - params.dx;
    var u = zero;
    if abs(rho) > 1e-30 { u = rhou / rho; }
    let p = max((params.gamma - 1.0) * (e - 0.5 * rho * u * u), zero + 1e-30);
    return vec3<f64>(rho, u, p);
}

fn euler_flux_vec(rho: f64, u: f64, p: f64) -> vec3<f64> {
    let e = p / (params.gamma - 1.0) + 0.5 * rho * u * u;
    return vec3<f64>(rho * u, rho * u * u + p, (e + p) * u);
}

fn sound_speed(rho: f64, p: f64) -> f64 {
    let zero = params.dx - params.dx;
    if rho > 1e-30 {
        return sqrt(params.gamma * p / rho);
    }
    return zero;
}

// Pass 1: compute HLL flux at interface i+1/2 (between cells i and i+1).
// Thread i computes flux at interface i (between cell i-1 and cell i).
// Thread 0 copies left boundary flux; thread nx copies right boundary flux.
@compute @workgroup_size(64)
fn compute_hll_flux(@builtin(global_invocation_id) gid: vec3<u32>) {
    let i = gid.x;
    let nx = params.nx;

    if i > nx { return; }

    let n = nx;

    if i == 0u {
        // Left boundary: outflow (copy cell 0 flux)
        let prim = cons_to_prim(cons[0], cons[n], cons[2u * n]);
        let f = euler_flux_vec(prim.x, prim.y, prim.z);
        flux[0] = f.x;
        flux[n + 1u] = f.y;
        flux[2u * (n + 1u)] = f.z;
        return;
    }

    if i == nx {
        // Right boundary: outflow (copy last cell flux)
        let last = nx - 1u;
        let prim = cons_to_prim(cons[last], cons[n + last], cons[2u * n + last]);
        let f = euler_flux_vec(prim.x, prim.y, prim.z);
        flux[nx] = f.x;
        flux[n + 1u + nx] = f.y;
        flux[2u * (n + 1u) + nx] = f.z;
        return;
    }

    // Interior interface between cell (i-1) and cell i
    let l = i - 1u;
    let r_idx = i;

    let prim_l = cons_to_prim(cons[l], cons[n + l], cons[2u * n + l]);
    let prim_r = cons_to_prim(cons[r_idx], cons[n + r_idx], cons[2u * n + r_idx]);

    let c_l = sound_speed(prim_l.x, prim_l.z);
    let c_r = sound_speed(prim_r.x, prim_r.z);

    let s_l = min(prim_l.y - c_l, prim_r.y - c_r);
    let s_r = max(prim_l.y + c_l, prim_r.y + c_r);

    let f_l = euler_flux_vec(prim_l.x, prim_l.y, prim_l.z);
    let f_r = euler_flux_vec(prim_r.x, prim_r.y, prim_r.z);

    var f_hll = vec3<f64>(0.0, 0.0, 0.0);

    if s_l >= 0.0 {
        f_hll = f_l;
    } else if s_r <= 0.0 {
        f_hll = f_r;
    } else {
        let denom = s_r - s_l;
        let u_l = vec3<f64>(cons[l], cons[n + l], cons[2u * n + l]);
        let u_r = vec3<f64>(cons[r_idx], cons[n + r_idx], cons[2u * n + r_idx]);
        f_hll = (f_l * s_r - f_r * s_l + u_r * (s_l * s_r) - u_l * (s_l * s_r)) * (1.0 / denom);
    }

    let fi = i;
    flux[fi] = f_hll.x;
    flux[n + 1u + fi] = f_hll.y;
    flux[2u * (n + 1u) + fi] = f_hll.z;
}

// Pass 2: conservative update U^{n+1} = U^n - (dt/dx)(F_{i+1/2} - F_{i-1/2}).
@compute @workgroup_size(64)
fn euler_update(@builtin(global_invocation_id) gid: vec3<u32>) {
    let i = gid.x;
    let nx = params.nx;
    if i >= nx { return; }

    let n = nx;
    let ratio = params.dt / params.dx;

    // Flux at i+1/2 is flux[i+1], flux at i-1/2 is flux[i]
    let f_rho_r = flux[i + 1u];
    let f_rho_l = flux[i];
    let f_mom_r = flux[n + 1u + i + 1u];
    let f_mom_l = flux[n + 1u + i];
    let f_ene_r = flux[2u * (n + 1u) + i + 1u];
    let f_ene_l = flux[2u * (n + 1u) + i];

    cons[i] = max(cons[i] - ratio * (f_rho_r - f_rho_l), 1e-10);
    cons[n + i] = cons[n + i] - ratio * (f_mom_r - f_mom_l);
    cons[2u * n + i] = cons[2u * n + i] - ratio * (f_ene_r - f_ene_l);
}