Blame src/main.ts at 481eeb96b9021bb6a0067c24baed09a483385636 - concept-collection/turing-surface-cache

concept-collection / turing-surface-cache

4f822e1 turing-surface-cache: reaction-diffusion solutions at a chosen end time, shared through a cloud cacheJeremy Magland 9 days ago1/**

2 * turing-surface-cache: reaction-diffusion solutions at a chosen end time,

3 * from a shared cloud cache when someone has computed them before, and from

4 * the local GPU when not.

5 *

6 * Every control is a choice from a short list (src/cache/options.ts), so the

7 * page's whole state is one small spec object. Get solution hashes that spec

8 * into a cache object name (src/cache/spec.ts) and fetches it; a 404 means

9 * nobody has computed it, so the solver runs here — live, watching the

10 * pattern form — and stops at exactly the requested time. A run to T passes

11 * exactly through every smaller listed end time, so those states are captured

12 * along the way; with an upload API key entered, all of them are contributed

13 * back to the cache.

14 *

15 * The solver is turing-surface's, unchanged: the model and geometry are

16 * MATLAB compiled (model) or interpreted (geometry) by numbl, the transforms

17 * are WGSL compute shaders. lmax, niter and the seed wavelength are fixed in

18 * this app (options.ts) — fewer knobs, same machinery.

19 */

20import { requestShtDevice, describeAdapter } from './sht/sht.ts';

21import { ModelSession } from './mgpu/session.ts';

481eeb9 Add Brusselator and Allen-Cahn modelsJeremy Magland 9 days ago22import { mModels, mModelByKey, type MModel, type Params } from './mgpu/registry.ts';

4f822e1 turing-surface-cache: reaction-diffusion solutions at a chosen end time, shared through a cloud cacheJeremy Magland 9 days ago23import { formatFailure } from './mgpu/errors.ts';

24import {

25 mGeometryByKey,

26 DEFAULT_GEOMETRY_KEY,

27 mGeometries,

28 type MGeometry,

29} from './geom/registry.ts';

30import {

31 buildTopology,

32 fillPositions,

33 fillFieldValues,

34 fillColors,

35 type SphereMeshTopology,

36} from './render/sphereMesh.ts';

37import { SphereScene } from './render/SphereScene.ts';

38import { Colorbar, floorRange } from './render/colorbar.ts';

39import { colormaps } from './render/colormaps.ts';

40import {

41 MODEL_CHOICES,

481eeb9 Add Brusselator and Allen-Cahn modelsJeremy Magland 9 days ago42 DEFAULT_MODEL_KEY,

4f822e1 turing-surface-cache: reaction-diffusion solutions at a chosen end time, shared through a cloud cacheJeremy Magland 9 days ago43 GEOMETRY_CHOICES,

44 SEED_CHOICE,

45 T_END_CHOICE,

46 LMAX,

47 NITER,

48 LAM3,

49 defaultChoiceParams,

50 fmtChoice,

51 type DiscreteChoice,

52} from './cache/options.ts';

53import { stepsFor, type CacheSpec, APP_NAME, FORMAT_VERSION } from './cache/spec.ts';

54import { lookupFor, fetchCached, uploadCacheFile, type CacheLookup } from './cache/client.ts';

55import { encodeCacheFile, decodeCacheFile, type DecodedCacheFile } from './cache/h5file.ts';

57const $ = <T extends HTMLElement>(id: string): T =>

58 document.getElementById(id) as T;

481eeb9 Add Brusselator and Allen-Cahn modelsJeremy Magland 9 days ago60const elModel = $<HTMLSelectElement>('model');

4f822e1 turing-surface-cache: reaction-diffusion solutions at a chosen end time, shared through a cloud cacheJeremy Magland 9 days ago61const elParams = $('params');

62const elGeometry = $<HTMLSelectElement>('geometry');

63const elGeomParams = $('geomparams');

64const elSeed = $<HTMLSelectElement>('seed');

65const elTend = $<HTMLSelectElement>('tend');

66const elSolve = $<HTMLButtonElement>('solve');

67const elStop = $<HTMLButtonElement>('stop');

68const elReset = $<HTMLButtonElement>('reset');

69const elCacheNote = $('cachenote');

70const elStatus = $('status');

71const elPanels = $('panels');

72const elResetView = $<HTMLButtonElement>('resetview');

73const elDownload = $<HTMLAnchorElement>('download');

74const elStats = $('stats');

75const elApiKey = $<HTMLInputElement>('apikey');

76const elUploadNote = $('uploadnote');

77const elErr = $('err');

79/**

80 * Test/debug hook: `?tend=5,10` replaces the end-time list with the given

81 * values (still cached under their own honest specs — a test end time hashes

82 * to its own object). The headless checks use this to keep their computed

83 * runs short; it is not part of the normal UI.

84 */

85{

86 const param = new URLSearchParams(location.search).get('tend');

87 if (param) {

88 const values = param

89 .split(',')

90 .map(Number)

91 .filter((v) => Number.isFinite(v) && v > 0);

92 if (values.length) {

93 T_END_CHOICE.values = values;

94 T_END_CHOICE.value = values[0];

95 }

96 }

97}

99const API_KEY_STORAGE = `${APP_NAME}:apiKey`;

100const COLORMAP = colormaps.viridis;

101/** Render on a 2x finer grid than the solver's; exact interpolation. */

102const OVERSAMPLE = 2;

103/** Cap on GPU dispatches per submission (watchdog safety; see turing-surface). */

104const DISPATCH_BUDGET = 1000;

105/** Steps between syncs during a computation: many small submissions queued

106 * back to back, one wait. The readbacks and renders that pace the live view

107 * happen per chunk, not per submission — that is what lets the run advance

108 * at close to the solver's own rate. */

109const CHUNK_STEPS = 32;

110/** How often the live view renders during a computation. */

111const RENDER_EVERY_MS = 250;

112

113// ---------------------------------------------------------------- state

481eeb9 Add Brusselator and Allen-Cahn modelsJeremy Magland 9 days ago114let model: MModel = mModelByKey(DEFAULT_MODEL_KEY)!;

4f822e1 turing-surface-cache: reaction-diffusion solutions at a chosen end time, shared through a cloud cacheJeremy Magland 9 days ago115let device: GPUDevice | null = null;

116let session: ModelSession | null = null;

117let adapterName = '';

118/** Steps per GPU submission, sized in boot() so one submission stays under

119 * the dispatch budget however expensive niter has made a step. */

120let stepsPerSubmit = 4;

121

122/** The discrete selections, always exactly values from options.ts. */

481eeb9 Add Brusselator and Allen-Cahn modelsJeremy Magland 9 days ago123let params: Params = defaultChoiceParams(MODEL_CHOICES[DEFAULT_MODEL_KEY]);

4f822e1 turing-surface-cache: reaction-diffusion solutions at a chosen end time, shared through a cloud cacheJeremy Magland 9 days ago124let geometry: MGeometry = mGeometryByKey(DEFAULT_GEOMETRY_KEY)!;

125let geomParams: Params = Object.fromEntries(

126 GEOMETRY_CHOICES[DEFAULT_GEOMETRY_KEY].map((c) => [c.key, c.value]),

127);

128let seed = SEED_CHOICE.value;

129let tEnd = T_END_CHOICE.value;

130

131// The URL fragment carries the whole selection, so a reload comes back to it

132// and a shared link opens on the same spec (and, through refresh(), the same

133// cached solution). Read once at startup; rewritten on every change.

134readUrlState();

135

481eeb9 Add Brusselator and Allen-Cahn modelsJeremy Magland 9 days ago136/** What the session currently has applied. Params are cheap (uniforms); a

137 * geometry change re-evaluates the surface and rebuilds the mesh; a model

138 * change recompiles the whole session, since the model is compiled into the

139 * GPU step. */

140let sessionModelKey = '';

4f822e1 turing-surface-cache: reaction-diffusion solutions at a chosen end time, shared through a cloud cacheJeremy Magland 9 days ago141let sessionGeomKey = '';

142let sessionGeomParams: Params = {};

143

144let topo: SphereMeshTopology | null = null;

145let scenes: SphereScene[] = [];

146let colorbars: Colorbar[] = [];

147/** The colorbar containers, hidden while the windows are empty. */

148let colorbarEls: HTMLElement[] = [];

149let valueBufs: Float32Array[] = [];

150let colorBufs: Float32Array[] = [];

151let ranges: { lo: number; hi: number }[] = [];

152let resizeObs: ResizeObserver | null = null;

153let coords: Float32Array | null = null;

154let posBuf: Float32Array | null = null;

155

156let generation = 0;

157let busy = false;

158/** True while computeLocally is stepping/reading back. Every read shares one

159 * staging buffer (GpuModel#readback), so a new solve must drain the old

160 * loop before issuing reads of its own. */

161let pumping = false;

162let stopRequested = false;

163/** Simulation time of the state on display (loadState resets session.t). */

164let shownT: number | null = null;

165let downloadUrl: string | null = null;

166

167const nextFrame = () => new Promise<number>(requestAnimationFrame);

168

169// ---------------------------------------------------------------- spec

170function currentSpec(): CacheSpec {

171 return {

172 app: APP_NAME,

173 formatVersion: FORMAT_VERSION,

174 model: model.key,

175 params: { ...params },

176 geometry: geometry.key,

177 geometryParams: { ...geomParams },

178 lmax: LMAX,

179 niter: NITER,

180 lam3: LAM3,

181 seed,

182 tEnd,

183 };

184}

185

186// ---------------------------------------------------------------- URL state

187/**

188 * The selection lives in the URL fragment, every value written explicitly

189 * (`#a=0.1&b=0.9&…&geometry=ellipsoid&ax=1.5&…&seed=1&tend=100`), so a link

190 * keeps meaning the same spec even if a default changes later. The fragment

191 * is chosen over the query string to leave `?tend` to the test hook. Values

192 * are only accepted if they are exactly entries of the discrete lists;

193 * anything else keeps the default.

194 */

195function readUrlState(): void {

196 const hash = location.hash.replace(/^#/, '');

197 if (!hash) return;

198 const p = new URLSearchParams(hash);

199 // `name` is the key as it appears in the URL; it defaults to the choice's

200 // own key but is passed explicitly where the two differ (tEnd vs tend).

201 const pick = (choice: DiscreteChoice, current: number, name = choice.key): number => {

202 const raw = p.get(name);

203 if (raw === null) return current;

204 const v = Number(raw);

205 return choice.values.includes(v) ? v : current;

206 };

481eeb9 Add Brusselator and Allen-Cahn modelsJeremy Magland 9 days ago207 const m = p.get('model');

208 if (m && mModelByKey(m) && MODEL_CHOICES[m]) {

209 model = mModelByKey(m)!;

210 params = defaultChoiceParams(MODEL_CHOICES[m]);

211 }

4f822e1 turing-surface-cache: reaction-diffusion solutions at a chosen end time, shared through a cloud cacheJeremy Magland 9 days ago212 const g = p.get('geometry');

213 if (g && mGeometryByKey(g) && GEOMETRY_CHOICES[g]) {

214 geometry = mGeometryByKey(g)!;

215 geomParams = defaultChoiceParams(GEOMETRY_CHOICES[g]);

216 }

481eeb9 Add Brusselator and Allen-Cahn modelsJeremy Magland 9 days ago217 for (const c of MODEL_CHOICES[model.key]) params[c.key] = pick(c, params[c.key]);