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
// capacitor_ode_rk4_f64.wgsl — Batched RK4 for phenotypic capacitor ODE
//
// LOCAL EVOLUTION — to be absorbed by ToadStool as BatchedOdeRK4Generic<6, 16>.
//
// ODE system (Mhatre et al. 2020):
//   dN/dt = mu_max·N·(1 - N/K) - death·N
//   dC/dt = stress·k_cdg·N - d_cdg·C
//   dV/dt = k_charge·hill(C, K_cdg, n)·(1-V) - k_discharge·V
//   dB/dt = w_bio·V·(1-B) - d_bio·B
//   dM/dt = w_mot·(1-V)·(1-M) - d_mot·M
//   dR/dt = w_rug·V²·(1-R) - d_rug·R
//
// State vector: [N, C, V, B, M, R]  (6 variables)
// Parameters (per batch, 16 values — matches CapacitorParams::to_flat()):
//   [mu_max, k_cap, death_rate, k_cdg_prod, d_cdg, k_vpsr_charge,
//    k_vpsr_discharge, n_vpsr, k_vpsr_cdg, w_biofilm, w_motility,
//    w_rugose, d_bio, d_mot, d_rug, stress_factor]

// f64 is enabled by compile_shader_f64() preamble injection

const N_VARS:   u32 = 6u;
const N_PARAMS: u32 = 16u;

struct OdeConfig {
    n_batches:      u32,
    n_steps:        u32,
    _pad0:          u32,
    _pad1:          u32,
    h:              f64,
    t0:             f64,
    clamp_max:      f64,
    clamp_min:      f64,
}

@group(0) @binding(0) var<uniform>             config:         OdeConfig;
@group(0) @binding(1) var<storage, read>       initial_states: array<f64>;
@group(0) @binding(2) var<storage, read>       batch_params:   array<f64>;
@group(0) @binding(3) var<storage, read_write> output_states:  array<f64>;

fn fmax(a: f64, b: f64) -> f64 {
    if (a >= b) { return a; }
    return b;
}
fn fclamp(x: f64, lo: f64, hi: f64) -> f64 {
    if (x < lo) { return lo; }
    if (x > hi) { return hi; }
    return x;
}
fn fpow(base: f64, exp_val: f64) -> f64 {
    let z = base - base;
    if (base <= z) { return z; }
    return exp(exp_val * log(base));
}

fn hill_n(x: f64, k: f64, n: f64) -> f64 {
    let z = x - x;
    if (x <= z) { return z; }
    let xn = fpow(x, n);
    let kn = fpow(k, n);
    return xn / (kn + xn + 1e-30);
}

fn cap_deriv(y: array<f64, 6>, p_base: u32) -> array<f64, 6> {
    let mu_max   = batch_params[p_base + 0u];
    let k_cap    = batch_params[p_base + 1u];
    let death    = batch_params[p_base + 2u];
    let k_cdg    = batch_params[p_base + 3u];
    let d_cdg    = batch_params[p_base + 4u];
    let k_charge = batch_params[p_base + 5u];
    let k_disch  = batch_params[p_base + 6u];
    let n_vpsr   = batch_params[p_base + 7u];
    let k_vcdg   = batch_params[p_base + 8u];
    let w_bio    = batch_params[p_base + 9u];
    let w_mot    = batch_params[p_base + 10u];
    let w_rug    = batch_params[p_base + 11u];
    let d_bio    = batch_params[p_base + 12u];
    let d_mot    = batch_params[p_base + 13u];
    let d_rug    = batch_params[p_base + 14u];
    let stress   = batch_params[p_base + 15u];

    let z   = y[0] - y[0];
    let one = z + 1.0;

    let cell = fmax(y[0], z);
    let cdg  = fmax(y[1], z);
    let vpsr = fmax(y[2], z);
    let bio  = fmax(y[3], z);
    let mot  = fmax(y[4], z);
    let rug  = fmax(y[5], z);

    var dy: array<f64, 6>;
    dy[0] = mu_max * cell * (one - cell / (k_cap + 1e-30)) - death * cell;
    dy[1] = stress * k_cdg * cell - d_cdg * cdg;

    let charge   = k_charge * hill_n(cdg, k_vcdg, n_vpsr) * (one - vpsr);
    let discharge = k_disch * vpsr;
    dy[2] = charge - discharge;

    dy[3] = w_bio * vpsr * (one - bio) - d_bio * bio;
    dy[4] = w_mot * (one - vpsr) * (one - mot) - d_mot * mot;
    dy[5] = w_rug * vpsr * vpsr * (one - rug) - d_rug * rug;
    return dy;
}

fn add6(a: array<f64, 6>, b: array<f64, 6>, s: f64) -> array<f64, 6> {
    var r: array<f64, 6>;
    r[0] = a[0] + s * b[0]; r[1] = a[1] + s * b[1]; r[2] = a[2] + s * b[2];
    r[3] = a[3] + s * b[3]; r[4] = a[4] + s * b[4]; r[5] = a[5] + s * b[5];
    return r;
}

fn rk4_step(y: array<f64, 6>, p_base: u32, h: f64) -> array<f64, 6> {
    let z    = h - h;
    let half = z + 0.5;
    let two  = z + 2.0;
    let h2   = h * half;

    let k1 = cap_deriv(y, p_base);
    let k2 = cap_deriv(add6(y, k1, h2), p_base);
    let k3 = cap_deriv(add6(y, k2, h2), p_base);
    let k4 = cap_deriv(add6(y, k3, h), p_base);

    let sixth = (z + 1.0) / (z + 6.0);
    var yn: array<f64, 6>;
    yn[0] = y[0] + h * sixth * (k1[0] + two * k2[0] + two * k3[0] + k4[0]);
    yn[1] = y[1] + h * sixth * (k1[1] + two * k2[1] + two * k3[1] + k4[1]);
    yn[2] = y[2] + h * sixth * (k1[2] + two * k2[2] + two * k3[2] + k4[2]);
    yn[3] = y[3] + h * sixth * (k1[3] + two * k2[3] + two * k3[3] + k4[3]);
    yn[4] = y[4] + h * sixth * (k1[4] + two * k2[4] + two * k3[4] + k4[4]);
    yn[5] = y[5] + h * sixth * (k1[5] + two * k2[5] + two * k3[5] + k4[5]);
    return yn;
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let b = global_id.x;
    if (b >= config.n_batches) { return; }

    let s_base = b * N_VARS;
    let p_base = b * N_PARAMS;

    var y: array<f64, 6>;
    y[0] = initial_states[s_base + 0u];
    y[1] = initial_states[s_base + 1u];
    y[2] = initial_states[s_base + 2u];
    y[3] = initial_states[s_base + 3u];
    y[4] = initial_states[s_base + 4u];
    y[5] = initial_states[s_base + 5u];

    let cmax = config.clamp_max;
    let cmin = config.clamp_min;
    let h    = config.h;

    for (var step = 0u; step < config.n_steps; step = step + 1u) {
        let yn = rk4_step(y, p_base, h);
        y[0] = fclamp(yn[0], cmin, cmax);
        y[1] = fclamp(yn[1], cmin, cmax);
        y[2] = fclamp(yn[2], cmin, cmin + 1.0);
        y[3] = fclamp(yn[3], cmin, cmin + 1.0);
        y[4] = fclamp(yn[4], cmin, cmin + 1.0);
        y[5] = fclamp(yn[5], cmin, cmin + 1.0);
    }

    output_states[s_base + 0u] = y[0];
    output_states[s_base + 1u] = y[1];
    output_states[s_base + 2u] = y[2];
    output_states[s_base + 3u] = y[3];
    output_states[s_base + 4u] = y[4];
    output_states[s_base + 5u] = y[5];
}