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
//
// fape_loss_f64.wgsl — Frame Aligned Point Error loss (AlphaFold2)
//
// FAPE = (1/N) Σ_i ||T_i^{-1}(x_pred) - T_i^{-1}(x_true)||
// Per-residue FAPE: compare predicted vs true atom positions in local frames.
// Frames stored as 4x4 row-major: [R|t; 0 0 0 1]. T^{-1}(x) = R^T * (x - t).
//
// Bindings: @0 pred_pos[N*M*3], @1 true_pos[N*M*3], @2 pred_frames[N*12], @3 true_frames[N*12],
//          @4 out[N], @5 uniform{n_residues, n_atoms, d_clamp}

struct FapeParams {
    n_residues: u32,
    n_atoms: u32,
    _pad: [u32; 2],
    d_clamp: f64,
}

@group(0) @binding(0) var<storage, read>       pred_pos: array<f64>;   // [N*M*3]
@group(0) @binding(1) var<storage, read>       true_pos: array<f64>;  // [N*M*3]
@group(0) @binding(2) var<storage, read>       pred_frames: array<f64>; // [N*12] 3x4 R|t
@group(0) @binding(3) var<storage, read>       true_frames: array<f64>; // [N*12]
@group(0) @binding(4) var<storage, read_write> out: array<f64>;       // [N] per-residue FAPE
@group(0) @binding(5) var<uniform>             params: FapeParams;

fn transform_inv_pred(i: u32, x: vec3<f64>) -> vec3<f64> {
    let base = i * 12u;
    let r00 = pred_frames[base + 0u];
    let r10 = pred_frames[base + 4u];
    let r20 = pred_frames[base + 8u];
    let tx = pred_frames[base + 3u];
    let ty = pred_frames[base + 7u];
    let tz = pred_frames[base + 11u];
    let dx = x.x - tx;
    let dy = x.y - ty;
    let dz = x.z - tz;
    return vec3<f64>(r00 * dx + r10 * dy + r20 * dz,
        pred_frames[base + 1u] * dx + pred_frames[base + 5u] * dy + pred_frames[base + 9u] * dz,
        pred_frames[base + 2u] * dx + pred_frames[base + 6u] * dy + pred_frames[base + 10u] * dz);
}

fn transform_inv_true(i: u32, x: vec3<f64>) -> vec3<f64> {
    let base = i * 12u;
    let r00 = true_frames[base + 0u];
    let r10 = true_frames[base + 4u];
    let r20 = true_frames[base + 8u];
    let tx = true_frames[base + 3u];
    let ty = true_frames[base + 7u];
    let tz = true_frames[base + 11u];
    let dx = x.x - tx;
    let dy = x.y - ty;
    let dz = x.z - tz;
    return vec3<f64>(r00 * dx + r10 * dy + r20 * dz,
        true_frames[base + 1u] * dx + true_frames[base + 5u] * dy + true_frames[base + 9u] * dz,
        true_frames[base + 2u] * dx + true_frames[base + 6u] * dy + true_frames[base + 10u] * dz);
}

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    let N = params.n_residues;
    let M = params.n_atoms;
    let d_clamp = params.d_clamp;

    let i = gid.x;
    if i >= N { return; }

    var sum_dist = f64(0.0);
    for (var a = 0u; a < M; a = a + 1u) {
        let pos_base = (i * M + a) * 3u;
        let pred_p = vec3<f64>(pred_pos[pos_base], pred_pos[pos_base + 1u], pred_pos[pos_base + 2u]);
        let true_p = vec3<f64>(true_pos[pos_base], true_pos[pos_base + 1u], true_pos[pos_base + 2u]);

        let pred_local = transform_inv_pred(i, pred_p);
        let true_local = transform_inv_true(i, true_p);

        let dx = pred_local.x - true_local.x;
        let dy = pred_local.y - true_local.y;
        let dz = pred_local.z - true_local.z;
        let d = sqrt_f64(dx * dx + dy * dy + dz * dz);
        sum_dist += min(d, d_clamp);
    }

    out[i] = sum_dist / f64(M);
}