@saber-usa/node-common 1.7.7-alpha.2 → 1.7.8

package/README.md

@@ -36,7 +36,8 @@ A transformer for object keys is provided. This will take an object and transfor
 ## Publishing changes
 
 1. Change the version in package.json
-2. Run `npm publish && npm install`
+2. Check you are logged in to npm `npm whoami`
+2. Run `npm install` then `npm publish`
 3. Enable GPG in GIT: `git config --global commit.gpgsign true`
 4. Run `gpg --list-keys` to get your <id> 
 5. Tell the GIT to use your key `git config user.signingkey <id>`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber-usa/node-common",
-  "version": "1.7.7-alpha.2",
+  "version": "1.7.8",
   "description": "Common node functions for Saber",
   "main": "src/index.js",
   "type": "module",
@@ -9,8 +9,7 @@
     "lint:fix": "eslint . --ext js --fix",
     "test": "jest --no-coverage --silent",
     "test:unit": "jest --coverage --runInBand --no-watch",
-    "sonar": "node --experimental-vm-modules sonar-project.js",
-    "prepub:alpha": "npm version prerelease --preid=alpha && npm publish --tag alpha"
+    "sonar": "node --experimental-vm-modules sonar-project.js"
   },
   "files": [
     "src/**/*"

package/src/FrameConverter.js

@@ -3,7 +3,6 @@ import {Matrix3D, Vector3D} from "pious-squid";
 import {LLA} from "./LLA.js";
 import {TimeConverter, RaDec} from "./TimeConverter.js";
 import {norm, cross} from "mathjs";
-import {DEG2RAD} from "./constants.js";
 
 
 // Enums (assuming these exist elsewhere)
@@ -958,12 +957,12 @@ class FrameConverter {
     }
 
     static perifocalToInertial(keplerianElements) {
-        const cosi = Math.cos(keplerianElements.i * DEG2RAD);
-        const sini = Math.sin(keplerianElements.i * DEG2RAD);
-        const cosRaan = Math.cos(keplerianElements.raan * DEG2RAD);
-        const sinRaan = Math.sin(keplerianElements.raan * DEG2RAD);
-        const cosw = Math.cos(keplerianElements.w * DEG2RAD);
-        const sinw = Math.sin(keplerianElements.w * DEG2RAD);
+        const cosi = Math.cos(keplerianElements.inclination);
+        const sini = Math.sin(keplerianElements.inclination);
+        const cosRaan = Math.cos(keplerianElements.raan);
+        const sinRaan = Math.sin(keplerianElements.raan);
+        const cosw = Math.cos(keplerianElements.argOfPeriapsis);
+        const sinw = Math.sin(keplerianElements.argOfPeriapsis);
 
         // The matrix elements
         const r11 = cosRaan * cosw - sinRaan * sinw * cosi;

package/src/LaunchNominalClass.js

@@ -5,14 +5,12 @@ import {WGS84_EARTH_EQUATORIAL_RADIUS_KM,
     GRAV_CONST,
     EARTH_MASS,
     MU,
-    EARTH_RADIUS_KM,
-    DEG2RAD} from "./constants.js";
+    EARTH_RADIUS_KM} from "./constants.js";
 import {FrameConverter} from "./FrameConverter.js";
 import {OrbitUtils} from "./OrbitUtils.js";
 import {wrapOneRevUnsigned} from "./utils.js";
 import {BallisticPropagator} from "./ballisticPropagator.js";
 import {norm, cross, dot} from "mathjs";
-import {cartesianToKeplerian, keplerianToCartesian} from "./astro.js";
 
 // Reference frames enum
 const ReferenceFrame = {
@@ -22,8 +20,6 @@ const ReferenceFrame = {
     GCRF: "GCRF",
 };
 
-const mu = GRAV_CONST * EARTH_MASS / 1e9; // km^3/s^2
-
 class LaunchNominalClass {
     /** Get position at a given time in specified reference frame
      *
@@ -58,6 +54,7 @@ class LaunchNominalClass {
         let bearingRad = degreesToRadians(bearingDeg);
         bearingRad = wrapOneRevUnsigned(bearingRad);
 
+        // const latRad = degreesToRadians(this.groundSiteLat);
         const latRad = llaVals.Latitude.Radians;
         const targetInclination = OrbitUtils.getInclination(bearingRad, latRad);
 
@@ -78,7 +75,23 @@ class LaunchNominalClass {
             ReferenceFrame.J2000,
             llaVals,
         );
-
+        // Trying something here
+
+        // const transformMatrix = FrameConverter.j2000ToTEME(orbitInsertionTime);
+        // const initialTemeState = {
+        //     position: this.transformVector(
+        //         new Vector3D(initialStateVector.position[0],
+        //             initialStateVector.position[1], initialStateVector.position[2]),
+        //         transformMatrix
+        //     ),
+        //     velocity: this.transformVector(
+        //         new Vector3D(initialStateVector.velocity[0],
+        //             initialStateVector.velocity[1], initialStateVector.velocity[2]),
+        //         transformMatrix
+        //     ),
+        // };
+
+        // End of something
         const initialJ2000State = new J2000(
             EpochUTC.fromDateString(orbitInsertionTime.toISOString()),
             new Vector3D(initialStateVector.position[0],
@@ -91,11 +104,11 @@ class LaunchNominalClass {
 
         let sat = {
             stateVector: initialStateVector,
-            elements: cartesianToKeplerian(
+            elements: OrbitUtils.stateVectorToElements(
                 [initialTemeState.position.x, initialTemeState.position.y,
                     initialTemeState.position.z],
                 [initialTemeState.velocity.x, initialTemeState.velocity.y,
-                    initialTemeState.velocity.z], mu),
+                    initialTemeState.velocity.z]),
             epoch: orbitInsertionTime,
         };
 
@@ -137,12 +150,12 @@ class LaunchNominalClass {
 
                 const temeState = propagatedJ2000State.toTEME();
 
-                // Convert to orbital elements - angles are in degrees
-                const elements = cartesianToKeplerian(
+                // Convert to orbital elements
+                const elements = OrbitUtils.stateVectorToElements(
                     [temeState.position.x, temeState.position.y,
                         temeState.position.z],
                     [temeState.velocity.x, temeState.velocity.y,
-                        temeState.velocity.z], mu);
+                        temeState.velocity.z]);
 
                 sat = {
                     stateVector: propagated,
@@ -152,7 +165,7 @@ class LaunchNominalClass {
 
                 // Calculate current inclination
                 oldInclinationDelta = inclinationDelta;
-                inclinationDelta = Math.abs((sat.elements.i)
+                inclinationDelta = Math.abs(radiansToDegrees(sat.elements.inclination)
                     - radiansToDegrees(targetInclination));
 
                 if (oldInclinationDelta < inclinationDelta) {
@@ -225,22 +238,22 @@ class LaunchNominalClass {
         // Transform to elliptical orbit
         const ellipticalElements = OrbitUtils.transformElliptical(
             svInitial,
-            initialNominal.states[0].elements.inc * DEG2RAD,
-            initialNominal.states[0].elements.raan * DEG2RAD,
+            initialNominal.states[0].elements.inc,
+            initialNominal.states[0].elements.raan,
             targetEcc,
-            targetArgOfPeriapsisDeg * DEG2RAD,
+            degreesToRadians(targetArgOfPeriapsisDeg),
             targetPerigeeKm + WGS84_EARTH_EQUATORIAL_RADIUS_KM,
         );
 
         // Convert elliptical elements to cartesian state
-        const ellipticalStateVector = keplerianToCartesian(ellipticalElements, mu);
+        const ellipticalStateVector = OrbitUtils.elementsToStateVector(ellipticalElements);
 
-        const ellipticalPos = ellipticalStateVector.r;
-        const ellipticalVel = ellipticalStateVector.v;
+        const ellipticalPos = ellipticalStateVector.position;
+        const ellipticalVel = ellipticalStateVector.velocity;
 
         const ellipticalState = {
-            position: new NodeVector3D(ellipticalPos.x, ellipticalPos.y, ellipticalPos.z),
-            velocity: new NodeVector3D(ellipticalVel.x, ellipticalVel.y, ellipticalVel.z),
+            position: new NodeVector3D(ellipticalPos[0], ellipticalPos[1], ellipticalPos[2]),
+            velocity: new NodeVector3D(ellipticalVel[0], ellipticalVel[1], ellipticalVel[2]),
             epochUtc: orbitInsertionTime,
             referenceFrame: "J2000",
         };
@@ -253,7 +266,7 @@ class LaunchNominalClass {
         const ellipNomVel = ellipticalNominal.velocity;
 
         // Convert to orbital elements
-        const elements = cartesianToKeplerian(
+        const elements = OrbitUtils.stateVectorToElements(
             [ellipNomPos.x, ellipNomPos.y, ellipNomPos.z],
             [ellipNomVel.x, ellipNomVel.y, ellipNomVel.z]);
 
@@ -393,7 +406,7 @@ class LaunchNominalClass {
     }
 
     static hohmannTransferWithIncZeroing(state0, targetSMA,
-        burnAtNodes = 1, mu = MU) {
+        burnAtNodes = 1, mu = MU / 1e9) {
         let t0 = state0.epochUtc;
         let i = null;
 
@@ -458,8 +471,8 @@ class LaunchNominalClass {
 
         const rElementConv = [state0.position.x, state0.position.y, state0.position.z];
         const vElementConv = [state0.velocity.x, state0.velocity.y, state0.velocity.z];
-        const elements0 = cartesianToKeplerian(rElementConv, vElementConv, mu);
-        const incDiff = elements0.i * DEG2RAD;
+        const elements0 = OrbitUtils.stateVectorToElements(rElementConv, vElementConv);
+        const incDiff = elements0.inclination;
 
         const h = cross([state0.position.x, state0.position.y, state0.position.z],
             [state0.velocity.x, state0.velocity.y, state0.velocity.z]);
@@ -525,34 +538,41 @@ class LaunchNominalClass {
     }
 
     static #getNextNodeCrossingGeoOrbit(sv) {
-        const geoElements = [35786 + EARTH_RADIUS_KM, 0, 0, 0, 0, 0];
+        const geoElements = {
+            semiMajorAxis: 35786.0 + EARTH_RADIUS_KM,
+            eccentricity: 0,
+            inclination: 0,
+            raan: 0,
+            argOfPeriapsis: 0,
+            trueAnomaly: 0,
+        };
         const geoOrbitState = {
-            state: keplerianToCartesian(geoElements, mu),
+            state: OrbitUtils.elementsToStateVector(geoElements),
             epochUtc: sv.epochUtc,
         };
         const nextNode = this.#findMutualNodeTimes(sv, geoOrbitState);
         return nextNode.nextNodeTime;
     }
 
-    static #findMutualNodeTimes(sv1, sv2, muEarth = MU) {
+    static #findMutualNodeTimes(sv1, sv2, muEarth = MU / 1e9) {
         // Implementation for finding mutual node times between two state vectors
 
         if (!(sv1.epochUtc === sv2.epochUtc)) {
             return "lol what on earth";
         }
 
-        const orbit1 = cartesianToKeplerian(
+        const orbit1 = OrbitUtils.stateVectorToElements(
             [sv1.position.x, sv1.position.y, sv1.position.z],
-            [sv1.velocity.x, sv1.velocity.y, sv1.velocity.z], muEarth);
+            [sv1.velocity.x, sv1.velocity.y, sv1.velocity.z]);
+        const orbit2 = OrbitUtils.stateVectorToElements(
+            sv2.state.position,
+            sv2.state.velocity);
 
-        const orbit2 = cartesianToKeplerian(
-            [sv2.state.r.x, sv2.state.r.y, sv2.state.r.z],
-            [sv2.state.v.x, sv2.state.v.y, sv2.state.v.z], muEarth);
+        const state1 = OrbitUtils.elementsToStateVector(orbit1);
+        const state2 = OrbitUtils.elementsToStateVector(orbit2);
 
-        const state1 = keplerianToCartesian(Object.values(orbit1), muEarth);
-        const state2 = keplerianToCartesian(Object.values(orbit2), muEarth);
-        const h1 = cross(Object.values(state1.r), Object.values(state1.v));
-        const h2 = cross(Object.values(state2.r), Object.values(state2.v));
+        const h1 = cross(state1.position, state1.velocity);
+        const h2 = cross(state2.position, state2.velocity);
         const h1Norm = norm(h1);
         const h2Norm = norm(h2);
 
@@ -565,8 +585,7 @@ class LaunchNominalClass {
             return Math.acos(dotProduct / normsProduct);
         }
 
-        const ascendingFirst
-            = getAngleBetween2Vectors(Object.values(state1.r), h2unit) > Math.PI / 2;
+        const ascendingFirst = getAngleBetween2Vectors(state1.position, h2unit) > Math.PI / 2;
 
         const nodalLine = cross(h1unit, h2unit);
         const nodalLineUnit = nodalLine.map((component) => component / norm(nodalLine));
@@ -581,10 +600,10 @@ class LaunchNominalClass {
 
         const mutualNodeLinePerifocal = rTilde1inverse.multiplyVector3D(nodalLineUnitVector3D);
         const slopeMutualNodalLinePerifocal = mutualNodeLinePerifocal.y / mutualNodeLinePerifocal.x;
-        const mutualNode = this.#findIntersectionEllipseLine(
+        const mutualNode = this.#findIntersectionEllipseLine( // inputs here are causing an error increase
             slopeMutualNodalLinePerifocal,
-            orbit1.a,
-            orbit1.e);
+            orbit1.semiMajorAxis,
+            orbit1.eccentricity);
 
         const q1 = mutualNode.vec1;
         const q2 = mutualNode.vec2;
@@ -595,13 +614,13 @@ class LaunchNominalClass {
             return ((n % m) + m) % m;
         }
 
-        const n0 = mod(orbit1.f * DEG2RAD, 2 * Math.PI);
+        const n0 = mod(orbit1.trueAnomaly, 2 * Math.PI);
         const n1 = mod(Math.atan2(dot(q1unit, [0, 1, 0]), dot(q1unit, [1, 0, 0])), 2 * Math.PI);
         const n2 = mod(Math.atan2(dot(q2unit, [0, 1, 0]), dot(q2unit, [1, 0, 0])), 2 * Math.PI);
 
-        const e0 = OrbitUtils.trueAnomalyToEccentricAnomaly(n0, orbit1.e);
-        let e1 = OrbitUtils.trueAnomalyToEccentricAnomaly(n1, orbit1.e); // only matching to 2 sig figs w astrolib
-        let e2 = OrbitUtils.trueAnomalyToEccentricAnomaly(n2, orbit1.e); // only matching to 3 sig figs w astrolib
+        const e0 = OrbitUtils.trueAnomalyToEccentricAnomaly(n0, orbit1.eccentricity);
+        let e1 = OrbitUtils.trueAnomalyToEccentricAnomaly(n1, orbit1.eccentricity); // only matching to 2 sig figs w astrolib
+        let e2 = OrbitUtils.trueAnomalyToEccentricAnomaly(n2, orbit1.eccentricity); // only matching to 3 sig figs w astrolib
 
         if (e1 < 0) {
             e1 += 2 * Math.PI;
@@ -614,13 +633,13 @@ class LaunchNominalClass {
         const k1 = n1 < n0 ? 1 : 0;
         const k2 = n2 < n0 ? 1 : 0;
 
-        const dt1 = Math.sqrt(Math.pow(orbit1.a, 3) / muEarth)
-            * (2 * k1 * Math.PI + (e1 - orbit1.e * Math.sin(e1))
-                - (e0 - orbit1.e * Math.sin(e0)));
+        const dt1 = Math.sqrt(Math.pow(orbit1.semiMajorAxis, 3) / muEarth)
+            * (2 * k1 * Math.PI + (e1 - orbit1.eccentricity * Math.sin(e1))
+                - (e0 - orbit1.eccentricity * Math.sin(e0)));
         const dt2 = Math.sqrt(
-            Math.pow(orbit1.a, 3) / muEarth)
-            * (2 * k2 * Math.PI + (e2 - orbit1.e * Math.sin(e2))
-                - (e0 - orbit1.e * Math.sin(e0)));
+            Math.pow(orbit1.semiMajorAxis, 3) / muEarth)
+            * (2 * k2 * Math.PI + (e2 - orbit1.eccentricity * Math.sin(e2))
+                - (e0 - orbit1.eccentricity * Math.sin(e0)));
         let first = null;
         let second = null;
 
@@ -700,7 +719,7 @@ class LaunchNominalOutput {
             const j2000ToTeme = FrameConverter.getTransform("J2000", "TEME", epoch);
             const posTeme = FrameConverter.transformVector(pos, j2000ToTeme);
             const velTeme = FrameConverter.transformVector(vel, j2000ToTeme);
-            elements = cartesianToKeplerian(
+            elements = OrbitUtils.stateVectorToElements(
                 [posTeme.x, posTeme.y, posTeme.z],
                 [velTeme.x, velTeme.y, velTeme.z]);
         }
@@ -712,12 +731,12 @@ class LaunchNominalOutput {
                 v: [vel.x, vel.y, vel.z],
             },
             elements: {
-                sma: elements.a,
-                ecc: elements.e,
-                inc: elements.i,
+                sma: elements.semiMajorAxis,
+                ecc: elements.eccentricity,
+                inc: elements.inclination,
                 raan: elements.raan,
-                argp: elements.w,
-                ta: elements.f,
+                argp: elements.argOfPeriapsis,
+                ta: elements.trueAnomaly,
             },
             // Placeholder for tle
         });

package/src/OrbitUtils.js

@@ -1,10 +1,13 @@
-import {MU, RAD2DEG} from "./constants.js";
+import {MU} from "./constants.js";
 import {cross, norm} from "mathjs";
 import {wrapHalfRevUnsigned, wrapOneRevUnsigned} from "./utils.js";
 
-const EARTH_MU_KM = MU; // km³/s²
+const EARTH_MU_KM = MU / 1e9;
 
 class OrbitUtils {
+    constructor() {
+        // Prevent instantiation
+    }
     /**
      * Get inclination based on azimuth and latitude.
      * @param {number} azimuthRad - Azimuth in radians
@@ -138,8 +141,15 @@ class OrbitUtils {
             if (Math.abs(b - a) < tolerance) {
                 // Found minimum
                 const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-                return [semiMajorAxis, targetEcc, incRad * RAD2DEG,
-                    raanRad * RAD2DEG, targetArgOfPeriapsisRad * RAD2DEG, c * RAD2DEG];
+                return {
+                    semiMajorAxis: semiMajorAxis,
+                    eccentricity: targetEcc,
+                    inclination: incRad,
+                    raan: raanRad,
+                    argOfPeriapsis: targetArgOfPeriapsisRad,
+                    trueAnomaly: c,
+                    epoch: svInitial.epoch,
+                };
             }
 
             xm = 0.5 * (a + b);
@@ -150,8 +160,15 @@ class OrbitUtils {
             if (min1 < tol1 || min2 < tol1) {
                 // Found minimum
                 const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-                return [semiMajorAxis, targetEcc, incRad * RAD2DEG,
-                    raanRad * RAD2DEG, targetArgOfPeriapsisRad * RAD2DEG, c * RAD2DEG];
+                return {
+                    semiMajorAxis: semiMajorAxis,
+                    eccentricity: targetEcc,
+                    inclination: incRad,
+                    raan: raanRad,
+                    argOfPeriapsis: targetArgOfPeriapsisRad,
+                    trueAnomaly: c,
+                    epoch: svInitial.epoch,
+                };
             }
 
             // Construct a trial parabolic fit
@@ -254,6 +271,170 @@ class OrbitUtils {
         return {position: r, velocity: v};
     }
 
+    /**
+     * Convert state vector (position, velocity) to classical orbital elements
+     * @param {Array} r - Position vector [x, y, z] in km
+     * @param {Array} v - Velocity vector [vx, vy, vz] in km/s
+     * @param {number} mu - Standard gravitational parameter (default: Earth)
+     * @return {Object} Orbital elements
+     */
+    static stateVectorToElements(r, v, mu = EARTH_MU_KM) {
+        const tol = 1e-9;
+
+        if (mu < 1e-30) {
+            throw new Error("Mu must be greater than 1e-30.");
+        }
+
+        // Helper functions
+        function cross(a, b) {
+            return [
+                a[1] * b[2] - a[2] * b[1],
+                a[2] * b[0] - a[0] * b[2],
+                a[0] * b[1] - a[1] * b[0],
+            ];
+        }
+
+        function dot(a, b) {
+            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+        }
+
+        function norm(v) {
+            return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+        }
+
+        function clamp(value, min, max) {
+            return Math.min(Math.max(value, min), max);
+        }
+
+        // Calculate basic vectors
+        const h = cross(r, v);
+        const n = cross([0, 0, 1], h);
+
+        const rLength = norm(r);
+        const vLength = norm(v);
+
+        if (rLength === 0) throw new Error("Position vector must not be zero.");
+        if (vLength === 0) throw new Error("Velocity vector must not be zero.");
+
+        // Eccentricity vector calculation (corrected formula)
+        const vLengthSq = vLength * vLength;
+        const muOverR = mu / rLength;
+        const rvDot = dot(r, v);
+
+        const e = [
+            (1 / mu) * ((vLengthSq - muOverR) * r[0] - rvDot * v[0]),
+            (1 / mu) * ((vLengthSq - muOverR) * r[1] - rvDot * v[1]),
+            (1 / mu) * ((vLengthSq - muOverR) * r[2] - rvDot * v[2]),
+        ];
+
+        const zeta = 0.5 * vLengthSq - muOverR;
+
+        if (zeta === 0) throw new Error("Zeta cannot be zero.");
+
+        const eLength = norm(e);
+        if (Math.abs(1.0 - eLength) <= tol) {
+            throw new Error("Parabolic orbit conversion is not supported.");
+        }
+
+        const a = -mu / (zeta * 2);
+
+        if (Math.abs(a * (1 - eLength)) < 1e-3) {
+            throw new Error("The state results in a singular conic section "
+                + "with radius of periapsis less than 1 m.");
+        }
+
+        const hLength = norm(h);
+        if (hLength === 0) {
+            throw new Error(`Cannot convert from Cartesian to Keplerian 
+                - angular momentum is zero.`);
+        }
+
+        const i = Math.acos(h[2] / hLength);
+
+        if (i >= Math.PI - tol) {
+            throw new Error("Cannot convert orbit with inclination of 180 degrees.");
+        }
+
+        let raan = 0;
+        let w = 0;
+        let f = 0;
+
+        const nLength = norm(n);
+
+        // CASE 1: Non-circular, Inclined Orbit
+        if (eLength >= 1e-11 && i >= 1e-11 && i <= Math.PI - 1e-11) {
+            if (nLength === 0.0) {
+                throw new Error("Cannot convert from Cartesian to Keplerian "
+                    + "- line-of-nodes vector is a zero vector.");
+            }
+
+            raan = Math.acos(n[0] / nLength);
+            if (n[1] < 0) raan = 2 * Math.PI - raan;
+
+            w = Math.acos(dot(n, e) / (nLength * eLength));
+            if (e[2] < 0) w = 2 * Math.PI - w;
+
+            f = Math.acos(clamp(dot(e, r) / (eLength * rLength), -1, 1));
+            if (rvDot < 0) f = 2 * Math.PI - f;
+        } else if (eLength >= 1e-11 && (i < 1e-11 || i > Math.PI - 1e-11)) { // CASE 2: Non-circular, Equatorial Orbit
+            if (eLength === 0.0) {
+                throw new Error(`Cannot convert from Cartesian to Keplerian 
+                    - eccentricity is zero.`);
+            }
+            raan = 0;
+            w = Math.acos(e[0] / eLength);
+            if (e[1] < 0) w = 2 * Math.PI - w;
+
+            // For GMT-4446 fix (LOJ: 2014.03.21)
+            if (i > Math.PI - 1e-11) w *= -1.0;
+            if (w < 0.0) w += 2 * Math.PI;
+
+            f = Math.acos(clamp(dot(e, r) / (eLength * rLength), -1, 1));
+            if (rvDot < 0) f = 2 * Math.PI - f;
+        } else if (eLength < 1e-11 && i >= 1e-11 && i <= Math.PI - 1e-11) { // CASE 3: Circular, Inclined Orbit
+            if (nLength === 0.0) {
+                throw new Error("Cannot convert from Cartesian to Keplerian "
+                   + "- line-of-nodes vector is a zero vector.");
+            }
+            raan = Math.acos(n[0] / nLength);
+            if (n[1] < 0) raan = 2 * Math.PI - raan;
+
+            w = 0;
+
+            f = Math.acos(clamp(dot(n, r) / (nLength * rLength), -1, 1));
+            if (r[2] < 0) f = 2 * Math.PI - f;
+        } else if (eLength < 1e-11 && (i < 1e-11 || i > Math.PI - 1e-11)) { // CASE 4: Circular, Equatorial Orbit
+            raan = 0;
+            w = 0;
+            f = Math.acos(clamp(r[0] / rLength, -1, 1));
+            if (r[1] < 0) f = 2 * Math.PI - f;
+
+            // For GMT-4446 fix (LOJ: 2014.03.21)
+            if (i > Math.PI - 1e-11) f *= -1.0;
+            if (f < 0.0) f += 2 * Math.PI;
+        }
+
+        // Calculate additional orbital parameters
+        const period = 2 * Math.PI * Math.sqrt(Math.pow(Math.abs(a), 3) / mu);
+        const meanMotion = 2 * Math.PI / period;
+
+        // Convert true anomaly to mean anomaly properly
+        const eccentricAnomaly = this.trueAnomalyToEccentricAnomaly(f, eLength);
+        const meanAnomaly = this.eccentricAnomalyToMeanAnomaly(eccentricAnomaly, eLength);
+
+        return {
+            semiMajorAxis: a, // km
+            eccentricity: eLength, // dimensionless
+            inclination: i, // radians
+            raan: raan, // radians (Right Ascension of Ascending Node)
+            argOfPeriapsis: w, // radians (Argument of Periapsis)
+            trueAnomaly: f, // radians
+            meanAnomaly: meanAnomaly, // radians (simplified)
+            period: period, // seconds
+            meanMotion: meanMotion, // rad/s
+        };
+    }
+
     /**
      * Convert true anomaly to eccentric anomaly
      * @param {number} nu - true anomaly

package/src/PropagateUtils.js

@@ -6,8 +6,8 @@ import {RungeKutta4Propagator,
     ClassicalElements} from "pious-squid";
 import {sgp4} from "satellite.js";
 import {NodeVector3D} from "./NodeVector3D.js";
-import {cartesianToKeplerian, checkTle} from "./astro.js";
-import {DEG2RAD} from "./constants.js";
+import {checkTle} from "./astro.js";
+import {OrbitUtils} from "./OrbitUtils.js";
 
 const ReferenceFrame = {
     ITRF: "ITRF",
@@ -62,17 +62,17 @@ class PropagateUtils {
     }
 
     static keplerianPropagator(initialState, time) {
-        const elementsObjReal = cartesianToKeplerian(
+        const elementsObj = OrbitUtils.stateVectorToElements(
             initialState.position, initialState.velocity);
 
         const elements = new ClassicalElements(
             new EpochUTC(initialState.epoch),
-            elementsObjReal.a,
-            elementsObjReal.e,
-            elementsObjReal.i * DEG2RAD,
-            elementsObjReal.raan * DEG2RAD,
-            elementsObjReal.w * DEG2RAD,
-            elementsObjReal.f * DEG2RAD,
+            elementsObj.semiMajorAxis,
+            elementsObj.eccentricity,
+            elementsObj.inclination,
+            elementsObj.raan,
+            elementsObj.argOfPeriapsis,
+            elementsObj.trueAnomaly,
         );
 
         // Now pass to KeplerPropagator:

package/src/astro.js

@@ -43,9 +43,6 @@ import {DEG2RAD,
     WGS84_EARTH_EQUATORIAL_RADIUS_KM,
     MILLIS_PER_DAY,
     GEO_ALTITUDE_KM,
-    MU,
-    MU_GRS80,
-    MU_SI,
     ERROR_CODES} from "./constants.js";
 
 // Solar Terminator
@@ -457,19 +454,25 @@ const angleBetween3DCoords = (coord1, coord2, coord3) => {
  * which uses the In-track,Cross-Track axes to instantiate it.
  * @param {Object} pv1
  * @param {Object} pv2
- * @return {Object} Delta-v in km/s in RSW frame to perform a single impulsive
+ * @return {Object} Delta-v in m/s in RSW frame to perform a single impulsive
  * plane match maneuver of sat1 to sat2.
 */
 const planeChangeDeltaV = (pv1, pv2) => {
+    const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
+
     // 1. Compute the angular momentum of each orbit from the pos vel vectors
-    const r = [pv1.position.x, pv1.position.y, pv1.position.z];
-    const v = [pv1.velocity.x, pv1.velocity.y, pv1.velocity.z];
+    const r = multiply([pv1.position.x, pv1.position.y, pv1.position.z],
+        1000.0);
+    const v = multiply([pv1.velocity.x, pv1.velocity.y, pv1.velocity.z],
+        1000.0);
     const h1 = cross(r, v);
 
     const vMag = norm(v);
 
-    const r2 = [pv2.position.x, pv2.position.y, pv2.position.z];
-    const v2 = [pv2.velocity.x, pv2.velocity.y, pv2.velocity.z];
+    const r2 = multiply([pv2.position.x, pv2.position.y, pv2.position.z],
+        1000.0);
+    const v2 = multiply([pv2.velocity.x, pv2.velocity.y, pv2.velocity.z],
+        1000.0);
     const h2 = cross(r2, v2);
 
     // 2. Compute the mutual line of nodes vector
@@ -477,9 +480,9 @@ const planeChangeDeltaV = (pv1, pv2) => {
 
     // 3. Compute the eccentricity vector of sat1
     const e = multiply(
-        (1 / MU),
+        (1 / mu),
         subtract(
-            (multiply(Math.pow(norm(v, 2), 2) - (MU / norm(r, 2)), r)),
+            (multiply(Math.pow(norm(v, 2), 2) - (mu / norm(r, 2)), r)),
             multiply(dot(r, v), v)),
     );
 
@@ -570,21 +573,21 @@ const planeChangeDeltaV = (pv1, pv2) => {
  *
  * @param {Object} pv1 Position and Velocity Vector of Satelltie 1 at Time = x
  * @param {Object} pv2 Position and velocity Vector of Satellite 2 at Time = x
- * @return {Object} Delta-v in km/s to perform a pure inclination plane change at
+ * @return {Object} Delta-v in m/s to perform a pure inclination plane change at
  * the sat1 asc or desc node.
  */
 const planeChangePureInclinationDeltaV = (pv1, pv2)=>{
     // 1. Get position and velocity vectors and magnitudes.
     // Note that the magnitude of the final velocity for sat1 will be EQUAL
     // to this initial velocity magnitude of sat1!
-    const r = [pv1.position.x, pv1.position.y, pv1.position.z];
-    const v = [pv1.velocity.x, pv1.velocity.y, pv1.velocity.z];
+    const r = multiply([pv1.position.x, pv1.position.y, pv1.position.z], 1000.0);
+    const v = multiply([pv1.velocity.x, pv1.velocity.y, pv1.velocity.z], 1000.0);
 
-    // Velocity Magnitude in km/s
+    // Velocity Magnitude in m/s
     const vMag = norm(v);
 
-    const r2 = [pv2.position.x, pv2.position.y, pv2.position.z];
-    const v2 = [pv2.velocity.x, pv2.velocity.y, pv2.velocity.z];
+    const r2 = multiply([pv2.position.x, pv2.position.y, pv2.position.z], 1000.0);
+    const v2 = multiply([pv2.velocity.x, pv2.velocity.y, pv2.velocity.z], 1000.0);
 
     // 2. Compute the Keplerian Elements of both satellites.
     const el = cartesianToKeplerian(r, v);
@@ -1401,12 +1404,12 @@ const GetElsetUdlFromTle = (
  * @param {Number} lon1 The longitude of the first coordinate in degrees
  * @param {Number} lat2 The latitude of the second coordinate in degrees
  * @param {Number} lon2 The longitude of the second coordinate in degrees
- * @return {Number} The distance between the two coordinates in kilometers
+ * @return {Number} The distance between the two coordinates in meters
  *
  * Source: https://www.movable-type.co.uk/scripts/latlong.html
  */
 const distGeodetic = (lat1, lon1, lat2, lon2) => {
-    const R = WGS84_EARTH_EQUATORIAL_RADIUS_KM; // kilometers
+    const R = WGS84_EARTH_EQUATORIAL_RADIUS_KM * 1000.0; // metres
     const phi1 = lat1 * DEG2RAD; // φ1 in formula
     const phi2 = lat2 * DEG2RAD; // φ2 in formula
     const deltaPhi = (lat2 - lat1) * DEG2RAD; // Δφ in formula
@@ -1419,7 +1422,7 @@ const distGeodetic = (lat1, lon1, lat2, lon2) => {
             * Math.sin(deltaLambda / 2);
     const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
 
-    const d = R * c; // in kilometers
+    const d = R * c; // in metres
 
     return d;
 };
@@ -1432,13 +1435,13 @@ const distGeodetic = (lat1, lon1, lat2, lon2) => {
  * NOTE 2: raan, argument of periapsis, and true anomaly are ALL in degrees!
  * NOTE 3: SMA (a) is in km
  *
- * @param {Array} r Position, in kilometers
- * @param {Array} v Velocity, in km/s
- * @param {Number} mu Gravitational Parameter, defaults to Earth's mu in km^3/s^2
+ * @param {Array} r Position, in meters
+ * @param {Array} v Velocity, in m/s
  * @return {Object} An object containing the Keplerian Elements, if successful. Otherwise, an empty object.
  */
-const cartesianToKeplerian = (r, v, mu = MU) => {
+const cartesianToKeplerian = (r, v) => {
     try {
+        const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
         const tol = 1e-9;
 
         const h = cross(r, v);
@@ -1449,20 +1452,20 @@ const cartesianToKeplerian = (r, v, mu = MU) => {
         if (norm(v, 2) === 0) throw new Error("Velocity vector must not be zero.");
 
         const e = multiply(
-            (1 / MU),
+            (1 / mu),
             subtract(
-                (multiply(Math.pow(norm(v, 2), 2) - (MU / norm(r, 2)), r)),
+                (multiply(Math.pow(norm(v, 2), 2) - (mu / norm(r, 2)), r)),
                 multiply(dot(r, v), v)),
         );
 
-        const zeta = 0.5 * Math.pow(norm(v), 2) - (MU / norm(r));
+        const zeta = 0.5 * Math.pow(norm(v), 2) - (mu / norm(r));
 
         if (zeta === 0) throw new Error("Zeta cannot be zero.");
         if (Math.abs(1.0 - norm(e)) <= tol) {
             throw new Error("Parabolic orbit conversion is not supported.");
         }
 
-        const a = -MU / zeta / 2;
+        const a = -mu / zeta / 2;
 
         if (Math.abs(a * (1 - norm(e))) < 1e-3) {
             throw new Error(`The state results in a singular conic section with 
@@ -1552,7 +1555,7 @@ const cartesianToKeplerian = (r, v, mu = MU) => {
         }
 
         return {
-            a: a, // km
+            a: a /1000.0, // km
             e: norm(e),
             i: i * RAD2DEG, // deg
             raan: raan * RAD2DEG, // deg
@@ -1575,9 +1578,9 @@ const cartesianToKeplerian = (r, v, mu = MU) => {
  *
  * @param {Array} elset Keplerian elements
  * @param {Number} mu The gravitational parameter for the celestial object that we orbit, in km based units
- * @return {Object} An object containing the position and velocity in *kilometer* based units
+ * @return {Object} An object containing the position and velocity in *meter* based units
  */
-const keplerianToCartesian = (elset, mu = MU) => {
+const keplerianToCartesian = (elset, mu = 398600.4418) => {
     const INFINITE_TOL = 1e-10;
     const ORBIT_TOL = 1e-10;
     try {
@@ -1613,17 +1616,17 @@ const keplerianToCartesian = (elset, mu = MU) => {
         const sinPer = Math.sin(w);
 
         const r = {
-            x: rad * (cosPerAnom * cosRaan - cosInc * sinPerAnom * sinRaan),
-            y: rad * (cosPerAnom * sinRaan + cosInc * sinPerAnom * cosRaan),
-            z: rad * sinPerAnom * sinInc,
+            x: 1000.0 * rad * (cosPerAnom * cosRaan - cosInc * sinPerAnom * sinRaan),
+            y: 1000.0 * rad * (cosPerAnom * sinRaan + cosInc * sinPerAnom * cosRaan),
+            z: 1000.0 * rad * sinPerAnom * sinInc,
         };
 
         const v = {
-            x: sqrtGravP * cosAnomPlusE * (-sinPer * cosRaan - cosInc * sinRaan * cosPer)
-               - sqrtGravP * sinAnom * (cosPer * cosRaan - cosInc * sinRaan * sinPer),
-            y: sqrtGravP * cosAnomPlusE * (-sinPer * sinRaan + cosInc * cosRaan * cosPer)
-               - sqrtGravP * sinAnom * (cosPer * sinRaan + cosInc * cosRaan * sinPer),
-            z: sqrtGravP * (cosAnomPlusE * sinInc * cosPer - sinAnom * sinInc * sinPer),
+            x: 1000.0 * (sqrtGravP * cosAnomPlusE * (-sinPer * cosRaan - cosInc * sinRaan * cosPer)
+               - sqrtGravP * sinAnom * (cosPer * cosRaan - cosInc * sinRaan * sinPer)),
+            y: 1000.0 * (sqrtGravP * cosAnomPlusE * (-sinPer * sinRaan + cosInc * cosRaan * cosPer)
+               - sqrtGravP * sinAnom * (cosPer * sinRaan + cosInc * cosRaan * sinPer)),
+            z: 1000.0 * (sqrtGravP * (cosAnomPlusE * sinInc * cosPer - sinAnom * sinInc * sinPer)),
         };
 
         return {r, v};
@@ -1635,8 +1638,8 @@ const keplerianToCartesian = (elset, mu = MU) => {
 const cartesianToElsetElements = (pv, epoch) => {
     // sma, eccentricity, inclination, raan, argp, trueAnomaly
     const kepl = cartesianToKeplerian(
-        posToArray(pv.position), // km
-        posToArray(pv.velocity), // km/s
+        multiply(posToArray(pv.position), 1000.0), // km to m
+        multiply(posToArray(pv.velocity), 1000.0), // km/s to m/s
     );
 
     const elset = {
@@ -1648,7 +1651,8 @@ const cartesianToElsetElements = (pv, epoch) => {
     };
 
     // Mean motion in radians per second
-    const meanMotion = Math.sqrt(MU/Math.pow((elset.SemiMajorAxis), 3));
+    const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
+    const meanMotion = Math.sqrt(mu/Math.pow((elset.SemiMajorAxis*1000.0), 3));
 
     elset.MeanMotion = meanMotion / (2*Math.PI) * 60 * 60 * 24; // rads/s to revs per day
 
@@ -1699,6 +1703,7 @@ const getLeoRpoData = (line1, line2, sats, startTime, endTime) => {
         Line2: line2,
     };
     const pEphem = prop(pElset, start, end, 10000);
+    if(pEphem.length === 0) return results; // Primary may have re-entered the atmosphere
 
     sats.forEach( (s) => {
         const sEphem = prop(s, start, end, 10000);
@@ -1743,8 +1748,8 @@ const getLeoRpoData = (line1, line2, sats, startTime, endTime) => {
         aResult.di = angleBetweenPlanes(pv1, pv2);
         aResult.dv = planeChangeDeltaV(pv1, pv2);
         aResult.dv = {
-            i: Math.round(aResult.dv.i*1000000)/1000, // Confirm rounding
-            c: Math.round(aResult.dv.c*1000000)/1000,
+            i: Math.round(aResult.dv.i*1000)/1000,
+            c: Math.round(aResult.dv.c*1000)/1000,
         }; // Round to 3 decimals
 
         // Find the distance at each time step
@@ -1783,7 +1788,8 @@ const getGeoRpoData = (line1, line2, sats, startTime, endTime, lonTime) => {
         Line1: line1,
         Line2: line2,
     }, start, end, 60000);
-
+    if(pEphem.length === 0) return results; // Primary may have re-entered the atmosphere
+    
     const lonEvalTime = lonTime ? new Date(lonTime) : new Date(end);
 
     const pLonAndDrift = getLonAndDrift(line1, line2, lonEvalTime);
@@ -1857,8 +1863,8 @@ const getGeoRpoData = (line1, line2, sats, startTime, endTime, lonTime) => {
         };
         aResult.di = angleBetweenPlanes(pv1, pv2);
         aResult.dv = {
-            i: Math.round(planeChangeDeltaV(pv1, pv2).i*1000000)/1000, // Confirm rounding
-            c: Math.round(planeChangeDeltaV(pv1, pv2).c*1000000)/1000,
+            i: Math.round(planeChangeDeltaV(pv1, pv2).i*1000)/1000,
+            c: Math.round(planeChangeDeltaV(pv1, pv2).c*1000)/1000,
         }; // Round to 3 decimals
 
         for (let i=0; i<pEphem.length; i++) {
@@ -2142,8 +2148,10 @@ const calculateGeoCrossingTimes = async (propagateBetween, start, end, stepMs =
  */
 const calculateNextApogeePerigeeTimesWithPropagation
     = async (pv, propagateTo, time, findApogee=true, findPerigee=true) => {
-        const r = [pv.position.x, pv.position.y, pv.position.z];
-        const v = [pv.velocity.x, pv.velocity.y, pv.velocity.z];
+        const r = multiply([pv.position.x, pv.position.y, pv.position.z],
+            1000.0);
+        const v = multiply([pv.velocity.x, pv.velocity.y, pv.velocity.z],
+            1000.0);
         const el = cartesianToKeplerian(r, v);
 
         // Compute Eccentric Anomaly from True Anomaly and Eccentricity
@@ -2153,7 +2161,8 @@ const calculateNextApogeePerigeeTimesWithPropagation
         const M = E - (el.e)*Math.sin(E);
 
         // Mean motion in radians per second
-        const n = Math.sqrt(MU/Math.pow((el.a), 3));
+        const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
+        const n = Math.sqrt(mu/Math.pow((el.a*1000.0), 3));
 
         // Orbit Period
         const periodSecs = 2*Math.PI/n;
@@ -2410,8 +2419,8 @@ const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
             const ephem = prop(elset, segmentStart, segmentEnd, stepMs);
             satEphems[satIndex].push(...ephem.map((point, pointInd) => {
                 const osculatingElements = cartesianToKeplerian(
-                    posToArray(point.p), // km
-                    posToArray(point.v), // km/s
+                    multiply(posToArray(point.p), 1000.0), // km to m
+                    multiply(posToArray(point.v), 1000.0), // km/s to m/s
                 );
                 return {
                     ...point,
@@ -2494,7 +2503,9 @@ const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
  * @param {Date} startTime The start time of the maneuver as unix timestamp in milliseconds
  * @return {Object} An object containing the maneuver properties
  */
-const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) => {
+const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) =>{
+    const mu = 3.986004415e5; // km based
+
     let minDv = Infinity;
     let revNum = 0;
     let minIntercept = [0, 0, 0]; // The minimum dv to intercept the target.
@@ -2515,7 +2526,7 @@ const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) => {
             const r2 = [sat2Pv.position.x, sat2Pv.position.y, sat2Pv.position.z]; // km based
 
 
-            const {v1, v2, vH1} = lambertThomsonAlgorithm(r1, r2, dt, rev, 0, v1Before, MU_GRS80);
+            const {v1, v2, vH1} = lambertThomsonAlgorithm(r1, r2, dt, rev, 0, v1Before, mu);
             const deltaV1 = isDefined(v1) ? subtract(v1, v1Before) : [0, 0, 0];
             const deltaVH1 = isDefined(vH1) ? subtract(vH1, v1Before): [0, 0, 0];
             const v1Mag = norm(deltaV1);
@@ -2595,7 +2606,7 @@ const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) => {
         interceptTime: new Date(startTime + (minDt*1000)).toISOString(),
         interceptManeuverECI_ms: {
             time: new Date(startTime).toISOString(),
-            x: minIntercept.x*1000, //  km/s to m/s
+            x: minIntercept.x*1000, // km/s to m/s
             y: minIntercept.y*1000,
             z: minIntercept.z*1000,
         },
@@ -2677,12 +2688,15 @@ const detectManeuverMinDv = (initialTLE, finalTLE) => {
         // Position of final TLE at its epoch
         const r2 = [pvFinal.position.x, pvFinal.position.y, pvFinal.position.z]; // km based
 
+        // Earth Gravitational Parameter
+        const mu = 3.986004415e5; // km based
+
         // Loop for N until NaN
         let minNorm = Infinity;
         // let minIndex = -1;
         let minVector = [0, 0, 0];
         for (let i=0; i<10; i++) { // loop up to 10 revolutions, it is a safe upper limit to capture impulsive maneuvers
-            const {v1, vH1} = lambertThomsonAlgorithm(r1, r2, dt, i, 0, v1Before, MU_GRS80);
+            const {v1, vH1} = lambertThomsonAlgorithm(r1, r2, dt, i, 0, v1Before, mu);
 
             const deltaV1 = isDefined(v1) ? subtract(v1, v1Before) : [0, 0, 0];
             const deltaVH1 = isDefined(vH1) ? subtract(vH1, v1Before): [0, 0, 0];
@@ -2744,7 +2758,7 @@ const detectManeuverMinDv = (initialTLE, finalTLE) => {
  *
  */
 const lambertThomsonAlgorithm
-= (r1, r2, t, N, D = 0, v1Minus, mu = MU, outOfPlaneError = 0) => {
+= (r1, r2, t, N, D = 0, v1Minus, mu = 3.986004415e14, outOfPlaneError = 0) => {
     // Out-Of-Plane error check
     const r1Mag = norm(r1);
     const r2Mag = norm(r2);
@@ -2938,7 +2952,7 @@ const lambertThomsonAlgorithm
  * @param {number} mu Gravitational parameter
  * @return {{v1: Array<number>, v2: Array<number>}} Initial and final velocity vectors
  */
-const hodographVelocityAlgorithm = (r1, r2, t, v1Minus, theta, p, e, mu = MU) => {
+const hodographVelocityAlgorithm = (r1, r2, t, v1Minus, theta, p, e, mu) => {
     // Line 2: Define L180 (in meters)
     const L180 = 1.0;
 

package/src/ballisticPropagator.js

@@ -13,7 +13,7 @@ import {NodeVector3D} from "./NodeVector3D.js";
 // Earth constants using existing constants.js values
 const EarthConstants = {
     EquatorialRadiusKm: WGS84_EARTH_EQUATORIAL_RADIUS_KM, // 6378.137 km
-    Mu: MU, // km³/s²
+    Mu: MU / 1e9, // Convert from m³/s² to km³/s² (398600.4418)
     J2: 1082.62999e-6,
     J3: -2.53215e-6,
 };

package/src/constants.js

@@ -7,9 +7,7 @@ export const MILLIS_PER_DAY = 24 * 60 * 60 * 1000; // Number of milliseconds in
 export const SUN_RADIUS_KM = 695701.0; // Sun radius in kilometers
 export const AU_KM = 149597870.7; // Astronomical Unit in kilometers
 
-export const MU = 3.986004418e5; // km³/s² WGS-84 Earth Mu
-export const MU_GRS80 = 3.986004415e5; // km³/s² Earth Mu in GRS-80
-export const MU_SI = 3.986004415e14; // m³/s² Earth Mu in SI units, GRS-80
+export const MU = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
 export const GRAV_CONST = 6.6743e-11; // N⋅m2⋅kg−2
 export const EARTH_MASS = 5.97219e24; // kg
 export const WGS72_EARTH_EQUATORIAL_RADIUS_KM = 6378.135; // in km. Use this when calculations are done with SGP4 which uses WGS72 assumptions.

package/src/launchNominal.js

@@ -194,7 +194,7 @@ const getOpopOtop = (
     const opopLat = degreesLat(opop.latitude);
     const opopLon = degreesLong(opop.longitude);
 
-    if (distGeodetic(opopLat, opopLon, padLat, padLon) > opopDistThresholdKm) {
+    if (distGeodetic(opopLat, opopLon, padLat, padLon) > opopDistThresholdKm * 1000) {
         throw new Error(`OPOP is more than ${opopDistThresholdKm}km from launch pad`);
     }