@jjlmoya/utils-science 1.43.0 → 1.45.0

package/src/tool/black-hole-event-horizon-simulator/component.astro

@@ -0,0 +1,302 @@
+---
+import './black-hole-event-horizon-simulator.css';
+
+interface Props {
+  ui: Record<string, string>;
+}
+
+const { ui } = Astro.props;
+---
+
+<div
+  class="bh-lab"
+  id="bh-lab"
+  data-rs-label={ui.rsLabel}
+  data-diameter-label={ui.diameterLabel}
+  data-time-label={ui.timeLabel}
+  data-redshift-label={ui.redshiftLabel}
+  data-status-safe={ui.statusSafe}
+  data-status-photon={ui.statusPhoton}
+  data-status-inside={ui.statusInside}
+  data-km-unit={ui.kilometerUnit}
+  data-ms-unit={ui.millisecondUnit}
+  data-second-unit={ui.secondUnit}
+  data-light-speed-unit={ui.lightSpeedUnit}
+  data-tidal-unit={ui.tidalUnit}
+  data-solar-masses-unit={ui.solarMassesUnit}
+  data-rs-unit={ui.rsUnit}
+>
+  <div class="bh-card">
+    <section class="bh-stage" aria-label={ui.visualTitle}>
+      <div class="bh-visual">
+        <svg class="bh-svg" viewBox="0 0 760 620" role="img" aria-label={ui.visualTitle}>
+          <defs>
+            <radialGradient id="bh-core-glow" cx="50%" cy="50%" r="50%">
+              <stop offset="0%" stop-color="#000000" />
+              <stop offset="54%" stop-color="#020204" />
+              <stop offset="100%" stop-color="#19161f" />
+            </radialGradient>
+            <linearGradient id="bh-disk" x1="0" x2="1" y1="0" y2="0">
+              <stop offset="0%" stop-color="#4dd7ff" />
+              <stop offset="42%" stop-color="#ffe27a" />
+              <stop offset="72%" stop-color="#ff7a3d" />
+              <stop offset="100%" stop-color="#fb2d5f" />
+            </linearGradient>
+            <filter id="bh-blur">
+              <feGaussianBlur stdDeviation="9" />
+            </filter>
+          </defs>
+          <rect class="bh-space" width="760" height="620"></rect>
+          <g class="bh-stars" id="bh-stars"></g>
+          <ellipse class="bh-disk bh-disk-back" cx="380" cy="314" rx="268" ry="68"></ellipse>
+          <circle class="bh-photon" id="bh-photon" cx="380" cy="310" r="152"></circle>
+          <circle class="bh-isco" id="bh-isco" cx="380" cy="310" r="216"></circle>
+          <circle class="bh-horizon-glow" id="bh-horizon-glow" cx="380" cy="310" r="102"></circle>
+          <circle class="bh-horizon" id="bh-horizon" cx="380" cy="310" r="96"></circle>
+          <ellipse class="bh-disk bh-disk-front" cx="380" cy="314" rx="268" ry="68"></ellipse>
+          <g class="bh-probe" id="bh-probe">
+            <circle r="9"></circle>
+            <path d="M-18 0 L-4 -5 L-4 5 Z"></path>
+          </g>
+          <g class="bh-label bh-label-rs">
+            <line x1="380" x2="476" y1="310" y2="310"></line>
+            <text x="394" y="298">{ui.eventHorizon}</text>
+          </g>
+          <g class="bh-label bh-label-photon">
+            <line x1="532" x2="594" y1="310" y2="254"></line>
+            <text x="596" y="250">{ui.photonSphere}</text>
+          </g>
+          <g class="bh-label bh-label-isco">
+            <line x1="596" x2="662" y1="310" y2="368"></line>
+            <text x="548" y="390">{ui.isco}</text>
+          </g>
+        </svg>
+      </div>
+      <div class="bh-readout">
+        <span id="bh-status">{ui.statusSafe}</span>
+        <strong id="bh-rs">{ui.zeroKilometers}</strong>
+        <p>{ui.visualCaption}</p>
+      </div>
+    </section>
+
+    <section class="bh-controls" aria-label={ui.controlsTitle}>
+      <div class="bh-kpis">
+        <div>
+          <span>{ui.diameter}</span>
+          <strong id="bh-diameter">{ui.zeroKilometers}</strong>
+        </div>
+        <div>
+          <span>{ui.lightCrossing}</span>
+          <strong id="bh-crossing">{ui.zeroMilliseconds}</strong>
+        </div>
+        <div>
+          <span>{ui.timeDilation}</span>
+          <strong id="bh-time">{ui.zeroMultiplier}</strong>
+        </div>
+        <div>
+          <span>{ui.redshift}</span>
+          <strong id="bh-redshift">0</strong>
+        </div>
+      </div>
+
+      <div class="bh-sliders">
+        <label class="bh-slider" for="bh-mass">
+          <span>{ui.mass}</span>
+          <output id="bh-mass-output">{ui.initialMassOutput}</output>
+          <input id="bh-mass" type="range" min="0.477" max="10" step="0.01" value="1" />
+        </label>
+        <label class="bh-slider" for="bh-distance">
+          <span>{ui.distance}</span>
+          <output id="bh-distance-output">{ui.initialDistanceOutput}</output>
+          <input id="bh-distance" type="range" min="1.02" max="12" step="0.01" value="3" />
+        </label>
+        <label class="bh-slider" for="bh-speed">
+          <span>{ui.speed}</span>
+          <output id="bh-speed-output">{ui.initialSpeedOutput}</output>
+          <input id="bh-speed" type="range" min="5" max="99" step="1" value="32" />
+        </label>
+      </div>
+
+      <div class="bh-orbit-panel">
+        <div>
+          <span>{ui.escapeVelocity}</span>
+          <strong id="bh-escape">{ui.zeroLightSpeed}</strong>
+        </div>
+        <div>
+          <span>{ui.orbitalPeriod}</span>
+          <strong id="bh-period">{ui.zeroMilliseconds}</strong>
+        </div>
+        <div>
+          <span>{ui.tidalGradient}</span>
+          <strong id="bh-tide">{ui.zeroTidal}</strong>
+        </div>
+      </div>
+    </section>
+  </div>
+</div>
+
+<script>
+  import { simulateEventHorizon } from './logic';
+
+  const root = document.getElementById('bh-lab');
+  const massInput = document.getElementById('bh-mass') as HTMLInputElement | null;
+  const distanceInput = document.getElementById('bh-distance') as HTMLInputElement | null;
+  const speedInput = document.getElementById('bh-speed') as HTMLInputElement | null;
+  const probe = document.getElementById('bh-probe');
+  const horizon = document.getElementById('bh-horizon');
+  const glow = document.getElementById('bh-horizon-glow');
+  const photon = document.getElementById('bh-photon');
+  const isco = document.getElementById('bh-isco');
+  const stars = document.getElementById('bh-stars');
+  const numberFormat = new Intl.NumberFormat('en', { maximumFractionDigits: 2 });
+  const compactFormat = new Intl.NumberFormat('en', { maximumFractionDigits: 1, notation: 'compact' });
+  const storageKey = 'black-hole-event-horizon-simulator:last-state';
+  const labels = {
+    km: root?.dataset.kmUnit ?? '',
+    ms: root?.dataset.msUnit ?? '',
+    seconds: root?.dataset.secondUnit ?? '',
+    lightSpeed: root?.dataset.lightSpeedUnit ?? '',
+    tidal: root?.dataset.tidalUnit ?? '',
+    solarMasses: root?.dataset.solarMassesUnit ?? '',
+    rs: root?.dataset.rsUnit ?? '',
+  };
+  const statusLabels = {
+    'inside-horizon': root?.dataset.statusInside ?? '',
+    'photon-sphere': root?.dataset.statusPhoton ?? '',
+    'stable-orbit': root?.dataset.statusSafe ?? '',
+  };
+
+  function text(id: string, value: string) {
+    const node = document.getElementById(id);
+    if (node) node.textContent = value;
+  }
+
+  function inputValue(input: HTMLInputElement | null, fallback: number) {
+    return input ? Number(input.value) : fallback;
+  }
+
+  function massFromSlider() {
+    return 10 ** inputValue(massInput, 1);
+  }
+
+  function km(value: number) {
+    return `${compactFormat.format(value)} ${labels.km}`;
+  }
+
+  function milliseconds(value: number) {
+    if (value >= 1000) return `${numberFormat.format(value / 1000)} ${labels.seconds}`;
+    return `${numberFormat.format(value)} ${labels.ms}`;
+  }
+
+  function setSliderOutput(input: HTMLInputElement | null, outputId: string, value: string) {
+    const output = document.getElementById(outputId);
+    if (!input || !output) return;
+    const min = Number(input.min);
+    const max = Number(input.max);
+    const progress = (Number(input.value) - min) / (max - min);
+    output.style.setProperty('--value-x', `${progress * 100}%`);
+    output.textContent = value;
+  }
+
+  function saveState() {
+    if (!massInput || !distanceInput || !speedInput) return;
+    window.localStorage.setItem(storageKey, JSON.stringify({
+      mass: massInput.value,
+      distance: distanceInput.value,
+      speed: speedInput.value,
+    }));
+  }
+
+  function restoreState() {
+    try {
+      const raw = window.localStorage.getItem(storageKey);
+      if (!raw) return;
+      const state = JSON.parse(raw) as Record<string, string>;
+      restoreInputValue(massInput, state.mass);
+      restoreInputValue(distanceInput, state.distance);
+      restoreInputValue(speedInput, state.speed);
+    } catch {
+      window.localStorage.removeItem(storageKey);
+    }
+  }
+
+  function restoreInputValue(input: HTMLInputElement | null, value: string | undefined) {
+    if (!input || !value) return;
+    input.value = value;
+  }
+
+  function drawStars() {
+    if (!stars || stars.childElementCount > 0) return;
+    const ns = 'http://www.w3.org/2000/svg';
+    for (let index = 0; index < 90; index += 1) {
+      const star = document.createElementNS(ns, 'circle');
+      const angle = index * 2.399963;
+      const radius = 35 + index * 3.1;
+      const x = 380 + Math.cos(angle) * radius * 1.3;
+      const y = 310 + Math.sin(angle) * radius * 0.78;
+      star.setAttribute('cx', x.toFixed(1));
+      star.setAttribute('cy', y.toFixed(1));
+      star.setAttribute('r', (index % 5 === 0 ? 1.7 : 0.9).toString());
+      stars.append(star);
+    }
+  }
+
+  function statusLabel(status: ReturnType<typeof simulateEventHorizon>['status']) {
+    return statusLabels[status];
+  }
+
+  function updateGeometry(massSolar: number, distance: number, speed: number, result: ReturnType<typeof simulateEventHorizon>) {
+    const horizonRadius = Math.max(58, Math.min(126, 48 + Math.log10(massSolar) * 13));
+    const probeRadius = horizonRadius * Math.min(3.4, distance);
+    const angle = performance.now() / 1300 * speed + distance;
+    const probeX = 380 + Math.cos(angle) * probeRadius;
+    const probeY = 310 + Math.sin(angle) * probeRadius * 0.33;
+
+    horizon?.setAttribute('r', horizonRadius.toFixed(1));
+    glow?.setAttribute('r', (horizonRadius + 18).toFixed(1));
+    photon?.setAttribute('r', (horizonRadius * 1.5).toFixed(1));
+    isco?.setAttribute('r', (horizonRadius * 3).toFixed(1));
+    probe?.setAttribute('transform', `translate(${probeX.toFixed(2)} ${probeY.toFixed(2)}) rotate(${angle * 57.2958 + 90})`);
+    root?.style.setProperty('--bh-warp', Math.min(1, result.escapeVelocityFraction).toFixed(3));
+  }
+
+  function updateReadouts(result: ReturnType<typeof simulateEventHorizon>) {
+    text('bh-status', statusLabel(result.status));
+    text('bh-rs', `${root?.dataset.rsLabel}: ${km(result.schwarzschildRadiusKm)}`);
+    text('bh-diameter', km(result.diameterKm));
+    text('bh-crossing', milliseconds(result.lightCrossingMs));
+    text('bh-time', `${numberFormat.format(result.timeDilationFactor)}x`);
+    text('bh-redshift', numberFormat.format(result.gravitationalRedshift));
+    text('bh-escape', `${numberFormat.format(result.escapeVelocityFraction * 100)}${labels.lightSpeed}`);
+    text('bh-period', milliseconds(result.orbitalPeriodMs));
+    text('bh-tide', `${numberFormat.format(result.tidalGradientEarthGPerMeter)} ${labels.tidal}`);
+  }
+
+  function updateSliderOutputs(massSolar: number, distance: number, speed: number) {
+    setSliderOutput(massInput, 'bh-mass-output', `${compactFormat.format(massSolar)} ${labels.solarMasses}`);
+    setSliderOutput(distanceInput, 'bh-distance-output', `${numberFormat.format(distance)} ${labels.rs}`);
+    setSliderOutput(speedInput, 'bh-speed-output', `${Math.round(speed * 100)}${labels.lightSpeed}`);
+  }
+
+  function update(shouldSave = true) {
+    if (shouldSave) saveState();
+    const massSolar = massFromSlider();
+    const distance = inputValue(distanceInput, 3);
+    const speed = inputValue(speedInput, 32) / 100;
+    const result = simulateEventHorizon({ massSolar, distanceMultiplier: distance, orbitalSpeedFraction: speed });
+
+    updateGeometry(massSolar, distance, speed, result);
+    updateReadouts(result);
+    updateSliderOutputs(massSolar, distance, speed);
+  }
+
+  function animate() {
+    update(false);
+    window.requestAnimationFrame(animate);
+  }
+
+  drawStars();
+  restoreState();
+  [massInput, distanceInput, speedInput].forEach((input) => input?.addEventListener('input', update));
+  animate();
+</script>

package/src/tool/black-hole-event-horizon-simulator/entry.ts

@@ -0,0 +1,29 @@
+import type { ScienceToolEntry, ToolLocaleContent } from '../../types';
+
+export interface BlackHoleEventHorizonSimulatorUI {
+  [key: string]: string;
+}
+
+export type BlackHoleEventHorizonSimulatorLocaleContent = ToolLocaleContent<BlackHoleEventHorizonSimulatorUI>;
+
+export const blackHoleEventHorizonSimulator: ScienceToolEntry<BlackHoleEventHorizonSimulatorUI> = {
+  id: 'black-hole-event-horizon-simulator',
+  icons: { bg: 'mdi:circle-opacity', fg: 'mdi:orbit' },
+  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),
+  },
+};

package/src/tool/black-hole-event-horizon-simulator/i18n/de.ts

@@ -0,0 +1,179 @@
+import { bibliography } from '../bibliography';
+import type { ToolLocaleContent } from '../../../types';
+
+const slug = 'schwarzes-loch-ereignishorizont-simulator';
+const title = 'Schwarzes Loch Ereignishorizont Simulator';
+const description = 'Erkunden Sie den Ereignishorizont eines schwarzen Lochs mit interaktiven Berechnungen von Masse, Orbitdistanz, Zeitdilatation, Photonensphäre, Fluchtgeschwindigkeit und Schwarzschild-Radius.';
+
+const howTo = [
+  {
+    name: 'Wählen Sie die Masse des schwarzen Lochs',
+    text: 'Bewegen Sie den Masse-Regler von einem stellaren schwarzen Loch zu einem supermassiven schwarzen Loch und beobachten Sie, wie der Schwarzschild-Radius in Echtzeit skaliert.',
+  },
+  {
+    name: 'Bewegen Sie die Sonde nahe an den Horizont',
+    text: 'Stellen Sie die Entfernung in Schwarzschild-Radien ein, um einen sicheren äußeren Orbit, die Region der Photonensphäre und den Rand des Ereignishorizonts zu vergleichen.',
+  },
+  {
+    name: 'Untersuchen Sie relativistische Effekte',
+    text: 'Lesen Sie die Fluchtgeschwindigkeit, die gravitative Zeitdilatation, die Rotverschiebung und die Umlaufzeit ab, um zu verstehen, warum die gewöhnliche Intuition in der Nähe des Horizonts versagt.',
+  },
+  {
+    name: 'Vergleichen Sie die charakteristischen Radien',
+    text: 'Nutzen Sie die Leitringe für Ereignishorizont, Photonensphäre und ISCO, um die verschiedenen Grenzen um ein nicht rotierendes schwarzes Loch zu verstehen.',
+  },
+];
+
+const faq = [
+  {
+    question: 'Was ist der Ereignishorizont eines schwarzen Lochs?',
+    answer: 'Der Ereignishorizont ist die Grenze, an der die Fluchtgeschwindigkeit die Lichtgeschwindigkeit erreicht. Sobald ein Objekt ihn überquert, kann kein Signal, das sich mit oder unter Lichtgeschwindigkeit bewegt, zum äußeren Universum zurückkehren.',
+  },
+  {
+    question: 'Was bedeutet der Schwarzschild-Radius?',
+    answer: 'Der Schwarzschild-Radius ist der Ereignishorizont-Radius für ein nicht rotierendes, ungeladenes schwarzes Loch. Er wächst linear mit der Masse, sodass eine Verdopplung der Masse den Horizontradius verdoppelt.',
+  },
+  {
+    question: 'Was ist die Photonensphäre?',
+    answer: 'Die Photonensphäre ist eine Region bei 1,5 Schwarzschild-Radien, in der Licht auf einem instabilen Pfad um das schwarze Loch kreisen kann. Winzige Störungen lassen Photonen entweder nach außen entkommen oder nach innen fallen.',
+  },
+  {
+    question: 'Was ist die ISCO?',
+    answer: 'ISCO steht für "Innermost Stable Circular Orbit" (innerster stabiler kreisförmiger Orbit). Bei einem nicht rotierenden schwarzen Loch liegt sie bei 3 Schwarzschild-Radien bzw. 6 Gravitationsradien und markiert den letzten stabilen kreisförmigen Orbit für massereiche Teilchen.',
+  },
+  {
+    question: 'Warum nimmt die Zeitdilatation in der Nähe des Horizonts zu?',
+    answer: 'In der Schwarzschild-Geometrie ticken Uhren, die tiefer im Gravitationsfeld liegen, langsamer relativ zu entfernten Beobachtern. Der angezeigte Faktor nähert sich Null, wenn sich die Sonde dem Ereignishorizont nähert.',
+  },
+  {
+    question: 'Kann dieser Simulator ein rotierendes schwarzes Loch modellieren?',
+    answer: 'Nein. Er verwendet die Schwarzschild-Lösung, die keine Rotation und keine elektrische Ladung annimmt. Echte astrophysikalische schwarze Löcher rotieren oft, und die Rotation verändert die Horizontgröße, die ISCO-Position und das Verhalten der Scheibe.',
+  },
+  {
+    question: 'Warum sind supermassive schwarze Löcher am Horizont weniger "tidal gewalttätig"?',
+    answer: 'Der Gezeitengradient am Horizont nimmt mit zunehmender Masse des schwarzen Lochs ab. Ein kleines stellares schwarzes Loch kann Objekte in der Nähe des Horizonts gewaltsam auseinanderziehen, während ein supermassives schwarzes Loch an dieser Grenze einen sanfteren lokalen Gradienten aufweisen kann.',
+  },
+  {
+    question: 'Zeigt die Visualisierung ein echtes Bild eines schwarzen Lochs?',
+    answer: 'Es ist ein lehrreiches Diagramm, keine Raytracing-Beobachtung. Die Ringe und die Scheibe sind auf die vereinfachten Schwarzschild-Radien skaliert, damit die physikalischen Zonen leicht vergleichbar sind.',
+  },
+];
+
+export const content: ToolLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    visualTitle: 'Ereignishorizont-Feldkarte',
+    visualCaption: 'Die Sonde bewegt sich durch die skalierte Schwarzschild-Geometrie. Die hellen Leitringe markieren den Horizont, die Photonensphäre und den innersten stabilen kreisförmigen Orbit.',
+    controlsTitle: 'Steuerung des schwarzen Lochs',
+    eventHorizon: 'Ereignishorizont',
+    photonSphere: 'Photonensphäre',
+    isco: 'ISCO',
+    rsLabel: 'Schwarzschild-Radius',
+    diameterLabel: 'Durchmesser',
+    timeLabel: 'Zeitdilatation',
+    redshiftLabel: 'Rotverschiebung',
+    statusSafe: 'Außerhalb der stabilen Orbitregion',
+    statusPhoton: 'Innerhalb der Photonensphären-Zone',
+    statusInside: 'An der Horizontgrenze',
+    diameter: 'Horizontdurchmesser',
+    lightCrossing: 'Lichtdurchquerungszeit',
+    timeDilation: 'Uhrenrate vs. entfernter Beobachter',
+    redshift: 'Gravitative Rotverschiebung',
+    mass: 'Masse des schwarzen Lochs',
+    distance: 'Sondenentfernung',
+    speed: 'Orbitalgeschwindigkeit der Sonde',
+    escapeVelocity: 'Fluchtgeschwindigkeit',
+    orbitalPeriod: 'Umlaufzeit der Sonde',
+    tidalGradient: 'Gezeitengradient',
+    kilometerUnit: 'km',
+    millisecondUnit: 'ms',
+    secondUnit: 's',
+    lightSpeedUnit: '% c',
+    tidalUnit: 'g/m',
+    solarMassesUnit: 'Sonnenmassen',
+    rsUnit: 'Rs',
+    zeroKilometers: '0 km',
+    zeroMilliseconds: '0 ms',
+    zeroMultiplier: '0x',
+    zeroLightSpeed: '0% c',
+    zeroTidal: '0 g/m',
+    initialMassOutput: '10 Sonnenmassen',
+    initialDistanceOutput: '3.0 Rs',
+    initialSpeedOutput: '32% c',
+  },
+  seo: [
+    {
+      type: 'title',
+      text: 'Schwarzes Loch Ereignishorizont Simulator für Schwarzschild-Radius, Photonensphäre und Zeitdilatation',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Dieser Schwarzes Loch Ereignishorizont Simulator verwandelt die Kernideen von Schwarzschild-schwarzen Löchern in ein interaktives visuelles Modell. Ändern Sie die Masse des schwarzen Lochs, bewegen Sie eine Sonde nach innen oder außen und vergleichen Sie, wie Ereignishorizont, Photonensphäre, innerster stabiler kreisförmiger Orbit, Fluchtgeschwindigkeit, gravitative Rotverschiebung und Zeitdilatation reagieren.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Simulator wurde für Astronomiestudenten, Physiklehrer, Wissenschaftsautoren und neugierige Lernende entwickelt, die mehr als eine statische Formel wollen. Die Anzeige verbindet die Zahlen mit einem räumlichen Diagramm, sodass Sie sehen können, warum der Ereignishorizont keine materielle Oberfläche ist, warum Photonen einen speziellen instabilen Orbit haben und warum stabile Kreisbewegungen stoppen, bevor der Horizont erreicht wird.',
+    },
+    {
+      type: 'title',
+      text: 'Wie der Ereignishorizont-Radius berechnet wird',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Für ein nicht rotierendes, ungeladenes schwarzes Loch ist der Ereignishorizont-Radius der <strong>Schwarzschild-Radius</strong>. Er wird berechnet als <strong>Rs = 2GM / c^2</strong>, wobei G die Gravitationskonstante, M die Masse des schwarzen Lochs und c die Lichtgeschwindigkeit ist. Eine Sonnenmasse entspricht einem Schwarzschild-Radius von etwa 2,95 Kilometern.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Da der Schwarzschild-Radius linear mit der Masse skaliert, hat ein schwarzes Loch mit 10 Sonnenmassen einen Radius von nahezu 29,5 Kilometern, während ein schwarzes Loch mit 4 Millionen Sonnenmassen wie Sagittarius A* einen Radius von etwa 11,8 Millionen Kilometern hat. Der Masse-Regler verwendet eine logarithmische Skala, damit sowohl stellare als auch supermassive Fälle in dieselbe Steuerung passen.',
+    },
+    {
+      type: 'table',
+      headers: ['Region', 'Radius in Schwarzschild-Radien', 'Bedeutung'],
+      rows: [
+        ['Ereignishorizont', '1.0 Rs', 'Die Einweg-Grenze, an der die Fluchtgeschwindigkeit der Lichtgeschwindigkeit entspricht.'],
+        ['Photonensphäre', '1.5 Rs', 'Der instabile kreisförmige Orbit für Licht um ein Schwarzschild-schwarzes Loch.'],
+        ['ISCO', '3.0 Rs', 'Der innerste stabile kreisförmige Orbit für massereiche Teilchen.'],
+        ['Schwaches Feld', '6 Rs und darüber', 'Die Schwerkraft ist immer noch stark, aber kreisförmige Orbits sind leichter aufrechtzuerhalten.'],
+      ],
+    },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: title,
+      description,
+      applicationCategory: 'ScientificApplication',
+      operatingSystem: 'Any',
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: faq.map((item) => ({
+        '@type': 'Question',
+        name: item.question,
+        acceptedAnswer: {
+          '@type': 'Answer',
+          text: item.answer,
+        },
+      })),
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: title,
+      step: howTo.map((step) => ({
+        '@type': 'HowToStep',
+        name: step.name,
+        text: step.text,
+      })),
+    },
+  ],
+};