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

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

@@ -43,6 +43,9 @@ 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
@@ -454,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
@@ -480,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)),
     );
 
@@ -573,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);
@@ -1404,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
@@ -1422,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;
 };
@@ -1435,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);
@@ -1452,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 
@@ -1555,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
@@ -1578,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 {
@@ -1616,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};
@@ -1638,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 = {
@@ -1651,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
 
@@ -1747,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
@@ -1861,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++) {
@@ -2146,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
@@ -2159,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;
@@ -2417,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,
@@ -2501,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.
@@ -2524,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);
@@ -2604,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,
         },
@@ -2686,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];
@@ -2756,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);
@@ -2950,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;
 

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/checkNetwork.cjs

@@ -1,20 +1,20 @@
-const _ = require("lodash");
-const {resolve4} = require("dns").promises;
-
-
-const checkRecord = (hostName) => resolve4(hostName).
-    then((addresss) => !_.isEmpty(addresss)).
-    catch(_.stubFalse);
-
-
-module.exports.checkRecord = checkRecord;
-module.exports.checkNetwork = (domains) => Promise.all(
-    _.map(
-        domains,
-        (hostName) => checkRecord(hostName).
-            then((found) => found
-                ? hostName
-                : null,
-            ),
-    ),
-).then((resolved) => _.flow(_.compact, _.first)(resolved) || null);
+const _ = require("lodash");
+const {resolve4} = require("dns").promises;
+
+
+const checkRecord = (hostName) => resolve4(hostName).
+    then((addresss) => !_.isEmpty(addresss)).
+    catch(_.stubFalse);
+
+
+module.exports.checkRecord = checkRecord;
+module.exports.checkNetwork = (domains) => Promise.all(
+    _.map(
+        domains,
+        (hostName) => checkRecord(hostName).
+            then((found) => found
+                ? hostName
+                : null,
+            ),
+    ),
+).then((resolved) => _.flow(_.compact, _.first)(resolved) || null);

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.

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`);
     }