| // The hurricane damage generator: a seeded draw of what a storm takes out, from the failure probabilities of the | |
| // Storm-to-Steel R3 ensemble (assets/data/storm_ensemble.json, written by tools/export_storm_ensemble.py). | |
| // | |
| // R3 is a model, not a list: given the track variant (shift across the track, wind-speed multiplier), line l fails iff a | |
| // uniform draw falls under its probability p[l], independently of the other lines. The wind farms above their cut-out speed | |
| // stop, and the damaged zone (the buses at the ends of lines with p >= 1%), are fixed by the variant. D44 kept the | |
| // draws that leave the network connected; so does this: it draws again until the network is in one piece, which gives | |
| // the same law as the kept R3 draws, for any variant (including those with no stored what-if). | |
| // A pure module: no DOM, so that node can test it (tools/test_storm_damage.mjs). | |
| import { connected } from "./weather.js"; | |
| export const variantOf = (E, shift, alpha) => E.shifts.indexOf(shift) * E.alphas.length + E.alphas.indexOf(alpha); | |
| // An exact early exit. A bus whose every line fails is cut off, and that is what makes most draws unusable; the buses | |
| // likeliest to be cut off (all their lines carry a probability) are tested first, on lines drawn only as needed, so a | |
| // refused draw costs a few random numbers and not a graph search. It changes no result: the graph search still decides. | |
| const GUARD_MIN = 1e-5; | |
| function guardsOf(G, V) { | |
| if (V.guards) return V.guards; | |
| const pos = new Map(V.lines.map((l, i) => [l, i])), inc = Array.from({ length: G.nBus }, () => []); | |
| for (let j = 0; j < G.nBranch; j++) if (G.branch.status[j] === 1) { inc[G.branch.from[j]].push(j); inc[G.branch.to[j]].push(j); } | |
| const gs = []; | |
| for (let b = 0; b < G.nBus; b++) { | |
| if (!inc[b].length || !inc[b].every((j) => pos.has(j))) continue; | |
| const ix = inc[b].map((j) => pos.get(j)), q = ix.reduce((a, i) => a * V.p[i] / 1e4, 1); // the chance that all fail | |
| if (q >= GUARD_MIN) gs.push({ ix, q }); | |
| } | |
| V.guards = gs.sort((a, b) => b.q - a.q).map((g) => g.ix); | |
| return V.guards; | |
| } | |
| // One connected draw of variant V (an entry of storm_ensemble.json) with the uniform generator rnd: {branches, tries} | |
| // (tries: the draws made, the refused ones included), or null if none of maxTries leaves the network connected. | |
| export function sampleDamage(G, V, rnd, maxTries = 100000) { | |
| const n = V.lines.length, gs = guardsOf(G, V), st = new Uint8Array(n); // 0 not drawn yet, 1 out, 2 stays | |
| const draw = (i) => (st[i] = rnd() * 1e4 < V.p[i] ? 1 : 2); // p is in units of 1e-4 | |
| for (let t = 1; t <= maxTries; t++) { | |
| st.fill(0); | |
| let cut = false; | |
| for (const ix of gs) { | |
| let alive = false; | |
| for (const i of ix) if ((st[i] || draw(i)) === 2) { alive = true; break; } | |
| if (!alive) { cut = true; break; } | |
| } | |
| if (cut) continue; | |
| const out = []; | |
| for (let i = 0; i < n; i++) if ((st[i] || draw(i)) === 1) out.push(V.lines[i]); | |
| if (connected(G, out)) return { branches: out, tries: t }; | |
| } | |
| return null; | |
| } | |
| // the generator's seed: the same for the same storm, variant and draw number, different between them | |
| export const damageSeed = (storm, variant, n) => (20261022 + (storm === "beryl" ? 1000003 : 0) + variant * 7919 + n * 104729) >>> 0; | |