@jjlmoya/utils-science 1.36.0 → 1.38.0

package/src/tool/dyson-sphere-energy-capture/index.ts

@@ -0,0 +1,11 @@
+import { dysonSphereEnergyCapture } from './entry';
+import type { ToolDefinition } from '../../types';
+
+export * from './entry';
+
+export const DYSON_SPHERE_ENERGY_CAPTURE_TOOL: ToolDefinition = {
+  entry: dysonSphereEnergyCapture,
+  Component: () => import('./component.astro'),
+  SEOComponent: () => import('./seo.astro'),
+  BibliographyComponent: () => import('./bibliography.astro'),
+};

package/src/tool/dyson-sphere-energy-capture/logic.ts

@@ -0,0 +1,120 @@
+export type StarType = 'm-dwarf' | 'sun' | 'a-star' | 'red-giant' | 'blue-giant';
+export type StructureType = 'swarm' | 'ring' | 'shell' | 'statite-cloud';
+
+export interface StarPreset {
+  id: StarType;
+  name: string;
+  luminositySolar: number;
+  massSolar: number;
+  radiusSolar: number;
+  temperatureK: number;
+}
+
+export interface StructurePreset {
+  id: StructureType;
+  name: string;
+  coverageEfficiency: number;
+  arealDensityKgM2: number;
+  thermalLimitK: number;
+  stabilityFactor: number;
+}
+
+export interface DysonInput {
+  star: StarType;
+  structure: StructureType;
+  coveragePercent: number;
+  operatingTempK: number;
+  kardashevTarget: number;
+}
+
+export interface DysonResult {
+  luminosityWatts: number;
+  capturedWatts: number;
+  optimalRadiusAu: number;
+  orbitalPeriodDays: number;
+  collectorAreaM2: number;
+  materialMassKg: number;
+  mercuryMasses: number;
+  earthMasses: number;
+  kardashevRating: number;
+  targetCoveragePercent: number;
+  status: 'underbuilt' | 'balanced' | 'extreme';
+}
+
+const SOLAR_LUMINOSITY_W = 3.828e26;
+const SOLAR_MASS_KG = 1.98847e30;
+const AU_M = 1.495978707e11;
+const STEFAN_BOLTZMANN = 5.670374419e-8;
+const MERCURY_MASS_KG = 3.3011e23;
+const EARTH_MASS_KG = 5.9722e24;
+const DAY_SECONDS = 86400;
+const GRAVITATIONAL_CONSTANT = 6.6743e-11;
+
+export const STAR_PRESETS: StarPreset[] = [
+  { id: 'm-dwarf', name: 'M dwarf', luminositySolar: 0.035, massSolar: 0.35, radiusSolar: 0.42, temperatureK: 3400 },
+  { id: 'sun', name: 'Sun-like G star', luminositySolar: 1, massSolar: 1, radiusSolar: 1, temperatureK: 5772 },
+  { id: 'a-star', name: 'A-type main sequence', luminositySolar: 25, massSolar: 2.1, radiusSolar: 1.9, temperatureK: 9000 },
+  { id: 'red-giant', name: 'Red giant', luminositySolar: 900, massSolar: 1.5, radiusSolar: 60, temperatureK: 3800 },
+  { id: 'blue-giant', name: 'Blue giant', luminositySolar: 20000, massSolar: 12, radiusSolar: 7, temperatureK: 22000 },
+];
+
+export const STRUCTURE_PRESETS: StructurePreset[] = [
+  { id: 'swarm', name: 'Dyson swarm', coverageEfficiency: 0.82, arealDensityKgM2: 0.35, thermalLimitK: 1100, stabilityFactor: 1.15 },
+  { id: 'ring', name: 'Equatorial ring', coverageEfficiency: 0.22, arealDensityKgM2: 1.4, thermalLimitK: 900, stabilityFactor: 0.62 },
+  { id: 'shell', name: 'Rigid shell', coverageEfficiency: 0.96, arealDensityKgM2: 8.5, thermalLimitK: 750, stabilityFactor: 0.28 },
+  { id: 'statite-cloud', name: 'Statite mirror cloud', coverageEfficiency: 0.68, arealDensityKgM2: 0.08, thermalLimitK: 650, stabilityFactor: 0.88 },
+];
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function findStar(id: StarType): StarPreset {
+  return STAR_PRESETS.find((star) => star.id === id) ?? STAR_PRESETS[1];
+}
+
+function findStructure(id: StructureType): StructurePreset {
+  return STRUCTURE_PRESETS.find((structure) => structure.id === id) ?? STRUCTURE_PRESETS[0];
+}
+
+function kardashevPower(rating: number): number {
+  return Math.pow(10, (rating * 10) + 6);
+}
+
+function getDysonStatus(ratio: number): DysonResult['status'] {
+  if (ratio < 0.85) return 'underbuilt';
+  if (ratio > 2.5) return 'extreme';
+  return 'balanced';
+}
+
+export function calculateDyson(input: DysonInput): DysonResult {
+  const star = findStar(input.star);
+  const structure = findStructure(input.structure);
+  const luminosityWatts = star.luminositySolar * SOLAR_LUMINOSITY_W;
+  const safeTemp = clamp(Math.min(input.operatingTempK, structure.thermalLimitK), 120, 1600);
+  const optimalRadiusM = Math.sqrt(luminosityWatts / (16 * Math.PI * STEFAN_BOLTZMANN * Math.pow(safeTemp, 4)));
+  const optimalRadiusAu = optimalRadiusM / AU_M;
+  const coverageFraction = clamp(input.coveragePercent / 100, 0.001, 1);
+  const capturedWatts = luminosityWatts * coverageFraction * structure.coverageEfficiency;
+  const collectorAreaM2 = 4 * Math.PI * optimalRadiusM * optimalRadiusM * coverageFraction / Math.max(0.05, structure.coverageEfficiency);
+  const materialMassKg = collectorAreaM2 * structure.arealDensityKgM2 * structure.stabilityFactor;
+  const orbitalPeriodDays = (2 * Math.PI * Math.sqrt(Math.pow(optimalRadiusM, 3) / (GRAVITATIONAL_CONSTANT * star.massSolar * SOLAR_MASS_KG))) / DAY_SECONDS;
+  const kardashevRating = (Math.log10(capturedWatts) - 6) / 10;
+  const targetCoveragePercent = clamp((kardashevPower(input.kardashevTarget) / (luminosityWatts * structure.coverageEfficiency)) * 100, 0, 100);
+  const ratio = input.coveragePercent / Math.max(0.01, targetCoveragePercent);
+  const status = getDysonStatus(ratio);
+
+  return {
+    luminosityWatts,
+    capturedWatts,
+    optimalRadiusAu,
+    orbitalPeriodDays,
+    collectorAreaM2,
+    materialMassKg,
+    mercuryMasses: materialMassKg / MERCURY_MASS_KG,
+    earthMasses: materialMassKg / EARTH_MASS_KG,
+    kardashevRating,
+    targetCoveragePercent,
+    status,
+  };
+}

package/src/tool/dyson-sphere-energy-capture/seo.astro

@@ -0,0 +1,15 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { dysonSphereEnergyCapture } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await dysonSphereEnergyCapture.i18n[locale]?.();
+if (!content) return null;
+---
+
+{content.seo?.length > 0 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/global-albedo-snowball-simulator/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { globalAlbedoSnowballSimulator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await globalAlbedoSnowballSimulator.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/global-albedo-snowball-simulator/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Budyko, The effect of solar radiation variations on the climate of the Earth',
+    url: 'https://onlinelibrary.wiley.com/doi/abs/10.1111/j.2153-3490.1969.tb00466.x',
+  },
+  {
+    name: 'A global climatic model based on the energy balance of the Earth-atmosphere system',
+    url: 'https://journals.ametsoc.org/view/journals/apme/8/3/1520-0450_1969_008_0392_agcmbo_2_0_co_2.xml',
+  },
+  {
+    name: 'NOAA Global Monitoring Laboratory, Trends in atmospheric carbon dioxide',
+    url: 'https://gml.noaa.gov/ccgg/trends/',
+  },
+];

package/src/tool/global-albedo-snowball-simulator/component.astro

@@ -0,0 +1,278 @@
+---
+import './global-albedo-snowball-simulator.css';
+
+interface Props {
+  ui: Record<string, string>;
+}
+
+const { ui } = Astro.props;
+---
+
+<div
+  class="albedo-lab"
+  id="albedo-lab"
+  data-snowball={ui.snowball}
+  data-temperate={ui.temperate}
+  data-hothouse={ui.hothouse}
+  data-retreating={ui.retreating}
+  data-advancing={ui.advancing}
+  data-stable={ui.stable}
+  data-watts={ui.watts}
+  data-ppm={ui.ppm}
+  data-percent={ui.percent}
+  data-celsius={ui.celsius}
+>
+  <section class="albedo-planet" aria-label={ui.timeline}>
+    <div class="albedo-guide albedo-guide-horizontal" aria-hidden="true"></div>
+    <div class="albedo-guide albedo-guide-vertical" aria-hidden="true"></div>
+    <div class="albedo-sun" id="albedo-sun" aria-hidden="true"></div>
+    <div class="albedo-orbit">
+      <div class="albedo-earth" id="albedo-earth">
+        <span class="albedo-atmosphere"></span>
+        <span class="albedo-ice albedo-ice-north"></span>
+        <span class="albedo-ice albedo-ice-mid"></span>
+        <span class="albedo-ice albedo-ice-south"></span>
+        <span class="albedo-glint"></span>
+      </div>
+    </div>
+    <div class="albedo-state-pill">
+      <span>{ui.state}</span>
+      <strong id="albedo-state">---</strong>
+    </div>
+  </section>
+
+  <section class="albedo-controls" aria-label={ui.controls}>
+    <label class="albedo-slider albedo-slider-solar" for="albedo-solar">
+      <span>{ui.solarConstant}</span>
+      <output id="albedo-solar-output">1361 W/m<sup>2</sup></output>
+      <input id="albedo-solar" type="range" min="1180" max="1500" value="1361" step="1" />
+    </label>
+    <label class="albedo-slider albedo-slider-greenhouse" for="albedo-greenhouse">
+      <span>{ui.greenhouse}</span>
+      <output id="albedo-greenhouse-output">420 ppm</output>
+      <input id="albedo-greenhouse" type="range" min="120" max="1800" value="420" step="10" />
+    </label>
+    <label class="albedo-slider albedo-slider-ice" for="albedo-ice">
+      <span>{ui.initialIce}</span>
+      <output id="albedo-ice-output">22%</output>
+      <input id="albedo-ice" type="range" min="0" max="100" value="22" step="1" />
+    </label>
+  </section>
+
+  <section class="albedo-readouts" aria-label={ui.diagnostics}>
+    <article>
+      <span>{ui.temperature}</span>
+      <strong id="albedo-temperature">--- °C</strong>
+    </article>
+    <article>
+      <span>{ui.absorbed}</span>
+      <strong id="albedo-absorbed">--- W/m<sup>2</sup></strong>
+    </article>
+    <article>
+      <span>{ui.finalIce}</span>
+      <strong id="albedo-final-ice">---</strong>
+    </article>
+    <article>
+      <span>{ui.albedo}</span>
+      <strong id="albedo-final-albedo">---</strong>
+    </article>
+  </section>
+
+  <section class="albedo-chart-panel" aria-label={ui.timeline}>
+    <div class="albedo-chart-head">
+      <span>{ui.timeline}</span>
+      <strong id="albedo-trend">---</strong>
+    </div>
+    <svg class="albedo-chart" viewBox="0 0 720 280" role="img" aria-label={ui.timeline}>
+      <defs>
+        <linearGradient id="albedo-ice-gradient" x1="0%" y1="0%" x2="0%" y2="100%">
+          <stop id="albedo-ice-gradient-top" offset="0%" stop-color="#dff9ff" stop-opacity="0.62"></stop>
+          <stop id="albedo-ice-gradient-bottom" offset="100%" stop-color="#1f8aa5" stop-opacity="0.02"></stop>
+        </linearGradient>
+      </defs>
+      <path class="albedo-chart-grid" d="M44 28 H684 M44 84 H684 M44 140 H684 M44 196 H684 M44 252 H684"></path>
+      <path class="albedo-chart-band" id="albedo-chart-band"></path>
+      <path class="albedo-chart-line" id="albedo-chart-line"></path>
+      <circle class="albedo-chart-dot" id="albedo-chart-dot" r="7"></circle>
+      <text x="44" y="270">0</text>
+      <text x="626" y="270">80 {ui.years}</text>
+      <text x="8" y="34">100%</text>
+      <text x="20" y="252">0%</text>
+    </svg>
+  </section>
+</div>
+
+<script>
+  import { simulateAlbedo } from './logic';
+
+  const root = document.getElementById('albedo-lab');
+
+  if (root) {
+    const labRoot = root;
+    const solarInput = document.getElementById('albedo-solar') as HTMLInputElement;
+    const greenhouseInput = document.getElementById('albedo-greenhouse') as HTMLInputElement;
+    const iceInput = document.getElementById('albedo-ice') as HTMLInputElement;
+    const chartLine = document.getElementById('albedo-chart-line');
+    const chartBand = document.getElementById('albedo-chart-band');
+    const chartDot = document.getElementById('albedo-chart-dot');
+    const gradientTop = document.getElementById('albedo-ice-gradient-top');
+    const gradientBottom = document.getElementById('albedo-ice-gradient-bottom');
+
+    const labelForState = {
+      snowball: root.dataset.snowball || 'Snowball lock-in',
+      temperate: root.dataset.temperate || 'Temperate balance',
+      hothouse: root.dataset.hothouse || 'Hothouse retreat',
+    };
+
+    function template(name: string, value: string) {
+      return (labRoot.dataset[name] || '{value}').replace('{value}', value);
+    }
+
+    function setText(id: string, value: string) {
+      const node = document.getElementById(id);
+      if (node) node.textContent = value;
+    }
+
+    function setHtml(id: string, value: string) {
+      const node = document.getElementById(id);
+      if (node) node.innerHTML = value;
+    }
+
+    function formatWatts(value: number) {
+      return `${value.toFixed(0)} W/m<sup>2</sup>`;
+    }
+
+    function formatWattsDecimal(value: number) {
+      return `${value.toFixed(1)} W/m<sup>2</sup>`;
+    }
+
+    function formatCelsius(value: number) {
+      return `${value.toFixed(1)} °C`;
+    }
+
+    function formatPath(points: { x: number; y: number }[]) {
+      return points.map((point, index) => `${index === 0 ? 'M' : 'L'}${point.x.toFixed(1)} ${point.y.toFixed(1)}`).join(' ');
+    }
+
+    function drawChart(result: ReturnType<typeof simulateAlbedo>) {
+      const left = 44;
+      const top = 28;
+      const width = 640;
+      const height = 224;
+      const points = result.steps.map((step) => ({
+        x: left + (step.year / 80) * width,
+        y: top + height - (step.iceCover / 100) * height,
+      }));
+      const last = points[points.length - 1]!;
+      const band = `${formatPath(points)} L${left + width} ${top + height} L${left} ${top + height} Z`;
+
+      chartLine?.setAttribute('d', formatPath(points));
+      chartBand?.setAttribute('d', band);
+      chartDot?.setAttribute('cx', last.x.toFixed(1));
+      chartDot?.setAttribute('cy', last.y.toFixed(1));
+      gradientTop?.setAttribute('stop-opacity', `${0.18 + result.finalIceCover / 140}`);
+      gradientBottom?.setAttribute('stop-opacity', `${Math.max(0.02, result.finalIceCover / 360)}`);
+    }
+
+    function updateSlider(input: HTMLInputElement) {
+      const min = Number(input.min);
+      const max = Number(input.max);
+      const value = Number(input.value);
+      input.style.setProperty('--fill', `${((value - min) / (max - min)) * 100}%`);
+    }
+
+    function setIceStyle(result: ReturnType<typeof simulateAlbedo>) {
+      const midIceOpacity = Math.max(0, Math.min(0.72, (result.finalIceCover - 36) / 56));
+
+      labRoot.style.setProperty('--ice-cover', `${result.finalIceCover}%`);
+      labRoot.style.setProperty('--initial-ice-cover', `${Number(iceInput.value)}%`);
+      labRoot.style.setProperty('--north-ice-height', `${8 + result.finalIceCover * 0.39}%`);
+      labRoot.style.setProperty('--south-ice-height', `${9 + result.finalIceCover * 0.43}%`);
+      labRoot.style.setProperty('--mid-ice-height', `${result.finalIceCover * 0.13}%`);
+      labRoot.style.setProperty('--mid-ice-opacity', `${midIceOpacity}`);
+      labRoot.style.setProperty('--north-ice-tilt', `${-4 + result.finalIceCover * 0.025}deg`);
+      labRoot.style.setProperty('--south-ice-tilt', `${5 - result.finalIceCover * 0.026}deg`);
+    }
+
+    function setLightStyle(result: ReturnType<typeof simulateAlbedo>, solarIntensity: number, atmosphere: number) {
+      const albedoGlow = Math.min(1, result.finalAlbedo * 1.45);
+
+      labRoot.style.setProperty('--solar-intensity', solarIntensity.toFixed(3));
+      labRoot.style.setProperty('--atmosphere-intensity', atmosphere.toFixed(3));
+      labRoot.style.setProperty('--albedo-glow', `${albedoGlow}`);
+      labRoot.style.setProperty('--chart-ice-opacity', `${Math.max(0.08, result.finalIceCover / 100)}`);
+      labRoot.style.setProperty('--solar-panel-alpha', `${0.1 + solarIntensity * 0.22}`);
+      labRoot.style.setProperty('--solar-panel-alpha-dark', `${0.12 + solarIntensity * 0.34}`);
+      labRoot.style.setProperty('--atmosphere-panel-alpha', `${0.07 + atmosphere * 0.1}`);
+      labRoot.style.setProperty('--atmosphere-panel-alpha-dark', `${0.08 + atmosphere * 0.12}`);
+      labRoot.style.setProperty('--glint-alpha', `${0.12 + albedoGlow * 0.26}`);
+    }
+
+    function setBodyStyle(result: ReturnType<typeof simulateAlbedo>, solarIntensity: number, greenhouseIntensity: number, atmosphere: number) {
+      const albedoGlow = Math.min(1, result.finalAlbedo * 1.45);
+
+      labRoot.style.setProperty('--greenhouse-intensity', greenhouseIntensity.toFixed(3));
+      labRoot.style.setProperty('--sun-size', `${168 + solarIntensity * 76}px`);
+      labRoot.style.setProperty('--sun-glow-near', `${42 + solarIntensity * 86}px`);
+      labRoot.style.setProperty('--sun-glow-far', `${120 + solarIntensity * 170}px`);
+      labRoot.style.setProperty('--sun-glow-alpha-near', `${0.42 + solarIntensity * 0.28}`);
+      labRoot.style.setProperty('--sun-glow-alpha-far', `${0.14 + solarIntensity * 0.18}`);
+      labRoot.style.setProperty('--sun-saturation', `${0.95 + solarIntensity * 0.34}`);
+      labRoot.style.setProperty('--earth-atmosphere-glow', `${22 + atmosphere * 74}px`);
+      labRoot.style.setProperty('--earth-atmosphere-alpha', `${0.18 + atmosphere * 0.32}`);
+      labRoot.style.setProperty('--earth-albedo-glow', `${20 + albedoGlow * 52}px`);
+      labRoot.style.setProperty('--earth-albedo-alpha', `${0.12 + albedoGlow * 0.22}`);
+      labRoot.style.setProperty('--earth-saturation', `${0.78 + greenhouseIntensity * 0.45}`);
+      labRoot.style.setProperty('--earth-brightness', `${0.9 + solarIntensity * 0.18}`);
+      labRoot.style.setProperty('--atmosphere-inset', `${-7 - atmosphere * 13}px`);
+      labRoot.style.setProperty('--atmosphere-border-width', `${2 + atmosphere * 5}px`);
+      labRoot.style.setProperty('--atmosphere-border-alpha', `${0.18 + atmosphere * 0.22}`);
+    }
+
+    function setVisualPhysics(result: ReturnType<typeof simulateAlbedo>, solarConstant: number, greenhousePpm: number) {
+      const solarIntensity = (solarConstant - 1180) / (1500 - 1180);
+      const greenhouseIntensity = (greenhousePpm - 120) / (1800 - 120);
+      const iceFraction = result.finalIceCover / 100;
+      const atmosphere = Math.max(0.1, Math.min(1, greenhouseIntensity * 0.72 + (1 - iceFraction) * 0.28));
+
+      setIceStyle(result);
+      setLightStyle(result, solarIntensity, atmosphere);
+      setBodyStyle(result, solarIntensity, greenhouseIntensity, atmosphere);
+    }
+
+    function trendLabel(result: ReturnType<typeof simulateAlbedo>) {
+      const firstIce = result.steps[0]!.iceCover;
+
+      if (result.finalIceCover > firstIce + 3) return labRoot.dataset.advancing;
+      if (result.finalIceCover < firstIce - 3) return labRoot.dataset.retreating;
+      return labRoot.dataset.stable;
+    }
+
+    function update() {
+      const solarConstant = Number(solarInput.value);
+      const greenhousePpm = Number(greenhouseInput.value);
+      const initialIceCover = Number(iceInput.value);
+      const result = simulateAlbedo({ solarConstant, greenhousePpm, initialIceCover });
+      const trend = trendLabel(result);
+
+      setHtml('albedo-solar-output', formatWatts(solarConstant));
+      setText('albedo-greenhouse-output', template('ppm', greenhousePpm.toFixed(0)));
+      setText('albedo-ice-output', template('percent', initialIceCover.toFixed(0)));
+      setText('albedo-state', labelForState[result.stability]);
+      setHtml('albedo-temperature', formatCelsius(result.equilibriumTemperatureC));
+      setHtml('albedo-absorbed', formatWattsDecimal(result.absorbedWattsM2));
+      setText('albedo-final-ice', template('percent', result.finalIceCover.toFixed(0)));
+      setText('albedo-final-albedo', result.finalAlbedo.toFixed(2));
+      setText('albedo-trend', trend || '');
+
+      labRoot.dataset.state = result.stability;
+      setVisualPhysics(result, solarConstant, greenhousePpm);
+      drawChart(result);
+      [solarInput, greenhouseInput, iceInput].forEach(updateSlider);
+    }
+
+    [solarInput, greenhouseInput, iceInput].forEach((input) => input.addEventListener('input', update));
+    update();
+  }
+</script>
+

package/src/tool/global-albedo-snowball-simulator/entry.ts

@@ -0,0 +1,26 @@
+import type { ScienceToolEntry } from '../../types';
+
+export const globalAlbedoSnowballSimulator: ScienceToolEntry = {
+  id: 'global-albedo-snowball-simulator',
+  icons: {
+    bg: 'mdi:snowflake',
+    fg: 'mdi:earth',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};