Skip to main content

qualia_extensions/webgpu_extension/
heat.rs

1//! 2D heat diffusion `∂u/∂t = α∇²u` by explicit finite differences (periodic).
2//!
3//! Validation: `u(x,y,0) = sin(x)·sin(y)` is an eigenfunction of the Laplacian
4//! (`∇²u = −2u`), so it decays as `u(t) = u(0)·exp(-2αt)`. The test reproduces
5//! that decay rate.
6
7use super::{dim, uniform, SolverReport, WebGpuJobParams};
8use std::collections::HashMap;
9use std::f64::consts::PI;
10
11#[inline]
12fn wrap(i: i64, n: i64) -> usize {
13    (((i % n) + n) % n) as usize
14}
15
16/// Solves.
17pub fn solve(params: &WebGpuJobParams) -> SolverReport {
18    let nx = dim(params.grid_size.0, 32);
19    let ny = dim(params.grid_size.1, 32);
20    let n = nx * ny;
21    let (nxi, nyi) = (nx as i64, ny as i64);
22
23    let hx = 2.0 * PI / nx as f64;
24    let hy = 2.0 * PI / ny as f64;
25    let alpha = uniform(params, "diffusivity", 0.5).max(0.0) as f64;
26
27    let mut dt = if params.dispatch_params.time_step > 0.0 {
28        params.dispatch_params.time_step
29    } else {
30        0.01
31    };
32    if alpha > 0.0 {
33        let dt_max = 0.25 * hx.min(hy).powi(2) / alpha;
34        if dt > dt_max {
35            dt = dt_max;
36        }
37    }
38    let steps = if params.dispatch_params.iterations > 0 {
39        params.dispatch_params.iterations
40    } else {
41        50
42    };
43
44    let idx = |i: usize, j: usize| j * nx + i;
45    let mut u = vec![0.0f64; n];
46    if let Some(field) = params.input_data.get("temperature_field") {
47        for k in 0..n.min(field.len()) {
48            u[k] = field[k] as f64;
49        }
50    } else {
51        for j in 0..ny {
52            for i in 0..nx {
53                u[idx(i, j)] = (i as f64 * hx).sin() * (j as f64 * hy).sin();
54            }
55        }
56    }
57
58    let inv_hx2 = 1.0 / (hx * hx);
59    let inv_hy2 = 1.0 / (hy * hy);
60    let mut next = vec![0.0f64; n];
61
62    for _ in 0..steps {
63        for j in 0..ny {
64            for i in 0..nx {
65                let c = idx(i, j);
66                let e = idx(wrap(i as i64 + 1, nxi), j);
67                let w = idx(wrap(i as i64 - 1, nxi), j);
68                let nn = idx(i, wrap(j as i64 + 1, nyi));
69                let s = idx(i, wrap(j as i64 - 1, nyi));
70                let lap =
71                    (u[e] + u[w] - 2.0 * u[c]) * inv_hx2 + (u[nn] + u[s] - 2.0 * u[c]) * inv_hy2;
72                next[c] = u[c] + dt * alpha * lap;
73            }
74        }
75        std::mem::swap(&mut u, &mut next);
76    }
77
78    let temperature_out: Vec<f32> = u.iter().map(|&x| x as f32).collect();
79    let mut output = HashMap::new();
80    output.insert("temperature_out".to_string(), temperature_out);
81
82    let flops = steps as u64 * n as u64 * 10;
83    SolverReport {
84        output,
85        iterations_used: steps,
86        final_residual: 0.0,
87        converged: true,
88        flops,
89    }
90}
91
92#[cfg(test)]
93mod tests {
94    use super::*;
95    use crate::webgpu_extension::DispatchParams;
96
97    fn rms(field: &[f32]) -> f64 {
98        let s: f64 = field.iter().map(|&x| (x as f64) * (x as f64)).sum();
99        (s / field.len() as f64).sqrt()
100    }
101
102    #[test]
103    fn eigenmode_decays_at_analytic_rate() {
104        // sin(x)sin(y) decays as exp(-2αt). α=0.5, Δt=0.01, 50 steps ⇒ t=0.5,
105        // ratio exp(-0.5)≈0.6065. Initial RMS of sin·sin = sqrt(1/4) = 0.5.
106        let alpha = 0.5;
107        let dt = 0.01;
108        let steps = 50;
109        let mut uniforms = HashMap::new();
110        uniforms.insert("diffusivity".to_string(), alpha);
111        let p = WebGpuJobParams {
112            shader_name: "heat_diffusion_2d".to_string(),
113            grid_size: (32, 32, 1),
114            input_data: HashMap::new(),
115            uniform_data: uniforms,
116            dispatch_params: DispatchParams {
117                iterations: steps,
118                time_step: dt,
119                convergence_threshold: 1e-3,
120                max_execution_time_ms: 30_000,
121            },
122        };
123        let r = solve(&p);
124        let final_rms = rms(&r.output["temperature_out"]);
125        let expected = 0.5 * (-2.0 * alpha as f64 * dt * steps as f64).exp();
126        let rel = (final_rms - expected).abs() / expected;
127        assert!(
128            rel < 0.05,
129            "heat decay off: got {final_rms:.5}, expected {expected:.5} (rel {rel:.3})"
130        );
131    }
132}