@saber-usa/node-common 1.7.2 → 1.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber-usa/node-common",
-  "version": "1.7.2",
+  "version": "1.7.4",
   "description": "Common node functions for Saber",
   "main": "src/index.js",
   "type": "module",

package/src/FrameConverter.js

@@ -31,6 +31,58 @@ const Earth = {
 };
 
 class FrameConverter {
+    /**
+     * Helper method to transform a vector using a Matrix3D
+     * @param {Vector3D} vector - Vector to transform
+     * @param {Matrix3D} matrix - Matrix to use for transformation
+     * @return {Vector3D} Transformed vector
+     */
+    static transformVector(vector, matrix) {
+        // Manual matrix-vector multiplication since pious-squid has issues
+        const x = matrix.get(0, 0) * vector.x
+            + matrix.get(0, 1) * vector.y + matrix.get(0, 2) * vector.z;
+        const y = matrix.get(1, 0) * vector.x
+            + matrix.get(1, 1) * vector.y + matrix.get(1, 2) * vector.z;
+        const z = matrix.get(2, 0) * vector.x
+            + matrix.get(2, 1) * vector.y + matrix.get(2, 2) * vector.z;
+        return new Vector3D(x, y, z);
+    }
+
+    /**
+     * Rotate a vector around an axis by an angle (Rodrigues' rotation formula)
+     * @param {Vector3D} vector - Vector to rotate
+     * @param {Vector3D} axis - Axis to rotate around (should be normalized)
+     * @param {number} angleRad - Angle in radians
+     * @return {Vector3D} Rotated vector
+     */
+    static rotateVector(vector, axis, angleRad) {
+        // Ensure axis is normalized
+        const k = axis.normalized();
+        const v = vector;
+        const cosTheta = Math.cos(angleRad);
+        const sinTheta = Math.sin(angleRad);
+
+        // Rodrigues' rotation formula:
+        // v_rot = v*cos(θ) + (k × v)*sin(θ) + k*(k·v)*(1-cos(θ))
+
+        // k × v (cross product)
+        const kCrossV = new Vector3D(
+            k.y * v.z - k.z * v.y,
+            k.z * v.x - k.x * v.z,
+            k.x * v.y - k.y * v.x,
+        );
+
+        // k·v (dot product)
+        const kDotV = k.x * v.x + k.y * v.y + k.z * v.z;
+
+        // Final rotation
+        return new Vector3D(
+            v.x * cosTheta + kCrossV.x * sinTheta + k.x * kDotV * (1 - cosTheta),
+            v.y * cosTheta + kCrossV.y * sinTheta + k.y * kDotV * (1 - cosTheta),
+            v.z * cosTheta + kCrossV.z * sinTheta + k.z * kDotV * (1 - cosTheta),
+        );
+    }
+
     /**
      * Helper to transpose a Matrix3D
      * @param {Matrix3D} m - The matrix to transpose

package/src/LaunchNominalClass.js

@@ -21,57 +21,7 @@ const ReferenceFrame = {
 };
 
 class LaunchNominalClass {
-    /**
-     * Helper method to transform a vector using a Matrix3D
-     * @param {Vector3D} vector - Vector to transform
-     * @param {Matrix3D} matrix - Matrix to use for transformation
-     * @return {Vector3D} Transformed vector
-     */
-    static transformVector(vector, matrix) {
-        // Manual matrix-vector multiplication since pious-squid has issues
-        const x = matrix.get(0, 0) * vector.x
-            + matrix.get(0, 1) * vector.y + matrix.get(0, 2) * vector.z;
-        const y = matrix.get(1, 0) * vector.x
-            + matrix.get(1, 1) * vector.y + matrix.get(1, 2) * vector.z;
-        const z = matrix.get(2, 0) * vector.x
-            + matrix.get(2, 1) * vector.y + matrix.get(2, 2) * vector.z;
-        return new Vector3D(x, y, z);
-    }
-
-    /**
-     * Rotate a vector around an axis by an angle (Rodrigues' rotation formula)
-     * @param {Vector3D} vector - Vector to rotate
-     * @param {Vector3D} axis - Axis to rotate around (should be normalized)
-     * @param {number} angleRad - Angle in radians
-     * @return {Vector3D} Rotated vector
-     */
-    static rotateVector(vector, axis, angleRad) {
-        // Ensure axis is normalized
-        const k = axis.normalized();
-        const v = vector;
-        const cosTheta = Math.cos(angleRad);
-        const sinTheta = Math.sin(angleRad);
-
-        // Rodrigues' rotation formula:
-        // v_rot = v*cos(θ) + (k × v)*sin(θ) + k*(k·v)*(1-cos(θ))
-
-        // k × v (cross product)
-        const kCrossV = new Vector3D(
-            k.y * v.z - k.z * v.y,
-            k.z * v.x - k.x * v.z,
-            k.x * v.y - k.y * v.x,
-        );
-
-        // k·v (dot product)
-        const kDotV = k.x * v.x + k.y * v.y + k.z * v.z;
-
-        // Final rotation
-        return new Vector3D(
-            v.x * cosTheta + kCrossV.x * sinTheta + k.x * kDotV * (1 - cosTheta),
-            v.y * cosTheta + kCrossV.y * sinTheta + k.y * kDotV * (1 - cosTheta),
-            v.z * cosTheta + kCrossV.z * sinTheta + k.z * kDotV * (1 - cosTheta),
-        );
-    }
+    
 
     /** Get position at a given time in specified reference frame
      *
@@ -82,7 +32,7 @@ class LaunchNominalClass {
     static getPositionJ2000(utc, posITRF) {
         const transformMatrix = FrameConverter.itrfToJ2000(utc);
 
-        return this.transformVector(posITRF, transformMatrix);
+        return FrameConverter.transformVector(posITRF, transformMatrix);
     }
 
     /** Generate a circular launch nominal.
@@ -427,16 +377,16 @@ class LaunchNominalClass {
         // Cardinal directions in ITRF frame
         // South vector (1, 0, 0) in SEZ
         const southSEZ = new Vector3D(1, 0, 0);
-        const south = this.transformVector(southSEZ, sez2ecef).normalized();
+        const south = FrameConverter.transformVector(southSEZ, sez2ecef).normalized();
         const north = south.scale(-1);
 
         // Zenith vector (0, 0, 1) in SEZ
         const zenithSEZ = new Vector3D(0, 0, 1);
-        const zenith = this.transformVector(zenithSEZ, sez2ecef).normalized();
+        const zenith = FrameConverter.transformVector(zenithSEZ, sez2ecef).normalized();
         const nadir = zenith.scale(-1);
 
-        const northJ2000 = this.transformVector(north, itrf2j2000).normalized();
-        const nadirJ2000 = this.transformVector(nadir, itrf2j2000).normalized();
+        const northJ2000 = FrameConverter.transformVector(north, itrf2j2000).normalized();
+        const nadirJ2000 = FrameConverter.transformVector(nadir, itrf2j2000).normalized();
 
         // Position of site in J2000 scaled by the orbit altitude
         const siteJ2000 = this.getPositionJ2000(orbitInsertionTime, positionITRF);
@@ -446,7 +396,7 @@ class LaunchNominalClass {
         // North vector rotated by azimuth along nadir vector scaled by the velocity of a circular orbit
         const rLength = Math.sqrt(r.x * r.x + r.y * r.y + r.z * r.z);
         const velocityMagnitude = Math.sqrt(mu / rLength);
-        const velocityDirection = this.rotateVector(northJ2000, nadirJ2000, azimuthRad);
+        const velocityDirection = FrameConverter.rotateVector(northJ2000, nadirJ2000, azimuthRad);
         const v = velocityDirection.scale(velocityMagnitude);
 
         return {
@@ -502,7 +452,7 @@ class LaunchNominalClass {
         };
 
         const rtnToEci = FrameConverter.rtnToEci(stateAtM1.position, stateAtM1.velocity);
-        const dv1eci = this.transformVector(burn1.dv, rtnToEci);
+        const dv1eci = FrameConverter.transformVector(burn1.dv, rtnToEci);
 
         const state1 = {
             position: new NodeVector3D(
@@ -564,7 +514,7 @@ class LaunchNominalClass {
         };
 
         const rtnToEci2 = FrameConverter.rtnToEci(stateAtM2.position, stateAtM2.velocity);
-        const dv1eci2 = this.transformVector(burn2.dv, rtnToEci2);
+        const dv1eci2 = FrameConverter.transformVector(burn2.dv, rtnToEci2);
 
         const state2 = {
             position: new NodeVector3D(
@@ -769,8 +719,8 @@ class LaunchNominalOutput {
 
         if (!elements) {
             const j2000ToTeme = FrameConverter.getTransform("J2000", "TEME", epoch);
-            const posTeme = LaunchNominalClass.transformVector(pos, j2000ToTeme);
-            const velTeme = LaunchNominalClass.transformVector(vel, j2000ToTeme);
+            const posTeme = FrameConverter.transformVector(pos, j2000ToTeme);
+            const velTeme = FrameConverter.transformVector(vel, j2000ToTeme);
             elements = OrbitUtils.stateVectorToElements(
                 [posTeme.x, posTeme.y, posTeme.z],
                 [velTeme.x, velTeme.y, velTeme.z]);

package/src/astro.js

@@ -779,6 +779,7 @@ const getTRIC = (pEphem, tEphem) => {
     const isPrimaryEpoch = []; // Whether point is primary epoch
     const isTargetEpoch = []; // Whether point is target epoch
     const sources = []; // Sources
+    const datamodes = []; // Data modes
 
     for (let j = 0; j < pEphem.length; j++) {
         const prim = pEphem[j];
@@ -788,6 +789,7 @@ const getTRIC = (pEphem, tEphem) => {
         isPrimaryEpoch.push((!!prim.isEpoch)+""); // it can't be a boolean for some reason
         isTargetEpoch.push((!!target.isEpoch)+"");
         sources.push(prim.source + ", " + target.source);
+        datamodes.push(prim.datamode + ", " + target.datamode);
 
         // Calculate RIC values.
         const deltaR = {
@@ -828,6 +830,7 @@ const getTRIC = (pEphem, tEphem) => {
         isPrimaryEpoch,
         isTargetEpoch,
         sources,
+        datamodes,
         targetVisibility,
         primaryVisibility,
     };