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

package/src/OrbitUtils.js

@@ -1,309 +1,309 @@
-import {MU, RAD2DEG} from "./constants.js";
-import {cross, norm} from "mathjs";
-import {wrapHalfRevUnsigned, wrapOneRevUnsigned} from "./utils.js";
-
-const EARTH_MU_KM = MU; // km³/s²
-
-class OrbitUtils {
-    /**
-     * Get inclination based on azimuth and latitude.
-     * @param {number} azimuthRad - Azimuth in radians
-     * @param {number} latitudeRad - Latitude in radians
-     * @return {number} Inclination in radians
-     */
-    static getInclination(azimuthRad, latitudeRad) {
-        const inclination = Math.acos(Math.cos(latitudeRad) * Math.sin(azimuthRad));
-        return wrapHalfRevUnsigned(inclination);
-    }
-
-    /**
-     * Get the azimuth based on inclination and latitude.
-     * Two results will be possible, based on whether you are Ascending from South to North or Descending from North to South.
-     * @param {number} inclinationRad - Inclination in radians
-     * @param {number} latitudeRad - Latitude in radians
-     * @param {boolean} ascending - Ascending (true) or descending (false)
-     * @return {number} Azimuth in radians
-     */
-    static getAzimuth(inclinationRad, latitudeRad, ascending = true) {
-        const azimuth = Math.asin(Math.cos(inclinationRad) / Math.cos(latitudeRad));
-        if (!ascending) {
-            return wrapOneRevUnsigned(Math.PI - azimuth);
-        }
-        return wrapOneRevUnsigned(azimuth);
-    }
-
-    /**
-     * Calculate the specific angular momentum (h) vector of an orbit.
-     * @param {Array} r - Position vector [x, y, z]
-     * @param {Array} v - Velocity vector [vx, vy, vz]
-     * @return {Array} Angular momentum vector
-     */
-    static getAngularMomentum(r, v) {
-        return cross(r, v);
-    }
-
-    /**
-     * Get mean motion (rad/sec).
-     * @param {number} a - Semi Major Axis (km)
-     * @param {number} mu - Standard gravitational parameter (km^3/s^2)
-     * @return {number} Mean motion in rad/sec
-     */
-    static getMeanMotion(a, mu = EARTH_MU_KM) {
-        return Math.sqrt(mu / Math.pow(a, 3));
-    }
-
-    /**
-     * Get the period of an orbit in seconds.
-     * @param {number} a - Semi Major Axis (km)
-     * @param {number} mu - Standard gravitational parameter (km^3/s^2)
-     * @return {number} Period in seconds
-     */
-    static getPeriod(a, mu = EARTH_MU_KM) {
-        if (a <= 0) return null;
-        return 2 * Math.PI * Math.sqrt(Math.pow(a, 3) / mu);
-    }
-
-    /**
-     * Transform an orbit to elliptical with target parameters using Brent's method.
-     * Accurate port of the C# TransformElliptical method.
-     * @param {Object} svInitial - Initial state vector {position: [x,y,z], velocity: [vx,vy,vz], epoch: Date}
-     * @param {number} incRad - Inclination in radians
-     * @param {number} raanRad - RAAN in radians
-     * @param {number} targetEcc - Target eccentricity
-     * @param {number} targetArgOfPeriapsisRad - Target argument of periapsis in radians
-     * @param {number} targetPerigeeKm - Target perigee in km
-     * @return {Object} Satellite object with new orbital elements
-     */
-    static transformElliptical(svInitial, incRad, raanRad,
-        targetEcc, targetArgOfPeriapsisRad, targetPerigeeKm) {
-        // Normalize the position vector
-        const rNorm = norm(svInitial.position);
-        const r = svInitial.position.map((x) => x / rNorm);
-
-        // Project the position vector onto the orbital plane
-        const projectedX = r[0] * Math.cos(raanRad) + r[1] * Math.sin(raanRad);
-        const projectedY = r[1] * Math.cos(raanRad) - r[0] * Math.sin(raanRad);
-
-        // Calculate the initial true anomaly using the projected coordinates and known argument of periapsis
-        let nu0 = Math.atan2(projectedY, projectedX) - targetArgOfPeriapsisRad;
-        nu0 = (nu0 + 2 * Math.PI) % (2 * Math.PI);
-
-        // Define the objective function that we want to minimize
-        const objectiveFunction = (nu) => {
-            nu = (nu + 2 * Math.PI) % (2 * Math.PI);
-
-            // Create orbital elements with the trial true anomaly
-            const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-            const elements = {
-                semiMajorAxis: semiMajorAxis,
-                eccentricity: targetEcc,
-                inclination: incRad,
-                raan: raanRad,
-                argOfPeriapsis: targetArgOfPeriapsisRad,
-                trueAnomaly: nu,
-                epoch: svInitial.epoch,
-            };
-
-            // Convert elements to state vector
-            const trialState = this.elementsToStateVector(elements);
-
-            // Normalize the trial position vector
-            const trialRNorm = norm(trialState.position);
-            const trialR = trialState.position.map((x) => x / trialRNorm);
-
-            // Scale trial position to match initial position magnitude
-            const pScaled = trialR.map((x) => x * rNorm);
-
-            // Return the distance between initial and trial positions
-            return norm(svInitial.position.map((x, i) => x - pScaled[i]));
-        };
-
-        // Use Brent's method for minimization
-        const tolerance = 1e-6; // radians
-        const maxIterations = 1000;
-
-        // Initial bracket around the solution
-        let a = nu0 - Math.PI;
-        let b = nu0 + Math.PI;
-        let c = nu0;
-
-        let fa = objectiveFunction(a);
-        let fb = objectiveFunction(b);
-        let fc = objectiveFunction(c);
-
-        let d = 0; let e = 0; let min1; let min2;
-        let p; let q; let r1; let tol1; let xm;
-
-        for (let iter = 0; iter < maxIterations; iter++) {
-            if (Math.abs(b - a) < tolerance) {
-                // Found minimum
-                const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-                return [semiMajorAxis, targetEcc, incRad * RAD2DEG,
-                    raanRad * RAD2DEG, targetArgOfPeriapsisRad * RAD2DEG, c * RAD2DEG];
-            }
-
-            xm = 0.5 * (a + b);
-            tol1 = tolerance * Math.abs(c) + 1e-10;
-            min1 = Math.abs(c - a);
-            min2 = Math.abs(b - c);
-
-            if (min1 < tol1 || min2 < tol1) {
-                // Found minimum
-                const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-                return [semiMajorAxis, targetEcc, incRad * RAD2DEG,
-                    raanRad * RAD2DEG, targetArgOfPeriapsisRad * RAD2DEG, c * RAD2DEG];
-            }
-
-            // Construct a trial parabolic fit
-            if (Math.abs(e) >= tol1) {
-                r1 = (c - a) * (fb - fc);
-                q = (c - b) * (fa - fc);
-                p = (c - b) * q - (c - a) * r1;
-                q = 2.0 * (q - r1);
-                if (q > 0.0) p = -p;
-                q = Math.abs(q);
-                min1 = 3.0 * q * Math.abs(xm);
-                min2 = Math.abs(e * q);
-                if (2.0 * p < (min1 < min2 ? min1 : min2)) {
-                    e = d;
-                    d = p / q;
-                } else {
-                    d = xm;
-                    e = d;
-                }
-            } else {
-                d = xm;
-                e = d;
-            }
-
-            a = b;
-            fa = fb;
-            if (Math.abs(d) > tol1) {
-                b += d;
-            } else {
-                b += (xm >= 0 ? Math.abs(tol1) : -Math.abs(tol1));
-            }
-            fb = objectiveFunction(b);
-            if ((fb <= fc && c > b) || (fb >= fc && c < b)) {
-                c = a;
-                fc = fa;
-                a = b;
-                fa = fb;
-                b = c;
-                fb = fc;
-            }
-        }
-
-        throw new Error("Did not converge within maximum iterations");
-    }
-
-    /**
-     * Convert orbital elements to state vector
-     * @param {Object} elements - Orbital elements
-     * @return {Object} State vector {position, velocity}
-     */
-    static elementsToStateVector(elements) {
-        const {semiMajorAxis, eccentricity, inclination,
-            raan, argOfPeriapsis, trueAnomaly} = elements;
-        const mu = EARTH_MU_KM;
-
-        // Calculate radius
-        const rMag = semiMajorAxis * (1 - eccentricity * eccentricity)
-            / (1 + eccentricity * Math.cos(trueAnomaly));
-
-        // Position in orbital plane
-        const rOrbital = [
-            rMag * Math.cos(trueAnomaly),
-            rMag * Math.sin(trueAnomaly),
-            0,
-        ];
-
-        // Velocity in orbital plane
-        const h = Math.sqrt(mu * semiMajorAxis * (1 - eccentricity * eccentricity));
-        const vOrbital = [
-            -mu / h * Math.sin(trueAnomaly),
-            mu / h * (eccentricity + Math.cos(trueAnomaly)),
-            0,
-        ];
-
-        // Rotation matrices
-        const cosW = Math.cos(argOfPeriapsis);
-        const sinW = Math.sin(argOfPeriapsis);
-        const cosO = Math.cos(raan);
-        const sinO = Math.sin(raan);
-        const cosI = Math.cos(inclination);
-        const sinI = Math.sin(inclination);
-
-        // Transform to inertial frame
-        const r = [
-            rOrbital[0] * (cosW * cosO - sinW * cosI * sinO)
-                - rOrbital[1] * (sinW * cosO + cosW * cosI * sinO),
-            rOrbital[0] * (cosW * sinO + sinW * cosI * cosO) + rOrbital[1]
-                * (cosW * cosI * cosO - sinW * sinO),
-            rOrbital[0] * (sinW * sinI) + rOrbital[1] * (cosW * sinI),
-        ];
-
-        const v = [
-            vOrbital[0] * (cosW * cosO - sinW * cosI * sinO)
-                - vOrbital[1] * (sinW * cosO + cosW * cosI * sinO),
-            vOrbital[0] * (cosW * sinO + sinW * cosI * cosO)
-                + vOrbital[1] * (cosW * cosI * cosO - sinW * sinO),
-            vOrbital[0] * (sinW * sinI) + vOrbital[1] * (cosW * sinI),
-        ];
-
-        return {position: r, velocity: v};
-    }
-
-    /**
-     * Convert true anomaly to eccentric anomaly
-     * @param {number} nu - true anomaly
-     * @param {number} e - eccentricity
-     * @return {number} Eccentric Anomaly
-     */
-    static trueAnomalyToEccentricAnomaly(nu, e) {
-        const cosE = (e + Math.cos(nu)) / (1 + e * Math.cos(nu));
-        const sinE = Math.sqrt(1 - e * e) * Math.sin(nu) / (1 + e * Math.cos(nu));
-        return Math.atan2(sinE, cosE);
-    }
-
-    /**
-     * Convert eccentric anomaly to mean anomaly
-     * @param {number} E - Eccentric anomaly
-     * @param {number} e - eccentricity
-     * @return {number} Mean Anomaly
-     */
-    static eccentricAnomalyToMeanAnomaly(E, e) {
-        return E - e * Math.sin(E);
-    }
-
-    /**
-     * Convert mean anomaly to eccentric anomaly (Kepler's equation)
-     * @param {number} M - Mean anomaly
-     * @param {number} e - eccentricity
-     * @param {number} tolerance - numerical tolerance
-     * @return {number} Eccentric Anomaly
-     */
-    static meanAnomalyToEccentricAnomaly(M, e, tolerance = 1e-8) {
-        let E = M;
-        let delta = 1;
-        while (Math.abs(delta) > tolerance) {
-            delta = (M - E + e * Math.sin(E)) / (1 - e * Math.cos(E));
-            E += delta;
-        }
-        return E;
-    }
-
-    /**
-     * Convert eccentric anomaly to true anomaly
-     * @param {number} E - Eccentric anomaly
-     * @param {number} e - eccentricity
-     * @return {number} true anomaly
-     */
-    static eccentricAnomalyToTrueAnomaly(E, e) {
-        const cosNu = (Math.cos(E) - e) / (1 - e * Math.cos(E));
-        const sinNu = Math.sqrt(1 - e * e) * Math.sin(E) / (1 - e * Math.cos(E));
-        return Math.atan2(sinNu, cosNu);
-    }
-}
-
-export {OrbitUtils};
+import {MU, RAD2DEG} from "./constants.js";
+import {cross, norm} from "mathjs";
+import {wrapHalfRevUnsigned, wrapOneRevUnsigned} from "./utils.js";
+
+const EARTH_MU_KM = MU; // km³/s²
+
+class OrbitUtils {
+    /**
+     * Get inclination based on azimuth and latitude.
+     * @param {number} azimuthRad - Azimuth in radians
+     * @param {number} latitudeRad - Latitude in radians
+     * @return {number} Inclination in radians
+     */
+    static getInclination(azimuthRad, latitudeRad) {
+        const inclination = Math.acos(Math.cos(latitudeRad) * Math.sin(azimuthRad));
+        return wrapHalfRevUnsigned(inclination);
+    }
+
+    /**
+     * Get the azimuth based on inclination and latitude.
+     * Two results will be possible, based on whether you are Ascending from South to North or Descending from North to South.
+     * @param {number} inclinationRad - Inclination in radians
+     * @param {number} latitudeRad - Latitude in radians
+     * @param {boolean} ascending - Ascending (true) or descending (false)
+     * @return {number} Azimuth in radians
+     */
+    static getAzimuth(inclinationRad, latitudeRad, ascending = true) {
+        const azimuth = Math.asin(Math.cos(inclinationRad) / Math.cos(latitudeRad));
+        if (!ascending) {
+            return wrapOneRevUnsigned(Math.PI - azimuth);
+        }
+        return wrapOneRevUnsigned(azimuth);
+    }
+
+    /**
+     * Calculate the specific angular momentum (h) vector of an orbit.
+     * @param {Array} r - Position vector [x, y, z]
+     * @param {Array} v - Velocity vector [vx, vy, vz]
+     * @return {Array} Angular momentum vector
+     */
+    static getAngularMomentum(r, v) {
+        return cross(r, v);
+    }
+
+    /**
+     * Get mean motion (rad/sec).
+     * @param {number} a - Semi Major Axis (km)
+     * @param {number} mu - Standard gravitational parameter (km^3/s^2)
+     * @return {number} Mean motion in rad/sec
+     */
+    static getMeanMotion(a, mu = EARTH_MU_KM) {
+        return Math.sqrt(mu / Math.pow(a, 3));
+    }
+
+    /**
+     * Get the period of an orbit in seconds.
+     * @param {number} a - Semi Major Axis (km)
+     * @param {number} mu - Standard gravitational parameter (km^3/s^2)
+     * @return {number} Period in seconds
+     */
+    static getPeriod(a, mu = EARTH_MU_KM) {
+        if (a <= 0) return null;
+        return 2 * Math.PI * Math.sqrt(Math.pow(a, 3) / mu);
+    }
+
+    /**
+     * Transform an orbit to elliptical with target parameters using Brent's method.
+     * Accurate port of the C# TransformElliptical method.
+     * @param {Object} svInitial - Initial state vector {position: [x,y,z], velocity: [vx,vy,vz], epoch: Date}
+     * @param {number} incRad - Inclination in radians
+     * @param {number} raanRad - RAAN in radians
+     * @param {number} targetEcc - Target eccentricity
+     * @param {number} targetArgOfPeriapsisRad - Target argument of periapsis in radians
+     * @param {number} targetPerigeeKm - Target perigee in km
+     * @return {Object} Satellite object with new orbital elements
+     */
+    static transformElliptical(svInitial, incRad, raanRad,
+        targetEcc, targetArgOfPeriapsisRad, targetPerigeeKm) {
+        // Normalize the position vector
+        const rNorm = norm(svInitial.position);
+        const r = svInitial.position.map((x) => x / rNorm);
+
+        // Project the position vector onto the orbital plane
+        const projectedX = r[0] * Math.cos(raanRad) + r[1] * Math.sin(raanRad);
+        const projectedY = r[1] * Math.cos(raanRad) - r[0] * Math.sin(raanRad);
+
+        // Calculate the initial true anomaly using the projected coordinates and known argument of periapsis
+        let nu0 = Math.atan2(projectedY, projectedX) - targetArgOfPeriapsisRad;
+        nu0 = (nu0 + 2 * Math.PI) % (2 * Math.PI);
+
+        // Define the objective function that we want to minimize
+        const objectiveFunction = (nu) => {
+            nu = (nu + 2 * Math.PI) % (2 * Math.PI);
+
+            // Create orbital elements with the trial true anomaly
+            const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
+            const elements = {
+                semiMajorAxis: semiMajorAxis,
+                eccentricity: targetEcc,
+                inclination: incRad,
+                raan: raanRad,
+                argOfPeriapsis: targetArgOfPeriapsisRad,
+                trueAnomaly: nu,
+                epoch: svInitial.epoch,
+            };
+
+            // Convert elements to state vector
+            const trialState = this.elementsToStateVector(elements);
+
+            // Normalize the trial position vector
+            const trialRNorm = norm(trialState.position);
+            const trialR = trialState.position.map((x) => x / trialRNorm);
+
+            // Scale trial position to match initial position magnitude
+            const pScaled = trialR.map((x) => x * rNorm);
+
+            // Return the distance between initial and trial positions
+            return norm(svInitial.position.map((x, i) => x - pScaled[i]));
+        };
+
+        // Use Brent's method for minimization
+        const tolerance = 1e-6; // radians
+        const maxIterations = 1000;
+
+        // Initial bracket around the solution
+        let a = nu0 - Math.PI;
+        let b = nu0 + Math.PI;
+        let c = nu0;
+
+        let fa = objectiveFunction(a);
+        let fb = objectiveFunction(b);
+        let fc = objectiveFunction(c);
+
+        let d = 0; let e = 0; let min1; let min2;
+        let p; let q; let r1; let tol1; let xm;
+
+        for (let iter = 0; iter < maxIterations; iter++) {
+            if (Math.abs(b - a) < tolerance) {
+                // Found minimum
+                const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
+                return [semiMajorAxis, targetEcc, incRad * RAD2DEG,
+                    raanRad * RAD2DEG, targetArgOfPeriapsisRad * RAD2DEG, c * RAD2DEG];
+            }
+
+            xm = 0.5 * (a + b);
+            tol1 = tolerance * Math.abs(c) + 1e-10;
+            min1 = Math.abs(c - a);
+            min2 = Math.abs(b - c);
+
+            if (min1 < tol1 || min2 < tol1) {
+                // Found minimum
+                const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
+                return [semiMajorAxis, targetEcc, incRad * RAD2DEG,
+                    raanRad * RAD2DEG, targetArgOfPeriapsisRad * RAD2DEG, c * RAD2DEG];
+            }
+
+            // Construct a trial parabolic fit
+            if (Math.abs(e) >= tol1) {
+                r1 = (c - a) * (fb - fc);
+                q = (c - b) * (fa - fc);
+                p = (c - b) * q - (c - a) * r1;
+                q = 2.0 * (q - r1);
+                if (q > 0.0) p = -p;
+                q = Math.abs(q);
+                min1 = 3.0 * q * Math.abs(xm);
+                min2 = Math.abs(e * q);
+                if (2.0 * p < (min1 < min2 ? min1 : min2)) {
+                    e = d;
+                    d = p / q;
+                } else {
+                    d = xm;
+                    e = d;
+                }
+            } else {
+                d = xm;
+                e = d;
+            }
+
+            a = b;
+            fa = fb;
+            if (Math.abs(d) > tol1) {
+                b += d;
+            } else {
+                b += (xm >= 0 ? Math.abs(tol1) : -Math.abs(tol1));
+            }
+            fb = objectiveFunction(b);
+            if ((fb <= fc && c > b) || (fb >= fc && c < b)) {
+                c = a;
+                fc = fa;
+                a = b;
+                fa = fb;
+                b = c;
+                fb = fc;
+            }
+        }
+
+        throw new Error("Did not converge within maximum iterations");
+    }
+
+    /**
+     * Convert orbital elements to state vector
+     * @param {Object} elements - Orbital elements
+     * @return {Object} State vector {position, velocity}
+     */
+    static elementsToStateVector(elements) {
+        const {semiMajorAxis, eccentricity, inclination,
+            raan, argOfPeriapsis, trueAnomaly} = elements;
+        const mu = EARTH_MU_KM;
+
+        // Calculate radius
+        const rMag = semiMajorAxis * (1 - eccentricity * eccentricity)
+            / (1 + eccentricity * Math.cos(trueAnomaly));
+
+        // Position in orbital plane
+        const rOrbital = [
+            rMag * Math.cos(trueAnomaly),
+            rMag * Math.sin(trueAnomaly),
+            0,
+        ];
+
+        // Velocity in orbital plane
+        const h = Math.sqrt(mu * semiMajorAxis * (1 - eccentricity * eccentricity));
+        const vOrbital = [
+            -mu / h * Math.sin(trueAnomaly),
+            mu / h * (eccentricity + Math.cos(trueAnomaly)),
+            0,
+        ];
+
+        // Rotation matrices
+        const cosW = Math.cos(argOfPeriapsis);
+        const sinW = Math.sin(argOfPeriapsis);
+        const cosO = Math.cos(raan);
+        const sinO = Math.sin(raan);
+        const cosI = Math.cos(inclination);
+        const sinI = Math.sin(inclination);
+
+        // Transform to inertial frame
+        const r = [
+            rOrbital[0] * (cosW * cosO - sinW * cosI * sinO)
+                - rOrbital[1] * (sinW * cosO + cosW * cosI * sinO),
+            rOrbital[0] * (cosW * sinO + sinW * cosI * cosO) + rOrbital[1]
+                * (cosW * cosI * cosO - sinW * sinO),
+            rOrbital[0] * (sinW * sinI) + rOrbital[1] * (cosW * sinI),
+        ];
+
+        const v = [
+            vOrbital[0] * (cosW * cosO - sinW * cosI * sinO)
+                - vOrbital[1] * (sinW * cosO + cosW * cosI * sinO),
+            vOrbital[0] * (cosW * sinO + sinW * cosI * cosO)
+                + vOrbital[1] * (cosW * cosI * cosO - sinW * sinO),
+            vOrbital[0] * (sinW * sinI) + vOrbital[1] * (cosW * sinI),
+        ];
+
+        return {position: r, velocity: v};
+    }
+
+    /**
+     * Convert true anomaly to eccentric anomaly
+     * @param {number} nu - true anomaly
+     * @param {number} e - eccentricity
+     * @return {number} Eccentric Anomaly
+     */
+    static trueAnomalyToEccentricAnomaly(nu, e) {
+        const cosE = (e + Math.cos(nu)) / (1 + e * Math.cos(nu));
+        const sinE = Math.sqrt(1 - e * e) * Math.sin(nu) / (1 + e * Math.cos(nu));
+        return Math.atan2(sinE, cosE);
+    }
+
+    /**
+     * Convert eccentric anomaly to mean anomaly
+     * @param {number} E - Eccentric anomaly
+     * @param {number} e - eccentricity
+     * @return {number} Mean Anomaly
+     */
+    static eccentricAnomalyToMeanAnomaly(E, e) {
+        return E - e * Math.sin(E);
+    }
+
+    /**
+     * Convert mean anomaly to eccentric anomaly (Kepler's equation)
+     * @param {number} M - Mean anomaly
+     * @param {number} e - eccentricity
+     * @param {number} tolerance - numerical tolerance
+     * @return {number} Eccentric Anomaly
+     */
+    static meanAnomalyToEccentricAnomaly(M, e, tolerance = 1e-8) {
+        let E = M;
+        let delta = 1;
+        while (Math.abs(delta) > tolerance) {
+            delta = (M - E + e * Math.sin(E)) / (1 - e * Math.cos(E));
+            E += delta;
+        }
+        return E;
+    }
+
+    /**
+     * Convert eccentric anomaly to true anomaly
+     * @param {number} E - Eccentric anomaly
+     * @param {number} e - eccentricity
+     * @return {number} true anomaly
+     */
+    static eccentricAnomalyToTrueAnomaly(E, e) {
+        const cosNu = (Math.cos(E) - e) / (1 - e * Math.cos(E));
+        const sinNu = Math.sqrt(1 - e * e) * Math.sin(E) / (1 - e * Math.cos(E));
+        return Math.atan2(sinNu, cosNu);
+    }
+}
+
+export {OrbitUtils};