@saber-usa/node-common 1.7.5 → 1.7.7-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber-usa/node-common",
-  "version": "1.7.5",
+  "version": "1.7.7-alpha.1",
   "description": "Common node functions for Saber",
   "main": "src/index.js",
   "type": "module",
@@ -9,7 +9,8 @@
     "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"
+    "sonar": "node --experimental-vm-modules sonar-project.js",
+    "prepub:alpha": "npm version prerelease --preid=alpha && npm publish --tag alpha"
   },
   "files": [
     "src/**/*"

package/src/FrameConverter.js

@@ -3,6 +3,7 @@ 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)
@@ -957,12 +958,12 @@ class FrameConverter {
     }
 
     static perifocalToInertial(keplerianElements) {
-        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);
+        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);
 
         // The matrix elements
         const r11 = cosRaan * cosw - sinRaan * sinw * cosi;

package/src/LaunchNominalClass.js

@@ -5,12 +5,14 @@ import {WGS84_EARTH_EQUATORIAL_RADIUS_KM,
     GRAV_CONST,
     EARTH_MASS,
     MU,
-    EARTH_RADIUS_KM} from "./constants.js";
+    EARTH_RADIUS_KM,
+    DEG2RAD} 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 = {
@@ -20,9 +22,9 @@ const ReferenceFrame = {
     GCRF: "GCRF",
 };
 
-class LaunchNominalClass {
-    
+const mu = GRAV_CONST * EARTH_MASS / 1e9; // km^3/s^2
 
+class LaunchNominalClass {
     /** Get position at a given time in specified reference frame
      *
      * @param {Date} utc - UTC time
@@ -56,7 +58,6 @@ 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);
 
@@ -77,23 +78,7 @@ 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],
@@ -106,11 +91,11 @@ class LaunchNominalClass {
 
         let sat = {
             stateVector: initialStateVector,
-            elements: OrbitUtils.stateVectorToElements(
+            elements: cartesianToKeplerian(
                 [initialTemeState.position.x, initialTemeState.position.y,
                     initialTemeState.position.z],
                 [initialTemeState.velocity.x, initialTemeState.velocity.y,
-                    initialTemeState.velocity.z]),
+                    initialTemeState.velocity.z], mu),
             epoch: orbitInsertionTime,
         };
 
@@ -152,12 +137,12 @@ class LaunchNominalClass {
 
                 const temeState = propagatedJ2000State.toTEME();
 
-                // Convert to orbital elements
-                const elements = OrbitUtils.stateVectorToElements(
+                // Convert to orbital elements - angles are in degrees
+                const elements = cartesianToKeplerian(
                     [temeState.position.x, temeState.position.y,
                         temeState.position.z],
                     [temeState.velocity.x, temeState.velocity.y,
-                        temeState.velocity.z]);
+                        temeState.velocity.z], mu);
 
                 sat = {
                     stateVector: propagated,
@@ -167,7 +152,7 @@ class LaunchNominalClass {
 
                 // Calculate current inclination
                 oldInclinationDelta = inclinationDelta;
-                inclinationDelta = Math.abs(radiansToDegrees(sat.elements.inclination)
+                inclinationDelta = Math.abs((sat.elements.i)
                     - radiansToDegrees(targetInclination));
 
                 if (oldInclinationDelta < inclinationDelta) {
@@ -240,22 +225,22 @@ class LaunchNominalClass {
         // Transform to elliptical orbit
         const ellipticalElements = OrbitUtils.transformElliptical(
             svInitial,
-            initialNominal.states[0].elements.inc,
-            initialNominal.states[0].elements.raan,
+            initialNominal.states[0].elements.inc * DEG2RAD,
+            initialNominal.states[0].elements.raan * DEG2RAD,
             targetEcc,
-            degreesToRadians(targetArgOfPeriapsisDeg),
+            targetArgOfPeriapsisDeg * DEG2RAD,
             targetPerigeeKm + WGS84_EARTH_EQUATORIAL_RADIUS_KM,
         );
 
         // Convert elliptical elements to cartesian state
-        const ellipticalStateVector = OrbitUtils.elementsToStateVector(ellipticalElements);
+        const ellipticalStateVector = keplerianToCartesian(ellipticalElements, mu);
 
-        const ellipticalPos = ellipticalStateVector.position;
-        const ellipticalVel = ellipticalStateVector.velocity;
+        const ellipticalPos = ellipticalStateVector.r;
+        const ellipticalVel = ellipticalStateVector.v;
 
         const ellipticalState = {
-            position: new NodeVector3D(ellipticalPos[0], ellipticalPos[1], ellipticalPos[2]),
-            velocity: new NodeVector3D(ellipticalVel[0], ellipticalVel[1], ellipticalVel[2]),
+            position: new NodeVector3D(ellipticalPos.x, ellipticalPos.y, ellipticalPos.z),
+            velocity: new NodeVector3D(ellipticalVel.x, ellipticalVel.y, ellipticalVel.z),
             epochUtc: orbitInsertionTime,
             referenceFrame: "J2000",
         };
@@ -268,7 +253,7 @@ class LaunchNominalClass {
         const ellipNomVel = ellipticalNominal.velocity;
 
         // Convert to orbital elements
-        const elements = OrbitUtils.stateVectorToElements(
+        const elements = cartesianToKeplerian(
             [ellipNomPos.x, ellipNomPos.y, ellipNomPos.z],
             [ellipNomVel.x, ellipNomVel.y, ellipNomVel.z]);
 
@@ -408,7 +393,7 @@ class LaunchNominalClass {
     }
 
     static hohmannTransferWithIncZeroing(state0, targetSMA,
-        burnAtNodes = 1, mu = MU / 1e9) {
+        burnAtNodes = 1, mu = MU) {
         let t0 = state0.epochUtc;
         let i = null;
 
@@ -473,8 +458,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 = OrbitUtils.stateVectorToElements(rElementConv, vElementConv);
-        const incDiff = elements0.inclination;
+        const elements0 = cartesianToKeplerian(rElementConv, vElementConv, mu);
+        const incDiff = elements0.i * DEG2RAD;
 
         const h = cross([state0.position.x, state0.position.y, state0.position.z],
             [state0.velocity.x, state0.velocity.y, state0.velocity.z]);
@@ -540,41 +525,34 @@ class LaunchNominalClass {
     }
 
     static #getNextNodeCrossingGeoOrbit(sv) {
-        const geoElements = {
-            semiMajorAxis: 35786.0 + EARTH_RADIUS_KM,
-            eccentricity: 0,
-            inclination: 0,
-            raan: 0,
-            argOfPeriapsis: 0,
-            trueAnomaly: 0,
-        };
+        const geoElements = [35786 + EARTH_RADIUS_KM, 0, 0, 0, 0, 0];
         const geoOrbitState = {
-            state: OrbitUtils.elementsToStateVector(geoElements),
+            state: keplerianToCartesian(geoElements, mu),
             epochUtc: sv.epochUtc,
         };
         const nextNode = this.#findMutualNodeTimes(sv, geoOrbitState);
         return nextNode.nextNodeTime;
     }
 
-    static #findMutualNodeTimes(sv1, sv2, muEarth = MU / 1e9) {
+    static #findMutualNodeTimes(sv1, sv2, muEarth = MU) {
         // Implementation for finding mutual node times between two state vectors
 
         if (!(sv1.epochUtc === sv2.epochUtc)) {
             return "lol what on earth";
         }
 
-        const orbit1 = OrbitUtils.stateVectorToElements(
+        const orbit1 = cartesianToKeplerian(
             [sv1.position.x, sv1.position.y, sv1.position.z],
-            [sv1.velocity.x, sv1.velocity.y, sv1.velocity.z]);
-        const orbit2 = OrbitUtils.stateVectorToElements(
-            sv2.state.position,
-            sv2.state.velocity);
+            [sv1.velocity.x, sv1.velocity.y, sv1.velocity.z], muEarth);
 
-        const state1 = OrbitUtils.elementsToStateVector(orbit1);
-        const state2 = OrbitUtils.elementsToStateVector(orbit2);
+        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 h1 = cross(state1.position, state1.velocity);
-        const h2 = cross(state2.position, state2.velocity);
+        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 h1Norm = norm(h1);
         const h2Norm = norm(h2);
 
@@ -587,7 +565,8 @@ class LaunchNominalClass {
             return Math.acos(dotProduct / normsProduct);
         }
 
-        const ascendingFirst = getAngleBetween2Vectors(state1.position, h2unit) > Math.PI / 2;
+        const ascendingFirst
+            = getAngleBetween2Vectors(Object.values(state1.r), h2unit) > Math.PI / 2;
 
         const nodalLine = cross(h1unit, h2unit);
         const nodalLineUnit = nodalLine.map((component) => component / norm(nodalLine));
@@ -602,10 +581,10 @@ class LaunchNominalClass {
 
         const mutualNodeLinePerifocal = rTilde1inverse.multiplyVector3D(nodalLineUnitVector3D);
         const slopeMutualNodalLinePerifocal = mutualNodeLinePerifocal.y / mutualNodeLinePerifocal.x;
-        const mutualNode = this.#findIntersectionEllipseLine( // inputs here are causing an error increase
+        const mutualNode = this.#findIntersectionEllipseLine(
             slopeMutualNodalLinePerifocal,
-            orbit1.semiMajorAxis,
-            orbit1.eccentricity);
+            orbit1.a,
+            orbit1.e);
 
         const q1 = mutualNode.vec1;
         const q2 = mutualNode.vec2;
@@ -616,13 +595,13 @@ class LaunchNominalClass {
             return ((n % m) + m) % m;
         }
 
-        const n0 = mod(orbit1.trueAnomaly, 2 * Math.PI);
+        const n0 = mod(orbit1.f * DEG2RAD, 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.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
+        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
 
         if (e1 < 0) {
             e1 += 2 * Math.PI;
@@ -635,13 +614,13 @@ class LaunchNominalClass {
         const k1 = n1 < n0 ? 1 : 0;
         const k2 = n2 < n0 ? 1 : 0;
 
-        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 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 dt2 = Math.sqrt(
-            Math.pow(orbit1.semiMajorAxis, 3) / muEarth)
-            * (2 * k2 * Math.PI + (e2 - orbit1.eccentricity * Math.sin(e2))
-                - (e0 - orbit1.eccentricity * Math.sin(e0)));
+            Math.pow(orbit1.a, 3) / muEarth)
+            * (2 * k2 * Math.PI + (e2 - orbit1.e * Math.sin(e2))
+                - (e0 - orbit1.e * Math.sin(e0)));
         let first = null;
         let second = null;
 
@@ -721,7 +700,7 @@ class LaunchNominalOutput {
             const j2000ToTeme = FrameConverter.getTransform("J2000", "TEME", epoch);
             const posTeme = FrameConverter.transformVector(pos, j2000ToTeme);
             const velTeme = FrameConverter.transformVector(vel, j2000ToTeme);
-            elements = OrbitUtils.stateVectorToElements(
+            elements = cartesianToKeplerian(
                 [posTeme.x, posTeme.y, posTeme.z],
                 [velTeme.x, velTeme.y, velTeme.z]);
         }
@@ -733,12 +712,12 @@ class LaunchNominalOutput {
                 v: [vel.x, vel.y, vel.z],
             },
             elements: {
-                sma: elements.semiMajorAxis,
-                ecc: elements.eccentricity,
-                inc: elements.inclination,
+                sma: elements.a,
+                ecc: elements.e,
+                inc: elements.i,
                 raan: elements.raan,
-                argp: elements.argOfPeriapsis,
-                ta: elements.trueAnomaly,
+                argp: elements.w,
+                ta: elements.f,
             },
             // Placeholder for tle
         });

package/src/OrbitUtils.js

@@ -1,13 +1,10 @@
-import {MU} from "./constants.js";
+import {MU, RAD2DEG} from "./constants.js";
 import {cross, norm} from "mathjs";
 import {wrapHalfRevUnsigned, wrapOneRevUnsigned} from "./utils.js";
 
-const EARTH_MU_KM = MU / 1e9;
+const EARTH_MU_KM = MU; // km³/s²
 
 class OrbitUtils {
-    constructor() {
-        // Prevent instantiation
-    }
     /**
      * Get inclination based on azimuth and latitude.
      * @param {number} azimuthRad - Azimuth in radians
@@ -141,15 +138,8 @@ class OrbitUtils {
             if (Math.abs(b - a) < tolerance) {
                 // Found minimum
                 const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-                return {
-                    semiMajorAxis: semiMajorAxis,
-                    eccentricity: targetEcc,
-                    inclination: incRad,
-                    raan: raanRad,
-                    argOfPeriapsis: targetArgOfPeriapsisRad,
-                    trueAnomaly: c,
-                    epoch: svInitial.epoch,
-                };
+                return [semiMajorAxis, targetEcc, incRad * RAD2DEG,
+                    raanRad * RAD2DEG, targetArgOfPeriapsisRad * RAD2DEG, c * RAD2DEG];
             }
 
             xm = 0.5 * (a + b);
@@ -160,15 +150,8 @@ class OrbitUtils {
             if (min1 < tol1 || min2 < tol1) {
                 // Found minimum
                 const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-                return {
-                    semiMajorAxis: semiMajorAxis,
-                    eccentricity: targetEcc,
-                    inclination: incRad,
-                    raan: raanRad,
-                    argOfPeriapsis: targetArgOfPeriapsisRad,
-                    trueAnomaly: c,
-                    epoch: svInitial.epoch,
-                };
+                return [semiMajorAxis, targetEcc, incRad * RAD2DEG,
+                    raanRad * RAD2DEG, targetArgOfPeriapsisRad * RAD2DEG, c * RAD2DEG];
             }
 
             // Construct a trial parabolic fit
@@ -271,170 +254,6 @@ 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 {checkTle} from "./astro.js";
-import {OrbitUtils} from "./OrbitUtils.js";
+import {cartesianToKeplerian, checkTle} from "./astro.js";
+import {DEG2RAD} from "./constants.js";
 
 const ReferenceFrame = {
     ITRF: "ITRF",
@@ -62,17 +62,17 @@ class PropagateUtils {
     }
 
     static keplerianPropagator(initialState, time) {
-        const elementsObj = OrbitUtils.stateVectorToElements(
+        const elementsObjReal = cartesianToKeplerian(
             initialState.position, initialState.velocity);
 
         const elements = new ClassicalElements(
             new EpochUTC(initialState.epoch),
-            elementsObj.semiMajorAxis,
-            elementsObj.eccentricity,
-            elementsObj.inclination,
-            elementsObj.raan,
-            elementsObj.argOfPeriapsis,
-            elementsObj.trueAnomaly,
+            elementsObjReal.a,
+            elementsObjReal.e,
+            elementsObjReal.i * DEG2RAD,
+            elementsObjReal.raan * DEG2RAD,
+            elementsObjReal.w * DEG2RAD,
+            elementsObjReal.f * DEG2RAD,
         );
 
         // Now pass to KeplerPropagator:

package/src/astro.js

@@ -42,7 +42,11 @@ import {DEG2RAD,
     WGS72_EARTH_EQUATORIAL_RADIUS_KM,
     WGS84_EARTH_EQUATORIAL_RADIUS_KM,
     MILLIS_PER_DAY,
-    GEO_ALTITUDE_KM} from "./constants.js";
+    GEO_ALTITUDE_KM,
+    MU,
+    MU_GRS80,
+    MU_SI,
+    ERROR_CODES} from "./constants.js";
 
 // Solar Terminator
 // Returns sun latitude and longitude as -180/180
@@ -74,6 +78,98 @@ const checkTle = (line1, line2) => {
     }
 };
 
+/**
+ * Validates the output of the satellite.js propagate function.
+ * The satellite.js propagate function returns a object with the following properties:
+ * - position: {x: number, y: number, z: number}
+ * - velocity: {x: number, y: number, z: number}
+ * - meanElements: {am: number, em: number, im: number, Om: number, om: number, nm: number, mm: number}
+ *
+ * When propgation fails, the output is null. However, there are cases where the output is not null, but the position and velocity are NaN.
+ * This happens when the input satrec is invalid or malformed due to a bad TLE, in some way. This is rare, and hard to reproduce.
+ *
+ * This function takes into account those rare cases as part of the validation.
+ *
+ * @param {Object} out The output of the satellite.js propagate function.
+ * @return {boolean} true if the propagation output is valid, false otherwise
+ */
+const isPropagateValid = (out) => {
+    if (out === null || out === undefined) {
+        return false;
+    }
+
+    if (out.position) {
+        const pos = out.position;
+        if (pos.x === null || pos.x === undefined || Number.isNaN(pos.x)
+            || pos.y === null || pos.y === undefined || Number.isNaN(pos.y)
+            || pos.z === null || pos.z === undefined || Number.isNaN(pos.z)) {
+            return false;
+        }
+    }
+
+    if (out.velocity) {
+        const vel = out.velocity;
+        if (vel.x === null || vel.x === undefined || Number.isNaN(vel.x)
+            || vel.y === null || vel.y === undefined || Number.isNaN(vel.y)
+            || vel.z === null || vel.z === undefined || Number.isNaN(vel.z)) {
+            return false;
+        }
+    }
+
+    return true;
+};
+
+/** A function that attempts to propagate a satellite record to a given time, and returns a standardized output object.
+ *
+ * @param {Object} satrec The satellite record from satellite.js
+ * @param {Date} time The time to propagate the satellite to
+ * @return {Object} An object with the following properties:
+ * - ok: 0 or 1
+ * - err: null or an error message
+ * - out: null or the output of the satellite.js propagate function
+ */
+const tryPropagateSatrec = (satrec, time) => {
+    // Validate time
+    if (!time || !(time instanceof Date)) {
+        return {
+            ok: 0,
+            err: ERROR_CODES.INVALID_TIME_INPUT,
+            out: null,
+        };
+    }
+    // Validate satrec
+    if (!satrec) {
+        return {
+            ok: 0,
+            err: ERROR_CODES.INVALID_SATELLITE_RECORD,
+            out: null,
+        };
+    }
+    // Propagate
+    try {
+        const out = propagate(satrec, time);
+        // Validate propagate output
+        if (!isPropagateValid(out)) {
+            return {
+                ok: 0,
+                err: ERROR_CODES.INVALID_PROPAGATE_OUTPUT + `: ${satrec.error}`,
+                out: null,
+            };
+        }
+        return {
+            ok: 1,
+            err: null,
+            out: out,
+        };
+    } catch (e) {
+        return {
+            ok: 0,
+            err: ERROR_CODES.INVALID_PROPAGATE_OUTPUT + `: ${e.message}`,
+            out: null,
+        };
+    }
+};
+
 /**
  * Calculates the semi-major axis in kilometers from a satellite record.
  * @param {Object} satrec The satellite record from satellite.js
@@ -361,25 +457,19 @@ 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 m/s in RSW frame to perform a single impulsive
+ * @return {Object} Delta-v in km/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 = 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 r = [pv1.position.x, pv1.position.y, pv1.position.z];
+    const v = [pv1.velocity.x, pv1.velocity.y, pv1.velocity.z];
     const h1 = cross(r, v);
 
     const vMag = norm(v);
 
-    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 r2 = [pv2.position.x, pv2.position.y, pv2.position.z];
+    const v2 = [pv2.velocity.x, pv2.velocity.y, pv2.velocity.z];
     const h2 = cross(r2, v2);
 
     // 2. Compute the mutual line of nodes vector
@@ -387,9 +477,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)),
     );
 
@@ -480,21 +570,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 m/s to perform a pure inclination plane change at
+ * @return {Object} Delta-v in km/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 = 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 r = [pv1.position.x, pv1.position.y, pv1.position.z];
+    const v = [pv1.velocity.x, pv1.velocity.y, pv1.velocity.z];
 
-    // Velocity Magnitude in m/s
+    // Velocity Magnitude in km/s
     const vMag = norm(v);
 
-    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 r2 = [pv2.position.x, pv2.position.y, pv2.position.z];
+    const v2 = [pv2.velocity.x, pv2.velocity.y, pv2.velocity.z];
 
     // 2. Compute the Keplerian Elements of both satellites.
     const el = cartesianToKeplerian(r, v);
@@ -1311,12 +1401,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 meters
+ * @return {Number} The distance between the two coordinates in kilometers
  *
  * Source: https://www.movable-type.co.uk/scripts/latlong.html
  */
 const distGeodetic = (lat1, lon1, lat2, lon2) => {
-    const R = WGS84_EARTH_EQUATORIAL_RADIUS_KM * 1000.0; // metres
+    const R = WGS84_EARTH_EQUATORIAL_RADIUS_KM; // kilometers
     const phi1 = lat1 * DEG2RAD; // φ1 in formula
     const phi2 = lat2 * DEG2RAD; // φ2 in formula
     const deltaPhi = (lat2 - lat1) * DEG2RAD; // Δφ in formula
@@ -1329,7 +1419,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 metres
+    const d = R * c; // in kilometers
 
     return d;
 };
@@ -1342,13 +1432,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 meters
- * @param {Array} v Velocity, in m/s
+ * @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
  * @return {Object} An object containing the Keplerian Elements, if successful. Otherwise, an empty object.
  */
-const cartesianToKeplerian = (r, v) => {
+const cartesianToKeplerian = (r, v, mu = MU) => {
     try {
-        const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
         const tol = 1e-9;
 
         const h = cross(r, v);
@@ -1359,20 +1449,20 @@ const cartesianToKeplerian = (r, v) => {
         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 
@@ -1462,7 +1552,7 @@ const cartesianToKeplerian = (r, v) => {
         }
 
         return {
-            a: a /1000.0, // km
+            a: a, // km
             e: norm(e),
             i: i * RAD2DEG, // deg
             raan: raan * RAD2DEG, // deg
@@ -1485,9 +1575,9 @@ const cartesianToKeplerian = (r, v) => {
  *
  * @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 *meter* based units
+ * @return {Object} An object containing the position and velocity in *kilometer* based units
  */
-const keplerianToCartesian = (elset, mu = 398600.4418) => {
+const keplerianToCartesian = (elset, mu = MU) => {
     const INFINITE_TOL = 1e-10;
     const ORBIT_TOL = 1e-10;
     try {
@@ -1523,17 +1613,17 @@ const keplerianToCartesian = (elset, mu = 398600.4418) => {
         const sinPer = Math.sin(w);
 
         const r = {
-            x: 1000.0 * rad * (cosPerAnom * cosRaan - cosInc * sinPerAnom * sinRaan),
-            y: 1000.0 * rad * (cosPerAnom * sinRaan + cosInc * sinPerAnom * cosRaan),
-            z: 1000.0 * rad * sinPerAnom * sinInc,
+            x: rad * (cosPerAnom * cosRaan - cosInc * sinPerAnom * sinRaan),
+            y: rad * (cosPerAnom * sinRaan + cosInc * sinPerAnom * cosRaan),
+            z: rad * sinPerAnom * sinInc,
         };
 
         const v = {
-            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)),
+            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),
         };
 
         return {r, v};
@@ -1545,8 +1635,8 @@ const keplerianToCartesian = (elset, mu = 398600.4418) => {
 const cartesianToElsetElements = (pv, epoch) => {
     // sma, eccentricity, inclination, raan, argp, trueAnomaly
     const kepl = cartesianToKeplerian(
-        multiply(posToArray(pv.position), 1000.0), // km to m
-        multiply(posToArray(pv.velocity), 1000.0), // km/s to m/s
+        posToArray(pv.position), // km
+        posToArray(pv.velocity), // km/s
     );
 
     const elset = {
@@ -1558,8 +1648,7 @@ const cartesianToElsetElements = (pv, epoch) => {
     };
 
     // Mean motion in radians per second
-    const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
-    const meanMotion = Math.sqrt(mu/Math.pow((elset.SemiMajorAxis*1000.0), 3));
+    const meanMotion = Math.sqrt(MU/Math.pow((elset.SemiMajorAxis), 3));
 
     elset.MeanMotion = meanMotion / (2*Math.PI) * 60 * 60 * 24; // rads/s to revs per day
 
@@ -1654,8 +1743,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*1000)/1000,
-            c: Math.round(aResult.dv.c*1000)/1000,
+            i: Math.round(aResult.dv.i*1000000)/1000, // Confirm rounding
+            c: Math.round(aResult.dv.c*1000000)/1000,
         }; // Round to 3 decimals
 
         // Find the distance at each time step
@@ -1768,8 +1857,8 @@ const getGeoRpoData = (line1, line2, sats, startTime, endTime, lonTime) => {
         };
         aResult.di = angleBetweenPlanes(pv1, pv2);
         aResult.dv = {
-            i: Math.round(planeChangeDeltaV(pv1, pv2).i*1000)/1000,
-            c: Math.round(planeChangeDeltaV(pv1, pv2).c*1000)/1000,
+            i: Math.round(planeChangeDeltaV(pv1, pv2).i*1000000)/1000, // Confirm rounding
+            c: Math.round(planeChangeDeltaV(pv1, pv2).c*1000000)/1000,
         }; // Round to 3 decimals
 
         for (let i=0; i<pEphem.length; i++) {
@@ -2053,10 +2142,8 @@ const calculateGeoCrossingTimes = async (propagateBetween, start, end, stepMs =
  */
 const calculateNextApogeePerigeeTimesWithPropagation
     = async (pv, propagateTo, time, findApogee=true, findPerigee=true) => {
-        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 r = [pv.position.x, pv.position.y, pv.position.z];
+        const v = [pv.velocity.x, pv.velocity.y, pv.velocity.z];
         const el = cartesianToKeplerian(r, v);
 
         // Compute Eccentric Anomaly from True Anomaly and Eccentricity
@@ -2066,8 +2153,7 @@ const calculateNextApogeePerigeeTimesWithPropagation
         const M = E - (el.e)*Math.sin(E);
 
         // Mean motion in radians per second
-        const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
-        const n = Math.sqrt(mu/Math.pow((el.a*1000.0), 3));
+        const n = Math.sqrt(MU/Math.pow((el.a), 3));
 
         // Orbit Period
         const periodSecs = 2*Math.PI/n;
@@ -2324,8 +2410,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(
-                    multiply(posToArray(point.p), 1000.0), // km to m
-                    multiply(posToArray(point.v), 1000.0), // km/s to m/s
+                    posToArray(point.p), // km
+                    posToArray(point.v), // km/s
                 );
                 return {
                     ...point,
@@ -2408,9 +2494,7 @@ 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 mu = 3.986004415e5; // km based
-
+const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) => {
     let minDv = Infinity;
     let revNum = 0;
     let minIntercept = [0, 0, 0]; // The minimum dv to intercept the target.
@@ -2431,7 +2515,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);
+            const {v1, v2, vH1} = lambertThomsonAlgorithm(r1, r2, dt, rev, 0, v1Before, MU_GRS80);
             const deltaV1 = isDefined(v1) ? subtract(v1, v1Before) : [0, 0, 0];
             const deltaVH1 = isDefined(vH1) ? subtract(vH1, v1Before): [0, 0, 0];
             const v1Mag = norm(deltaV1);
@@ -2511,7 +2595,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,
         },
@@ -2593,15 +2677,12 @@ 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);
+            const {v1, vH1} = lambertThomsonAlgorithm(r1, r2, dt, i, 0, v1Before, MU_GRS80);
 
             const deltaV1 = isDefined(v1) ? subtract(v1, v1Before) : [0, 0, 0];
             const deltaVH1 = isDefined(vH1) ? subtract(vH1, v1Before): [0, 0, 0];
@@ -2663,7 +2744,7 @@ const detectManeuverMinDv = (initialTLE, finalTLE) => {
  *
  */
 const lambertThomsonAlgorithm
-= (r1, r2, t, N, D = 0, v1Minus, mu = 3.986004415e14, outOfPlaneError = 0) => {
+= (r1, r2, t, N, D = 0, v1Minus, mu = MU_SI, outOfPlaneError = 0) => {
     // Out-Of-Plane error check
     const r1Mag = norm(r1);
     const r2Mag = norm(r2);
@@ -2857,7 +2938,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) => {
+const hodographVelocityAlgorithm = (r1, r2, t, v1Minus, theta, p, e, mu = MU_SI) => {
     // Line 2: Define L180 (in meters)
     const L180 = 1.0;
 
@@ -3209,6 +3290,7 @@ export {REGIMES,
     getRaanDetails,
     isSatInShadow,
     calculateGeoCrossingTimes,
+    tryPropagateSatrec,
 };
 export const raDecToGeodetic = RaDecToGeodetic;
 export const getResiduals = GetResiduals;

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 / 1e9, // Convert from m³/s² to km³/s² (398600.4418)
+    Mu: MU, // km³/s²
     J2: 1082.62999e-6,
     J3: -2.53215e-6,
 };

package/src/constants.js

@@ -7,7 +7,9 @@ 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.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
+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 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.
@@ -28,3 +30,8 @@ export const REGIMES = {
     GeoDrifter: 512,
 };
 
+export const ERROR_CODES = {
+    INVALID_TIME_INPUT: "Invalid time input",
+    INVALID_SATELLITE_RECORD: "Invalid satellite record",
+    INVALID_PROPAGATE_OUTPUT: "Invalid propagate output",
+};

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 * 1000) {
+    if (distGeodetic(opopLat, opopLon, padLat, padLon) > opopDistThresholdKm) {
         throw new Error(`OPOP is more than ${opopDistThresholdKm}km from launch pad`);
     }