Download Why-plotters/fix/gravity-why-plotter2.html from perrabyte/unifying_electro_magnetism: direct link, hf CLI and curl.
- Browser
- Download file 51.7 kB
-
https://huggingface.co/datasets/perrabyte/unifying_electro_magnetism/resolve/main/Why-plotters/fix/gravity-why-plotter2.html
- Command line
-
hf download hf://datasets/perrabyte/unifying_electro_magnetism/Why-plotters/fix/gravity-why-plotter2.html
-
curl -L -o gravity-why-plotter2.html https://huggingface.co/datasets/perrabyte/unifying_electro_magnetism/resolve/main/Why-plotters/fix/gravity-why-plotter2.html
51.7 kB
| <html lang="en"> | |
| <head> | |
| <meta charset="utf-8"> | |
| <meta name="viewport" content="width=device-width, initial-scale=1"> | |
| <title>Why does this orbit do that? — Gravity sandbox (+ colored noise)</title> | |
| <style> | |
| :root { | |
| --bg: #07070f; --panel: #111120; --border: #27273a; --text: #e8e8f2; | |
| --dim: #8a8aa4; --accent: #6cf; --good: #4caf50; --bad: #ff5566; | |
| --warn: #ffb454; --star: #ffd257; --planet: #5ea8ff; --hole: #b47aff; | |
| } | |
| * { box-sizing: border-box; } | |
| body { | |
| margin: 0; background: var(--bg); color: var(--text); | |
| font-family: ui-sans-serif, system-ui, -apple-system, sans-serif; | |
| font-size: 14px; line-height: 1.55; | |
| } | |
| header { padding: 14px 22px; border-bottom: 1px solid var(--border); } | |
| header h1 { margin: 0 0 3px; font-size: 17px; font-weight: 600; } | |
| header p { margin: 0; color: var(--dim); font-size: 12.5px; max-width: 980px; } | |
| main { | |
| display: grid; grid-template-columns: minmax(0, 1.15fr) minmax(0, 1fr); | |
| gap: 14px; padding: 14px; max-width: 1480px; margin: 0 auto; | |
| } | |
| @media (max-width: 1000px) { main { grid-template-columns: 1fr; } } | |
| .panel { background: var(--panel); border: 1px solid var(--border); border-radius: 8px; overflow: hidden; } | |
| .panel-header { | |
| padding: 8px 12px; border-bottom: 1px solid var(--border); | |
| display: flex; align-items: center; justify-content: space-between; | |
| gap: 8px; flex-wrap: wrap; | |
| } | |
| .panel-header h2 { | |
| margin: 0; font-size: 11px; font-weight: 600; | |
| text-transform: uppercase; letter-spacing: 0.07em; color: var(--dim); | |
| } | |
| .toolrow { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; } | |
| button, select { | |
| background: #0d0d19; color: var(--text); border: 1px solid var(--border); | |
| border-radius: 4px; padding: 4px 9px; font-size: 11.5px; cursor: pointer; | |
| font-family: inherit; | |
| } | |
| button:hover { border-color: var(--accent); color: var(--accent); } | |
| button.on { border-color: var(--accent); color: var(--accent); background: rgba(102,204,255,0.10); } | |
| .canvas-wrap { position: relative; background: #04040a; line-height: 0; } | |
| canvas { display: block; width: 100%; height: auto; touch-action: none; } | |
| #stage { cursor: crosshair; } | |
| .badge { | |
| position: absolute; font-family: ui-monospace, monospace; font-size: 10.5px; | |
| color: var(--dim); background: rgba(0,0,0,0.55); padding: 3px 7px; | |
| border-radius: 4px; pointer-events: none; | |
| } | |
| #coordBadge { bottom: 8px; left: 8px; } | |
| #modeBadge { top: 8px; left: 8px; } | |
| #modeBadge.armed { color: var(--accent); border: 1px solid rgba(102,204,255,0.4); } | |
| .strip { | |
| display: grid; grid-template-columns: repeat(4, minmax(0,1fr)); | |
| gap: 1px; background: var(--border); border-top: 1px solid var(--border); | |
| } | |
| .stat { background: var(--panel); padding: 7px 10px; } | |
| .stat .k { font-size: 9.5px; color: var(--dim); text-transform: uppercase; letter-spacing: 0.05em; } | |
| .stat .v { font-family: ui-monospace, monospace; font-size: 13px; color: var(--text); margin-top: 1px; } | |
| @media (max-width: 620px) { .strip { grid-template-columns: repeat(2, minmax(0,1fr)); } } | |
| #explanation { padding: 12px 15px; font-size: 12.5px; max-height: 560px; overflow-y: auto; } | |
| #explanation h3 { margin: 0 0 8px; font-size: 12.5px; color: var(--accent); font-weight: 600; } | |
| #explanation h4 { margin: 14px 0 4px; font-size: 11px; color: var(--dim); text-transform: uppercase; letter-spacing: 0.06em; } | |
| #explanation p { margin: 7px 0; } | |
| .verdict { padding: 7px 11px; border-radius: 4px; margin: 9px 0; font-weight: 600; font-size: 12.5px; } | |
| .verdict.bad { background: rgba(255,85,102,0.12); color: #ff8a99; border-left: 3px solid #ff5566; } | |
| .verdict.good { background: rgba(76,175,80,0.12); color: #8fdc92; border-left: 3px solid #4caf50; } | |
| .verdict.warn { background: rgba(255,180,84,0.12); color: #ffcf8a; border-left: 3px solid #ffb454; } | |
| .verdict.info { background: rgba(180,122,255,0.12); color: #d3b3ff; border-left: 3px solid #b47aff; } | |
| #explanation table { width: 100%; border-collapse: collapse; font-family: ui-monospace, monospace; font-size: 11px; margin: 7px 0; } | |
| #explanation th, #explanation td { text-align: left; padding: 3px 6px; border-bottom: 1px solid var(--border); } | |
| #explanation th { color: var(--dim); font-weight: 500; } | |
| .eq { font-family: ui-monospace, monospace; font-size: 12px; background: #0d0d19; border: 1px solid var(--border); border-radius: 4px; padding: 7px 10px; margin: 7px 0; line-height: 1.85; overflow-x: auto; } | |
| .note { color: var(--dim); font-size: 11.5px; border-top: 1px solid var(--border); padding-top: 9px; margin-top: 13px; line-height: 1.6; } | |
| .legend { display: flex; gap: 11px; flex-wrap: wrap; font-size: 10.5px; color: var(--dim); align-items: center; } | |
| .legend span { display: inline-flex; align-items: center; gap: 4px; } | |
| .swatch { width: 9px; height: 9px; border-radius: 50%; display: inline-block; } | |
| .slider-row { display: flex; align-items: center; gap: 7px; font-size: 10.5px; color: var(--dim); } | |
| input[type="range"] { width: 92px; accent-color: var(--accent); cursor: pointer; } | |
| .massval { font-family: ui-monospace, monospace; color: var(--text); min-width: 34px; display: inline-block; } | |
| /* ---- colored-noise panel ---- */ | |
| .noise-box { | |
| border-top: 1px solid var(--border); padding: 9px 12px; display: flex; | |
| gap: 16px; flex-wrap: wrap; align-items: center; | |
| background: rgba(180,122,255,0.045); | |
| } | |
| .noise-box.disabled { opacity: 0.75; } | |
| .noise-box input[type="range"] { accent-color: #b47aff; } | |
| .noise-title { | |
| font-size: 10px; text-transform: uppercase; letter-spacing: 0.07em; | |
| color: #c9a8ff; font-weight: 600; display: flex; align-items: center; gap: 6px; | |
| } | |
| .noise-title input { accent-color: #b47aff; } | |
| .tau-meter { | |
| font-family: ui-monospace, monospace; font-size: 10.5px; | |
| padding: 2px 7px; border-radius: 4px; border: 1px solid var(--border); | |
| white-space: nowrap; | |
| } | |
| .tau-meter.stiff { color: #8fdc92; border-color: rgba(76,175,80,0.55); background: rgba(76,175,80,0.08); } | |
| .tau-meter.mid { color: #ffcf8a; border-color: rgba(255,180,84,0.55); background: rgba(255,180,84,0.08); } | |
| .tau-meter.soft { color: #ff8a99; border-color: rgba(255,85,102,0.55); background: rgba(255,85,102,0.08); } | |
| .gamma-note { font-size: 10px; color: var(--dim); font-family: ui-monospace, monospace; } | |
| </style> | |
| </head> | |
| <body> | |
| <header> | |
| <h1>Why does this orbit do that?</h1> | |
| <p>A gravitational sandbox. Place stars, planets and black holes, drop test particles, and read <i>why</i> the motion is what it is. Now with a <b>colored-noise</b> bath: an Ornstein–Uhlenbeck process with its own relaxation time τ, paired to damping by the fluctuation–dissipation relation.</p> | |
| </header> | |
| <main> | |
| <div class="panel"> | |
| <div class="panel-header"> | |
| <h2>Space</h2> | |
| <div class="toolrow"> | |
| <button id="btnStar" class="tool">+ Star</button> | |
| <button id="btnPlanet" class="tool">+ Planet</button> | |
| <button id="btnHole" class="tool">+ Black hole</button> | |
| <button id="btnClear">Clear</button> | |
| </div> | |
| </div> | |
| <div class="canvas-wrap"> | |
| <canvas id="stage" width="720" height="620"></canvas> | |
| <div class="badge" id="modeBadge">click to drop a test particle</div> | |
| <div class="badge" id="coordBadge">—</div> | |
| </div> | |
| <div class="toolrow" style="padding:8px 12px; border-top:1px solid var(--border);"> | |
| <button id="btnParticle" class="tool on">+ Test particle</button> | |
| <button id="btnEnsemble">+ noise ensemble</button> | |
| <button id="btnPause">Pause</button> | |
| <button id="btnReset">Reset sim</button> | |
| <button id="btnPreset">Sun + planets</button> | |
| <button id="btnBinary">binary + circumbinary</button> | |
| <button id="btnBH">black hole + star</button> | |
| <span class="slider-row">mass <input type="range" id="massSlider" min="1" max="60" value="10"><span class="massval" id="massVal">10</span></span> | |
| <span class="slider-row">GR <input type="range" id="grSlider" min="0" max="1" step="0.05" value="0"><span class="massval" id="grVal">0.00</span></span> | |
| </div> | |
| <!-- ======== colored noise controls ======== --> | |
| <div class="noise-box" id="noiseBox"> | |
| <label class="noise-title"><input type="checkbox" id="noiseEnable" checked> colored-noise bath (OU)</label> | |
| <span class="slider-row">τ <input type="range" id="tauSlider" min="-3.3" max="1.3" step="0.05" value="-0.7"><span class="massval" id="tauVal">0.20</span></span> | |
| <span class="slider-row">D <input type="range" id="dSlider" min="-6" max="0" step="0.05" value="-3.30"><span class="massval" id="dVal">0.0005</span></span> | |
| <span class="tau-meter" id="tauMeter">dt/τ —</span> | |
| <span class="gamma-note" id="gammaNote">γ = 1/τ = — , pairing active</span> | |
| </div> | |
| <div class="legend" style="padding:0 12px 9px;"> | |
| <span><i class="swatch" style="background:var(--star)"></i>star</span> | |
| <span><i class="swatch" style="background:var(--planet)"></i>planet</span> | |
| <span><i class="swatch" style="background:var(--hole)"></i>black hole</span> | |
| <span><i class="swatch" style="background:#ff5566"></i>deterministic particle</span> | |
| <span><i class="swatch" style="background:#b47aff"></i>noisy particle (OU)</span> | |
| <span>drag a body to move · drag empty space to pan · scroll to zoom</span> | |
| </div> | |
| <div class="strip"> | |
| <div class="stat"><div class="k">Flux through ring</div><div class="v" id="s-flux">—</div></div> | |
| <div class="stat"><div class="k">Enclosed mass</div><div class="v" id="s-menc">—</div></div> | |
| <div class="stat"><div class="k">ω_r / ω_φ</div><div class="v" id="s-ratio">—</div></div> | |
| <div class="stat"><div class="k">escape time</div><div class="v" id="s-escape">safe</div></div> | |
| </div> | |
| </div> | |
| <div class="panel"> | |
| <div class="panel-header"> | |
| <h2>Why — local analysis</h2> | |
| <div class="toolrow"> | |
| <button id="btnProbe" class="on">ring probe</button> | |
| <button id="btnField" class="on">field</button> | |
| <button id="btnStream" class="on">streamlines</button> | |
| <button id="btnTrace" class="on">trace orbits</button> | |
| <button id="btnNoiseHist" class="on">noise η(t)</button> | |
| </div> | |
| </div> | |
| <div class="canvas-wrap"> | |
| <canvas id="noisePlot" width="720" height="130"></canvas> | |
| </div> | |
| <div id="explanation"> | |
| <p style="color:var(--dim)">Place a body, move the cursor to probe Gauss's law, drop a test particle to trace an orbit, or enable the colored-noise bath.</p> | |
| </div> | |
| </div> | |
| </main> | |
| <script> | |
| ; | |
| // ================================================================ constants | |
| const W = 720, H = 620; | |
| const G_CONST = 1.0; | |
| const SOFT2 = 0.05; | |
| const DT = 0.0012; | |
| const SUBS = 4; | |
| const ESCAPE_RADIUS = 18; | |
| const stage = document.getElementById("stage"); | |
| const ctx = stage.getContext("2d"); | |
| const noisePlot = document.getElementById("noisePlot"); | |
| const nctx = noisePlot.getContext("2d"); | |
| const explanationEl = document.getElementById("explanation"); | |
| const coordBadge = document.getElementById("coordBadge"); | |
| const modeBadge = document.getElementById("modeBadge"); | |
| // ================================================================ state | |
| let bodies = []; | |
| let particles = []; | |
| let view = { xmin: -5, xmax: 5, ymin: -4.3, ymax: 4.3 }; | |
| const HOME_VIEW = { ...view }; | |
| let placing = "star"; | |
| let placingParticle = true; | |
| let paused = false; | |
| let newMass = 10; | |
| let grMode = 0; | |
| let cursor = null; | |
| let dragBody = null; | |
| let dragging = false, dragStart = null; | |
| let showProbe = true, showField = true, showStream = true, showTrace = true, showNoiseHist = true; | |
| // ---- colored-noise (Ornstein–Uhlenbeck) bath parameters | |
| // dη = -(1/τ) η dt + sqrt(2D/τ) dW (stationary variance = D) | |
| // dv += η dt (the random force) AND dv += -(1/τ) v dt (the paired damping) | |
| let noiseEnabled = true; | |
| let tau = 0.2; // relaxation time | |
| let D = 0.0005; // noise strength (stationary variance of η) | |
| const STAR_PRESET_M = 20; | |
| const HOLE_PRESET_M = 55; | |
| const PLANET_PRESET_M = 1.2; | |
| // gaussian sampler (Box–Muller) | |
| let _gaussSpare = null; | |
| function gauss() { | |
| if (_gaussSpare !== null) { const s = _gaussSpare; _gaussSpare = null; return s; } | |
| let u = 0, v = 0, s = 0; | |
| do { | |
| u = Math.random() * 2 - 1; | |
| v = Math.random() * 2 - 1; | |
| s = u * u + v * v; | |
| } while (s >= 1 || s === 0); | |
| const mul = Math.sqrt(-2 * Math.log(s) / s); | |
| _gaussSpare = v * mul; | |
| return u * mul; | |
| } | |
| // ================================================================ presets | |
| function loadSunSystem() { | |
| bodies = []; particles = []; | |
| bodies.push({ x: 0, y: 0, vx: 0, vy: 0, m: STAR_PRESET_M, type: "star" }); | |
| const Rs = [1.1, 1.8, 2.6, 3.5]; | |
| const ts = [0, 0.9, -1.8, 2.4]; | |
| Rs.forEach((r, i) => { | |
| const v = Math.sqrt(G_CONST * STAR_PRESET_M / r); | |
| bodies.push({ | |
| x: r * Math.cos(ts[i]), y: r * Math.sin(ts[i]), | |
| vx: -v * Math.sin(ts[i]), vy: v * Math.cos(ts[i]), | |
| m: PLANET_PRESET_M * (1 + 0.3 * i), type: "planet", | |
| }); | |
| }); | |
| view = { xmin: -4.1, xmax: 4.1, ymin: -3.5, ymax: 3.5 }; | |
| dropTestParticle(2.15, 0.0, null, noiseEnabled); | |
| } | |
| function loadBinary() { | |
| bodies = []; particles = []; | |
| const m = STAR_PRESET_M * 0.75, d = 1.2; | |
| const v = Math.sqrt(G_CONST * m / (2 * d)); | |
| bodies.push({ x: -d / 2, y: 0, vx: 0, vy: -v, m, type: "star" }); | |
| bodies.push({ x: d / 2, y: 0, vx: 0, vy: v, m, type: "star" }); | |
| view = { xmin: -5.5, xmax: 5.5, ymin: -4.7, ymax: 4.7 }; | |
| dropTestParticle(4.0, 0, -Math.sqrt(G_CONST * 2 * m / 4.0), noiseEnabled); | |
| } | |
| function loadBlackHole() { | |
| bodies = []; particles = []; | |
| bodies.push({ x: 0, y: 0, vx: 0, vy: 0, m: HOLE_PRESET_M, type: "hole" }); | |
| view = { xmin: -6, xmax: 6, ymin: -5.2, ymax: 5.2 }; | |
| dropTestParticle(4.2, 0, -Math.sqrt(G_CONST * HOLE_PRESET_M / 4.2) * 0.72, noiseEnabled); | |
| } | |
| // ================================================================ physics | |
| const _acc = { ax: 0, ay: 0 }; | |
| function accelAt(x, y, out) { | |
| let ax = 0, ay = 0; | |
| for (const b of bodies) { | |
| const dx = b.x - x, dy = b.y - y; | |
| const r2 = dx * dx + dy * dy + SOFT2; | |
| const r = Math.sqrt(r2); | |
| let a = G_CONST * b.m / (r2 * r); | |
| if (grMode > 0 && b.type === "hole") { | |
| const rs = 0.35 * (b.m / HOLE_PRESET_M); | |
| a *= (1 + grMode * 3 * rs / r); | |
| } | |
| ax += a * dx; | |
| ay += a * dy; | |
| } | |
| out.ax = ax; out.ay = ay; | |
| return out; | |
| } | |
| function accel(x, y) { return accelAt(x, y, _acc); } | |
| function speedAt(x, y) { const a = accel(x, y); return Math.hypot(a.ax, a.ay); } | |
| function fieldAt(x, y) { const a = accel(x, y); return { f: a.ax, g: a.ay }; } | |
| function fluxThroughRing(cx, cy, R, samples = 480) { | |
| let sum = 0; | |
| const dL = 2 * Math.PI * R / samples; | |
| for (let i = 0; i < samples; i++) { | |
| const t = 2 * Math.PI * i / samples; | |
| const nx = Math.cos(t), ny = Math.sin(t); | |
| const F = fieldAt(cx + R * nx, cy + R * ny); | |
| sum += (F.f * nx + F.g * ny) * dL; | |
| } | |
| return sum; | |
| } | |
| function enclosedMass(cx, cy, R) { | |
| let M = 0; | |
| for (const b of bodies) if (Math.hypot(b.x - cx, b.y - cy) <= R) M += b.m; | |
| return M; | |
| } | |
| function totalMassInside(cx, cy, R) { return enclosedMass(cx, cy, R); } | |
| // ================================================================ integrator | |
| function bodyAccel(i, out) { | |
| let ax = 0, ay = 0; | |
| const bi = bodies[i]; | |
| for (let j = 0; j < bodies.length; j++) { | |
| if (j === i) continue; | |
| const bj = bodies[j]; | |
| const dx = bj.x - bi.x, dy = bj.y - bi.y; | |
| const r2 = dx * dx + dy * dy + SOFT2; | |
| const r = Math.sqrt(r2); | |
| let a = G_CONST * bj.m / (r2 * r); | |
| if (grMode > 0 && bj.type === "hole") { | |
| const rs = 0.35 * (bj.m / HOLE_PRESET_M); | |
| a *= (1 + grMode * 3 * rs / r); | |
| } | |
| ax += a * dx; ay += a * dy; | |
| } | |
| out.ax = ax; out.ay = ay; | |
| return out; | |
| } | |
| const _ba1 = { ax: 0, ay: 0 }, _ba2 = { ax: 0, ay: 0 }; | |
| function stepBodies() { | |
| const n = bodies.length; | |
| if (n === 0) return; | |
| for (let i = 0; i < n; i++) { | |
| bodyAccel(i, _ba1); | |
| bodies[i].vx += _ba1.ax * DT * 0.5; | |
| bodies[i].vy += _ba1.ay * DT * 0.5; | |
| bodies[i].x += bodies[i].vx * DT; | |
| bodies[i].y += bodies[i].vy * DT; | |
| } | |
| for (let i = n - 1; i >= 0; i--) { | |
| if (!bodies[i]) continue; | |
| bodyAccel(i, _ba2); | |
| bodies[i].vx += _ba2.ax * DT * 0.5; | |
| bodies[i].vy += _ba2.ay * DT * 0.5; | |
| if (!isFinite(bodies[i].x) || !isFinite(bodies[i].y) || | |
| !isFinite(bodies[i].vx) || !isFinite(bodies[i].vy)) { | |
| bodies.splice(i, 1); continue; | |
| } | |
| const sp = Math.hypot(bodies[i].vx, bodies[i].vy); | |
| if (sp > 80) { bodies[i].vx *= 80 / sp; bodies[i].vy *= 80 / sp; } | |
| } | |
| } | |
| // ---- one substep of a test particle, including optional OU noise bath | |
| function stepParticle(p) { | |
| // deterministic part: velocity-Verlet | |
| let a = accel(p.x, p.y); | |
| p.vx += a.ax * DT * 0.5; p.vy += a.ay * DT * 0.5; | |
| // OU colored noise: evolve η, then apply it as an acceleration AND | |
| // apply the fluctuation–dissipation paired damping -γv (γ = 1/τ). | |
| let etaX = 0, etaY = 0; | |
| if (noiseEnabled && p.noisy) { | |
| const gamma = 1 / tau; | |
| // exact OU update: η ← η e^{-γ dt} + sqrt(D (1 - e^{-2γ dt})) * N(0,1) | |
| const decay = Math.exp(-gamma * DT); | |
| const amp = Math.sqrt(D * (1 - decay * decay)); | |
| p.etaX = p.etaX * decay + amp * gauss(); | |
| p.etaY = p.etaY * decay + amp * gauss(); | |
| etaX = p.etaX; etaY = p.etaY; | |
| // paired damping (the "flow re-fitting the perturbation"), same γ as the noise | |
| p.vx -= gamma * p.vx * DT; | |
| p.vy -= gamma * p.vy * DT; | |
| // the noise force itself | |
| p.vx += etaX * DT; | |
| p.vy += etaY * DT; | |
| // record η history for the little plot | |
| p.etaHist.push(p.etaX); | |
| if (p.etaHist.length > 220) p.etaHist.shift(); | |
| } | |
| p.x += p.vx * DT; p.y += p.vy * DT; | |
| a = accel(p.x, p.y); | |
| p.vx += a.ax * DT * 0.5; p.vy += a.ay * DT * 0.5; | |
| if (!isFinite(p.x) || !isFinite(p.y)) { p.dead = true; return; } | |
| const sp = Math.hypot(p.vx, p.vy); | |
| if (sp > 120) { p.vx *= 120 / sp; p.vy *= 120 / sp; } | |
| p.trail.push([p.x, p.y]); | |
| if (p.trail.length > 1400) p.trail.shift(); | |
| // ---- orbital clocks about the heaviest body | |
| const host = heaviestBody(); | |
| if (host) { | |
| const dx = p.x - host.x, dy = p.y - host.y; | |
| const r = Math.hypot(dx, dy); | |
| const th = Math.atan2(dy, dx); | |
| if (p.prevTheta === undefined) { p.prevTheta = th; p.prevR = r; } | |
| let dth = th - p.prevTheta; | |
| while (dth > Math.PI) dth -= 2 * Math.PI; | |
| while (dth < -Math.PI) dth += 2 * Math.PI; | |
| p.angleTotal = (p.angleTotal || 0) + dth; | |
| p.prevTheta = th; | |
| p.phiCycles = Math.abs(p.angleTotal) / (2 * Math.PI); | |
| const drdt = r - p.prevR; | |
| if (p.lastDrdt !== undefined && Math.sign(drdt) !== Math.sign(p.lastDrdt)) { | |
| p.radialTurns = (p.radialTurns || 0) + 1; | |
| } | |
| p.lastDrdt = drdt; | |
| p.prevR = r; | |
| p.radialCycles = (p.radialTurns || 0) / 2; | |
| p.radius = r; | |
| if (r > p.far) p.far = r; | |
| if (r < p.near) p.near = r; | |
| // ---- escape detection: unbind from the host | |
| const Menc = totalMassInside(host.x, host.y, Math.max(r, 1e-6)); | |
| const vEsc = Math.sqrt(2 * G_CONST * Math.max(Menc, 1e-9) / Math.max(r, 1e-6)); | |
| const vNow = Math.hypot(p.vx, p.vy); | |
| if (!p.escaped && (r > ESCAPE_RADIUS || (vNow > vEsc && r > p.far * 0.9 && r > 2.5))) { | |
| p.escaped = true; | |
| p.escapeTime = simTime; | |
| } | |
| } | |
| } | |
| function stepParticles() { | |
| for (const p of particles) stepParticle(p); | |
| particles = particles.filter(p => !p.dead && Math.hypot(p.x, p.y) < 60); | |
| } | |
| function heaviestBody() { | |
| let best = null; | |
| for (const b of bodies) if (!best || b.m > best.m) best = b; | |
| return best; | |
| } | |
| function dropTestParticle(x, y, vyOverride, noisy) { | |
| const host = heaviestBody(); | |
| let vx = 0, vy = 0; | |
| if (host) { | |
| const dx = x - host.x, dy = y - host.y; | |
| const r = Math.hypot(dx, dy) + 1e-9; | |
| const Menc = totalMassInside(host.x, host.y, r); | |
| const vc = Math.sqrt(G_CONST * Math.max(Menc, 1e-9) / r); | |
| vx = -dy / r * vc; vy = dx / r * vc; | |
| } | |
| if (vyOverride !== undefined && vyOverride !== null) vy = vyOverride; | |
| particles.push({ | |
| x, y, vx, vy, trail: [[x, y]], | |
| near: Infinity, far: 0, radialTurns: 0, angleTotal: 0, | |
| noisy: !!noisy, etaX: 0, etaY: 0, etaHist: [], | |
| escaped: false, escapeTime: 0, | |
| }); | |
| } | |
| // drop a fan of noisy copies drawn from a Gaussian around (x,y) | |
| function dropNoiseEnsemble(x, y, n, sigma) { | |
| const host = heaviestBody(); | |
| if (!host) return; | |
| const dx = x - host.x, dy = y - host.y; | |
| const r = Math.hypot(dx, dy) + 1e-9; | |
| const Menc = totalMassInside(host.x, host.y, r); | |
| const vc = Math.sqrt(G_CONST * Math.max(Menc, 1e-9) / r); | |
| const baseVx = -dy / r * vc, baseVy = dx / r * vc; | |
| for (let i = 0; i < n; i++) { | |
| particles.push({ | |
| x: x + gauss() * sigma, y: y + gauss() * sigma, | |
| vx: baseVx + gauss() * sigma * 0.35, vy: baseVy + gauss() * sigma * 0.35, | |
| trail: [], near: Infinity, far: 0, radialTurns: 0, angleTotal: 0, | |
| noisy: true, etaX: 0, etaY: 0, etaHist: [], | |
| escaped: false, escapeTime: 0, | |
| }); | |
| } | |
| } | |
| // ================================================================ drawing | |
| function toPx(x, y) { | |
| return { | |
| sx: (x - view.xmin) / (view.xmax - view.xmin) * W, | |
| sy: (view.ymax - y) / (view.ymax - view.ymin) * H, | |
| }; | |
| } | |
| function toWorld(sx, sy) { | |
| return { | |
| x: view.xmin + (sx / W) * (view.xmax - view.xmin), | |
| y: view.ymax - (sy / H) * (view.ymax - view.ymin), | |
| }; | |
| } | |
| const PAL = [ | |
| [8, 8, 20], [14, 20, 48], [26, 44, 96], [48, 84, 160], | |
| [92, 140, 220], [170, 208, 255], [255, 255, 255], | |
| [255, 236, 170], [255, 190, 90], [240, 120, 30], [170, 40, 10], | |
| ]; | |
| function lerp(a, b, t) { return a + (b - a) * t; } | |
| function palColor(u) { | |
| u = Math.max(0, Math.min(1, u)); | |
| const n = PAL.length - 1, x = u * n, i = Math.floor(x), f = x - i; | |
| const c0 = PAL[i], c1 = PAL[Math.min(n, i + 1)]; | |
| return [Math.round(lerp(c0[0], c1[0], f)), Math.round(lerp(c0[1], c1[1], f)), Math.round(lerp(c0[2], c1[2], f))]; | |
| } | |
| function bodyRadius(b) { | |
| if (b.type === "hole") return 7 + Math.sqrt(b.m) * 0.55; | |
| if (b.type === "star") return 5 + Math.sqrt(b.m) * 0.55; | |
| return 3.2 + Math.sqrt(b.m) * 0.7; | |
| } | |
| function bodyColor(b) { | |
| if (b.type === "hole") return "#b47aff"; | |
| if (b.type === "star") return "#ffd257"; | |
| return "#5ea8ff"; | |
| } | |
| const offCanvas = document.createElement("canvas"); | |
| offCanvas.width = W; offCanvas.height = H; | |
| const offCtx = offCanvas.getContext("2d"); | |
| function drawFieldLayer() { | |
| const img = offCtx.createImageData(W, H); | |
| const data = img.data; | |
| let maxA = 0; | |
| const N = 40; | |
| for (let i = 0; i <= N; i++) for (let j = 0; j <= N; j++) { | |
| const w = toWorld(i / N * W, j / N * H); | |
| const s = speedAt(w.x, w.y); | |
| if (isFinite(s) && s > maxA) maxA = s; | |
| } | |
| if (maxA === 0) maxA = 1; | |
| const lmax = Math.log(1 + maxA); | |
| const step = 4; | |
| for (let py = 0; py < H; py += step) { | |
| for (let px = 0; px < W; px += step) { | |
| const w = toWorld(px, py); | |
| const s = speedAt(w.x, w.y); | |
| const u = isFinite(s) ? Math.log(1 + s) / lmax : 0; | |
| const c = palColor(u * 0.85); | |
| for (let dy = 0; dy < step && py + dy < H; dy++) { | |
| for (let dx = 0; dx < step && px + dx < W; dx++) { | |
| const idx = ((py + dy) * W + px + dx) * 4; | |
| data[idx] = c[0]; data[idx + 1] = c[1]; data[idx + 2] = c[2]; data[idx + 3] = 255; | |
| } | |
| } | |
| } | |
| } | |
| offCtx.putImageData(img, 0, 0); | |
| ctx.drawImage(offCanvas, 0, 0); | |
| } | |
| function drawGlyphs() { | |
| const n = 26; | |
| const cell = Math.min(W / n, H / n); | |
| const cols = Math.ceil(W / cell), rows = Math.ceil(H / cell); | |
| const maxLen = cell * 0.8; | |
| let amax = 1e-9; | |
| const cells = []; | |
| for (let i = 0; i < cols; i++) for (let j = 0; j < rows; j++) { | |
| const sx = (i + 0.5) * cell, sy = (j + 0.5) * cell; | |
| const w = toWorld(sx, sy); | |
| const F = fieldAt(w.x, w.y); | |
| const m = Math.hypot(F.f, F.g); | |
| cells.push({ sx, sy, F, m }); | |
| if (isFinite(m) && m > amax) amax = m; | |
| } | |
| for (const c of cells) { | |
| if (!isFinite(c.m) || c.m < 1e-7) continue; | |
| const ang = Math.atan2(c.F.g, c.F.f); | |
| const u = Math.pow(c.m / amax, 0.32); | |
| const L = maxLen * u; | |
| const ux = Math.cos(ang), uy = -Math.sin(ang); | |
| const x0 = c.sx - ux * L * 0.5, y0 = c.sy - uy * L * 0.5; | |
| const x1 = c.sx + ux * L * 0.5, y1 = c.sy + uy * L * 0.5; | |
| let hue = ang * 180 / Math.PI; if (hue < 0) hue += 360; | |
| const light = 32 + 40 * u, sat = 65 + 25 * u; | |
| ctx.strokeStyle = `hsla(${hue}, ${sat}%, ${light}%, 0.85)`; | |
| ctx.fillStyle = ctx.strokeStyle; | |
| ctx.lineWidth = 1.2; | |
| const dx = x1 - x0, dy = y1 - y0, len = Math.hypot(dx, dy); | |
| if (len < 2) continue; | |
| const vx = dx / len, vy = dy / len; | |
| const head = Math.min(6, 2.4 + len * 0.22); | |
| ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x1 - vx * head * 0.7, y1 - vy * head * 0.7); ctx.stroke(); | |
| ctx.beginPath(); | |
| ctx.moveTo(x1, y1); | |
| ctx.lineTo(x1 - vx * head - vy * head * 0.5, y1 - vy * head + vx * head * 0.5); | |
| ctx.lineTo(x1 - vx * head + vy * head * 0.5, y1 - vy * head - vx * head * 0.5); | |
| ctx.closePath(); ctx.fill(); | |
| } | |
| } | |
| function traceStreamline(x0, y0, dir, color) { | |
| let x = x0, y = y0; | |
| const pts = []; | |
| for (let i = 0; i < 240; i++) { | |
| const a = accel(x, y); | |
| const m = Math.hypot(a.ax, a.ay); | |
| if (!isFinite(m) || m < 1e-9) break; | |
| const stepLen = 0.04; | |
| x += (a.ax / m) * stepLen * dir; | |
| y += (a.ay / m) * stepLen * dir; | |
| pts.push(toPx(x, y)); | |
| if (x < view.xmin - 1 || x > view.xmax + 1 || y < view.ymin - 1 || y > view.ymax + 1) break; | |
| } | |
| if (pts.length < 2) return; | |
| ctx.strokeStyle = color; ctx.lineWidth = 1.2; | |
| ctx.beginPath(); ctx.moveTo(pts[0].sx, pts[0].sy); | |
| for (let i = 1; i < pts.length; i++) ctx.lineTo(pts[i].sx, pts[i].sy); | |
| ctx.stroke(); | |
| } | |
| function drawBodies() { | |
| for (const b of bodies) { | |
| const p = toPx(b.x, b.y); | |
| const R = bodyRadius(b); | |
| const col = bodyColor(b); | |
| if (b.type === "hole") { | |
| const g = ctx.createRadialGradient(p.sx, p.sy, R * 0.4, p.sx, p.sy, R * 3.2); | |
| g.addColorStop(0, "rgba(180,122,255,0.55)"); | |
| g.addColorStop(1, "rgba(180,122,255,0)"); | |
| ctx.fillStyle = g; | |
| ctx.beginPath(); ctx.arc(p.sx, p.sy, R * 3.2, 0, 2 * Math.PI); ctx.fill(); | |
| ctx.fillStyle = "#0a0612"; | |
| ctx.beginPath(); ctx.arc(p.sx, p.sy, R, 0, 2 * Math.PI); ctx.fill(); | |
| ctx.strokeStyle = col; ctx.lineWidth = 2; | |
| ctx.beginPath(); ctx.arc(p.sx, p.sy, R, 0, 2 * Math.PI); ctx.stroke(); | |
| ctx.strokeStyle = "rgba(180,122,255,0.35)"; ctx.lineWidth = 1; | |
| ctx.beginPath(); ctx.arc(p.sx, p.sy, R * 1.55, 0, 2 * Math.PI); ctx.stroke(); | |
| } else { | |
| if (b.type === "star") { | |
| const g = ctx.createRadialGradient(p.sx, p.sy, R * 0.3, p.sx, p.sy, R * 3.5); | |
| g.addColorStop(0, "rgba(255,210,87,0.55)"); | |
| g.addColorStop(1, "rgba(255,160,40,0)"); | |
| ctx.fillStyle = g; | |
| ctx.beginPath(); ctx.arc(p.sx, p.sy, R * 3.5, 0, 2 * Math.PI); ctx.fill(); | |
| } | |
| ctx.fillStyle = col; | |
| ctx.beginPath(); ctx.arc(p.sx, p.sy, R, 0, 2 * Math.PI); ctx.fill(); | |
| ctx.strokeStyle = "rgba(255,255,255,0.55)"; ctx.lineWidth = 1; | |
| ctx.stroke(); | |
| } | |
| ctx.fillStyle = "rgba(255,255,255,0.6)"; | |
| ctx.font = "9.5px ui-monospace, monospace"; | |
| ctx.fillText("m=" + b.m.toFixed(1), p.sx + R + 4, p.sy + 3); | |
| } | |
| } | |
| function drawParticles() { | |
| for (const p of particles) { | |
| const tr = p.trail; | |
| const isNoisy = p.noisy; | |
| if (tr.length > 1) { | |
| ctx.strokeStyle = isNoisy ? "rgba(180,122,255,0.60)" : "rgba(255,85,102,0.75)"; | |
| ctx.lineWidth = 1.2; | |
| ctx.beginPath(); | |
| const s0 = toPx(tr[0][0], tr[0][1]); | |
| ctx.moveTo(s0.sx, s0.sy); | |
| for (let i = 1; i < tr.length; i++) { | |
| const s = toPx(tr[i][0], tr[i][1]); | |
| ctx.lineTo(s.sx, s.sy); | |
| } | |
| ctx.stroke(); | |
| } | |
| const s = toPx(p.x, p.y); | |
| const sp = Math.hypot(p.vx, p.vy); | |
| if (sp > 1e-6 && !isNoisy) { | |
| const ux = p.vx / sp, uy = -p.vy / sp; | |
| const L = 12 + 8 * Math.log(1 + sp); | |
| ctx.strokeStyle = "#ff8a99"; ctx.lineWidth = 1.6; | |
| ctx.beginPath(); ctx.moveTo(s.sx, s.sy); ctx.lineTo(s.sx + ux * L, s.sy + uy * L); ctx.stroke(); | |
| } | |
| ctx.fillStyle = isNoisy ? "#b47aff" : "#ff5566"; | |
| ctx.beginPath(); ctx.arc(s.sx, s.sy, isNoisy ? 2.4 : 3.4, 0, 2 * Math.PI); ctx.fill(); | |
| if (!isNoisy) { ctx.strokeStyle = "#fff"; ctx.lineWidth = 1; ctx.stroke(); } | |
| // escape halo | |
| if (p.escaped) { | |
| ctx.strokeStyle = "rgba(255,85,102,0.8)"; | |
| ctx.lineWidth = 1.2; | |
| ctx.beginPath(); ctx.arc(s.sx, s.sy, 7, 0, 2 * Math.PI); ctx.stroke(); | |
| } | |
| } | |
| } | |
| function drawRingProbe(cx, cy, R) { | |
| const p = toPx(cx, cy); | |
| const rpx = R / (view.xmax - view.xmin) * W; | |
| ctx.strokeStyle = "rgba(108,204,255,0.55)"; | |
| ctx.lineWidth = 1.4; | |
| ctx.setLineDash([6, 5]); | |
| ctx.beginPath(); ctx.arc(p.sx, p.sy, rpx, 0, 2 * Math.PI); ctx.stroke(); | |
| ctx.setLineDash([]); | |
| const samples = 40; | |
| let fluxSum = 0; | |
| const dL = 2 * Math.PI * R / samples; | |
| let maxN = 1e-9; | |
| const vals = []; | |
| for (let i = 0; i < samples; i++) { | |
| const t = 2 * Math.PI * i / samples; | |
| const nx = Math.cos(t), ny = Math.sin(t); | |
| const F = fieldAt(cx + R * nx, cy + R * ny); | |
| const ncomp = F.f * nx + F.g * ny; | |
| fluxSum += ncomp * dL; | |
| vals.push({ nx, ny, ncomp }); | |
| if (Math.abs(ncomp) > maxN) maxN = Math.abs(ncomp); | |
| } | |
| const Menc = enclosedMass(cx, cy, R); | |
| const predicted = -2 * Math.PI * G_CONST * Menc; | |
| const consistent = Math.abs(fluxSum - predicted) < 0.3 * Math.max(1, Math.abs(predicted)); | |
| for (const v of vals) { | |
| const x = cx + R * v.nx, y = cy + R * v.ny; | |
| const q = toPx(x, y); | |
| const u = Math.abs(v.ncomp) / maxN; | |
| const L = 4 + 13 * u; | |
| const inward = v.ncomp < 0; | |
| const ux = inward ? -v.nx : v.nx; | |
| const uy = inward ? -v.ny : v.ny; | |
| ctx.strokeStyle = inward ? "rgba(108,204,255,0.85)" : "rgba(76,175,80,0.9)"; | |
| ctx.fillStyle = ctx.strokeStyle; | |
| ctx.lineWidth = 1.3; | |
| ctx.beginPath(); | |
| ctx.moveTo(q.sx, q.sy); | |
| ctx.lineTo(q.sx + ux * L, q.sy - uy * L); | |
| ctx.stroke(); | |
| const hx = q.sx + ux * L, hy = q.sy - uy * L; | |
| ctx.beginPath(); | |
| ctx.moveTo(hx, hy); | |
| ctx.lineTo(hx - ux * 3 - uy * 2, hy + uy * 3 - ux * 2); | |
| ctx.lineTo(hx - ux * 3 + uy * 2, hy + uy * 3 + ux * 2); | |
| ctx.closePath(); ctx.fill(); | |
| } | |
| ctx.fillStyle = "#6cf"; | |
| ctx.beginPath(); ctx.arc(p.sx, p.sy, 2.6, 0, 2 * Math.PI); ctx.fill(); | |
| return { flux: fluxSum, Menc, predicted, consistent, R, cx, cy }; | |
| } | |
| // ---- the η(t) strip chart | |
| function drawNoisePlot() { | |
| const w = noisePlot.width, h = noisePlot.height; | |
| nctx.clearRect(0, 0, w, h); | |
| nctx.fillStyle = "#0a0a14"; | |
| nctx.fillRect(0, 0, w, h); | |
| if (!showNoiseHist) return; | |
| // find the noisiest particle with history | |
| let p = null; | |
| for (const q of particles) if (q.etaHist && q.etaHist.length > 5) { p = q; break; } | |
| nctx.strokeStyle = "#1e1e2e"; | |
| nctx.beginPath(); nctx.moveTo(0, h / 2); nctx.lineTo(w, h / 2); nctx.stroke(); | |
| nctx.fillStyle = "#8a8aa4"; | |
| nctx.font = "10px ui-monospace, monospace"; | |
| nctx.fillText("η(t) — Ornstein–Uhlenbeck colored noise", 8, 13); | |
| if (!p) { | |
| nctx.fillStyle = "#55556a"; | |
| nctx.fillText(noiseEnabled ? "enable + add a noisy particle to see the trace" : "noise bath off", 8, h / 2 - 6); | |
| return; | |
| } | |
| const hist = p.etaHist; | |
| // scale to ±3σ_stationary, σ² = D | |
| const lim = Math.sqrt(D) * 3 || 1e-6; | |
| nctx.strokeStyle = "rgba(180,122,255,0.9)"; | |
| nctx.lineWidth = 1.3; | |
| nctx.beginPath(); | |
| for (let i = 0; i < hist.length; i++) { | |
| const x = (i / (hist.length - 1)) * w; | |
| const y = h / 2 - (hist[i] / lim) * (h / 2 - 14); | |
| if (i === 0) nctx.moveTo(x, y); else nctx.lineTo(x, y); | |
| } | |
| nctx.stroke(); | |
| // reference bands at ±σ | |
| nctx.strokeStyle = "rgba(180,122,255,0.25)"; | |
| nctx.setLineDash([3, 4]); | |
| [1, -1].forEach(s => { | |
| const y = h / 2 - s * (Math.sqrt(D) / lim) * (h / 2 - 14); | |
| nctx.beginPath(); nctx.moveTo(0, y); nctx.lineTo(w, y); nctx.stroke(); | |
| }); | |
| nctx.setLineDash([]); | |
| // correlation length marker: τ in samples | |
| const tauSamples = Math.min(hist.length, Math.max(2, tau / DT)); | |
| const xTau = (tauSamples / hist.length) * w; | |
| nctx.strokeStyle = "rgba(108,204,255,0.5)"; | |
| nctx.beginPath(); nctx.moveTo(xTau, 14); nctx.lineTo(xTau, h); nctx.stroke(); | |
| nctx.fillStyle = "rgba(108,204,255,0.8)"; | |
| nctx.fillText("τ", xTau + 4, h - 6); | |
| } | |
| // ================================================================ render | |
| let lastProbe = null; | |
| let simTime = 0; | |
| function render() { | |
| ctx.fillStyle = "#04040a"; | |
| ctx.fillRect(0, 0, W, H); | |
| if (showField) { drawFieldLayer(); drawGlyphs(); } | |
| if (showStream && cursor) { | |
| traceStreamline(cursor.x, cursor.y, 1, "rgba(108,204,255,0.28)"); | |
| traceStreamline(cursor.x, cursor.y, -1, "rgba(108,204,255,0.16)"); | |
| } | |
| drawBodies(); | |
| if (showTrace) drawParticles(); | |
| if (showProbe && cursor) { | |
| const host = heaviestBody(); | |
| if (host) { | |
| const R = Math.hypot(cursor.x - host.x, cursor.y - host.y); | |
| if (R > 0.15) lastProbe = drawRingProbe(host.x, host.y, R); | |
| else lastProbe = null; | |
| } | |
| const c = toPx(cursor.x, cursor.y); | |
| ctx.strokeStyle = "rgba(255,255,255,0.75)"; | |
| ctx.lineWidth = 1; | |
| ctx.beginPath(); | |
| ctx.moveTo(c.sx - 12, c.sy); ctx.lineTo(c.sx - 4, c.sy); | |
| ctx.moveTo(c.sx + 4, c.sy); ctx.lineTo(c.sx + 12, c.sy); | |
| ctx.moveTo(c.sx, c.sy - 12); ctx.lineTo(c.sx, c.sy - 4); | |
| ctx.moveTo(c.sx, c.sy + 4); ctx.lineTo(c.sx, c.sy + 12); | |
| ctx.stroke(); | |
| } | |
| } | |
| // ================================================================ explanation | |
| function fmt(x, d = 3) { | |
| if (!isFinite(x)) return "∞"; | |
| if (Math.abs(x) < 1e-10) return "0"; | |
| if (Math.abs(x) >= 1e4 || Math.abs(x) < 1e-3) return x.toExponential(2); | |
| return x.toFixed(d); | |
| } | |
| function regimetext() { | |
| const r = DT / tau; // dt/τ | |
| if (r < 0.1) return { klass: "stiff", text: "stiff limit (dt ≪ τ): the flow outruns the noise — perturbations are re-absorbed before they grow. Effectively deterministic." }; | |
| if (r > 1.0) return { klass: "soft", text: "soft limit (dt ≫ τ): each step re-draws fresh noise — you are back to white noise, and the bath injects energy every step. Orbits diffuse and escape." }; | |
| return { klass: "mid", text: "intermediate (dt ~ τ): the noise is correlated over several steps — the regime where the deterministic flow is genuinely competing with the bath. Look for metastable orbits that survive a long time then escape." }; | |
| } | |
| function buildExplanation() { | |
| let html = ""; | |
| if (cursor) { | |
| const F = fieldAt(cursor.x, cursor.y); | |
| const mag = Math.hypot(F.f, F.g); | |
| html += `<h4>At the cursor (${fmt(cursor.x, 2)}, ${fmt(cursor.y, 2)})</h4>`; | |
| html += `<p>Acceleration <b>g = (${fmt(F.f, 3)}, ${fmt(F.g, 3)})</b>, magnitude <b>${fmt(mag, 3)}</b>.</p>`; | |
| } | |
| // ---- noise regime analysis | |
| if (noiseEnabled) { | |
| const reg = regimetext(); | |
| html += `<h4>Colored-noise bath — which regime are you in?</h4>`; | |
| html += `<div class="verdict ${reg.klass === "stiff" ? "good" : reg.klass === "soft" ? "bad" : "warn"}">${reg.text}</div>`; | |
| html += `<p>The bath is an Ornstein–Uhlenbeck process with relaxation time <b>τ = ${fmt(tau, 3)}</b> and strength <b>D = ${fmt(D, 5)}</b> (stationary variance of η). The update is <b>exact</b>, not a naive Euler step:</p>`; | |
| html += `<div class="eq">η ← η·e^(−Δt/τ) + √(D(1−e^(−2Δt/τ)))·N(0,1)<br>dv ← −(1/τ)·v·Δt + η·Δt</div>`; | |
| html += `<p>The damping <b>γ = 1/τ = ${fmt(1 / tau, 3)}</b> is <i>not</i> optional. It is the fluctuation–dissipation partner of the noise: without it the bath only injects energy and every orbit spirals outward regardless of your other settings. With it, energy input and removal balance, and the long-run behaviour is a Kramers-type escape from the well.</p>`; | |
| const ratio = DT / tau; | |
| html += `<table> | |
| <tr><th>quantity</th><th>value</th><th>meaning</th></tr> | |
| <tr><td>τ</td><td>${fmt(tau, 3)}</td><td>memory time of the noise</td></tr> | |
| <tr><td>γ = 1/τ</td><td>${fmt(1 / tau, 3)}</td><td>damping rate (paired)</td></tr> | |
| <tr><td>Δt</td><td>${fmt(DT, 5)}</td><td>integrator step</td></tr> | |
| <tr><td>Δt/τ</td><td><b>${fmt(ratio, 4)}</b></td><td>the one number that sets the regime</td></tr> | |
| <tr><td>σ_stationary</td><td>${fmt(Math.sqrt(D), 5)}</td><td>typical kick size</td></tr> | |
| </table>`; | |
| html += `<p>Contrast the two limits deliberately: pull τ down to the minimum (fast memory) and the bath behaves like white noise — orbits smear diffusively. Push τ up (slow memory) and the same D produces gentle, trackable drift that the flow can follow. <b>Same noise strength, different physics</b> — because the flow's ability to re-fit a perturbation depends on the perturbation's memory, not just its size.</p>`; | |
| } else { | |
| html += `<h4>Colored-noise bath</h4>`; | |
| html += `<p style="color:var(--dim)">Tick <b>colored-noise bath (OU)</b> below the canvas to switch it on. A noisy particle is drawn in violet. Use <b>+ noise ensemble</b> to drop a fan of copies from a Gaussian cloud.</p>`; | |
| } | |
| // ---- escape statistics | |
| const noisyParticles = particles.filter(p => p.noisy); | |
| if (noisyParticles.length) { | |
| const escaped = noisyParticles.filter(p => p.escaped); | |
| html += `<h4>Escape statistics (live)</h4>`; | |
| html += `<p>${escaped.length} of ${noisyParticles.length} noisy particles have left the well (r > ${ESCAPE_RADIUS} or unbound). ${ | |
| escaped.length ? "First escape at sim time t = " + fmt(Math.min(...escaped.map(p => p.escapeTime)), 2) + "." : "None yet." | |
| }</p>`; | |
| if (escaped.length) { | |
| const meanT = escaped.reduce((a, p) => a + p.escapeTime, 0) / escaped.length; | |
| html += `<p><b>Mean escape time</b> = ${fmt(meanT, 2)} over the escapees. This grows <i>exponentially</i> as D falls (a Kramers law), which is why small noise looks like stability for a very long time and then abruptly isn't.</p>`; | |
| } | |
| html += `<p style="color:var(--dim); font-size:11.5px;">Note the honest caveat: pure two-body gravity has <i>no</i> attractor and no restoring τ of its own — the damping here is a modelled bath (gas drag / tidal dissipation / radiation reaction), not gravity. This is exactly why real orbits need an extra dissipative mechanism to be stable.</p>`; | |
| } | |
| // ---- orbital clocks | |
| let p = null; | |
| for (const q of particles) if (!p || (q.trail && q.trail.length > (p.trail ? p.trail.length : 0))) p = q; | |
| if (p && p.phiCycles > 0.12) { | |
| const ratio = p.radialCycles / p.phiCycles; | |
| const closed = ratio > 0.97 && ratio < 1.03; | |
| html += `<h4>The orbit's two clocks</h4>`; | |
| html += `<table> | |
| <tr><th>quantity</th><th>value</th><th>meaning</th></tr> | |
| <tr><td>ω_φ</td><td>${fmt(p.phiCycles, 3)}</td><td>angle wound</td></tr> | |
| <tr><td>ω_r</td><td>${fmt(p.radialCycles, 3)}</td><td>radial cycles</td></tr> | |
| <tr><td>ω_r/ω_φ</td><td><b>${fmt(ratio, 4)}</b></td><td>${closed ? "1:1 — closed (Kepler)" : "≠1 — precessing"}</td></tr> | |
| </table>`; | |
| if (noiseEnabled && p.noisy) { | |
| html += `<div class="verdict ${closed ? "good" : "info"}">${closed | |
| ? "Despite the noise, the two clocks are still near 1:1 — the bath is too weak (or too fast) to break the degeneracy yet." | |
| : "The noise has pulled ω_r/ω_φ off 1:1 faster than damping can restore it — the bath is winning on this timescale."}</div>`; | |
| } | |
| } | |
| if (lastProbe) { | |
| const P = lastProbe; | |
| html += `<h4>Gauss's law on the ring</h4>`; | |
| html += `<div class="verdict ${P.consistent ? "good" : "warn"}">Φ = ${fmt(P.flux, 3)} vs −2πG·M<sub>enc</sub> = ${fmt(P.predicted, 3)} — ${P.consistent ? "consistent" : "differing (mass outside ring / softening)"}</div>`; | |
| } | |
| html += `<div class="note"><b>Model honesty.</b> The bath is an OU process with the fluctuation–dissipation damping paired to it, integrated exactly. It is a <i>modelled</i> environment (gas, tides, radiation reaction) — not gravity itself. The gravitational field is Newtonian with a softening length, plus the optional GR cartoon near black holes. No geodesics, no shadow.</div>`; | |
| return html; | |
| } | |
| function updateReadout() { | |
| if (lastProbe) { | |
| document.getElementById("s-flux").textContent = fmt(lastProbe.flux, 3); | |
| document.getElementById("s-menc").textContent = fmt(lastProbe.Menc, 3); | |
| } else { | |
| document.getElementById("s-flux").textContent = "—"; | |
| document.getElementById("s-menc").textContent = "—"; | |
| } | |
| let p = null; | |
| for (const q of particles) if (!p || (q.trail && q.trail.length > (p.trail ? p.trail.length : 0))) p = q; | |
| if (p && p.phiCycles > 0.12) { | |
| document.getElementById("s-ratio").textContent = fmt(p.radialCycles / p.phiCycles, 4); | |
| } else { | |
| document.getElementById("s-ratio").textContent = "—"; | |
| } | |
| // escape stat | |
| const noisyParticles = particles.filter(q => q.noisy); | |
| const escaped = noisyParticles.filter(q => q.escaped); | |
| const el = document.getElementById("s-escape"); | |
| if (noisyParticles.length === 0) { el.textContent = "safe"; el.style.color = ""; } | |
| else if (escaped.length === 0) { el.textContent = "0 / " + noisyParticles.length; el.style.color = "#8fdc92"; } | |
| else { | |
| const meanT = escaped.reduce((a, q) => a + q.escapeTime, 0) / escaped.length; | |
| el.textContent = escaped.length + " / " + noisyParticles.length + " (t̄=" + meanT.toFixed(2) + ")"; | |
| el.style.color = "#ff8a99"; | |
| } | |
| } | |
| // ================================================================ UI helpers | |
| function syncNoiseUI() { | |
| document.getElementById("tauVal").textContent = tau < 0.01 ? tau.toExponential(1) : tau.toFixed(3); | |
| document.getElementById("dVal").textContent = D.toExponential(1).replace("e-", "e−"); | |
| const ratio = DT / tau; | |
| const meter = document.getElementById("tauMeter"); | |
| if (ratio < 0.1) { meter.textContent = "Δt/τ = " + ratio.toFixed(3) + " stiff (flow wins)"; meter.className = "tau-meter stiff"; } | |
| else if (ratio > 1.0) { meter.textContent = "Δt/τ = " + ratio.toFixed(3) + " soft (noise wins)"; meter.className = "tau-meter soft"; } | |
| else { meter.textContent = "Δt/τ = " + ratio.toFixed(3) + " intermediate"; meter.className = "tau-meter mid"; } | |
| document.getElementById("gammaNote").textContent = noiseEnabled | |
| ? "γ = 1/τ = " + (1 / tau).toFixed(3) + " , fluctuation–dissipation pairing active" | |
| : "γ = 1/τ = " + (1 / tau).toFixed(3) + " , bath off"; | |
| document.getElementById("noiseBox").classList.toggle("disabled", !noiseEnabled); | |
| } | |
| // ================================================================ interaction | |
| function mouseWorld(e) { | |
| const rect = stage.getBoundingClientRect(); | |
| const sx = (e.clientX - rect.left) / rect.width * W; | |
| const sy = (e.clientY - rect.top) / rect.height * H; | |
| return { w: toWorld(sx, sy), sx, sy, rect }; | |
| } | |
| stage.addEventListener("mousemove", (e) => { | |
| const m = mouseWorld(e); | |
| const w = m.w; | |
| if (dragBody) { dragBody.x = w.x; dragBody.y = w.y; return; } | |
| if (dragging) { | |
| const dx = (e.clientX - dragStart.x) / m.rect.width * (dragStart.view.xmax - dragStart.view.xmin); | |
| const dy = (e.clientY - dragStart.y) / m.rect.height * (dragStart.view.ymax - dragStart.view.ymin); | |
| view.xmin = dragStart.view.xmin - dx; | |
| view.xmax = dragStart.view.xmax - dx; | |
| view.ymin = dragStart.view.ymin + dy; | |
| view.ymax = dragStart.view.ymax + dy; | |
| return; | |
| } | |
| cursor = w; | |
| coordBadge.textContent = `(${w.x.toFixed(3)}, ${w.y.toFixed(3)})`; | |
| explanationEl.innerHTML = buildExplanation(); | |
| updateReadout(); | |
| }); | |
| stage.addEventListener("mouseleave", () => { cursor = null; }); | |
| // ensemble mode flag | |
| let placingEnsemble = false; | |
| stage.addEventListener("mousedown", (e) => { | |
| const m = mouseWorld(e); | |
| const { w, sx, sy } = m; | |
| let grabbed = null; | |
| for (const b of bodies) { | |
| const p = toPx(b.x, b.y); | |
| if (Math.hypot(p.sx - sx, p.sy - sy) < bodyRadius(b) + 8) { grabbed = b; break; } | |
| } | |
| if (grabbed) { dragBody = grabbed; return; } | |
| if (placingEnsemble && bodies.length) { | |
| dropNoiseEnsemble(w.x, w.y, 36, 0.02 + 0.04 * Math.sqrt(D * 1e4)); | |
| explanationEl.innerHTML = buildExplanation(); | |
| return; | |
| } | |
| if (placingParticle) { | |
| dropTestParticle(w.x, w.y, null, noiseEnabled); | |
| explanationEl.innerHTML = buildExplanation(); | |
| } else { | |
| let mm = newMass; | |
| if (placing === "star") mm = Math.max(4, newMass * 1.6); | |
| if (placing === "planet") mm = Math.max(0.4, newMass * 0.12); | |
| if (placing === "hole") mm = Math.max(20, newMass * 4.2); | |
| const b = { x: w.x, y: w.y, vx: 0, vy: 0, m: mm, type: placing }; | |
| const host = heaviestBody(); | |
| if (host && (host.x !== w.x || host.y !== w.y)) { | |
| const dx = w.x - host.x, dy = w.y - host.y, r = Math.hypot(dx, dy); | |
| const Menc = totalMassInside(host.x, host.y, r); | |
| const vc = Math.sqrt(G_CONST * Math.max(Menc, 1e-9) / Math.max(r, 0.2)); | |
| b.vx = -dy / r * vc; b.vy = dx / r * vc; | |
| } | |
| bodies.push(b); | |
| explanationEl.innerHTML = buildExplanation(); | |
| } | |
| }); | |
| stage.addEventListener("mouseup", () => { dragBody = null; dragging = false; }); | |
| window.addEventListener("mouseup", () => { dragBody = null; dragging = false; }); | |
| stage.addEventListener("dblclick", () => { view = { ...HOME_VIEW }; }); | |
| stage.addEventListener("wheel", (e) => { | |
| e.preventDefault(); | |
| const rect = stage.getBoundingClientRect(); | |
| const pxFrac = (e.clientX - rect.left) / rect.width; | |
| const pyFrac = (e.clientY - rect.top) / rect.height; | |
| const cx = view.xmin + pxFrac * (view.xmax - view.xmin); | |
| const cy = view.ymax - pyFrac * (view.ymax - view.ymin); | |
| const factor = e.deltaY < 0 ? 0.82 : 1.22; | |
| const nw = (view.xmax - view.xmin) * factor; | |
| const nh = (view.ymax - view.ymin) * factor; | |
| view.xmin = cx - pxFrac * nw; view.xmax = view.xmin + nw; | |
| view.ymax = cy + pyFrac * nh; view.ymin = view.ymax - nh; | |
| }, { passive: false }); | |
| stage.addEventListener("mousedown", (e) => { | |
| const m = mouseWorld(e); | |
| let overBody = false; | |
| for (const b of bodies) { | |
| const p = toPx(b.x, b.y); | |
| if (Math.hypot(p.sx - m.sx, p.sy - m.sy) < bodyRadius(b) + 8) { overBody = true; break; } | |
| } | |
| if (!overBody && !placingParticle && !placingEnsemble) { | |
| dragging = true; | |
| dragStart = { x: e.clientX, y: e.clientY, view: { ...view } }; | |
| } | |
| }); | |
| // ================================================================ tools | |
| function selectTool(which) { | |
| placingParticle = (which === "particle"); | |
| placingEnsemble = (which === "ensemble"); | |
| if (!placingParticle && !placingEnsemble) placing = which; | |
| document.getElementById("btnStar").classList.toggle("on", which === "star"); | |
| document.getElementById("btnPlanet").classList.toggle("on", which === "planet"); | |
| document.getElementById("btnHole").classList.toggle("on", which === "hole"); | |
| document.getElementById("btnParticle").classList.toggle("on", which === "particle"); | |
| document.getElementById("btnEnsemble").classList.toggle("on", which === "ensemble"); | |
| modeBadge.textContent = placingParticle ? "click to drop a test particle" | |
| : placingEnsemble ? "click to drop a 36-copy noise ensemble" | |
| : "click to place a " + which; | |
| modeBadge.classList.add("armed"); | |
| } | |
| function activateNoise() { | |
| if (!noiseEnabled) { | |
| noiseEnabled = true; | |
| document.getElementById("noiseEnable").checked = true; | |
| const last = particles[particles.length - 1]; | |
| if (last && !last.noisy && last.etaHist) { | |
| last.noisy = true; | |
| last.etaX = 0; last.etaY = 0; | |
| } | |
| } | |
| } | |
| document.getElementById("btnStar").addEventListener("click", () => selectTool("star")); | |
| document.getElementById("btnPlanet").addEventListener("click", () => selectTool("planet")); | |
| document.getElementById("btnHole").addEventListener("click", () => selectTool("hole")); | |
| document.getElementById("btnParticle").addEventListener("click", () => selectTool("particle")); | |
| document.getElementById("btnEnsemble").addEventListener("click", () => { | |
| selectTool("ensemble"); | |
| activateNoise(); | |
| syncNoiseUI(); | |
| explanationEl.innerHTML = buildExplanation(); | |
| }); | |
| document.getElementById("btnClear").addEventListener("click", () => { | |
| bodies = []; particles = []; lastProbe = null; simTime = 0; | |
| explanationEl.innerHTML = '<p style="color:var(--dim)">Cleared. Place a body to begin.</p>'; | |
| }); | |
| document.getElementById("btnPause").addEventListener("click", (e) => { | |
| paused = !paused; | |
| e.target.textContent = paused ? "Resume" : "Pause"; | |
| e.target.classList.toggle("on", paused); | |
| }); | |
| document.getElementById("btnReset").addEventListener("click", () => { | |
| particles = []; simTime = 0; | |
| const host = heaviestBody(); | |
| if (host) dropTestParticle(host.x + 2.2, host.y, null, noiseEnabled); | |
| }); | |
| document.getElementById("btnPreset").addEventListener("click", () => { loadSunSystem(); lastProbe = null; simTime = 0; }); | |
| document.getElementById("btnBinary").addEventListener("click", () => { loadBinary(); lastProbe = null; simTime = 0; }); | |
| document.getElementById("btnBH").addEventListener("click", () => { loadBlackHole(); lastProbe = null; simTime = 0; }); | |
| document.getElementById("massSlider").addEventListener("input", (e) => { | |
| newMass = Number(e.target.value); | |
| document.getElementById("massVal").textContent = e.target.value; | |
| }); | |
| document.getElementById("grSlider").addEventListener("input", (e) => { | |
| grMode = Number(e.target.value); | |
| document.getElementById("grVal").textContent = grMode.toFixed(2); | |
| }); | |
| // ---- colored noise controls | |
| document.getElementById("noiseEnable").addEventListener("change", (e) => { | |
| noiseEnabled = e.target.checked; | |
| syncNoiseUI(); | |
| explanationEl.innerHTML = buildExplanation(); | |
| // existing noisy particles keep going; new ones will be noisy | |
| if (noiseEnabled) { | |
| // tag the most recent particle as noisy so something is visible | |
| const last = particles[particles.length - 1]; | |
| if (last && !last.noisy && last.etaHist) { | |
| last.noisy = true; | |
| last.etaX = 0; last.etaY = 0; | |
| } | |
| } | |
| }); | |
| document.getElementById("tauSlider").addEventListener("input", (e) => { | |
| // slider is log10(τ) | |
| tau = Math.pow(10, Number(e.target.value)); | |
| activateNoise(); | |
| syncNoiseUI(); | |
| explanationEl.innerHTML = buildExplanation(); | |
| }); | |
| document.getElementById("dSlider").addEventListener("input", (e) => { | |
| // slider is log10(D) | |
| D = Math.pow(10, Number(e.target.value)); | |
| activateNoise(); | |
| syncNoiseUI(); | |
| explanationEl.innerHTML = buildExplanation(); | |
| }); | |
| document.getElementById("btnProbe").addEventListener("click", (e) => { showProbe = !showProbe; e.target.classList.toggle("on", showProbe); }); | |
| document.getElementById("btnField").addEventListener("click", (e) => { showField = !showField; e.target.classList.toggle("on", showField); }); | |
| document.getElementById("btnStream").addEventListener("click", (e) => { showStream = !showStream; e.target.classList.toggle("on", showStream); }); | |
| document.getElementById("btnTrace").addEventListener("click", (e) => { showTrace = !showTrace; e.target.classList.toggle("on", showTrace); }); | |
| document.getElementById("btnNoiseHist").addEventListener("click", (e) => { showNoiseHist = !showNoiseHist; e.target.classList.toggle("on", showNoiseHist); }); | |
| // ================================================================ main loop | |
| function loop() { | |
| if (!paused) { | |
| for (let s = 0; s < SUBS; s++) { stepBodies(); stepParticles(); simTime += DT; } | |
| } | |
| render(); | |
| drawNoisePlot(); | |
| if (cursor) explanationEl.innerHTML = buildExplanation(); | |
| updateReadout(); | |
| requestAnimationFrame(loop); | |
| } | |
| // ================================================================ init | |
| loadSunSystem(); | |
| selectTool("particle"); | |
| syncNoiseUI(); | |
| requestAnimationFrame(loop); | |
| </script> | |
| </body> | |
| </html> |