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
// Coulomb Force Kernel
//
// **Purpose**: Electrostatic interactions (q1*q2/r)
// **Use Case**: Charged particles, ions, proteins
// **Range**: Long-range (1/r decay)
//
// **Deep Debt Compliance**:
// - Pure WGSL (universal GPU compute)
// - Vectorized calculation (all pairs)
// - Capability-based dispatch
//
// **Formula**: F = k * q_i * q_j / r^2 * r_hat
//   where k = Coulomb constant (can be absorbed into charges)
//   r_hat = unit vector from i to j

@group(0) @binding(0) var<storage, read> positions: array<f32>;  // [N, 3] flattened
@group(0) @binding(1) var<storage, read> charges: array<f32>;    // [N]
@group(0) @binding(2) var<storage, read_write> forces: array<f32>; // [N, 3]
@group(0) @binding(3) var<uniform> params: Params;

struct Params {
    n_particles: u32,
    coulomb_constant: f32,
    cutoff_radius: f32,
    epsilon: f32,  // Softening parameter (avoid singularity)
}

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let i = global_id.x;
    
    if (i >= params.n_particles) {
        return;
    }
    
    // Load position of particle i
    let pos_i = vec3<f32>(
        positions[i * 3u],
        positions[i * 3u + 1u],
        positions[i * 3u + 2u]
    );
    let q_i = charges[i];
    
    // Accumulate forces from all other particles
    var force = vec3<f32>(0.0, 0.0, 0.0);
    
    for (var j = 0u; j < params.n_particles; j = j + 1u) {
        if (i == j) {
            continue;
        }
        
        let pos_j = vec3<f32>(
            positions[j * 3u],
            positions[j * 3u + 1u],
            positions[j * 3u + 2u]
        );
        let q_j = charges[j];
        
        // Compute distance vector (from i to j)
        let r_vec = pos_j - pos_i;
        let r2 = dot(r_vec, r_vec) + params.epsilon;  // Softened
        let r = sqrt(r2);
        
        // Apply cutoff
        if (r > params.cutoff_radius) {
            continue;
        }
        
        // Coulomb force on i from j
        // Standard formula: F = k * q_i * q_j / r² * (r_i - r_j) / |r_i - r_j|
        // Since r_vec = r_j - r_i, the unit vector should be -r_vec/r
        // Like charges (q_i * q_j > 0) → force away from j (along -r_hat)
        // Opposite charges (q_i * q_j < 0) → force toward j (along +r_hat)
        let force_magnitude = params.coulomb_constant * q_i * q_j / r2;
        let r_hat = r_vec / r;
        
        // Apply negative sign for correct direction
        force = force - force_magnitude * r_hat;
    }
    
    // Write accumulated force
    forces[i * 3u] = force.x;
    forces[i * 3u + 1u] = force.y;
    forces[i * 3u + 2u] = force.z;
}