qualia_extensions/webgpu_extension/
heat.rs1use 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
16pub 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 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}