Standardatmosphäre, Höhen und Geschwindigkeiten

Wer für die Luftfahrt rechnet, stolpert zuerst über die Begriffe: es gibt fünf verschiedene Höhen und vier verschiedene Geschwindigkeiten, und sie heißen alle ähnlich. Dieser Guide sortiert sie, zeigt für jede den Aufruf aus std.aero.atmos und benennt die Verwechslungen, die in der Luftfahrt schon Zwischenfälle verursacht haben.

→ Guides · std.aero Übersicht · Guide: Flugführungsrechner bauen · Unit-Referenz

import std.aero.atmos;   // alles auf dieser Seite

<WRAP center round important 90%> std.aero ist neu (Compiler-Repo, 2026-09-04) und im ausgelieferten lyxc 1.1.18A noch nicht enthalten. Die Beispiele dieser Seite wurden gegen den Standardbibliotheks-Baum des Compiler-Repos übersetzt und ausgeführt. </WRAP>

Die ICAO-Standardatmosphäre ist eine Vereinbarung, keine Messung: ein festgelegter Verlauf von Temperatur, Druck und Dichte über der Höhe. Sie beschreibt nicht das Wetter von heute — sie ist der gemeinsame Nullpunkt, auf den alle Angaben bezogen werden. Ein Höhenmesser, ein Flughandbuch und eine Flugfläche wären ohne sie nicht vergleichbar.

unit main;
import std.aero.atmos;
import std.io;
import std.string;

fn zeile(fl: f64): void {
    var hFt: f64 := AvDruckhoeheFtAusFlugflaeche(fl);
    var hM:  f64 := AvFtToM(hFt);
    var s: pchar := StrConcat("FL", IntToStr(fl as int64));
    s := StrConcat(s, "  T=");
    s := StrConcat(s, FloatToStr(AvKToC(AvIsaTemperaturK(hM)), 1));
    s := StrConcat(s, " C   p=");
    s := StrConcat(s, FloatToStr(AvPaToHpa(AvIsaDruckPa(hM)), 1));
    s := StrConcat(s, " hPa   rho=");
    s := StrConcat(s, FloatToStr(AvIsaDichte(hM), 3));
    s := StrConcat(s, " kg/m3   a=");
    s := StrConcat(s, FloatToStr(AvSchallgeschwindigkeitKt(AvIsaTemperaturK(hM)), 0));
    PrintLn(StrConcat(s, " kt"));
}

fn main(): int64 {
    zeile(0.0);
    zeile(100.0);
    zeile(200.0);
    zeile(350.0);
    zeile(400.0);
    return 0;
}

FL0    T=15.0 C    p=1013.3 hPa   rho=1.225 kg/m3   a=661 kt
FL100  T=-4.8 C    p=696.8 hPa    rho=0.905 kg/m3   a=638 kt
FL200  T=-24.6 C   p=465.6 hPa    rho=0.653 kg/m3   a=614 kt
FL350  T=-54.3 C   p=238.4 hPa    rho=0.380 kg/m3   a=576 kt
FL400  T=-56.5 C   p=187.5 hPa    rho=0.302 kg/m3   a=574 kt

Zwischen FL350 und FL400 ändert sich die Temperatur kaum noch — das ist die Tropopause. Und die Schallgeschwindigkeit hängt nur an der Temperatur, nicht am Druck: deshalb fällt sie oben nicht weiter.

ISA ist über der geopotentiellen Höhe definiert — einer Höhe, die die abnehmende Schwerkraft schon eingerechnet hat. Ein Höhenmesser misst Druck und liefert damit ebenfalls eine geopotentielle Größe. Der Unterschied zur geometrischen Höhe ist klein (in 11 km rund 19 m), aber er ist da:

var hPot: f64 := AvGeometrischZuGeopotentiell(11000.0);   // geometrisch -> geopotentiell
var hGeo: f64 := AvGeopotentiellZuGeometrisch(11000.0);   // und zurück

Für Flugführungsrechnungen ist die geopotentielle Höhe die richtige Größe; die geometrische braucht man beim Vergleich mit Geländedaten und Satellitenhöhen.

unit main;
import std.aero.atmos;
import std.io;
import std.string;

fn zeig(name: pchar, wert: f64, einheit: pchar): void {
    PrintLn(StrConcat(StrConcat(name, FloatToStr(wert, 0)), einheit));
}

fn main(): int64 {
    var platzFt: f64 := 1500.0;        // Platzhöhe
    var qnh:     f64 := 985.0;         // Tiefdruck
    var oatC:    f64 := 0.0 - 15.0;    // kalt

    var dhFt: f64 := AvDruckhoeheFt(qnh, platzFt);
    zeig("Druckhoehe:            ", dhFt, " ft");
    zeig("Dichtehoehe:           ", AvDichtehoeheFt(dhFt, oatC), " ft");

    var isaAbw: f64 := AvIsaAbweichungK(AvFtToM(dhFt), oatC);
    zeig("ISA-Abweichung:        ", isaAbw, " K");

    var wahrM: f64 := AvWahreHoeheM(AvFtToM(3000.0), AvFtToM(platzFt), isaAbw);
    zeig("angezeigt 3000 ft ->   ", AvMToFt(wahrM), " ft wahr");

    zeig("Uebergangsflaeche:  FL", AvUebergangsflaeche(5000.0, qnh, 1000.0), "");
    return 0;
}

Druckhoehe:            2272 ft
Dichtehoehe:           -932 ft
ISA-Abweichung:        -25 K
angezeigt 3000 ft ->   2866 ft wahr
Uebergangsflaeche:  FL70

Drei Dinge lassen sich daran ablesen:

• QNH 985 hebt die Druckhöhe um rund 770 ft über die Platzhöhe. Deshalb liegt auch die Übergangsfläche höher als bei Normaldruck — sie wird gerechnet und nicht als Konstante geführt.
• Die Dichtehöhe ist negativ, weil die Luft kalt und damit dicht ist. An einem heißen Tag ist es umgekehrt: das Flugzeug steht leistungsmäßig Tausende Fuß höher, als der Höhenmesser zeigt — das ist die Zahl, die über Startstrecke und Steigleistung entscheidet.
• Bei kalter Luft ist die wahre Höhe kleiner als die angezeigte. 3000 angezeigte Fuß sind hier 2866 wahre — 134 ft fehlen. Das ist die gefährliche Richtung, und der Grund, warum es AvWahreHoeheM überhaupt gibt.

unit main;
import std.aero.atmos;
import std.io;
import std.string;

fn zeile(fl: f64, casKt: f64): void {
    var hM:   f64 := AvFtToM(AvDruckhoeheFtAusFlugflaeche(fl));
    var oatC: f64 := AvKToC(AvIsaTemperaturK(hM));
    var s: pchar := StrConcat("FL", IntToStr(fl as int64));
    s := StrConcat(s, "  CAS=");
    s := StrConcat(s, FloatToStr(casKt, 0));
    s := StrConcat(s, "  EAS=");
    s := StrConcat(s, FloatToStr(AvEasKtAusTasKt(AvTasKtAusCasKt(casKt, hM, oatC), hM), 0));
    s := StrConcat(s, "  TAS=");
    s := StrConcat(s, FloatToStr(AvTasKtAusCasKt(casKt, hM, oatC), 0));
    s := StrConcat(s, "  M=");
    PrintLn(StrConcat(s, FloatToStr(AvMachAusCasKt(casKt, hM), 3)));
}

fn main(): int64 {
    zeile(0.0,   280.0);
    zeile(100.0, 280.0);
    zeile(200.0, 280.0);
    zeile(300.0, 280.0);
    zeile(390.0, 280.0);

    var xoverFt: f64 := AvUebergangshoeheFt(280.0, 0.78);
    PrintLn(StrConcat("Crossover 280 kt / M0.78: ",
                      StrConcat(FloatToStr(xoverFt, 0), " ft")));
    return 0;
}

FL0    CAS=280  EAS=280  TAS=280  M=0.423
FL100  CAS=280  EAS=277  TAS=323  M=0.506
FL200  CAS=280  EAS=273  TAS=375  M=0.610
FL300  CAS=280  EAS=268  TAS=437  M=0.742
FL390  CAS=280  EAS=260  TAS=511  M=0.891
Crossover 280 kt / M0.78: 32464 ft

Dieselbe angezeigte Geschwindigkeit ist oben fast doppelt so schnell. Und die Machzahl wächst dabei von 0,42 auf 0,89 — deshalb kann ein Flugzeug nicht in jeder Höhe dieselbe CAS fliegen: irgendwann stößt es an MMO.

Ein Verkehrsflugzeug steigt unten mit fester CAS und oben mit fester Machzahl. Genau in einer Höhe gehören beide zusammen — dort wird umgeschaltet:

var xoverFt: f64 := AvUebergangshoeheFt(280.0, 0.78);   // 32464 ft

Die Höhe wird per Bisektion gesucht, nicht geschätzt: die Beziehung ist nicht geschlossen umkehrbar. Wer sie ignoriert und durchgehend mit CAS rechnet, bekommt oben eine zu kleine TAS und damit eine zu kurze Strecke — ein Fehler, der sich über einen Steigflug zu mehreren Meilen summiert.

Jede Funktion liefert bei unsinniger Eingabe NaN, nicht 0:

var tas: f64 := AvTasKtAusCasKt(casKt, hM, oatC);
if (AvIsError(tas)) {
    PrintLn("ausserhalb des Gueltigkeitsbereichs");
    return 1;
}

Der Grund: 0 und 1 sehen bei physikalischen Größen beide nach einem gültigen Ergebnis aus. Eine Steigrate von 0 ist eine Aussage; eine Steigrate von 0, weil die Eingabe unsinnig war, ist eine Lüge — und sie wandert unbemerkt in die nächste Rechnung. AvIsError prüft auf NaN, den einzigen Wert, der sich selbst ungleich ist.

Gültig sind 0 bis 20 km geopotentielle Höhe und Unterschall bis Mach 1.

• Die Einheit steht im Namen: AvTasKtAusCasKt nimmt und liefert Knoten, AvIsaDruckPa Pascal. Ein Name ohne Einheit wäre in dieser Unit ein Fehler.
• Druckhöhe für alles, was mit Flugflächen und Instrumenten zu tun hat. Dichtehöhe für alles, was mit Leistung zu tun hat. Wahre Höhe für alles, was mit Gelände zu tun hat.
• Bei kalter Luft ist die wahre Höhe kleiner als die angezeigte — nie umgekehrt annehmen.
• CAS fliegt man, TAS navigiert man, EAS hält die Struktur, Mach hält die Aerodynamik.
• Oberhalb der Tropopause ändert sich die Temperatur nicht mehr — und damit auch die Schallgeschwindigkeit nicht.

Weiter: Navigation und Wegpunkte rechnet die waagerechte Seite (Kurse, Strecken, Wind), Einen Flugführungsrechner bauen (MCDU/FMS) baut auf diesen Größen auf — Steig- und Sinkprofile, Sinkflugbeginn, Vorhersage über die Route und Warteschleifen.

Letzte Aktualisierung: 2026-09-05 — Seite neu angelegt; alle Beispiele gegen lyxc 1.1.18A übersetzt und ausgeführt, die Ausgaben stammen aus dem Lauf.

Prüflauf 2026-09-05 mit doku-pruefer.py über den gesamten Aero-Bereich (Repo-Compiler lyxc 1.2.2A): 13 Vollprogramme, 13 übersetzen, 0 echte Fehler; 193 Aufrufe gegen die pub fn-Signaturen in aurum/std gehalten, 0 Abweichungen.