====== std.astro.insertion — Einfang, Bahnwechsel, Korrekturschübe ======
''import std.astro.insertion;''
Was nach dem Anflug kommt: bremsen und einfangen, zirkularisieren, Perizentrum anheben, die Umlaufbahn wieder verlassen — und Korrekturschübe aus dem Vergleich zweier Zustände. Alle Schubwerte in m/s.
→ [[lyx_-_programmiersprache:units:astro|std.astro (Übersicht)]] · [[lyx_-_programmiersprache:units:astro:orbit|std.astro.orbit]] · [[lyx_-_programmiersprache:units:astro:entry|std.astro.entry]]
----
===== 1. Anflug und Einfang =====
^ Funktion ^ Rückgabe ^ Bedeutung ^
| ''AApproachSpeed(mu, rp, vInf)'' | ''f64'' | Tempo im Perizentrum der Anflughyperbel. Ruft ''AInjectionSpeed'' aus ''std.astro.orbit'' — dieselbe Formel, bewusst **nicht** zweimal geschrieben |
| ''ACaptureDv(mu, vInf, rp, ra)'' | ''f64'' | Bremsschub im Perizentrum für eine Ellipse ''rp''…''ra''. **Positiv als Betrag** — die Richtung ist immer entgegen der Flugrichtung |
| ''ACaptureDvCircular(mu, vInf, r)'' | ''f64'' | Sonderfall ''ra = rp'': direkt in die Kreisbahn. Der **teuerste** Einfang |
| ''ACaptureDvMinimal(mu, vInf, rp)'' | ''f64'' | gerade so viel, dass die Bahnenergie knapp negativ wird |
| ''AApoapsisAfterCapture(mu, vInf, rp, dv)'' | ''f64'' [m] | die **Planungsrichtung**: welches Apozentrum erreicht ein gegebener Schub? NaN, wenn er für einen Einfang nicht reicht |
| ''ACapturePossible(mu, vInf, rp, dvBudget)'' | ''bool'' | reicht das Budget überhaupt? |
> **''ACaptureDvMinimal'' ist eine untere Schranke, kein Plan.** Die entstehende Bahn ist beliebig groß — Umlaufzeiten von Monaten, und die geringste Störung löst sie wieder. Der Wert taugt für die Auslegung („weniger geht keinesfalls"), nicht für ein Manöver.
===== 2. Nach dem Einfang =====
^ Funktion ^ Rückgabe ^ Bedeutung ^
| ''ACircularizeDv(mu, rp, ra)'' | ''f64'' | Schub **im Apozentrum**, um die Ellipse zur Kreisbahn zu machen; positiv = beschleunigen |
| ''ARaisePeriapsisDv(mu, ra, rpAlt, rpNeu)'' | ''f64'' | Perizentrum anheben, ebenfalls im Apozentrum |
Das Anflugperizentrum liegt oft tief in der Atmosphäre oder dicht über der Oberfläche, weil der Einfang dort am billigsten ist. Angehoben wird danach — das ist der übliche zweite Schritt.
===== 3. Die Umlaufbahn verlassen =====
^ Funktion ^ Rückgabe ^ Bedeutung ^
| ''ADeorbitDvCircular(mu, r, rTarget)'' | ''f64'' | Bremsschub aus der Kreisbahn auf ein Zielperizentrum |
| ''ADeorbitDv(mu, rp, ra, rTarget)'' | ''f64'' | dasselbe aus einer Ellipse — gebremst wird im Apozentrum |
| ''APeriapsisAfterBraking(mu, r, dv)'' | ''f64'' [m] | Planungsrichtung: welches Perizentrum erzeugt ein gegebener Schub? NaN, wenn die Bahn den Körper trifft |
| ''ADeorbitSufficient(mu, r, dv, rLimit)'' | ''bool'' | erreicht der Schub die Atmosphäre? |
Aus 400 km Höhe auf ein Perizentrum von 50 km sind es rund **100 m/s** — erstaunlich wenig gemessen daran, dass es die ganze Rückkehr auslöst. Der Grund: gebremst wird nicht die Bahn, sondern nur ihre **Gegenseite**.
===== 4. Korrekturschübe aus Zuständen =====
Bis hier war jede Größe eine Zahl aus einer Formel. Ein wirklicher Korrekturschub entsteht anders: aus dem Vergleich zweier Zustände **am selben Ort**.
^ Funktion ^ Rückgabe ^ Bedeutung ^
| ''ACorrectionVec(ist, soll)'' | ''AVec3'' | Schubvektor, der ''ist'' in ''soll'' überführt |
| ''ACorrectionDv(ist, soll)'' | ''f64'' | dessen Betrag |
| ''ACorrectionPrograde(ist, soll)'' | ''f64'' | Anteil in Flugrichtung |
| ''ACorrectionRadial(ist, soll)'' | ''f64'' | Anteil nach außen |
| ''ACorrectionNormal(ist, soll)'' | ''f64'' | Anteil senkrecht auf der Bahnebene — der teuerste je Wirkung |
| ''ACircularizeFromStateDv(mu, ist)'' | ''f64'' | auf die Kreisbahn am aktuellen Ort, **ohne** Bahnelemente — die Form, die eine Bordrechnung benutzt |
So wird ein Schub in der Praxis ausgeschrieben: „12 m/s prograde" ist eine Anweisung, „(3.1, −8.4, 7.9) m/s im Inertialsystem" ist es nicht.
> **Beide Zustände müssen am selben Ort und im selben Rahmen stehen — das prüft die Unit nicht**, weil sie den Rahmen nicht kennt. Dafür gibt es ''AFrameMatches'' in [[lyx_-_programmiersprache:units:astro:state|std.astro.state]]; die Prüfung bleibt beim Aufrufer.
===== 5. Die Parameter im Einzelnen =====
^ Name ^ Bedeutung ^ Einheit ^ Zu beachten ^
| ''mu'' | Gravitationsparameter des **Zielkörpers** — beim Marseinfang also ''AMuMars()'', nicht die Sonne | m³/s² | |
| ''vInf'' | Überschussgeschwindigkeit beim Anflug, aus der interplanetaren Bahn | m/s | typisch 2.5…3.5 km/s für Mars, 5…6 km/s für Venus |
| ''rp'' | Perizentrum: der **Radius** der dichtesten Annäherung, vom Mittelpunkt aus | m | ''ARadiusMars() + hoehe''. Muss über der Atmosphäre liegen, sonst ist es kein Einfang, sondern ein Eintritt |
| ''ra'' | Apozentrum der Zielellipse | m | muss ''≥ rp'' sein, sonst NaN |
| ''r'' | Radius der Kreisbahn (bei den ''…Circular''-Formen) | m | |
| ''rTarget'' | Zielperizentrum beim Deorbit — die Höhe, in der die Atmosphäre übernimmt | m | muss **kleiner** als der Ausgangsradius sein |
| ''rLimit'' | Radius der Eintrittsgrenze für ''ADeorbitSufficient'' | m | für die Erde ''ARadiusEarth() + 122000'' |
| ''dv'' | vorhandener oder geplanter Schub | m/s | immer **positiv als Betrag**; die Richtung steckt in der Funktion |
| ''dvBudget'' | verfügbarer Schub bei ''ACapturePossible'' | m/s | |
| ''ist'', ''soll'' | zwei Zustände **am selben Ort** und im selben Rahmen | — | die Unit prüft das nicht — siehe Kasten oben |
> **Warum die Schubwerte Beträge sind.** Beim Einfang und beim Deorbit geht der Schub immer entgegen der Flugrichtung; ein Vorzeichen würde nichts hinzufügen und beim Aufsummieren nur schaden. Anders bei ''ACircularizeDv'' und ''ARaisePeriapsisDv'': dort wird **beschleunigt**, und der positive Wert meint genau das. Die Zerlegung eines Korrekturschubs (''ACorrectionPrograde'' und die beiden anderen) ist dagegen **vorzeichenbehaftet** — negativ heißt: in die Gegenrichtung.
===== 6. Beispiel: Marsankunft und Erdrückkehr =====
import std.astro.state;
import std.astro.orbit;
import std.astro.insertion;
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 {
// Mars, Anflug mit v_inf = 2.65 km/s, Perizentrum 250 km Hoehe
var muM: f64 := AMuMars();
var rp: f64 := ARadiusMars() + 250000.0;
zeig("Mars Anflugtempo : ", AApproachSpeed(muM, rp, 2650.0), 1);
zeig("Einfang minimal : ", ACaptureDvMinimal(muM, 2650.0, rp), 1);
zeig("Einfang in Kreis : ", ACaptureDvCircular(muM, 2650.0, rp), 1);
zeig("Einfang ra=30000km : ", ACaptureDv(muM, 2650.0, rp, 30000000.0), 1);
zeig("Apoapsis bei 800dv : ", AApoapsisAfterCapture(muM, 2650.0, rp, 800.0) / 1000.0, 1);
Print("Einfang moeglich? : ");
PrintLn(IntToStr(BI(ACapturePossible(muM, 2650.0, rp, 800.0))));
// Erde: Deorbit aus 400 km
var muE: f64 := AMuEarth();
var r400: f64 := ARadiusEarth() + 400000.0;
zeig("Deorbit dv m/s : ", ADeorbitDvCircular(muE, r400, ARadiusEarth() + 50000.0), 1);
zeig("rp nach 100 m/s km : ", (APeriapsisAfterBraking(muE, r400, 100.0) - ARadiusEarth()) / 1000.0, 1);
return 0;
}
Mars Anflugtempo : 5524.0
Einfang minimal : 677.1
Einfang in Kreis : 2096.8
Einfang ra=30000km : 947.3
Apoapsis bei 800dv : 69197.5
Einfang moeglich? : 1
Deorbit dv m/s : 102.3
rp nach 100 m/s km : 57.6
Die Zahlen zeigen die Spreizung, um die es beim Einfang geht: **677 m/s** für die gerade noch gebundene Bahn, **947 m/s** für eine brauchbare Ellipse, **2097 m/s** für die Kreisbahn. Mit 800 m/s Budget entsteht ein Apozentrum von rund 69 000 km — gefangen, aber weit draußen.
===== 7. Beispiel: der Einfang in drei Schritten =====
Der billige Weg in eine niedrige Marsbahn ist nicht ein Schub, sondern drei — jeder dort angesetzt, wo er am wenigsten kostet:
import std.astro.state;
import std.astro.orbit;
import std.astro.insertion;
import std.io;
fn zeig(n: pchar, v: f64, d: int64): void { Print(n); PrintLn(FloatToStr(v, d)); }
fn main(): int64 {
var mu: f64 := AMuMars();
var rp: f64 := ARadiusMars() + 250000.0; // tiefer Anflug: billiger Einfang
var ra: f64 := ARadiusMars() + 30000000.0; // weit draussen: billiges Umformen
var dv1: f64 := ACaptureDv(mu, 2650.0, rp, ra);
zeig("1) Einfang : ", dv1, 1);
var dv2: f64 := ARaisePeriapsisDv(mu, ra, rp, ARadiusMars() + 400000.0);
zeig("2) Perizentrum heben: ", dv2, 1);
var dv3: f64 := ACircularizeDv(mu, ARadiusMars() + 400000.0, ra);
zeig("3) Zirkularisieren : ", dv3, 1);
zeig("Summe : ", dv1 + dv2 + dv3, 1);
zeig("direkt in Kreisbahn : ", ACaptureDvCircular(mu, 2650.0, ra), 1);
// Korrekturschub: 5 m/s zu langsam und 3 m/s aus der Ebene
var muE: f64 := AMuEarth();
var r: f64 := 6678000.0;
var vc: f64 := ACircularSpeed(muE, r);
var ist: AState := AMakeState(r, 0.0, 0.0, 0.0, vc - 5.0, 3.0);
var soll: AState := AMakeState(r, 0.0, 0.0, 0.0, vc, 0.0);
zeig("Korrektur gesamt : ", ACorrectionDv(ist, soll), 3);
zeig(" davon prograde : ", ACorrectionPrograde(ist, soll), 3);
zeig(" davon radial : ", ACorrectionRadial(ist, soll), 3);
zeig(" davon normal : ", ACorrectionNormal(ist, soll), 3);
return 0;
}
1) Einfang : 921.9
2) Perizentrum heben: 9.2
3) Zirkularisieren : 620.8
Summe : 1551.8
direkt in Kreisbahn : 1963.9
Korrektur gesamt : 5.831
davon prograde : 4.999
davon radial : 0.000
davon normal : -3.002
**Der Umweg über die große Ellipse spart 412 m/s** gegenüber dem direkten Einfang in dieselbe Kreisbahn — rund ein Fünftel. Das Anheben des Perizentrums um 150 km kostet dabei ganze **9.2 m/s**, weil es im 30 000 km entfernten Apozentrum geschieht; dort ist die Bahn langsam und lässt sich billig umformen.
Die Zerlegung des Korrekturschubs zeigt die zweite Regel: von 5.83 m/s Gesamtschub stecken 5.0 in der Flugrichtung und 3.0 senkrecht zur Bahnebene. Das Vorzeichen der Normalkomponente sagt, in welche Richtung — und genau dieser Anteil ist der teuerste je Wirkung.
----
Letzte Aktualisierung: 2026-08-31 — Parametertabelle samt Vorzeichenregel und ein zweites Beispiel (Einfang in drei Schritten, Zerlegung eines Korrekturschubs) ergänzt; beide Beispiele mit ''lyxc 1.1.15B'' gebaut und ausgeführt.
Zuvor 2026-08-31 — Seite neu angelegt aus ''std/astro/insertion.lyx'' (PR #1890).