std.astro.state — Zustandsvektoren, Rahmen, Dreibein

import std.astro.state;

Ort und Geschwindigkeit in einem Inertialsystem, dazu Vektorrechnung und das begleitende Dreibein. Die Unit ist die Grundlage der übrigen std.astro-Units; sie rechnet selbst keine Bahnmechanik.

Einheiten durchgehend SI: Meter, Meter je Sekunde, Sekunden, m³/s².

→ std.astro (Übersicht) · std.astro.orbit · Guide: Kurs und Lage im 3D-Raum

pub type AVec3 = struct { x: f64; y: f64; z: f64; }

pub type AState = struct {
  rx: f64;  ry: f64;  rz: f64;          // Ort [m]
  vx: f64;  vy: f64;  vTarget: f64;     // Geschwindigkeit [m/s]
}

Sie rechnen nichts. Sie erlauben, eine Verwechslung auszusprechen, statt sie im Kommentar zu lassen.

Der Ursprung ist kein Randfall, den man mitrechnen könnte: dort ist die Gravitationsbeschleunigung nicht definiert, und jede Bahnrechnung teilt durch den Abstand.

import std.astro.state;
import std.astro.orbit;
import std.math;
import std.io;

fn zeig(n: pchar, v: f64, d: int64): void { Print(n); PrintLn(FloatToStr(v, d)); }
fn BI(b: bool): int64 { if (b) { return 1; } return 0; }

fn main(): int64 {
    var mu: f64 := AMuEarth();
    var r:  f64 := 6678000.0;                     // 300 km Hoehe
    var vc: f64 := ACircularSpeed(mu, r);
    var inc: f64 := 51.6 * Pi() / 180.0;          // Neigung wie die ISS

    var s: AState := AMakeState(r, 0.0, 0.0,  0.0, vc * CosF64(inc), vc * SinF64(inc));

    Print("Zustand gueltig    : "); PrintLn(IntToStr(BI(AStateValid(s))));
    zeig("Radius             : ", ARadius(s), 1);
    zeig("Tempo              : ", ASpeed(s), 2);
    zeig("Radialtempo        : ", ARadialSpeed(s), 6);
    zeig("|h|                : ", AMagnitude(AAngularMomentum(s)), 1);

    var t: AVec3 := ATangent(s);
    var b: AVec3 := ABinormal(s);
    var n: AVec3 := ANormal(s);
    zeig("T*B (soll 0)       : ", ADot(t, b), 12);
    zeig("|N| (soll 1)       : ", AMagnitude(n), 12);

    Print("Rahmen ECI==ECEF   : ");
    PrintLn(IntToStr(BI(AFrameMatches(AFRAME_ECI, AFRAME_ECEF))));
    Print("Rahmen UNKNOWN     : ");
    PrintLn(IntToStr(BI(AFrameMatches(AFRAME_UNKNOWN, AFRAME_UNKNOWN))));
    return 0;
}

Zustand gueltig    : 1
Radius             : 6678000.0
Tempo              : 7725.84
Radialtempo        : 0.000000
|h|                : 51593156041.7
T*B (soll 0)       : 0.000000000000
|N| (soll 1)       : 1.000000000000
Rahmen ECI==ECEF   : 0
Rahmen UNKNOWN     : 0

Die Unit gibt bei unmöglicher Eingabe NaN zurück — hier drei Fälle, in denen das trägt:

import std.astro.state;
import std.io;

fn BI(b: bool): int64 { if (b) { return 1; } return 0; }

fn zeigVec(n: pchar, v: AVec3): void {
    Print(n);
    if (AVecIsError(v)) { PrintLn("NaN (nicht bestimmt)"); return; }
    Print("("); Print(FloatToStr(v.x, 3)); Print(", ");
    Print(FloatToStr(v.y, 3)); Print(", "); Print(FloatToStr(v.z, 3)); PrintLn(")");
}

fn main(): int64 {
    // 1. Senkrechter Aufstieg: Ort und Geschwindigkeit parallel -> keine Bahnebene
    var senk: AState := AMakeState(6678000.0, 0.0, 0.0,  1200.0, 0.0, 0.0);
    Print("Zustand gueltig    : "); PrintLn(IntToStr(BI(AStateValid(senk))));
    zeigVec("Tangente           : ", ATangent(senk));
    zeigVec("Binormale          : ", ABinormal(senk));
    zeigVec("Normale            : ", ANormal(senk));
    Print("Radialtempo        : "); PrintLn(FloatToStr(ARadialSpeed(senk), 1));

    // 2. Ort im Ursprung: dort ist die Schwerkraft nicht definiert
    var nullpunkt: AState := AMakeState(0.0, 0.0, 0.0,  0.0, 7700.0, 0.0);
    Print("Ursprung gueltig   : "); PrintLn(IntToStr(BI(AStateValid(nullpunkt))));

    // 3. NaN pflanzt sich fort und wird EINMAL geprueft
    var x: f64 := AAngle(AVec(0.0, 0.0, 0.0), AVec(1.0, 0.0, 0.0));
    var y: f64 := x * 2.0 + 100.0;
    Print("Kette NaN geblieben: "); PrintLn(IntToStr(BI(AIsError(y))));
    return 0;
}

Zustand gueltig    : 1
Tangente           : (1.000, 0.000, 0.000)
Binormale          : NaN (nicht bestimmt)
Normale            : NaN (nicht bestimmt)
Radialtempo        : 1200.0
Ursprung gueltig   : 0
Kette NaN geblieben: 1

Drei Dinge stehen darin:

• Der senkrechte Aufstieg ist ein gültiger Zustand — AStateValid meldet 1, die Tangente zeigt nach außen, das Radialtempo ist die volle Geschwindigkeit. Nur eine Bahnebene gibt es nicht, und deshalb sind Binormale und Normale NaN. Eine gewählte Ersatzrichtung sähe hier aus wie eine echte Bahnebene.
• Der Ursprung wird von AStateValid abgefangen, bevor irgendeine Formel durch den Abstand teilt.
• NaN überlebt jede Rechnung: x * 2.0 + 100.0 ist immer noch NaN. Deshalb genügt eine Prüfung am Ende einer Kette statt einer nach jedem Schritt.

Letzte Aktualisierung: 2026-09-05 (#1902, nachgemessen mit lyxc 1.2.2B) — das Feld heißt wieder vz; der Kasten zum Benennungsfehler ist auf den behobenen Stand gezogen.

Vorherige letzte Aktualisierung: 2026-08-31 — Parametertabelle samt Höhe-gegen-Radius-Kasten und ein zweites Beispiel zu den Fehlerfällen ergänzt; beide Beispiele mit lyxc 1.1.15B gebaut und ausgeführt.

Zuvor 2026-08-31 — Seite neu angelegt aus std/astro/state.lyx (PR #1890).