@interstellar-tools/equations 1.2.0 → 1.4.0

package/dist/categories/entry/ballistic-coefficient.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Compute the **ballistic coefficient** of an entry vehicle: how much mass it has per unit of drag.
+ *
+ * $$
+ * \beta = \frac{m}{C_D A}
+ * $$
+ *
+ * Where:
+ * - $ m $ is the vehicle's mass (kg)
+ * - $ C_D $ is its drag coefficient (dimensionless)
+ * - $ A $ is its reference area, usually the frontal area (m²)
+ *
+ * **Units**
+ * - Inputs: `m` in **kg**, `Cd` dimensionless, `A` in **m²**.
+ * - Output: $ \beta $ in **kg/m²**.
+ *
+ * ::: info Notes
+ *
+ * - A low $ \beta $ slows down high in the thin upper atmosphere; a high $ \beta $ plunges deeper before it slows.
+ * - The drag deceleration is $ a = \rho V^2 / (2\beta) $.
+ * - Some texts define it the other way up, as $ C_D A / m $. This library uses $ m / (C_D A) $ throughout.
+ *
+ * :::
+ *
+ * @param m - Mass $ m $ in **kg** (finite, > 0).
+ * @param Cd - Drag coefficient $ C_D $ (finite, > 0).
+ * @param A - Reference area $ A $ in **m²** (finite, > 0).
+ * @returns Ballistic coefficient $ \beta $ in **kg/m²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is `<= 0`.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * // A 5000 kg capsule, 3.9 m across, with Cd = 1.3
+ * const beta = ballisticCoefficient(5000, 1.3, Math.PI * 1.95 ** 2);
+ * // beta ≈ 322 kg/m²
+ * ```
+ *
+ * @see {@link ballisticEntrySpeed}
+ * @see https://en.wikipedia.org/wiki/Ballistic_coefficient Ballistic coefficient
+ */
+export declare const ballisticCoefficient: (m: number, Cd: number, A: number) => number;
+//# sourceMappingURL=ballistic-coefficient.d.ts.map

package/dist/categories/entry/ballistic-coefficient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-coefficient.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-coefficient.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,oBAAoB,GAC/B,GAAG,MAAM,EACT,IAAI,MAAM,EACV,GAAG,MAAM,KACR,MAWF,CAAC"}

package/dist/categories/entry/ballistic-coefficient.js

@@ -0,0 +1,54 @@
+import { assertFinite, assertPositive } from './validate.js';
+/**
+ * Compute the **ballistic coefficient** of an entry vehicle: how much mass it has per unit of drag.
+ *
+ * $$
+ * \beta = \frac{m}{C_D A}
+ * $$
+ *
+ * Where:
+ * - $ m $ is the vehicle's mass (kg)
+ * - $ C_D $ is its drag coefficient (dimensionless)
+ * - $ A $ is its reference area, usually the frontal area (m²)
+ *
+ * **Units**
+ * - Inputs: `m` in **kg**, `Cd` dimensionless, `A` in **m²**.
+ * - Output: $ \beta $ in **kg/m²**.
+ *
+ * ::: info Notes
+ *
+ * - A low $ \beta $ slows down high in the thin upper atmosphere; a high $ \beta $ plunges deeper before it slows.
+ * - The drag deceleration is $ a = \rho V^2 / (2\beta) $.
+ * - Some texts define it the other way up, as $ C_D A / m $. This library uses $ m / (C_D A) $ throughout.
+ *
+ * :::
+ *
+ * @param m - Mass $ m $ in **kg** (finite, > 0).
+ * @param Cd - Drag coefficient $ C_D $ (finite, > 0).
+ * @param A - Reference area $ A $ in **m²** (finite, > 0).
+ * @returns Ballistic coefficient $ \beta $ in **kg/m²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is `<= 0`.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * // A 5000 kg capsule, 3.9 m across, with Cd = 1.3
+ * const beta = ballisticCoefficient(5000, 1.3, Math.PI * 1.95 ** 2);
+ * // beta ≈ 322 kg/m²
+ * ```
+ *
+ * @see {@link ballisticEntrySpeed}
+ * @see https://en.wikipedia.org/wiki/Ballistic_coefficient Ballistic coefficient
+ */
+export const ballisticCoefficient = (m, Cd, A) => {
+    const inputs = [
+        ['m', m],
+        ['Cd', Cd],
+        ['A', A]
+    ];
+    assertFinite(inputs);
+    assertPositive(inputs);
+    return m / (Cd * A);
+};
+//# sourceMappingURL=ballistic-coefficient.js.map

package/dist/categories/entry/ballistic-coefficient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-coefficient.js","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-coefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,CAAS,EACT,EAAU,EACV,CAAS,EACD,EAAE;IACV,MAAM,MAAM,GAAG;QACb,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;KACA,CAAC;IAEX,YAAY,CAAC,MAAM,CAAC,CAAC;IACrB,cAAc,CAAC,MAAM,CAAC,CAAC;IAEvB,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AACtB,CAAC,CAAC"}

package/dist/categories/entry/ballistic-entry-speed.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Compute the **speed of a ballistic entry** at an altitude, with the Allen–Eggers solution.
+ *
+ * $$
+ * V(h) = V_E \exp\left(-\frac{\rho_0 H}{2\beta\sin\lvert\gamma\rvert}\, e^{-h/H}\right)
+ * $$
+ *
+ * Where:
+ * - $ V_E $ is the speed at entry (m/s)
+ * - $ \gamma $ is the flight-path angle, constant along the straight path (rad)
+ * - $ \beta $ is the ballistic coefficient (kg/m²)
+ * - $ \rho_0 $ and $ H $ describe an exponential atmosphere, $ \rho = \rho_0 e^{-h/H} $
+ *
+ * **Units**
+ * - Inputs: `h` and `H` in **m**, `VE` in **m/s**, `gamma` in **radians**, `beta` in **kg/m²**, `rho0` in **kg/m³**.
+ * - Output: $ V $ in **m/s**.
+ *
+ * ::: info Notes
+ *
+ * - Assumes drag dominates: no lift, no gravity, and a straight path at a constant angle. That holds well for steep, fast entries of non-lifting bodies.
+ * - The deceleration at any altitude is $ \rho V^2 / (2\beta) $; its peak is {@link ballisticPeakDeceleration}, at {@link ballisticPeakDecelerationAltitude}.
+ * - `gamma` can be given as negative (descending, the usual convention) or positive: only its size is used.
+ * - Earth's lower atmosphere is roughly $ \rho_0 = 1.225 $ kg/m³ with $ H \approx 7.2 $ km. A single exponential is a rough fit; see the density models in [#226](https://github.com/phun-ky/interstellar-tools/issues/226).
+ *
+ * :::
+ *
+ * @param h - Altitude $ h $ in **m** (finite).
+ * @param VE - Entry speed $ V_E $ in **m/s** (finite, > 0).
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param beta - Ballistic coefficient $ \beta $ in **kg/m²** (finite, > 0).
+ * @param rho0 - Reference density $ \rho_0 $ in **kg/m³** (finite, > 0).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Speed $ V $ in **m/s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `VE`, `beta`, `rho0` or `H` is `<= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // A 322 kg/m² capsule entering at 11 km/s, 6.5° below horizontal
+ * const v = ballisticEntrySpeed(40_000, 11_000, (-6.5 * Math.PI / 180) as Radians, 322, 1.225, 7200);
+ * // v ≈ 6.9 km/s at 40 km
+ * ```
+ *
+ * @see {@link ballisticCoefficient}
+ * @see {@link ballisticPeakDeceleration}
+ * @see https://en.wikipedia.org/wiki/Atmospheric_entry Atmospheric entry
+ */
+export declare const ballisticEntrySpeed: (h: number, VE: number, gamma: number, beta: number, rho0: number, H: number) => number;
+//# sourceMappingURL=ballistic-entry-speed.d.ts.map

package/dist/categories/entry/ballistic-entry-speed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-entry-speed.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-entry-speed.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,mBAAmB,GAC9B,GAAG,MAAM,EACT,IAAI,MAAM,EACV,OAAO,MAAM,EACb,MAAM,MAAM,EACZ,MAAM,MAAM,EACZ,GAAG,MAAM,KACR,MAoBF,CAAC"}

package/dist/categories/entry/ballistic-entry-speed.js

@@ -0,0 +1,71 @@
+import { assertFinite, assertFlightPathAngle, assertPositive } from './validate.js';
+/**
+ * Compute the **speed of a ballistic entry** at an altitude, with the Allen–Eggers solution.
+ *
+ * $$
+ * V(h) = V_E \exp\left(-\frac{\rho_0 H}{2\beta\sin\lvert\gamma\rvert}\, e^{-h/H}\right)
+ * $$
+ *
+ * Where:
+ * - $ V_E $ is the speed at entry (m/s)
+ * - $ \gamma $ is the flight-path angle, constant along the straight path (rad)
+ * - $ \beta $ is the ballistic coefficient (kg/m²)
+ * - $ \rho_0 $ and $ H $ describe an exponential atmosphere, $ \rho = \rho_0 e^{-h/H} $
+ *
+ * **Units**
+ * - Inputs: `h` and `H` in **m**, `VE` in **m/s**, `gamma` in **radians**, `beta` in **kg/m²**, `rho0` in **kg/m³**.
+ * - Output: $ V $ in **m/s**.
+ *
+ * ::: info Notes
+ *
+ * - Assumes drag dominates: no lift, no gravity, and a straight path at a constant angle. That holds well for steep, fast entries of non-lifting bodies.
+ * - The deceleration at any altitude is $ \rho V^2 / (2\beta) $; its peak is {@link ballisticPeakDeceleration}, at {@link ballisticPeakDecelerationAltitude}.
+ * - `gamma` can be given as negative (descending, the usual convention) or positive: only its size is used.
+ * - Earth's lower atmosphere is roughly $ \rho_0 = 1.225 $ kg/m³ with $ H \approx 7.2 $ km. A single exponential is a rough fit; see the density models in [#226](https://github.com/phun-ky/interstellar-tools/issues/226).
+ *
+ * :::
+ *
+ * @param h - Altitude $ h $ in **m** (finite).
+ * @param VE - Entry speed $ V_E $ in **m/s** (finite, > 0).
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param beta - Ballistic coefficient $ \beta $ in **kg/m²** (finite, > 0).
+ * @param rho0 - Reference density $ \rho_0 $ in **kg/m³** (finite, > 0).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Speed $ V $ in **m/s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `VE`, `beta`, `rho0` or `H` is `<= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // A 322 kg/m² capsule entering at 11 km/s, 6.5° below horizontal
+ * const v = ballisticEntrySpeed(40_000, 11_000, (-6.5 * Math.PI / 180) as Radians, 322, 1.225, 7200);
+ * // v ≈ 6.9 km/s at 40 km
+ * ```
+ *
+ * @see {@link ballisticCoefficient}
+ * @see {@link ballisticPeakDeceleration}
+ * @see https://en.wikipedia.org/wiki/Atmospheric_entry Atmospheric entry
+ */
+export const ballisticEntrySpeed = (h, VE, gamma, beta, rho0, H) => {
+    assertFinite([
+        ['h', h],
+        ['VE', VE],
+        ['gamma', gamma],
+        ['beta', beta],
+        ['rho0', rho0],
+        ['H', H]
+    ]);
+    assertPositive([
+        ['VE', VE],
+        ['beta', beta],
+        ['rho0', rho0],
+        ['H', H]
+    ]);
+    assertFlightPathAngle(gamma);
+    const k = (rho0 * H) / (2 * beta * Math.sin(Math.abs(gamma)));
+    return VE * Math.exp(-k * Math.exp(-h / H));
+};
+//# sourceMappingURL=ballistic-entry-speed.js.map

package/dist/categories/entry/ballistic-entry-speed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-entry-speed.js","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-entry-speed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,CAAS,EACT,EAAU,EACV,KAAa,EACb,IAAY,EACZ,IAAY,EACZ,CAAS,EACD,EAAE;IACV,YAAY,CAAC;QACX,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,OAAO,EAAE,KAAK,CAAC;QAChB,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,cAAc,CAAC;QACb,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAE7B,MAAM,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAE9D,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC9C,CAAC,CAAC"}

package/dist/categories/entry/ballistic-peak-deceleration-altitude.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Compute the **altitude of peak deceleration** in a ballistic entry, with the Allen–Eggers solution.
+ *
+ * $$
+ * h^\ast = H \ln\frac{\rho_0 H}{\beta \sin\lvert\gamma\rvert}
+ * $$
+ *
+ * Where:
+ * - $ \beta $ is the ballistic coefficient (kg/m²)
+ * - $ \gamma $ is the flight-path angle (rad)
+ * - $ \rho_0 $ and $ H $ describe an exponential atmosphere, $ \rho = \rho_0 e^{-h/H} $
+ *
+ * **Units**
+ * - Inputs: `gamma` in **radians**, `beta` in **kg/m²**, `rho0` in **kg/m³**, `H` in **m**.
+ * - Output: $ h^\ast $ in **m**.
+ *
+ * ::: info Notes
+ *
+ * - Unlike the size of the peak ({@link ballisticPeakDeceleration}), its altitude does depend on the vehicle: a higher $ \beta $ peaks lower down.
+ * - A negative result means the vehicle would reach the surface before its deceleration peaks: it hits the ground still fast.
+ * - Same assumptions as {@link ballisticEntrySpeed}.
+ *
+ * :::
+ *
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param beta - Ballistic coefficient $ \beta $ in **kg/m²** (finite, > 0).
+ * @param rho0 - Reference density $ \rho_0 $ in **kg/m³** (finite, > 0).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Altitude of peak deceleration $ h^\ast $ in **m** (negative if below the surface).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `beta`, `rho0` or `H` is `<= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // A 322 kg/m² capsule, 6.5° below horizontal, in Earth's atmosphere
+ * const h = ballisticPeakDecelerationAltitude((-6.5 * Math.PI / 180) as Radians, 322, 1.225, 7200);
+ * // h ≈ 39.5 km
+ * ```
+ *
+ * @see {@link ballisticPeakDeceleration}
+ * @see {@link ballisticEntrySpeed}
+ */
+export declare const ballisticPeakDecelerationAltitude: (gamma: number, beta: number, rho0: number, H: number) => number;
+//# sourceMappingURL=ballistic-peak-deceleration-altitude.d.ts.map

package/dist/categories/entry/ballistic-peak-deceleration-altitude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-peak-deceleration-altitude.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-peak-deceleration-altitude.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,iCAAiC,GAC5C,OAAO,MAAM,EACb,MAAM,MAAM,EACZ,MAAM,MAAM,EACZ,GAAG,MAAM,KACR,MAeF,CAAC"}

package/dist/categories/entry/ballistic-peak-deceleration-altitude.js

@@ -0,0 +1,62 @@
+import { assertFinite, assertFlightPathAngle, assertPositive } from './validate.js';
+/**
+ * Compute the **altitude of peak deceleration** in a ballistic entry, with the Allen–Eggers solution.
+ *
+ * $$
+ * h^\ast = H \ln\frac{\rho_0 H}{\beta \sin\lvert\gamma\rvert}
+ * $$
+ *
+ * Where:
+ * - $ \beta $ is the ballistic coefficient (kg/m²)
+ * - $ \gamma $ is the flight-path angle (rad)
+ * - $ \rho_0 $ and $ H $ describe an exponential atmosphere, $ \rho = \rho_0 e^{-h/H} $
+ *
+ * **Units**
+ * - Inputs: `gamma` in **radians**, `beta` in **kg/m²**, `rho0` in **kg/m³**, `H` in **m**.
+ * - Output: $ h^\ast $ in **m**.
+ *
+ * ::: info Notes
+ *
+ * - Unlike the size of the peak ({@link ballisticPeakDeceleration}), its altitude does depend on the vehicle: a higher $ \beta $ peaks lower down.
+ * - A negative result means the vehicle would reach the surface before its deceleration peaks: it hits the ground still fast.
+ * - Same assumptions as {@link ballisticEntrySpeed}.
+ *
+ * :::
+ *
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param beta - Ballistic coefficient $ \beta $ in **kg/m²** (finite, > 0).
+ * @param rho0 - Reference density $ \rho_0 $ in **kg/m³** (finite, > 0).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Altitude of peak deceleration $ h^\ast $ in **m** (negative if below the surface).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `beta`, `rho0` or `H` is `<= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // A 322 kg/m² capsule, 6.5° below horizontal, in Earth's atmosphere
+ * const h = ballisticPeakDecelerationAltitude((-6.5 * Math.PI / 180) as Radians, 322, 1.225, 7200);
+ * // h ≈ 39.5 km
+ * ```
+ *
+ * @see {@link ballisticPeakDeceleration}
+ * @see {@link ballisticEntrySpeed}
+ */
+export const ballisticPeakDecelerationAltitude = (gamma, beta, rho0, H) => {
+    assertFinite([
+        ['gamma', gamma],
+        ['beta', beta],
+        ['rho0', rho0],
+        ['H', H]
+    ]);
+    assertPositive([
+        ['beta', beta],
+        ['rho0', rho0],
+        ['H', H]
+    ]);
+    assertFlightPathAngle(gamma);
+    return H * Math.log((rho0 * H) / (beta * Math.sin(Math.abs(gamma))));
+};
+//# sourceMappingURL=ballistic-peak-deceleration-altitude.js.map

package/dist/categories/entry/ballistic-peak-deceleration-altitude.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-peak-deceleration-altitude.js","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-peak-deceleration-altitude.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAC/C,KAAa,EACb,IAAY,EACZ,IAAY,EACZ,CAAS,EACD,EAAE;IACV,YAAY,CAAC;QACX,CAAC,OAAO,EAAE,KAAK,CAAC;QAChB,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,cAAc,CAAC;QACb,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAE7B,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC,CAAC"}

package/dist/categories/entry/ballistic-peak-deceleration.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Compute the **peak deceleration of a ballistic entry**, with the Allen–Eggers solution.
+ *
+ * $$
+ * a_\text{max} = \frac{V_E^2 \sin\lvert\gamma\rvert}{2\,e\,H}
+ * $$
+ *
+ * reached when the speed has fallen to $ V_E / \sqrt{e} \approx 0.61\,V_E $.
+ *
+ * Where:
+ * - $ V_E $ is the speed at entry (m/s)
+ * - $ \gamma $ is the flight-path angle (rad)
+ * - $ H $ is the atmosphere's scale height (m)
+ * - $ e $ is Euler's number
+ *
+ * **Units**
+ * - Inputs: `VE` in **m/s**, `gamma` in **radians**, `H` in **m**.
+ * - Output: $ a_\text{max} $ in **m/s²**. Divide by 9.80665 for g.
+ *
+ * ::: info Notes
+ *
+ * - The peak doesn't depend on the vehicle's mass, size or drag: a heavier one just reaches it lower down. Only the entry speed and angle matter.
+ * - It grows with $ \sin\lvert\gamma\rvert $: a steeper entry is a harder one.
+ * - Same assumptions as {@link ballisticEntrySpeed}: no lift, no gravity, a straight path. A lifting entry spreads the deceleration out and peaks much lower.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, coming home
+ *
+ * **35.8 g**
+ *
+ * _A ballistic entry at 11.03 km/s and −6.48°, with H = 7.2 km_
+ *
+ * The crew felt 6.56 g at the peak. The command module flew with lift, banking to control it, so it slowed down more gradually than a ballistic body would.
+ *
+ * ```ts
+ * ballisticPeakDeceleration(11_032, toRad(-6.48), 7200) / 9.80665; // ≈ 35.8 g
+ * ```
+ *
+ * :::
+ *
+ * @param VE - Entry speed $ V_E $ in **m/s** (finite, > 0).
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Peak deceleration $ a_\text{max} $ in **m/s²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `VE <= 0`, `H <= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // Entering at 7.8 km/s, 2° below horizontal
+ * const a = ballisticPeakDeceleration(7800, (-2 * Math.PI / 180) as Radians, 7200);
+ * // a ≈ 54 m/s², about 5.5 g
+ * ```
+ *
+ * @see {@link ballisticPeakDecelerationAltitude}
+ * @see {@link ballisticEntrySpeed}
+ */
+export declare const ballisticPeakDeceleration: (VE: number, gamma: number, H: number) => number;
+//# sourceMappingURL=ballistic-peak-deceleration.d.ts.map

package/dist/categories/entry/ballistic-peak-deceleration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-peak-deceleration.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-peak-deceleration.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,eAAO,MAAM,yBAAyB,GACpC,IAAI,MAAM,EACV,OAAO,MAAM,EACb,GAAG,MAAM,KACR,MAaF,CAAC"}

package/dist/categories/entry/ballistic-peak-deceleration.js

@@ -0,0 +1,76 @@
+import { assertFinite, assertFlightPathAngle, assertPositive } from './validate.js';
+/**
+ * Compute the **peak deceleration of a ballistic entry**, with the Allen–Eggers solution.
+ *
+ * $$
+ * a_\text{max} = \frac{V_E^2 \sin\lvert\gamma\rvert}{2\,e\,H}
+ * $$
+ *
+ * reached when the speed has fallen to $ V_E / \sqrt{e} \approx 0.61\,V_E $.
+ *
+ * Where:
+ * - $ V_E $ is the speed at entry (m/s)
+ * - $ \gamma $ is the flight-path angle (rad)
+ * - $ H $ is the atmosphere's scale height (m)
+ * - $ e $ is Euler's number
+ *
+ * **Units**
+ * - Inputs: `VE` in **m/s**, `gamma` in **radians**, `H` in **m**.
+ * - Output: $ a_\text{max} $ in **m/s²**. Divide by 9.80665 for g.
+ *
+ * ::: info Notes
+ *
+ * - The peak doesn't depend on the vehicle's mass, size or drag: a heavier one just reaches it lower down. Only the entry speed and angle matter.
+ * - It grows with $ \sin\lvert\gamma\rvert $: a steeper entry is a harder one.
+ * - Same assumptions as {@link ballisticEntrySpeed}: no lift, no gravity, a straight path. A lifting entry spreads the deceleration out and peaks much lower.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, coming home
+ *
+ * **35.8 g**
+ *
+ * _A ballistic entry at 11.03 km/s and −6.48°, with H = 7.2 km_
+ *
+ * The crew felt 6.56 g at the peak. The command module flew with lift, banking to control it, so it slowed down more gradually than a ballistic body would.
+ *
+ * ```ts
+ * ballisticPeakDeceleration(11_032, toRad(-6.48), 7200) / 9.80665; // ≈ 35.8 g
+ * ```
+ *
+ * :::
+ *
+ * @param VE - Entry speed $ V_E $ in **m/s** (finite, > 0).
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Peak deceleration $ a_\text{max} $ in **m/s²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `VE <= 0`, `H <= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // Entering at 7.8 km/s, 2° below horizontal
+ * const a = ballisticPeakDeceleration(7800, (-2 * Math.PI / 180) as Radians, 7200);
+ * // a ≈ 54 m/s², about 5.5 g
+ * ```
+ *
+ * @see {@link ballisticPeakDecelerationAltitude}
+ * @see {@link ballisticEntrySpeed}
+ */
+export const ballisticPeakDeceleration = (VE, gamma, H) => {
+    assertFinite([
+        ['VE', VE],
+        ['gamma', gamma],
+        ['H', H]
+    ]);
+    assertPositive([
+        ['VE', VE],
+        ['H', H]
+    ]);
+    assertFlightPathAngle(gamma);
+    return (VE * VE * Math.sin(Math.abs(gamma))) / (2 * Math.E * H);
+};
+//# sourceMappingURL=ballistic-peak-deceleration.js.map

package/dist/categories/entry/ballistic-peak-deceleration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-peak-deceleration.js","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-peak-deceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,EAAU,EACV,KAAa,EACb,CAAS,EACD,EAAE;IACV,YAAY,CAAC;QACX,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,OAAO,EAAE,KAAK,CAAC;QAChB,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,cAAc,CAAC;QACb,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAE7B,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAClE,CAAC,CAAC"}

package/dist/categories/entry/stagnation-heat-flux.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Compute the **convective heat flux at the stagnation point** of an entry vehicle, with the Sutton–Graves relation.
+ *
+ * $$
+ * \dot q = k\,\sqrt{\frac{\rho}{R_n}}\;V^3
+ * $$
+ *
+ * Where:
+ * - $ \rho $ is the free-stream density (kg/m³)
+ * - $ R_n $ is the nose radius: the radius of curvature at the stagnation point (m)
+ * - $ V $ is the speed (m/s)
+ * - $ k $ depends on the atmosphere's composition: about $ 1.7415 \times 10^{-4} $ kg$^{1/2}$/m for Earth's air and $ 1.9027 \times 10^{-4} $ for Mars
+ *
+ * **Units**
+ * - Inputs: `rho` in **kg/m³**, `V` in **m/s**, `Rn` in **m**, `k` in **kg^½/m**.
+ * - Output: $ \dot q $ in **W/m²**.
+ *
+ * ::: info Notes
+ *
+ * - The $ V^3 $ is why returning from the Moon is so much harder on a heat shield than returning from Earth orbit: 11 km/s against 7.8 km/s is almost three times the heating.
+ * - A blunter nose (larger $ R_n $) heats less, which is why capsules have broad, rounded heat shields rather than sharp points.
+ * - Convective heating only. At lunar return speeds the hot shock layer also radiates, which this doesn't include.
+ *
+ * :::
+ *
+ * @param rho - Free-stream density $ \rho $ in **kg/m³** (finite, > 0).
+ * @param V - Speed $ V $ in **m/s** (finite, > 0).
+ * @param Rn - Nose radius $ R_n $ in **m** (finite, > 0).
+ * @param k - Sutton–Graves constant $ k $ (finite, > 0). Defaults to `1.7415e-4`, for Earth.
+ * @returns Stagnation-point heat flux $ \dot q $ in **W/m²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is `<= 0`.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * // 11 km/s at about 60 km (ρ ≈ 3 × 10⁻⁴ kg/m³), with a 4.7 m nose radius
+ * const q = stagnationHeatFlux(3e-4, 11_000, 4.69);
+ * // q ≈ 1.85 MW/m²
+ * ```
+ *
+ * @see {@link ballisticEntrySpeed}
+ * @see https://en.wikipedia.org/wiki/Atmospheric_entry Atmospheric entry
+ */
+export declare const stagnationHeatFlux: (rho: number, V: number, Rn: number, k?: number) => number;
+//# sourceMappingURL=stagnation-heat-flux.d.ts.map

package/dist/categories/entry/stagnation-heat-flux.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stagnation-heat-flux.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/stagnation-heat-flux.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,kBAAkB,GAC7B,KAAK,MAAM,EACX,GAAG,MAAM,EACT,IAAI,MAAM,EACV,UAAa,KACZ,MAYF,CAAC"}

package/dist/categories/entry/stagnation-heat-flux.js

@@ -0,0 +1,57 @@
+import { assertFinite, assertPositive } from './validate.js';
+/**
+ * Compute the **convective heat flux at the stagnation point** of an entry vehicle, with the Sutton–Graves relation.
+ *
+ * $$
+ * \dot q = k\,\sqrt{\frac{\rho}{R_n}}\;V^3
+ * $$
+ *
+ * Where:
+ * - $ \rho $ is the free-stream density (kg/m³)
+ * - $ R_n $ is the nose radius: the radius of curvature at the stagnation point (m)
+ * - $ V $ is the speed (m/s)
+ * - $ k $ depends on the atmosphere's composition: about $ 1.7415 \times 10^{-4} $ kg$^{1/2}$/m for Earth's air and $ 1.9027 \times 10^{-4} $ for Mars
+ *
+ * **Units**
+ * - Inputs: `rho` in **kg/m³**, `V` in **m/s**, `Rn` in **m**, `k` in **kg^½/m**.
+ * - Output: $ \dot q $ in **W/m²**.
+ *
+ * ::: info Notes
+ *
+ * - The $ V^3 $ is why returning from the Moon is so much harder on a heat shield than returning from Earth orbit: 11 km/s against 7.8 km/s is almost three times the heating.
+ * - A blunter nose (larger $ R_n $) heats less, which is why capsules have broad, rounded heat shields rather than sharp points.
+ * - Convective heating only. At lunar return speeds the hot shock layer also radiates, which this doesn't include.
+ *
+ * :::
+ *
+ * @param rho - Free-stream density $ \rho $ in **kg/m³** (finite, > 0).
+ * @param V - Speed $ V $ in **m/s** (finite, > 0).
+ * @param Rn - Nose radius $ R_n $ in **m** (finite, > 0).
+ * @param k - Sutton–Graves constant $ k $ (finite, > 0). Defaults to `1.7415e-4`, for Earth.
+ * @returns Stagnation-point heat flux $ \dot q $ in **W/m²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is `<= 0`.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * // 11 km/s at about 60 km (ρ ≈ 3 × 10⁻⁴ kg/m³), with a 4.7 m nose radius
+ * const q = stagnationHeatFlux(3e-4, 11_000, 4.69);
+ * // q ≈ 1.85 MW/m²
+ * ```
+ *
+ * @see {@link ballisticEntrySpeed}
+ * @see https://en.wikipedia.org/wiki/Atmospheric_entry Atmospheric entry
+ */
+export const stagnationHeatFlux = (rho, V, Rn, k = 1.7415e-4) => {
+    const inputs = [
+        ['rho', rho],
+        ['V', V],
+        ['Rn', Rn],
+        ['k', k]
+    ];
+    assertFinite(inputs);
+    assertPositive(inputs);
+    return k * Math.sqrt(rho / Rn) * V ** 3;
+};
+//# sourceMappingURL=stagnation-heat-flux.js.map

package/dist/categories/entry/stagnation-heat-flux.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stagnation-heat-flux.js","sourceRoot":"","sources":["../../../src/categories/entry/stagnation-heat-flux.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,GAAW,EACX,CAAS,EACT,EAAU,EACV,CAAC,GAAG,SAAS,EACL,EAAE;IACV,MAAM,MAAM,GAAG;QACb,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;KACA,CAAC;IAEX,YAAY,CAAC,MAAM,CAAC,CAAC;IACrB,cAAc,CAAC,MAAM,CAAC,CAAC;IAEvB,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC1C,CAAC,CAAC"}