Instead of one lumped thermal mass, the die is discretized into a 24×24 grid of thermal cells. Each cell exchanges heat with its 4 neighbours (finite-difference diffusion) and loses heat to ambient through the cooling solution — the exact same physics as a single-node RC model, just spatially resolved:
c_i · dT_i/dt = g·Σ(T_j − T_i) + q_i(t) − k_cell·(T_i − T_ambient)
q_i(t) = P(t)/N_hotspot for cells inside the compute core, else 0
P(t) = P_idle + throughput(t) · E_token(quant)
Summed over every cell, the diffusion term cancels exactly (energy leaving one cell enters its neighbour) so the grid's average temperature obeys the identical lumped equation used by the 3D version — this is a genuine spatial refinement of the same model, not a different one. The DVFS controller reads that grid-average temperature and scales the clock exactly as before:
clock_scale(T_avg) = 1 T_avg ≤ T_warm
clock_scale(T_avg) = 1 − (T_avg−T_warm)/(T_max−T_warm)·(1−s_min) T_warm < T_avg < T_max
clock_scale(T_avg) = s_min T_avg ≥ T_max
throughput(t) = min(demand, max_tok_s · clock_scale(T_avg))
- Heat-map — live die temperature field; the compute core (centre) runs hottest, heat spreads outward and is carried away at the edges by the chosen cooling solution.
- Ripples — one ring per generated token, expanding outward from the compute core at a rate equal to real throughput, not requested demand.
- Strip chart — scrolling trace of average die temperature, clock scale and throughput so you can see the heat-up → throttle → equilibrium cycle unfold over time.
- Weight precision / cooling / demand — identical trade-offs as the lumped model: lower-bit quantization cuts joules per token (thermal headroom), better cooling raises k_cell, higher demand pushes more power through the same hotspot.
Honest simplifications. A single lumped (or 24×24 grid) thermal capacitance of 5.2 J/°C, linear cooling k·(T−Tamb), a piecewise-linear DVFS ramp between 45 and 62 °C and joules-per-token values are illustrative parameters for a phone-class NPU, not data for any real chip. Real SoCs have several thermal zones, skin-temperature limits, battery heat and memory-bound (not clock-bound) token rates. The steady state solves P(T) = k·(T−Tamb) with P = Pidle + throughput(T)·Etoken; the checks compare that fixed point with time integration, the exact RC step response and (2D) the full grid.