@ripple-ui/svelte 0.0.0-stage → 0.8.2

package/dist/figures/particle-collider/index.d.ts

@@ -0,0 +1,4 @@
+import type { FigureMeta } from '../types.js';
+import { mount } from './figure.js';
+export declare const meta: FigureMeta;
+export { mount };

package/dist/figures/particle-collider/index.js

@@ -0,0 +1,17 @@
+import { PARAMS } from './model.js';
+import { anchorsOf, mount } from './figure.js';
+export const meta = {
+    id: 'particle-collider',
+    title: 'How a particle collider works',
+    params: PARAMS,
+    readouts: [
+        { key: 'speed', label: 'Share of light speed', unit: '%' },
+        { key: 'field', label: 'Dipole field', unit: 'T' },
+        { key: 'energy', label: 'Collision energy', unit: 'TeV' },
+        { key: 'collisions', label: 'Collisions a second' }
+    ],
+    get anchors() {
+        return anchorsOf();
+    }
+};
+export { mount };

package/dist/figures/particle-collider/model.d.ts

@@ -0,0 +1,81 @@
+export interface ColliderParams {
+    energy: number;
+    rate: number;
+}
+export interface ParamSpec {
+    key: keyof ColliderParams;
+    label: string;
+    min: number;
+    max: number;
+    step: number;
+    unit: string;
+    value: number;
+}
+export declare const PARAMS: ParamSpec[];
+/** Proton rest energy, GeV. */
+export declare const PROTON_GEV = 0.938272;
+/** Bending radius of the arc dipoles, metres (the LHC's). */
+export declare const BEND_M = 2804;
+/** Speed of light, m/s. */
+export declare const C = 299792458;
+/** Proton pairs that collide each time two bunches cross. */
+export declare const PILEUP = 25;
+/** Ring units a bunch moves per second in the drawing. */
+export declare const DRAW_SPEED = 60;
+/** Drawn gap between bunches at 40 million a second; it scales as 40 / rate. */
+export declare const SPACING_40 = 64;
+/** Seconds a collision burst lasts in the drawing. */
+export declare const BURST_S = 1.1;
+export declare function clampParams(p?: Partial<Record<string, unknown>>): ColliderParams;
+export declare const gammaOf: (p: ColliderParams) => number;
+/** 1 - v/c, computed without cancelling: 1 / (gamma^2 (1 + beta)). */
+export declare function shortfallOf(p: ColliderParams): number;
+export declare const betaOf: (p: ColliderParams) => number;
+/** How much slower than light, m/s. */
+export declare const lagOf: (p: ColliderParams) => number;
+/** Dipole field that keeps the proton on the ring, tesla. */
+export declare function fieldOf(p: ColliderParams): number;
+export declare const collisionEnergyOf: (p: ColliderParams) => number;
+export declare const collisionsOf: (p: ColliderParams) => number;
+export declare function bigNumber(n: number): string;
+export declare function readoutsOf(p: ColliderParams): Record<string, string>;
+/** Drawn gap between bunches, ring units. */
+export declare const spacingOf: (p: ColliderParams) => number;
+/** Seconds into the loop for the still frame: a burst well under way, bunches just past the crossing. */
+export declare const stillTime: () => number;
+/** Ring positions (s) of every bunch of each beam inside [lo, hi] at time t. Beam 1 runs toward +s, beam 2 toward -s; both pass s = 0 together. */
+export declare function bunchesAt(p: ColliderParams, t: number, lo: number, hi: number): {
+    one: number[];
+    two: number[];
+};
+export type TrackKind = 'muon' | 'hadron' | 'electron';
+export interface Track {
+    kind: TrackKind;
+    /** Direction in the cut quadrant: 0 = toward the viewer, PI/2 = straight up. */
+    angle: number;
+    /** Drift along the beam per unit of radius. */
+    slope: number;
+    /** Bend in the solenoid field, 1/units (sign = charge). */
+    curl: number;
+    /** Radius where it stops: calorimeter or muon chamber, units of the drawing. */
+    reach: number;
+}
+export interface Burst {
+    /** Seconds since this crossing. */
+    age: number;
+    /** 0..1 how far the tracks have flown out. */
+    reach: number;
+    /** 0..1 brightness envelope (attack then decay). */
+    glow: number;
+    tracks: Track[];
+}
+/** Radii of the detector layers the tracks stop in (drawing units). Kept in step with the figure's LAYERS. */
+export declare const STOP: {
+    readonly ecal: readonly [18, 23];
+    readonly hcal: readonly [26, 32];
+    readonly muon: readonly [50, 56];
+};
+export declare function tracksOf(p: ColliderParams, crossing: number): Track[];
+/** The bursts still showing at time t (the newest and, while it fades, the one before). */
+export declare function burstsAt(p: ColliderParams, t: number): Burst[];
+export declare function describe(p: ColliderParams): string;

package/dist/figures/particle-collider/model.js

@@ -0,0 +1,147 @@
+// figures/particle-collider/model.ts: the one model behind the particle
+// collider figure. Pure, no DOM. From the beam energy (TeV per proton) and the
+// bunch rate (million bunch crossings a second at the detector) it gives the
+// proton's speed as a share of light speed, the dipole field that bends it,
+// the collision energy, the collisions a second, where every bunch is on the
+// drawn ring at time t, the collision bursts (seeded, so a frame is
+// reproducible) and the screen-reader text.
+//
+// Physics, with LHC numbers: gamma = E / 0.938272 GeV, beta = sqrt(1 - 1/g^2);
+// B [T] = p [GeV/c] / (0.2998 x 2804 m), the dipoles' bending radius, so
+// 7 TeV needs 8.33 T; head-on beams collide at twice the beam energy; about 25
+// proton pairs collide each time two bunches cross (PILEUP), so 40 million
+// crossings a second give about a billion collisions. The drawing runs hugely
+// slowed: bunches move DRAW_SPEED units of ring a second, and the gap between
+// bunches grows as the rate falls (fewer bunches, same speed).
+export const PARAMS = [
+    { key: 'energy', label: 'Beam energy', min: 0.5, max: 7, step: 0.1, unit: 'TeV', value: 6.8 },
+    { key: 'rate', label: 'Bunches a second', min: 5, max: 40, step: 1, unit: 'million', value: 40 }
+];
+/** Proton rest energy, GeV. */
+export const PROTON_GEV = 0.938272;
+/** Bending radius of the arc dipoles, metres (the LHC's). */
+export const BEND_M = 2804;
+/** Speed of light, m/s. */
+export const C = 299_792_458;
+/** Proton pairs that collide each time two bunches cross. */
+export const PILEUP = 25;
+/** Ring units a bunch moves per second in the drawing. */
+export const DRAW_SPEED = 60;
+/** Drawn gap between bunches at 40 million a second; it scales as 40 / rate. */
+export const SPACING_40 = 64;
+/** Seconds a collision burst lasts in the drawing. */
+export const BURST_S = 1.1;
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+const fin = (v, fallback) => (typeof v === 'number' && Number.isFinite(v) ? v : fallback);
+export function clampParams(p = {}) {
+    const [energy, rate] = PARAMS;
+    return {
+        energy: clamp(Math.round(fin(p.energy, energy.value) * 10) / 10, energy.min, energy.max),
+        rate: clamp(Math.round(fin(p.rate, rate.value)), rate.min, rate.max)
+    };
+}
+export const gammaOf = (p) => (p.energy * 1000) / PROTON_GEV;
+/** 1 - v/c, computed without cancelling: 1 / (gamma^2 (1 + beta)). */
+export function shortfallOf(p) {
+    const g = gammaOf(p);
+    const beta = Math.sqrt(1 - 1 / (g * g));
+    return 1 / (g * g * (1 + beta));
+}
+export const betaOf = (p) => 1 - shortfallOf(p);
+/** How much slower than light, m/s. */
+export const lagOf = (p) => shortfallOf(p) * C;
+/** Dipole field that keeps the proton on the ring, tesla. */
+export function fieldOf(p) {
+    const momentum = Math.sqrt((p.energy * 1000) ** 2 - PROTON_GEV ** 2);
+    return momentum / (0.299792458 * BEND_M);
+}
+export const collisionEnergyOf = (p) => 2 * p.energy;
+export const collisionsOf = (p) => p.rate * 1e6 * PILEUP;
+export function bigNumber(n) {
+    return n >= 1e9 ? `${(n / 1e9).toFixed(1)} billion` : `${Math.round(n / 1e6)} million`;
+}
+export function readoutsOf(p) {
+    return {
+        speed: (100 - shortfallOf(p) * 100).toFixed(7),
+        field: fieldOf(p).toFixed(2),
+        energy: collisionEnergyOf(p).toFixed(1),
+        collisions: bigNumber(collisionsOf(p))
+    };
+}
+// ---- motion ------------------------------------------------------------------
+/** Drawn gap between bunches, ring units. */
+export const spacingOf = (p) => (SPACING_40 * 40) / p.rate;
+/** Seconds into the loop for the still frame: a burst well under way, bunches just past the crossing. */
+export const stillTime = () => 0.24;
+/** Ring positions (s) of every bunch of each beam inside [lo, hi] at time t. Beam 1 runs toward +s, beam 2 toward -s; both pass s = 0 together. */
+export function bunchesAt(p, t, lo, hi) {
+    const d = spacingOf(p);
+    const q = DRAW_SPEED * t;
+    const phase = ((q % d) + d) % d;
+    const along = (a, b) => {
+        const out = [];
+        for (let k = Math.ceil((a - phase) / d); phase + k * d <= b; k++)
+            out.push(phase + k * d);
+        return out;
+    };
+    return { one: along(lo, hi), two: along(-hi, -lo).map((s) => -s) };
+}
+const smooth = (a, b, x) => {
+    const u = clamp((x - a) / (b - a), 0, 1);
+    return u * u * (3 - 2 * u);
+};
+/** A small seeded generator so each crossing always throws the same tracks. */
+function rng(seed) {
+    let s = (seed * 2654435761) >>> 0 || 1;
+    return () => {
+        s ^= s << 13;
+        s >>>= 0;
+        s ^= s >>> 17;
+        s ^= s << 5;
+        s >>>= 0;
+        return s / 4294967296;
+    };
+}
+/** Radii of the detector layers the tracks stop in (drawing units). Kept in step with the figure's LAYERS. */
+export const STOP = { ecal: [18, 23], hcal: [26, 32], muon: [50, 56] };
+export function tracksOf(p, crossing) {
+    const r = rng(crossing + 7919);
+    const count = 8 + Math.round((10 * p.energy) / 7);
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        const roll = r();
+        const kind = i === 0 || roll < 0.06 ? 'muon' : roll < 0.55 ? 'hadron' : 'electron';
+        const [a, b] = kind === 'muon' ? STOP.muon : kind === 'hadron' ? STOP.hcal : STOP.ecal;
+        const reach = a + r() * (b - a);
+        const curl = (r() < 0.5 ? -1 : 1) * (kind === 'muon' ? 0.001 + r() * 0.003 : 0.003 + r() * 0.011);
+        // Keep the whole bent track inside the cut-away quadrant, clear of both walls.
+        const turn = curl * reach;
+        const lo = Math.max(0.16, 0.16 - turn);
+        const hi = Math.min(Math.PI / 2 - 0.16, Math.PI / 2 - 0.16 - turn);
+        out.push({ kind, angle: lo + r() * Math.max(0, hi - lo), slope: (r() - 0.5) * 0.5, curl, reach });
+    }
+    return out;
+}
+/** The bursts still showing at time t (the newest and, while it fades, the one before). */
+export function burstsAt(p, t) {
+    const d = spacingOf(p);
+    const q = DRAW_SPEED * t;
+    const n = Math.floor(q / d);
+    const out = [];
+    for (let i = n; i >= n - 2; i--) {
+        const age = (q - i * d) / DRAW_SPEED;
+        if (age < 0 || age > BURST_S)
+            continue;
+        out.push({ age, reach: 1 - (1 - Math.min(1, age / 0.22)) ** 3, glow: smooth(0, 0.04, age) * (1 - smooth(0.25, BURST_S, age)), tracks: tracksOf(p, i) });
+    }
+    return out;
+}
+export function describe(p) {
+    const lag = lagOf(p);
+    return (`A cutaway piece of a circular particle collider. Two beams of protons travel in opposite directions in twin beam pipes: ` +
+        `superconducting dipole magnets bend them round the ring, quadrupole magnets focus them, and radio-frequency cavities push them along. ` +
+        `At ${p.energy.toFixed(1)} TeV a proton moves at ${readoutsOf(p).speed} percent of light speed, about ${lag < 10 ? lag.toFixed(1) : Math.round(lag)} metres a second slower than light, ` +
+        `and the dipoles need ${fieldOf(p).toFixed(2)} tesla to bend it round. Where the beams cross inside the detector, ${p.rate} million bunch crossings a second, ` +
+        `about ${PILEUP} proton pairs each, make about ${bigNumber(collisionsOf(p))} collisions a second at ${collisionEnergyOf(p).toFixed(1)} TeV; ` +
+        `the tracker, calorimeters and muon chambers record what flies out. Shown hugely slowed down.`);
+}

package/dist/figures/rocket-engine/figure.d.ts

@@ -0,0 +1,37 @@
+import * as k from '@ripple-ui/core/iso';
+import { type EngineParams } from './model.js';
+export declare const WIDTH = 640;
+export declare const HEIGHT = 420;
+/** Bell radius at x (throat to exit): a parabola-like curve from 34 deg at the throat to 10 deg at the lip. */
+export declare function bellR(x: number): number;
+export declare const ENGINE_CSS: string;
+export declare const LABEL = "A liquid-fuel rocket engine firing on a test stand: two propellant tanks, a cut-open turbopump on top, the preburner, injector, combustion chamber and bell nozzle, hung from a load cell through its gimbal.";
+export interface DriveState {
+    /** Shaft angle, radians. */
+    theta: number;
+    /** Seconds, for the plume's flicker. */
+    t: number;
+}
+export declare const STILL: DriveState;
+/** The whole figure as an SVG string, framed to everything it draws. */
+export declare function engineSvg(params?: EngineParams, drive?: Partial<DriveState>, standalone?: k.Theme | false): string;
+export interface Anchor {
+    id: string;
+    label: string;
+    x: number;
+    y: number;
+}
+export declare function anchorsOf(): Anchor[];
+export interface MountOptions {
+    theme?: k.Theme;
+    params?: Partial<EngineParams>;
+    onReadout?: (values: Record<string, string>) => void;
+}
+export interface FigureHandle {
+    update(params: Partial<Record<string, number>>): void;
+    setTheme(theme: k.Theme): void;
+    /** Park the engine `t` seconds into the run and stop the loop (captures, tests). */
+    seek(t: number): void;
+    destroy(): void;
+}
+export declare function mount(el: HTMLElement, { theme, params: initial, onReadout }?: MountOptions): FigureHandle;