Tooling

Tools/Orogen/js/temperature.js

@@ -0,0 +1,239 @@
+// Temperature simulation: computes per-region surface temperature for summer
+// and winter seasons based on ITCZ position, continentality, moisture-dependent
+// elevation lapse rate (dry adiabatic 9.3 C/km to moist adiabatic 4.5 C/km),
+// ocean current warmth, and precipitation/cloud cover moderation.
+// Returns normalized 0-1 values mapped to a fixed -45 to +45 C range.
+
+import { smoothstep } from './wind.js';
+import { elevToHeightKm } from './color-map.js';
+import { smoothField, makeItczLookup } from './climate-util.js';
+
+const DEG = Math.PI / 180;
+
+// ── Diffuse ocean warmth onto nearby coastal land ───────────────────────────
+// Uses plate-based continentality so that warmth spreads freely across
+// shallow continental-shelf ocean and penetrates further inland. Ocean cells
+// on continental plates (shallow seas) inherit warmth from nearby oceanic-
+// plate cells first, then the warmth diffuses onto land.
+
+function diffuseOceanWarmth(mesh, r_oceanWarmth, r_isLand, r_plateContinentality, passes) {
+    const { adjOffset, adjList, numRegions } = mesh;
+    const coastal = new Float32Array(numRegions);
+
+    // Seed: all ocean cells contribute their warmth directly.
+    // Continental-shelf ocean cells may have weak/no current warmth;
+    // they'll pick up values from nearby oceanic-plate neighbors via diffusion.
+    for (let r = 0; r < numRegions; r++) {
+        if (!r_isLand[r]) {
+            coastal[r] = r_oceanWarmth ? r_oceanWarmth[r] : 0;
+        }
+    }
+
+    const tmp = new Float32Array(numRegions);
+    for (let pass = 0; pass < passes; pass++) {
+        tmp.set(coastal);
+        for (let r = 0; r < numRegions; r++) {
+            // Skip deep-interior continental cells (plate-based)
+            if (r_plateContinentality && r_plateContinentality[r] >= 0.95) continue;
+
+            // Ocean cells also participate in diffusion so continental-shelf
+            // cells inherit warmth from nearby open-ocean neighbors
+            let sum = coastal[r];
+            let count = 1;
+            const end = adjOffset[r + 1];
+            for (let ni = adjOffset[r]; ni < end; ni++) {
+                sum += coastal[adjList[ni]];
+                count++;
+            }
+            tmp[r] = sum / count;
+        }
+        coastal.set(tmp);
+    }
+
+    return coastal;
+}
+
+// ── Main entry point ────────────────────────────────────────────────────────
+
+/**
+ * Compute seasonal temperature fields.
+ *
+ * @param {SphereMesh} mesh
+ * @param {Float32Array} r_xyz - per-region 3D positions
+ * @param {Float32Array} r_elevation - per-region elevation
+ * @param {object} windResult - output from computeWind()
+ * @param {object} oceanResult - output from computeOceanCurrents()
+ * @param {object} precipResult - output from computePrecipitation()
+ * @returns {{ r_temperature_summer, r_temperature_winter, _tempTiming }}
+ */
+export function computeTemperature(mesh, r_xyz, r_elevation, windResult, oceanResult, precipResult, temperatureOffset = 0) {
+    const numRegions = mesh.numRegions;
+    const timing = [];
+
+    const { r_lat, r_lon, r_isLand, r_continentality, r_plateContinentality } = windResult;
+
+    // Minimal smoothing: 1 pass just to blend cell-to-cell noise
+    const smoothPasses = 1;
+
+    const T_MIN = -45;
+    const T_MAX = 45;
+    const T_RANGE = T_MAX - T_MIN;
+
+    const result = {};
+
+    // Pre-compute constants shared across seasons
+    const avgEdgeKm = (Math.PI * 6371) / Math.sqrt(numRegions);
+    const oceanWarmthPasses = Math.max(4, Math.round(1400 / avgEdgeKm));
+    const plateCont = r_plateContinentality || r_continentality;
+
+    const seasons = ['summer', 'winter'];
+
+    for (const name of seasons) {
+        const t0 = performance.now();
+
+        const r_oceanWarmth = oceanResult[`r_ocean_warmth_${name}`];
+        const r_oceanSpeed = oceanResult[`r_ocean_speed_${name}`];
+        const r_precip = precipResult[`r_precip_${name}`];
+
+        const itczLookup = makeItczLookup(windResult.itczLons,
+            name === 'summer' ? windResult.itczLatsSummer : windResult.itczLatsWinter);
+
+        // Pre-compute diffused ocean warmth for coastal land influence
+        // Use plate-based continentality for diffusion so warmth crosses
+        // continental shelves and reaches further inland
+        const coastalWarmth = diffuseOceanWarmth(mesh, r_oceanWarmth, r_isLand, plateCont, oceanWarmthPasses);
+
+        const temp = new Float32Array(numRegions);
+
+        for (let r = 0; r < numRegions; r++) {
+            const lat = r_lat[r];
+            const lon = r_lon[r];
+            const latDeg = lat / DEG;
+            const isLand = r_isLand[r];
+            const elev = r_elevation[r];
+            const cont = r_continentality ? r_continentality[r] : 0;
+            const pCont = r_plateContinentality ? r_plateContinentality[r] : cont;
+
+            // ── 1. Base temperature from thermal equator (ITCZ) ──
+            // Two curves blended by absolute latitude:
+            //  - T_itcz: based on distance from the actual (land-warped) ITCZ
+            //  - T_flat: based on distance from a fixed ITCZ at ±5° (ocean default)
+            // Near the tropics the real ITCZ matters; at high latitudes the
+            // ITCZ position is irrelevant and a stable zonal baseline takes over.
+            const tropicalHW = 13;  // flat plateau half-width (degrees)
+            const maxDist = 90 - tropicalHW;
+
+            // Actual ITCZ curve
+            const itczLat = itczLookup(lon);
+            const distItcz = Math.abs(lat - itczLat) / DEG;
+            const tItcz = Math.max(0, distItcz - tropicalHW) / maxDist;
+            const T_itcz = 28 - 47 * Math.pow(tItcz, 1.4);
+
+            // Flat reference curve (ITCZ at 5° in summer hemisphere)
+            const flatItczLat = (name === 'summer' ? 5 : -5) * DEG;
+            const distFlat = Math.abs(lat - flatItczLat) / DEG;
+            const tFlat = Math.max(0, distFlat - tropicalHW) / maxDist;
+            const T_flat = 28 - 47 * Math.pow(tFlat, 1.4);
+
+            // Blend: ITCZ curve dominates tropics, flat curve dominates poles
+            const absLatDeg = Math.abs(lat) / DEG;
+            const blend = smoothstep(45, 90, absLatDeg);
+            let T = T_itcz * (1 - blend) + T_flat * blend;
+
+            // ── 2. Elevation lapse rate ──
+            // Moisture-dependent: dry air cools at ~9.8 C/km (dry adiabatic),
+            // saturated air at ~5 C/km (moist adiabatic) due to latent heat
+            // release. Use precipitation as a moisture proxy to interpolate.
+            const moisture = r_precip ? r_precip[r] : 0.5;
+            const lapse = 4.5 + 4.8 * (1 - moisture); // 4.5 C/km (wet) to 9.3 C/km (dry)
+            if (isLand && elev > 0) {
+                T -= lapse * elevToHeightKm(elev);
+            }
+
+            // ── 5. Ocean current temperature influence ──
+            if (!isLand && r_oceanWarmth && r_oceanSpeed) {
+                // Direct ocean effect: warm/cold currents shift SST
+                const warmth = r_oceanWarmth[r];
+                const speed = r_oceanSpeed[r];
+                T += warmth * Math.min(1, speed * 2) * 16;
+            } else if (isLand) {
+                // Coastal land: diffused ocean warmth fades with plate-based
+                // continentality so the effect reaches further inland and
+                // crosses continental shelves naturally
+                const cw = coastalWarmth[r];
+                if (Math.abs(cw) > 0.001) {
+                    T += cw * (1 - smoothstep(0, 0.95, pCont)) * 20;
+                }
+            }
+
+            // ── 6. Precipitation / cloud cover moderation ──
+            if (r_precip) {
+                const p = r_precip[r];
+                if (p > 0.5) {
+                    // High precip → clouds → moderate toward latitude baseline
+                    const mod = smoothstep(0.5, 1.0, p) * 0.15;
+                    // Pull toward 0 (moderate extremes)
+                    T *= (1 - mod);
+                } else if (p < 0.3) {
+                    // Low precip → clear skies → amplify extremes
+                    const amp = smoothstep(0.3, 0.0, p) * 0.15;
+                    T *= (1 + amp);
+                }
+            }
+
+            // ── 7. Maritime / continental moderation ──
+            // Ocean has high thermal inertia: coasts and small islands have
+            // smaller seasonal temperature swings (moderate climate), while
+            // continental interiors get more extreme summers and winters.
+            // Compute an annual-mean baseline (ITCZ at equator, no seasonal
+            // shift) and scale the seasonal deviation by continentality.
+            {
+                const distAnn = Math.abs(lat) / DEG; // distance from equator
+                const tAnn = Math.max(0, distAnn - tropicalHW) / maxDist;
+                const T_annual = 28 - 47 * Math.pow(tAnn, 1.4);  // match new curve
+                // Apply same moisture-dependent lapse to annual baseline
+                const T_ann_adj = isLand && elev > 0
+                    ? T_annual - lapse * elevToHeightKm(elev)
+                    : T_annual;
+                const deviation = T - T_ann_adj;
+                // Latitude-dependent seasonal boost: ITCZ shift alone gives ~5-6°C
+                // swing; real planets have 15-25°C from direct solar heating.
+                // Peaks at 55-75° latitude, zero at equator and poles.
+                const seasonalBoost = 12 * smoothstep(10, 55, distAnn)
+                                         * (1 - smoothstep(75, 90, distAnn));
+                const isLocalSummer = (name === 'summer') ? (lat >= 0) : (lat < 0);
+                const seasonSign = isLocalSummer ? 1 : -1;
+                const boostedDeviation = deviation + seasonSign * seasonalBoost;
+                // Maritime: coast damps swing to 50%, deep interior amplifies to 120%
+                const maritimeFactor = 0.50 + cont * 0.70;
+                T = T_ann_adj + boostedDeviation * maritimeFactor;
+            }
+
+            T += temperatureOffset;
+            temp[r] = T;
+        }
+
+        const tCompute = performance.now() - t0;
+
+        // ── 7. Laplacian smoothing ──
+        const tSmooth0 = performance.now();
+        smoothField(mesh, temp, smoothPasses);
+        const tSmooth = performance.now() - tSmooth0;
+
+        // ── 8. Normalize to 0-1 using fixed range ──
+        const tNorm0 = performance.now();
+        for (let r = 0; r < numRegions; r++) {
+            temp[r] = Math.max(0, Math.min(1, (temp[r] - T_MIN) / T_RANGE));
+        }
+        const tNorm = performance.now() - tNorm0;
+
+        timing.push({ stage: `Temp: compute (${name})`, ms: tCompute });
+        timing.push({ stage: `Temp: smooth (${name})`, ms: tSmooth });
+        timing.push({ stage: `Temp: normalize (${name})`, ms: tNorm });
+
+        result[`r_temperature_${name}`] = temp;
+    }
+
+    result._tempTiming = timing;
+    return result;
+}