Campaign sizing calculator
One cell's grid params drive three independent budgets: solve — the field cube must fit
GPU VRAM; reduce — harmonic_products must fit host RAM (a second,
larger memory bill, at a different stage); and pipeline balance — with REDUCE_OVERLAP
a cell is stable only while its wall-time ≥ reduce+sha+upload. Cube bytes are N-independent,
so raising N shifts time balance, never memory.
Load a run from the dashboard …
Fetching /index.json…
Knobs
General sizing · any campaign — drives the cube / RAM / pipeline
Inverse-Thomson window & bunching · script-specific — parametrize per campaign later
Setup schematic — watch the pulse arrive
Left: the collision — the dashed ghost is the pulse when the ±TSPAN·τ solve ends (ghost on the disk = truncated physics). Right: the arrival map at the screen — the burst is a parabolic band in (arrival clock, radius); the shaded column is what the window records. Mistakes are shape mismatches: band outside column = missed burst, coarse dots = aliasing, ring past the dashed screen edge = screen too small. Tick legend: gray = lead/tail margins, amber = corner spread (screen corners sit ρ²/2Z farther than the centre, smearing arrival across the amber span), purple = the burst itself. With prebunching the band switches to the focused geometry: the ρ²/2Z focus offset cancels the emitter-side smear at every pixel (razor-thin at the centre), leaving the screen parabola ± a signed Rmax·ρ/Z cross-term — whose earliest arrivals land up to Rmax²/2Z ≈ 0.15λ before unbunched first contact. The script budgets the unbunched envelope (gray dashed ghost): conservative on the tail, but the lead margin must absorb those early arrivals — the bunch-lead chip checks exactly that. The resolution chip compares the pixel pitch (2·hw·w₀/NX) against the one transverse scale that rules the screen — δr = λₙZ/2Rmax, which is both the speckle grain and the diffraction-limited spot (they are the same Fourier transform of the same aperture); the face view draws both to scale, and an even NX leaves no on-axis pixel for a winding-0 spot — the 9×-deficit bug.
3D setup preview — bunching · 1/γ cone · ring-vs-screen (stylized)
Screen square scales with the screen half-width knob; the predicted spot/ring (purple — red when clipped) is dashed until the burst lands, and its fit line is the actual screen-size check. The amber dashed circle shows only the 1/γ emission direction — the real footprint at Z is Z/γ, tens of times wider than any screen, so screens deliberately sample its core (the readout gives the true percentage). Drag to orbit. Slice count tracks the bunch-count knob (capped for legibility). Bunching = placing every electron on the surface of simultaneous arrival, Δz = (1+β)/2 · [ρ²/2Z + ℓ·φ/2π · λ/n_b] — a paraboloid (the lens term) pitched helically by ℓ (primer §5). Distances compressed — geometry is qualitative.
Window & coverage
| N₀ = on-axis fundamental (drive-harmonic units) | |
| δt = T/SPP (observer step) | |
| window length | |
| Nsamples (drives every budget below) | |
| trajectory knots per e⁻ (SAVEAT=16 over ±TSPAN·τ) |
Budgets, where they're incurred
stage 1 · solve — GPU cube
stage 2 · reduce — host RAM
drain — reduce + sha + upload
| reduce + sha256 + R2 upload (all ∝ cube bytes) | |
| measured cell wall-time (producer) |
cube = comp · Ns · NX² · 8 B (comp = 6 total / 12 split / 4 potential); VRAM guard = 90% of the device, matching gpu_memory_info. reduce peak = rf · cube ; overlap adds one concurrent next-cube read (REDUCE_OVERLAP).
Cloud cost — if run in the cloud
| GPU-hours (cells × per-cell wall-time) | |
| compute | |
| overhead (warm ~8 min/VM ) | |
| storage (network volume ) | |
| total |
cost = GPU-hours × rate + overhead + storage. Overhead = one ~8-min VM warm + (with overlapped reduce off) the inline reduce+drain per cell. Storage = RunPod network-attached volume (needed once cubes pass ~100 GB), prorated over campaign GPU-hours at 730 h/mo; auto-size = one cube, ×2 with overlapped reduce. List prices (token-gated page); issaf/local are $0 and skip the volume. Cost math is new — same compute×rate+overhead spirit as estimate_run.sh.
Phased-array prebunching — coherence, not memory
| mode | |
| observed azimuthal winding (2 + ℓ) | |
| per-e⁻ offset Δz = (1+β)/2 · [ρ²/2Z + ℓ·φ/2π · λ/n_b] |
Memory-neutral: bunching is a per-electron start offset — the cube is N-independent, so none of the budgets above move. EDM_BUNCH_CHIRP exists but measured harmful; leave unset.
Model mirrors orchestration/estimate_run.sh (memory + balance) and scripts/inverse_thomson_scattering.jl (window → Ns). Anchors are MI300X-node / R2; recalibrate per box. This page is a visual companion — the script is the source of truth.