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

package/README.md

@@ -1,42 +1,42 @@
-# Saber Common node functions
-
-The contains common node functions used across saber applications
-
-## Logger
-
-The logger component is a standard logger based on [winston](https://github.com/winstonjs/winston). The logger factory
-creates a default console logger for errors along with exception/rejection catching. By setting the `CONSOLE_LOG` 
-variable to `true` will turn on the console logger for local development. The log level is configured by the `LOG_LEVEL`
-environment variable to one of the following levels: `emerg`, `alert`, `crit`, `error`, `warning`, `warn`, `notice`, 
-`info`, `debug` (default level is `error`). The reason using an environment variable for the level is useful when 
-deployed to the server. Changing the environment variable is easier than setting a new flag in the script execution.
-
-### Usage
-
-To create a new logger, just pass in options to the factory:
-
-```javascript
-const logger = loggerFactory(opts);
-
-logger.debug("This is a debug message");
-```
-
-For further usage, consult [winston](https://github.com/winstonjs/winston)
-
-### Options
-
-- `nameSpace` help distinguish where the logger message comes from.
-- `additionalData` Data to include with each message 
-- `level` overwrite the `LOG_LEVEL` environment level
-
-## Transformer
-
-A transformer for object keys is provided. This will take an object and transform the keys using a function. 
-
-## Publishing changes
-
-1. Change the version in package.json
-2. Run `npm publish && npm install`
-3. Enable GPG in GIT: `git config --global commit.gpgsign true`
-4. Run `gpg --list-keys` to get your <id> 
+# Saber Common node functions
+
+The contains common node functions used across saber applications
+
+## Logger
+
+The logger component is a standard logger based on [winston](https://github.com/winstonjs/winston). The logger factory
+creates a default console logger for errors along with exception/rejection catching. By setting the `CONSOLE_LOG` 
+variable to `true` will turn on the console logger for local development. The log level is configured by the `LOG_LEVEL`
+environment variable to one of the following levels: `emerg`, `alert`, `crit`, `error`, `warning`, `warn`, `notice`, 
+`info`, `debug` (default level is `error`). The reason using an environment variable for the level is useful when 
+deployed to the server. Changing the environment variable is easier than setting a new flag in the script execution.
+
+### Usage
+
+To create a new logger, just pass in options to the factory:
+
+```javascript
+const logger = loggerFactory(opts);
+
+logger.debug("This is a debug message");
+```
+
+For further usage, consult [winston](https://github.com/winstonjs/winston)
+
+### Options
+
+- `nameSpace` help distinguish where the logger message comes from.
+- `additionalData` Data to include with each message 
+- `level` overwrite the `LOG_LEVEL` environment level
+
+## Transformer
+
+A transformer for object keys is provided. This will take an object and transform the keys using a function. 
+
+## Publishing changes
+
+1. Change the version in package.json
+2. Run `npm publish && npm install`
+3. Enable GPG in GIT: `git config --global commit.gpgsign true`
+4. Run `gpg --list-keys` to get your <id> 
 5. Tell the GIT to use your key `git config user.signingkey <id>`

package/package.json

@@ -1,51 +1,52 @@
-{
-  "name": "@saber-usa/node-common",
-  "version": "1.7.6",
-  "description": "Common node functions for Saber",
-  "main": "src/index.js",
-  "type": "module",
-  "scripts": {
-    "lint": "eslint . --ext js",
-    "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"
-  },
-  "files": [
-    "src/**/*"
-  ],
-  "author": "Saber USA",
-  "license": "ISC",
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.666.0",
-    "date-fns": "^4.1.0",
-    "lodash": "4.17.21",
-    "mathjs": "^14.7.0",
-    "pious-squid": "^2.3.0",
-    "plotly": "^1.0.6",
-    "satellite.js": "^6.0.1",
-    "solar-calculator": "^0.3.0",
-    "three": "^0.178.0",
-    "winston": "3.3.3"
-  },
-  "devDependencies": {
-    "@babel/core": "7.16.0",
-    "@babel/eslint-parser": "7.16.3",
-    "@babel/plugin-transform-modules-commonjs": "7.16.0",
-    "@jest/globals": "27.4.4",
-    "eslint-config-google": "0.14.0",
-    "eslint-plugin-jest": "25.3.0",
-    "jest": "29.7.0",
-    "jest-diff": "29.7.0",
-    "nodemon": "3.1.4",
-    "sonarqube-scanner": "3.0.1"
-  },
-  "overrides": {
-    "braces": "3.0.3"
-  },
-  "babel": {
-    "plugins": [
-      "@babel/plugin-transform-modules-commonjs"
-    ]
-  }
-}
+{
+  "name": "@saber-usa/node-common",
+  "version": "1.7.7-alpha.1",
+  "description": "Common node functions for Saber",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "lint": "eslint . --ext js",
+    "lint:fix": "eslint . --ext js --fix",
+    "test": "jest --no-coverage --silent",
+    "test:unit": "jest --coverage --runInBand --no-watch",
+    "sonar": "node --experimental-vm-modules sonar-project.js",
+    "prepub:alpha": "npm version prerelease --preid=alpha && npm publish --tag alpha"
+  },
+  "files": [
+    "src/**/*"
+  ],
+  "author": "Saber USA",
+  "license": "ISC",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.666.0",
+    "date-fns": "^4.1.0",
+    "lodash": "4.17.21",
+    "mathjs": "^14.7.0",
+    "pious-squid": "^2.3.0",
+    "plotly": "^1.0.6",
+    "satellite.js": "^6.0.1",
+    "solar-calculator": "^0.3.0",
+    "three": "^0.178.0",
+    "winston": "3.3.3"
+  },
+  "devDependencies": {
+    "@babel/core": "7.16.0",
+    "@babel/eslint-parser": "7.16.3",
+    "@babel/plugin-transform-modules-commonjs": "7.16.0",
+    "@jest/globals": "27.4.4",
+    "eslint-config-google": "0.14.0",
+    "eslint-plugin-jest": "25.3.0",
+    "jest": "29.7.0",
+    "jest-diff": "29.7.0",
+    "nodemon": "3.1.4",
+    "sonarqube-scanner": "3.0.1"
+  },
+  "overrides": {
+    "braces": "3.0.3"
+  },
+  "babel": {
+    "plugins": [
+      "@babel/plugin-transform-modules-commonjs"
+    ]
+  }
+}

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,6 +22,8 @@ const ReferenceFrame = {
     GCRF: "GCRF",
 };
 
+const mu = GRAV_CONST * EARTH_MASS / 1e9; // km^3/s^2
+
 class LaunchNominalClass {
     /** Get position at a given time in specified reference frame
      *
@@ -54,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);
 
@@ -75,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],
@@ -104,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,
         };
 
@@ -150,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,
@@ -165,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) {
@@ -238,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",
         };
@@ -266,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]);
 
@@ -406,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;
 
@@ -471,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]);
@@ -538,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);
 
@@ -585,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));
@@ -600,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;
@@ -614,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;
@@ -633,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;
 
@@ -719,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]);
         }
@@ -731,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
         });