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
// Morse Force Kernel
//
// **Purpose**: Bonded interactions (chemical bonds)
// **Use Case**: Molecular mechanics, reactive MD, bond stretching
// **Range**: Short-range (anharmonic bonded potential)
//
// **Potential**: U(r) = D[1 - exp(-a(r-r0))]^2
// **Force**: F = 2Da[1 - exp(-a(r-r0))] * exp(-a(r-r0)) * r_hat
//   where D = bond dissociation energy
//         a = width parameter
//         r0 = equilibrium bond distance

@group(0) @binding(0) var<storage, read> positions: array<f32>;
@group(0) @binding(1) var<storage, read> bond_pairs: array<f32>;  // [N_bonds, 2]
@group(0) @binding(2) var<storage, read> dissociation_energy: array<f32>;  // [N_bonds]
@group(0) @binding(3) var<storage, read> width_param: array<f32>;  // [N_bonds]
@group(0) @binding(4) var<storage, read> equilibrium_dist: array<f32>;  // [N_bonds]
@group(0) @binding(5) var<storage, read_write> forces: array<atomic<i32>>;  // Atomic for concurrent updates
@group(0) @binding(6) var<uniform> params: Params;

struct Params {
    n_particles: u32,
    n_bonds: u32,
    pad1: f32,
    pad2: f32,
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let bond_idx = global_id.x;
    
    if (bond_idx >= params.n_bonds) {
        return;
    }
    
    // Load bond pair (stored as f32, convert to u32)
    let i = u32(bond_pairs[bond_idx * 2u]);
    let j = u32(bond_pairs[bond_idx * 2u + 1u]);
    
    // Load positions
    let pos_i = vec3<f32>(
        positions[i * 3u],
        positions[i * 3u + 1u],
        positions[i * 3u + 2u]
    );
    let pos_j = vec3<f32>(
        positions[j * 3u],
        positions[j * 3u + 1u],
        positions[j * 3u + 2u]
    );
    
    // Load bond parameters
    let D = dissociation_energy[bond_idx];
    let a = width_param[bond_idx];
    let r0 = equilibrium_dist[bond_idx];
    
    // Compute distance
    let r_vec = pos_j - pos_i;
    let r = length(r_vec);
    
    if (r < 1e-6) {
        return;
    }
    
    // Morse force: F = 2Da[1 - exp(-a(r-r0))] * exp(-a(r-r0)) * r_hat
    let delta_r = r - r0;
    let exp_term = exp(-a * delta_r);
    let force_magnitude = 2.0 * D * a * (1.0 - exp_term) * exp_term;
    
    let r_hat = r_vec / r;
    let force_vec = force_magnitude * r_hat;
    
    // Convert to fixed-point for atomic operations (scale by 1000)
    let force_scaled = vec3<i32>(
        i32(force_vec.x * 1000.0),
        i32(force_vec.y * 1000.0),
        i32(force_vec.z * 1000.0)
    );
    
    // Apply forces (Newton's third law) using atomics
    atomicAdd(&forces[i * 3u], force_scaled.x);
    atomicAdd(&forces[i * 3u + 1u], force_scaled.y);
    atomicAdd(&forces[i * 3u + 2u], force_scaled.z);
    
    atomicAdd(&forces[j * 3u], -force_scaled.x);
    atomicAdd(&forces[j * 3u + 1u], -force_scaled.y);
    atomicAdd(&forces[j * 3u + 2u], -force_scaled.z);
}