Tooling
This commit is contained in:
Rainer Leit
@@ -0,0 +1,768 @@
|
||||
// Wind simulation: pressure-driven seasonal wind with longitude-varying ITCZ.
|
||||
// Computes pressure fields and wind vectors for summer and winter seasons.
|
||||
|
||||
import { elevToHeightKm } from './color-map.js';
|
||||
import { smoothField, percentile } from './climate-util.js';
|
||||
|
||||
const DEG = Math.PI / 180;
|
||||
const RAD = 180 / Math.PI;
|
||||
|
||||
// ── Periodic cubic spline interpolation ──────────────────────────────────────
|
||||
|
||||
function buildPeriodicSpline(xs, ys) {
|
||||
// xs: sorted longitude samples (radians), ys: ITCZ latitude values
|
||||
// Returns spline data for evaluateSpline()
|
||||
const n = xs.length;
|
||||
const period = 2 * Math.PI;
|
||||
|
||||
// Build tridiagonal system for periodic natural cubic spline
|
||||
const h = new Float64Array(n);
|
||||
const alpha = new Float64Array(n);
|
||||
for (let i = 0; i < n; i++) {
|
||||
const next = (i + 1) % n;
|
||||
h[i] = (xs[next] - xs[i] + period) % period;
|
||||
if (h[i] === 0) h[i] = period / n;
|
||||
}
|
||||
for (let i = 0; i < n; i++) {
|
||||
const prev = (i - 1 + n) % n;
|
||||
const next = (i + 1) % n;
|
||||
alpha[i] = (3 / h[i]) * (ys[next] - ys[i]) - (3 / h[prev]) * (ys[i] - ys[prev]);
|
||||
}
|
||||
|
||||
// Solve with Thomas-like algorithm for periodic system
|
||||
// Simplified: use iterative relaxation (fast enough for n=72)
|
||||
const c = new Float64Array(n);
|
||||
for (let iter = 0; iter < 20; iter++) {
|
||||
for (let i = 0; i < n; i++) {
|
||||
const prev = (i - 1 + n) % n;
|
||||
const next = (i + 1) % n;
|
||||
c[i] = (alpha[i] - h[prev] * c[prev] - h[i] * c[next]) /
|
||||
(2 * (h[prev] + h[i]));
|
||||
}
|
||||
}
|
||||
|
||||
const b = new Float64Array(n);
|
||||
const d = new Float64Array(n);
|
||||
for (let i = 0; i < n; i++) {
|
||||
const next = (i + 1) % n;
|
||||
b[i] = (ys[next] - ys[i]) / h[i] - h[i] * (c[next] + 2 * c[i]) / 3;
|
||||
d[i] = (c[next] - c[i]) / (3 * h[i]);
|
||||
}
|
||||
|
||||
return { xs, ys, b, c, d, h, n, period };
|
||||
}
|
||||
|
||||
function evaluateSpline(spline, lon) {
|
||||
const { xs, ys, b, c, d, n, period } = spline;
|
||||
// Normalize lon to [xs[0], xs[0] + period)
|
||||
let t = ((lon - xs[0]) % period + period) % period + xs[0];
|
||||
|
||||
// Direct index calculation — segments are equally spaced
|
||||
const segStep = period / n;
|
||||
let seg = Math.floor((t - xs[0]) / segStep);
|
||||
if (seg < 0) seg = 0;
|
||||
else if (seg >= n) seg = n - 1;
|
||||
|
||||
const dx = t - xs[seg];
|
||||
return ys[seg] + b[seg] * dx + c[seg] * dx * dx + d[seg] * dx * dx * dx;
|
||||
}
|
||||
|
||||
// ── Smoothstep utility ───────────────────────────────────────────────────────
|
||||
|
||||
export function smoothstep(edge0, edge1, x) {
|
||||
if (edge0 === edge1) return x >= edge1 ? 1 : 0;
|
||||
const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
|
||||
return t * t * (3 - 2 * t);
|
||||
}
|
||||
|
||||
// ── ITCZ computation ─────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Build a spatial index binning regions by latitude/longitude for fast
|
||||
* geographic sampling. Returns a function landFracAndElev(lat, lon, radius)
|
||||
* that returns { landFrac, avgElev } by scanning nearby bins.
|
||||
*/
|
||||
function buildGeoIndex(r_lat, r_lon, r_sinLat, r_cosLat, r_elevation, r_isLand, numRegions) {
|
||||
const LAT_BINS = 36; // 5° each
|
||||
const LON_BINS = 72; // 5° each
|
||||
const numBins = LAT_BINS * LON_BINS;
|
||||
|
||||
// CSR (compressed sparse row) format: count regions per bin, then prefix-sum
|
||||
// Cache bin index per region to avoid recomputing in the fill pass
|
||||
const r_bin = new Uint32Array(numRegions);
|
||||
const binCount = new Uint32Array(numBins);
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
const latBin = Math.max(0, Math.min(LAT_BINS - 1,
|
||||
Math.floor((r_lat[r] + Math.PI / 2) / Math.PI * LAT_BINS)));
|
||||
const lonBin = Math.max(0, Math.min(LON_BINS - 1,
|
||||
Math.floor((r_lon[r] + Math.PI) / (2 * Math.PI) * LON_BINS)));
|
||||
const bin = latBin * LON_BINS + lonBin;
|
||||
r_bin[r] = bin;
|
||||
binCount[bin]++;
|
||||
}
|
||||
|
||||
const binOffset = new Uint32Array(numBins + 1);
|
||||
for (let i = 0; i < numBins; i++) {
|
||||
binOffset[i + 1] = binOffset[i] + binCount[i];
|
||||
}
|
||||
|
||||
const indices = new Uint32Array(numRegions);
|
||||
const fillPos = new Uint32Array(numBins);
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
const bin = r_bin[r];
|
||||
indices[binOffset[bin] + fillPos[bin]] = r;
|
||||
fillPos[bin]++;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sample land fraction and average elevation in a circular region.
|
||||
* @param {number} lat - center latitude (radians)
|
||||
* @param {number} lon - center longitude (radians)
|
||||
* @param {number} radius - great-circle radius (radians)
|
||||
*/
|
||||
return function sample(lat, lon, radius) {
|
||||
const latMin = lat - radius, latMax = lat + radius;
|
||||
const bMin = Math.max(0, Math.floor((latMin + Math.PI / 2) / Math.PI * LAT_BINS));
|
||||
const bMax = Math.min(LAT_BINS - 1, Math.floor((latMax + Math.PI / 2) / Math.PI * LAT_BINS));
|
||||
|
||||
// Longitude span widens near equator
|
||||
const cosLat = Math.cos(lat) || 0.01;
|
||||
const lonSpan = radius / cosLat;
|
||||
const lMin = Math.floor((lon - lonSpan + Math.PI) / (2 * Math.PI) * LON_BINS);
|
||||
const lMax = Math.floor((lon + lonSpan + Math.PI) / (2 * Math.PI) * LON_BINS);
|
||||
|
||||
let landCount = 0, totalCount = 0, elevSum = 0;
|
||||
const cosRadius = Math.cos(radius);
|
||||
const sinLat0 = Math.sin(lat), cosLat0 = Math.cos(lat);
|
||||
|
||||
for (let bi = bMin; bi <= bMax; bi++) {
|
||||
for (let li = lMin; li <= lMax; li++) {
|
||||
const lj = ((li % LON_BINS) + LON_BINS) % LON_BINS;
|
||||
const bin = bi * LON_BINS + lj;
|
||||
const start = binOffset[bin];
|
||||
const end = binOffset[bin + 1];
|
||||
for (let k = start; k < end; k++) {
|
||||
const r = indices[k];
|
||||
const sinLat1 = r_sinLat[r];
|
||||
const cosLat1 = r_cosLat[r];
|
||||
const dlon = r_lon[r] - lon;
|
||||
const cosDist = sinLat0 * sinLat1 + cosLat0 * cosLat1 * Math.cos(dlon);
|
||||
if (cosDist >= cosRadius) {
|
||||
totalCount++;
|
||||
if (r_isLand[r]) landCount++;
|
||||
elevSum += Math.max(0, r_elevation[r]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (totalCount === 0) return { landFrac: 0, avgElev: 0 };
|
||||
return { landFrac: landCount / totalCount, avgElev: elevSum / totalCount };
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute ITCZ latitude at sampled longitudes for a given season.
|
||||
* Uses a thermal equator search: scans latitudes from -30° to +30°,
|
||||
* computes a heating score at each, and picks the peak.
|
||||
*
|
||||
* Heating score combines:
|
||||
* - Solar insolation (cosine of latitude offset from subsolar point)
|
||||
* - Land thermal boost (land heats faster than ocean)
|
||||
* - Elevation boost (plateaus heat more intensely — thinner atmosphere)
|
||||
* - Cross-equatorial anchoring (winter-hemisphere land pulls ITCZ equatorward)
|
||||
*
|
||||
* @param {function} geoSample - from buildGeoIndex
|
||||
* @param {string} season - 'summer' (NH) or 'winter' (NH)
|
||||
* @param {number} tiltRad - axial tilt in radians
|
||||
* @returns {{ spline, lons: Float64Array, lats: Float64Array }}
|
||||
*/
|
||||
function computeITCZ(geoSample, season, tiltRad) {
|
||||
const NUM_LON = 72;
|
||||
// Two sampling radii: local (5°) for precise land detection, wide (30°) for continental scale
|
||||
const localRadius = 5 * DEG;
|
||||
const wideRadius = 30 * DEG;
|
||||
|
||||
// +1 = NH summer, -1 = SH summer (NH winter)
|
||||
const sign = season === 'summer' ? 1 : -1;
|
||||
|
||||
// Subsolar latitude: where the sun is directly overhead this season
|
||||
// Full tilt in summer hemisphere (e.g. +23.5° for NH summer)
|
||||
const subsolarLat = sign * tiltRad;
|
||||
|
||||
// Scan range: -30° to +30° in 2.5° steps
|
||||
const SCAN_MIN = -30;
|
||||
const SCAN_MAX = 30;
|
||||
const SCAN_STEP = 2.5;
|
||||
const numScans = Math.round((SCAN_MAX - SCAN_MIN) / SCAN_STEP) + 1;
|
||||
|
||||
const lons = new Float64Array(NUM_LON);
|
||||
const rawLats = new Float64Array(NUM_LON);
|
||||
|
||||
for (let i = 0; i < NUM_LON; i++) {
|
||||
const lon = -Math.PI + (i + 0.5) * (2 * Math.PI / NUM_LON);
|
||||
lons[i] = lon;
|
||||
|
||||
let bestScore = -Infinity;
|
||||
let bestLat = sign * 5 * DEG; // fallback
|
||||
|
||||
for (let si = 0; si < numScans; si++) {
|
||||
const latDeg = SCAN_MIN + si * SCAN_STEP;
|
||||
const lat = latDeg * DEG;
|
||||
const local = geoSample(lat, lon, localRadius);
|
||||
const wide = geoSample(lat, lon, wideRadius);
|
||||
|
||||
// (a) Solar insolation: peaks at subsolar latitude, broad Gaussian falloff.
|
||||
// σ = 25° gives a wide heating dome — the ITCZ doesn't track the
|
||||
// subsolar point 1:1, it lags and is damped by ocean thermal inertia.
|
||||
const dSolar = (lat - subsolarLat) * RAD; // degrees from subsolar
|
||||
const solarScore = Math.exp(-0.5 * (dSolar / 25) ** 2);
|
||||
|
||||
// (b) Land thermal boost: uses multi-scale sampling.
|
||||
// Only truly continental-scale landmasses pull the ITCZ significantly.
|
||||
// Islands, thin peninsulas, and coastlines near ocean register low at
|
||||
// the wide (30°) radius and get suppressed by the steep ramp.
|
||||
const localLand = local.landFrac;
|
||||
const wideLand = wide.landFrac;
|
||||
|
||||
// Also sample poleward of this latitude: a massive continent extending
|
||||
// poleward (like Asia beyond 20°N) creates an enormous heat reservoir
|
||||
// that pulls the ITCZ toward it even if the scan point itself is at
|
||||
// the continent's edge. Sample 15° poleward in the summer hemisphere.
|
||||
const polewardLat = lat + sign * 15 * DEG;
|
||||
const poleward = geoSample(polewardLat, lon, wideRadius);
|
||||
// Combined land signal: max of local-wide and poleward-wide.
|
||||
// Poleward land contributes at 70% strength (heat diffuses equatorward).
|
||||
const effectiveWideLand = Math.max(wideLand, poleward.landFrac * 0.7);
|
||||
|
||||
// Wide-scale land must exceed ~20% before any real pull kicks in.
|
||||
const continentalScale = smoothstep(0.20, 0.45, effectiveWideLand);
|
||||
// Square it so moderate land fractions still contribute little.
|
||||
const scaledLand = continentalScale * continentalScale;
|
||||
// Local land gate: require >25% local land fraction to activate.
|
||||
// At 5° radius (~560 km), ocean near thin islands stays well below this.
|
||||
const landGate = smoothstep(0.25, 0.55, localLand);
|
||||
// Strong max boost so massive continents pull ITCZ toward 25-30°
|
||||
const landBoost = landGate * scaledLand * 1.0;
|
||||
|
||||
// (c) Elevation boost: high plateaus heat more intensely
|
||||
// (thinner atmosphere, stronger surface insolation).
|
||||
// Also scaled by continental size — isolated volcanic peaks don't pull ITCZ.
|
||||
const elevKm = elevToHeightKm(Math.max(0, wide.avgElev));
|
||||
const elevBoost = Math.min(0.30, elevKm * 0.12) * scaledLand;
|
||||
|
||||
// (d) Cross-equatorial anchoring: if this latitude is in the
|
||||
// winter hemisphere but there's significant land, it anchors
|
||||
// the ITCZ closer to the equator (resists poleward migration).
|
||||
const isWinterHemi = (sign > 0 && latDeg < 0) || (sign < 0 && latDeg > 0);
|
||||
const anchorBoost = isWinterHemi ? landBoost * 0.4 : 0;
|
||||
|
||||
// (e) Ocean baseline: slight poleward bias in summer hemisphere
|
||||
// even over open ocean (~6-8° from equator on average).
|
||||
const isSummerHemi = !isWinterHemi;
|
||||
const oceanBias = isSummerHemi && localLand < 0.1
|
||||
? 0.08 * Math.exp(-0.5 * ((Math.abs(latDeg) - 7) / 5) ** 2)
|
||||
: 0;
|
||||
|
||||
const score = solarScore + landBoost + elevBoost + anchorBoost + oceanBias;
|
||||
|
||||
if (score > bestScore) {
|
||||
bestScore = score;
|
||||
bestLat = lat;
|
||||
}
|
||||
}
|
||||
|
||||
rawLats[i] = bestLat;
|
||||
}
|
||||
|
||||
// Pull extreme outliers toward the zonal mean before longitude smoothing.
|
||||
// The ITCZ is a planetary-scale feature — individual longitude columns
|
||||
// shouldn't deviate too far from the overall trend.
|
||||
const lats = new Float64Array(rawLats);
|
||||
const tmp = new Float64Array(NUM_LON);
|
||||
// Wide periodic moving average (kernel = 5 neighbors) for heavy smoothing,
|
||||
// then narrow (kernel = 3) for fine cleanup. More passes = smoother ITCZ.
|
||||
// Wide kernel: weights [0.1, 0.2, 0.4, 0.2, 0.1] over 5 neighbors
|
||||
for (let pass = 0; pass < 4; pass++) {
|
||||
for (let i = 0; i < NUM_LON; i++) {
|
||||
const p2 = (i - 2 + NUM_LON) % NUM_LON;
|
||||
const p1 = (i - 1 + NUM_LON) % NUM_LON;
|
||||
const n1 = (i + 1) % NUM_LON;
|
||||
const n2 = (i + 2) % NUM_LON;
|
||||
tmp[i] = 0.1 * lats[p2] + 0.2 * lats[p1] + 0.4 * lats[i] + 0.2 * lats[n1] + 0.1 * lats[n2];
|
||||
}
|
||||
lats.set(tmp);
|
||||
}
|
||||
// Narrow cleanup passes
|
||||
for (let pass = 0; pass < 3; pass++) {
|
||||
for (let i = 0; i < NUM_LON; i++) {
|
||||
const p = (i - 1 + NUM_LON) % NUM_LON;
|
||||
const n = (i + 1) % NUM_LON;
|
||||
tmp[i] = 0.25 * lats[p] + 0.5 * lats[i] + 0.25 * lats[n];
|
||||
}
|
||||
lats.set(tmp);
|
||||
}
|
||||
|
||||
// Clamp to ±30° (ITCZ never migrates beyond the tropics)
|
||||
for (let i = 0; i < NUM_LON; i++) {
|
||||
lats[i] = Math.max(-30 * DEG, Math.min(30 * DEG, lats[i]));
|
||||
}
|
||||
|
||||
const spline = buildPeriodicSpline(lons, lats);
|
||||
return { spline, lons, lats };
|
||||
}
|
||||
|
||||
// ── Pressure field ───────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Compute pressure at a single region.
|
||||
*/
|
||||
function regionPressure(lat, lon, itczSpline, season, landFrac, elevation, noiseFn, px, py, pz) {
|
||||
const itczLat = evaluateSpline(itczSpline, lon);
|
||||
const latDeg = lat * RAD;
|
||||
const seasonSign = season === 'summer' ? 1 : -1;
|
||||
|
||||
let p = 1013; // baseline hPa
|
||||
|
||||
// (a) ITCZ low — follows thermal equator
|
||||
const dItcz = (lat - itczLat) * RAD; // degrees from ITCZ
|
||||
p -= 15 * Math.exp(-0.5 * (dItcz / 8) ** 2);
|
||||
|
||||
// (b) Subtropical highs — shift with season, weaker over hot land
|
||||
const shiftDeg = seasonSign * 5;
|
||||
const nhSubHigh = 30 + shiftDeg;
|
||||
const shSubHigh = -(30 - shiftDeg);
|
||||
const highIntensity = 12 * (1 - 0.3 * landFrac);
|
||||
p += highIntensity * Math.exp(-0.5 * ((latDeg - nhSubHigh) / 10) ** 2);
|
||||
p += highIntensity * Math.exp(-0.5 * ((latDeg - shSubHigh) / 10) ** 2);
|
||||
|
||||
// (c) Subpolar lows
|
||||
p -= 10 * Math.exp(-0.5 * ((latDeg - 60) / 10) ** 2);
|
||||
p -= 10 * Math.exp(-0.5 * ((latDeg + 60) / 10) ** 2);
|
||||
|
||||
// (d) Polar highs
|
||||
p += 8 * Math.exp(-0.5 * ((latDeg - 85) / 8) ** 2);
|
||||
p += 8 * Math.exp(-0.5 * ((latDeg + 85) / 8) ** 2);
|
||||
|
||||
// (e) Land/sea thermal modifier
|
||||
// landFrac here is actually continentality (0 at coast → ~1 deep interior).
|
||||
// Only continental-scale landmasses produce meaningful thermal pressure:
|
||||
// small islands (continentality < 0.2) → 0, ramps to full at 0.5+.
|
||||
const continentalScale = smoothstep(0.2, 0.5, landFrac);
|
||||
if (continentalScale > 0.001) {
|
||||
// Continental thermal effect profile:
|
||||
// 0 at 0-15°, rises to ~0.75 at 30°, plateau ~1.0 at 45-60°, falls to ~0.5 at 75°, 0 at 90°
|
||||
const absLatDeg = Math.abs(lat) * RAD;
|
||||
const latFactor = absLatDeg < 15 ? 0
|
||||
: absLatDeg < 30 ? 0.75 * smoothstep(15, 30, absLatDeg)
|
||||
: absLatDeg < 45 ? 0.75 + 0.25 * smoothstep(30, 45, absLatDeg)
|
||||
: absLatDeg < 60 ? 1
|
||||
: absLatDeg < 90 ? smoothstep(90, 60, absLatDeg)
|
||||
: 0;
|
||||
const isSummerHemisphere = (seasonSign > 0 && lat > 0) || (seasonSign < 0 && lat < 0);
|
||||
if (isSummerHemisphere) {
|
||||
// Thermal low over hot continent
|
||||
p -= 10 * latFactor * continentalScale;
|
||||
} else {
|
||||
// Thermal high over cold continent (stronger — Siberian/Canadian highs)
|
||||
p += 14 * latFactor * continentalScale;
|
||||
}
|
||||
}
|
||||
|
||||
// (f) Elevation (barometric) — mild effect; real weather maps use
|
||||
// sea-level-reduced pressure so elevation doesn't dominate zonal bands
|
||||
p -= 3 * elevToHeightKm(Math.max(0, elevation));
|
||||
|
||||
// (g) Noise perturbation
|
||||
if (noiseFn) {
|
||||
p += noiseFn.fbm(px * 2, py * 2, pz * 2, 3) * 2;
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
// ── Pressure gradient on mesh ────────────────────────────────────────────────
|
||||
|
||||
export function computeGradients(mesh, r_xyz, r_pressure,
|
||||
r_eastX, r_eastY, r_eastZ, r_northX, r_northY, r_northZ,
|
||||
r_gradE, r_gradN) {
|
||||
const { adjOffset, adjList, numRegions } = mesh;
|
||||
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
const px = r_xyz[3 * r], py = r_xyz[3 * r + 1], pz = r_xyz[3 * r + 2];
|
||||
const ex = r_eastX[r], ey = r_eastY[r], ez = r_eastZ[r];
|
||||
const nx = r_northX[r], ny = r_northY[r], nz = r_northZ[r];
|
||||
const pHere = r_pressure[r];
|
||||
|
||||
let sumEP = 0, sumEE = 0, sumNP = 0, sumNN = 0;
|
||||
const end = adjOffset[r + 1];
|
||||
|
||||
for (let ni = adjOffset[r]; ni < end; ni++) {
|
||||
const nb = adjList[ni];
|
||||
const dx = r_xyz[3 * nb] - px;
|
||||
const dy = r_xyz[3 * nb + 1] - py;
|
||||
const dz = r_xyz[3 * nb + 2] - pz;
|
||||
|
||||
const de = dx * ex + dy * ey + dz * ez;
|
||||
const dn = dx * nx + dy * ny + dz * nz;
|
||||
const dp = r_pressure[nb] - pHere;
|
||||
|
||||
sumEP += de * dp;
|
||||
sumEE += de * de;
|
||||
sumNP += dn * dp;
|
||||
sumNN += dn * dn;
|
||||
}
|
||||
|
||||
r_gradE[r] = sumEE > 1e-12 ? sumEP / sumEE : 0;
|
||||
r_gradN[r] = sumNN > 1e-12 ? sumNP / sumNN : 0;
|
||||
}
|
||||
}
|
||||
|
||||
// ── Pressure gradient → wind ─────────────────────────────────────────────────
|
||||
|
||||
function pressureToWind(r_gradE, r_gradN, r_sinLat,
|
||||
r_windE, r_windN, r_windSpeed, numRegions) {
|
||||
const sin5 = Math.sin(5 * DEG);
|
||||
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
// PGF: from high to low = negative gradient
|
||||
const pgfE = -r_gradE[r];
|
||||
const pgfN = -r_gradN[r];
|
||||
|
||||
const sinLat = r_sinLat[r];
|
||||
const absSinLat = Math.abs(sinLat);
|
||||
|
||||
// Geostrophic deflection: 0° at equator → 70° at ≥5° latitude
|
||||
const geoAngle = 70 * DEG * smoothstep(0, sin5, absSinLat);
|
||||
|
||||
// Surface friction turns wind 20° back toward low pressure
|
||||
const frictionAngle = 20 * DEG;
|
||||
|
||||
// Net rotation: NH = clockwise (negative), SH = counterclockwise (positive)
|
||||
// The rotation matrix [cosθ,-sinθ; sinθ,cosθ] is counterclockwise for +θ,
|
||||
// so NH right-deflection needs negative angle, SH left-deflection needs positive.
|
||||
const sign = sinLat >= 0 ? -1 : 1;
|
||||
const totalAngle = sign * (geoAngle - frictionAngle);
|
||||
|
||||
const cosA = Math.cos(totalAngle);
|
||||
const sinA = Math.sin(totalAngle);
|
||||
|
||||
// Rotate PGF vector and apply friction speed reduction
|
||||
const we = (pgfE * cosA - pgfN * sinA) * 0.6;
|
||||
const wn = (pgfE * sinA + pgfN * cosA) * 0.6;
|
||||
|
||||
r_windE[r] = we;
|
||||
r_windN[r] = wn;
|
||||
r_windSpeed[r] = Math.sqrt(we * we + wn * wn);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Main entry point ─────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Compute seasonal pressure fields and wind vectors.
|
||||
*
|
||||
* @param {SphereMesh} mesh
|
||||
* @param {Float32Array} r_xyz - per-region 3D positions (3 * numRegions)
|
||||
* @param {Float32Array} r_elevation - per-region elevation
|
||||
* @param {Set} plateIsOcean - ocean plate seed set
|
||||
* @param {Int32Array} r_plate - per-region plate ID
|
||||
* @param {SimplexNoise} noise - seeded noise instance
|
||||
* @param {number} [axialTilt=23.5] - axial tilt in degrees
|
||||
* @returns {object} pressure and wind arrays for both seasons
|
||||
*/
|
||||
export function computeWind(mesh, r_xyz, r_elevation, plateIsOcean, r_plate, noise, axialTilt = 23.5) {
|
||||
const numRegions = mesh.numRegions;
|
||||
const avgEdgeKm = (Math.PI * 6371) / Math.sqrt(numRegions);
|
||||
const tiltRad = axialTilt * DEG;
|
||||
const timing = [];
|
||||
|
||||
// ── Step 0: Precompute per-region properties ──
|
||||
|
||||
let t0 = performance.now();
|
||||
|
||||
const r_lat = new Float32Array(numRegions);
|
||||
const r_lon = new Float32Array(numRegions);
|
||||
const r_sinLat = new Float32Array(numRegions);
|
||||
const r_cosLat = new Float32Array(numRegions);
|
||||
const r_isLand = new Uint8Array(numRegions);
|
||||
|
||||
// Tangent frame arrays
|
||||
const r_eastX = new Float32Array(numRegions);
|
||||
const r_eastY = new Float32Array(numRegions);
|
||||
const r_eastZ = new Float32Array(numRegions);
|
||||
const r_northX = new Float32Array(numRegions);
|
||||
const r_northY = new Float32Array(numRegions);
|
||||
const r_northZ = new Float32Array(numRegions);
|
||||
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
const x = r_xyz[3 * r], y = r_xyz[3 * r + 1], z = r_xyz[3 * r + 2];
|
||||
|
||||
// Y-up convention (matches map projection)
|
||||
r_lat[r] = Math.asin(Math.max(-1, Math.min(1, y)));
|
||||
r_lon[r] = Math.atan2(x, z);
|
||||
r_sinLat[r] = y;
|
||||
r_cosLat[r] = Math.sqrt(1 - y * y) || 0.01;
|
||||
r_isLand[r] = r_elevation[r] > 0 ? 1 : 0;
|
||||
|
||||
// East = normalize(Ŷ × P) = normalize(z, 0, -x)
|
||||
let ex = z, ey = 0, ez = -x;
|
||||
let elen = Math.sqrt(ex * ex + ez * ez);
|
||||
if (elen < 1e-10) { ex = 1; ez = 0; elen = 1; } // pole fallback
|
||||
ex /= elen; ez /= elen;
|
||||
|
||||
// North = P × East
|
||||
let nx = y * ez - z * ey;
|
||||
let ny = z * ex - x * ez;
|
||||
let nz = x * ey - y * ex;
|
||||
const nlen = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
|
||||
nx /= nlen; ny /= nlen; nz /= nlen;
|
||||
|
||||
r_eastX[r] = ex; r_eastY[r] = ey; r_eastZ[r] = ez;
|
||||
r_northX[r] = nx; r_northY[r] = ny; r_northZ[r] = nz;
|
||||
}
|
||||
|
||||
timing.push({ stage: 'Wind: precompute lat/lon/tangent', ms: performance.now() - t0 });
|
||||
|
||||
// ── Step 1: Build geographic index + compute ITCZ ──
|
||||
|
||||
t0 = performance.now();
|
||||
const geoSample = buildGeoIndex(r_lat, r_lon, r_sinLat, r_cosLat, r_elevation, r_isLand, numRegions);
|
||||
const itczSummer = computeITCZ(geoSample, 'summer', tiltRad);
|
||||
const itczWinter = computeITCZ(geoSample, 'winter', tiltRad);
|
||||
timing.push({ stage: 'Wind: ITCZ computation', ms: performance.now() - t0 });
|
||||
|
||||
// ── Step 2–5: Compute pressure & wind for each season ──
|
||||
|
||||
const seasons = [
|
||||
{ name: 'summer', itcz: itczSummer },
|
||||
{ name: 'winter', itcz: itczWinter }
|
||||
];
|
||||
|
||||
const result = {};
|
||||
|
||||
// Precompute continentality via BFS coast distance.
|
||||
// Laplacian smoothing of binary r_isLand converges too fast — interior
|
||||
// cells hit 0.95+ within a few hundred km. Instead, compute actual
|
||||
// hop distance from coast through land, convert to km, and map with
|
||||
// smoothstep for a wide, tunable gradient.
|
||||
// 0 km (coast): cont ≈ 0.0
|
||||
// 500 km: cont ≈ 0.16
|
||||
// 1000 km: cont ≈ 0.50
|
||||
// 1500 km: cont ≈ 0.84
|
||||
// 2000 km+: cont ≈ 1.0
|
||||
// Ocean cells near coast get a small value (~0.05–0.15) via a few
|
||||
// smoothing passes, giving a natural land/sea thermal gradient.
|
||||
t0 = performance.now();
|
||||
const { adjOffset, adjList } = mesh;
|
||||
|
||||
// Find the main ocean: largest connected component of non-land cells.
|
||||
// Inland seas / small lakes don't count as "ocean" for continentality.
|
||||
const r_oceanLabel = new Int32Array(numRegions);
|
||||
r_oceanLabel.fill(-1);
|
||||
let mainOceanLabel = -1, mainOceanSize = 0;
|
||||
let nextLabel = 0;
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
if (r_isLand[r] || r_oceanLabel[r] >= 0) continue;
|
||||
const label = nextLabel++;
|
||||
let size = 0;
|
||||
const floodQueue = [r];
|
||||
r_oceanLabel[r] = label;
|
||||
let fHead = 0;
|
||||
while (fHead < floodQueue.length) {
|
||||
const cur = floodQueue[fHead++];
|
||||
size++;
|
||||
const end = adjOffset[cur + 1];
|
||||
for (let ni = adjOffset[cur]; ni < end; ni++) {
|
||||
const nb = adjList[ni];
|
||||
if (!r_isLand[nb] && r_oceanLabel[nb] === -1) {
|
||||
r_oceanLabel[nb] = label;
|
||||
floodQueue.push(nb);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (size > mainOceanSize) {
|
||||
mainOceanSize = size;
|
||||
mainOceanLabel = label;
|
||||
}
|
||||
}
|
||||
|
||||
// BFS coast distance through land, seeded only from main-ocean coastline
|
||||
const r_coastDist = new Int32Array(numRegions);
|
||||
r_coastDist.fill(-1);
|
||||
const bfsQueue = [];
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
if (!r_isLand[r]) continue;
|
||||
const end = adjOffset[r + 1];
|
||||
for (let ni = adjOffset[r]; ni < end; ni++) {
|
||||
const nb = adjList[ni];
|
||||
if (!r_isLand[nb] && r_oceanLabel[nb] === mainOceanLabel) {
|
||||
r_coastDist[r] = 0;
|
||||
bfsQueue.push(r);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
let head = 0;
|
||||
while (head < bfsQueue.length) {
|
||||
const r = bfsQueue[head++];
|
||||
const d = r_coastDist[r] + 1;
|
||||
const end = adjOffset[r + 1];
|
||||
for (let ni = adjOffset[r]; ni < end; ni++) {
|
||||
const nb = adjList[ni];
|
||||
if (r_isLand[nb] && r_coastDist[nb] === -1) {
|
||||
r_coastDist[nb] = d;
|
||||
bfsQueue.push(nb);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Map BFS distance to continentality [0, 1]
|
||||
const CONT_RANGE_KM = 2000; // distance at which cont reaches ~1.0
|
||||
const r_continentality = new Float32Array(numRegions);
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
if (r_isLand[r] && r_coastDist[r] >= 0) {
|
||||
const distKm = r_coastDist[r] * avgEdgeKm;
|
||||
r_continentality[r] = smoothstep(0, CONT_RANGE_KM, distKm);
|
||||
}
|
||||
// Ocean cells stay at 0; a few smooth passes below will bleed
|
||||
// small values onto nearshore ocean for thermal gradient.
|
||||
}
|
||||
// Light smoothing (~100 km) to soften BFS stepping artifacts and
|
||||
// bleed a small thermal signal onto nearshore ocean cells.
|
||||
const contSmoothPasses = Math.max(1, Math.round(100 / avgEdgeKm));
|
||||
smoothField(mesh, r_continentality, contSmoothPasses);
|
||||
|
||||
// Plate-based continentality: uses plate type (continental vs oceanic)
|
||||
// instead of actual land/ocean. Same BFS approach for wide gradient.
|
||||
const r_plateContinentality = new Float32Array(numRegions);
|
||||
// BFS through continental-plate cells
|
||||
const r_plateDist = new Int32Array(numRegions);
|
||||
r_plateDist.fill(-1);
|
||||
const plateBfsQueue = [];
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
if (plateIsOcean.has(r_plate[r])) continue; // skip oceanic plate cells
|
||||
const end = adjOffset[r + 1];
|
||||
for (let ni = adjOffset[r]; ni < end; ni++) {
|
||||
if (plateIsOcean.has(r_plate[adjList[ni]])) {
|
||||
r_plateDist[r] = 0;
|
||||
plateBfsQueue.push(r);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
head = 0;
|
||||
while (head < plateBfsQueue.length) {
|
||||
const r = plateBfsQueue[head++];
|
||||
const d = r_plateDist[r] + 1;
|
||||
const end = adjOffset[r + 1];
|
||||
for (let ni = adjOffset[r]; ni < end; ni++) {
|
||||
const nb = adjList[ni];
|
||||
if (!plateIsOcean.has(r_plate[nb]) && r_plateDist[nb] === -1) {
|
||||
r_plateDist[nb] = d;
|
||||
plateBfsQueue.push(nb);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
if (!plateIsOcean.has(r_plate[r]) && r_plateDist[r] >= 0) {
|
||||
const distKm = r_plateDist[r] * avgEdgeKm;
|
||||
r_plateContinentality[r] = smoothstep(0, CONT_RANGE_KM, distKm);
|
||||
}
|
||||
}
|
||||
smoothField(mesh, r_plateContinentality, contSmoothPasses);
|
||||
timing.push({ stage: 'Wind: continentality BFS', ms: performance.now() - t0 });
|
||||
|
||||
// Shared gradient scratch arrays
|
||||
const r_gradE = new Float32Array(numRegions);
|
||||
const r_gradN = new Float32Array(numRegions);
|
||||
|
||||
// Smooth pressure field ~75 km (scale-invariant) — constant across seasons
|
||||
const pressSmoothPasses = Math.max(1, Math.round(75 / avgEdgeKm));
|
||||
|
||||
for (const { name, itcz } of seasons) {
|
||||
// Step 2: Pressure field
|
||||
t0 = performance.now();
|
||||
const r_pressure = new Float32Array(numRegions);
|
||||
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
r_pressure[r] = regionPressure(
|
||||
r_lat[r], r_lon[r], itcz.spline, name,
|
||||
r_continentality[r], r_elevation[r], noise,
|
||||
r_xyz[3 * r], r_xyz[3 * r + 1], r_xyz[3 * r + 2]
|
||||
);
|
||||
}
|
||||
smoothField(mesh, r_pressure, pressSmoothPasses);
|
||||
timing.push({ stage: `Wind: pressure field (${name})`, ms: performance.now() - t0 });
|
||||
|
||||
// Step 3: Gradient
|
||||
t0 = performance.now();
|
||||
r_gradE.fill(0);
|
||||
r_gradN.fill(0);
|
||||
computeGradients(mesh, r_xyz, r_pressure,
|
||||
r_eastX, r_eastY, r_eastZ, r_northX, r_northY, r_northZ,
|
||||
r_gradE, r_gradN);
|
||||
timing.push({ stage: `Wind: gradient (${name})`, ms: performance.now() - t0 });
|
||||
|
||||
// Step 4: Wind
|
||||
t0 = performance.now();
|
||||
const r_windE = new Float32Array(numRegions);
|
||||
const r_windN = new Float32Array(numRegions);
|
||||
const r_windSpeed = new Float32Array(numRegions);
|
||||
pressureToWind(r_gradE, r_gradN, r_sinLat,
|
||||
r_windE, r_windN, r_windSpeed, numRegions);
|
||||
|
||||
// Step 5: Normalize wind speed to 0-1
|
||||
const maxSpeed = percentile(r_windSpeed, 0.95);
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
r_windSpeed[r] = Math.min(1, r_windSpeed[r] / maxSpeed);
|
||||
}
|
||||
timing.push({ stage: `Wind: pressure→wind (${name})`, ms: performance.now() - t0 });
|
||||
|
||||
// Store pressure as deviation from 1013 for visualization (blue=low, red=high)
|
||||
const r_pressureDev = new Float32Array(numRegions);
|
||||
for (let r = 0; r < numRegions; r++) {
|
||||
r_pressureDev[r] = r_pressure[r] - 1013;
|
||||
}
|
||||
|
||||
const S = name === 'summer' ? 'Summer' : 'Winter';
|
||||
result[`r_pressure_${name}`] = r_pressureDev;
|
||||
result[`r_wind_east_${name}`] = r_windE;
|
||||
result[`r_wind_north_${name}`] = r_windN;
|
||||
result[`r_wind_speed_${name}`] = r_windSpeed;
|
||||
}
|
||||
|
||||
// Pre-evaluate ITCZ splines at 360 longitude points for visualization
|
||||
const ITCZ_SAMPLES = 360;
|
||||
const itczLons = new Float32Array(ITCZ_SAMPLES);
|
||||
const itczLatsSummer = new Float32Array(ITCZ_SAMPLES);
|
||||
const itczLatsWinter = new Float32Array(ITCZ_SAMPLES);
|
||||
for (let i = 0; i < ITCZ_SAMPLES; i++) {
|
||||
const lon = -Math.PI + (i + 0.5) * (2 * Math.PI / ITCZ_SAMPLES);
|
||||
itczLons[i] = lon;
|
||||
itczLatsSummer[i] = evaluateSpline(itczSummer.spline, lon);
|
||||
itczLatsWinter[i] = evaluateSpline(itczWinter.spline, lon);
|
||||
}
|
||||
result.itczLons = itczLons;
|
||||
result.itczLatsSummer = itczLatsSummer;
|
||||
result.itczLatsWinter = itczLatsWinter;
|
||||
|
||||
// Expose precomputed geographic data for downstream modules (ocean.js)
|
||||
result.r_lat = r_lat;
|
||||
result.r_lon = r_lon;
|
||||
result.r_sinLat = r_sinLat;
|
||||
result.r_isLand = r_isLand;
|
||||
result.r_continentality = r_continentality;
|
||||
result.r_coastDistLand = r_coastDist;
|
||||
result.r_plateContinentality = r_plateContinentality;
|
||||
result.r_eastX = r_eastX;
|
||||
result.r_eastY = r_eastY;
|
||||
result.r_eastZ = r_eastZ;
|
||||
result.r_northX = r_northX;
|
||||
result.r_northY = r_northY;
|
||||
result.r_northZ = r_northZ;
|
||||
|
||||
result._windTiming = timing;
|
||||
return result;
|
||||
}
|
||||
Reference in New Issue
Block a user