@saber-usa/node-common 1.6.207

package/src/ballisticPropagator/ballisticPropagator.js

@@ -0,0 +1,1047 @@
+/**
+ * Refactored Vinti Ballistic Propagator JavaScript Implementation
+ * Uses existing node-common libraries instead of custom implementations
+ *
+ * This is a refactored version of the complete Vinti Ballistic Propagator
+ * that replaces custom implementations with existing node-common libraries.
+ */
+
+// Import existing libraries instead of defining custom ones
+const {
+    MU,
+    WGS84_EARTH_EQUATORIAL_RADIUS_KM,
+} = require("../constants");
+const {NodeVector3D} = require("../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)
+    J2: 1082.62999e-6,
+    J3: -2.53215e-6,
+};
+
+/**
+ * Position-Velocity vector pair
+ * Enhanced to work with pious-squid Vector3D
+ */
+class PosVelVec {
+    constructor(posOrX, velOrY, z, vx, vy, vz) {
+        if (posOrX instanceof NodeVector3D) {
+            this.position = posOrX;
+            this.velocity = velOrY;
+        } else {
+            this.position = new NodeVector3D(posOrX, velOrY, z);
+            this.velocity = new NodeVector3D(vx, vy, vz);
+        }
+    }
+
+    /**
+     * Get a zero vector for position and velocity
+     * @return {PosVelVec} zero vector
+     */
+    static zero() {
+        return new PosVelVec(new NodeVector3D(0, 0, 0), new NodeVector3D(0, 0, 0));
+    }
+
+    /**
+     * Get the position vector
+     * @return {NodeVector3D} Position vector
+     */
+    get Position() {
+        return this.position;
+    }
+
+    /**
+     * Get the velocity vector
+     * @return {NodeVector3D} Velocity vector
+     */
+    get Velocity() {
+        return this.velocity;
+    }
+
+    /**
+     * Get the value at a specific index
+     * @param {*} index
+     * @return {number}
+     */
+    get(index) {
+        switch (index) {
+            case 0: return this.position.x;
+            case 1: return this.position.y;
+            case 2: return this.position.z;
+            case 3: return this.velocity.x;
+            case 4: return this.velocity.y;
+            case 5: return this.velocity.z;
+            default: throw new Error(`Index ${index} out of range`);
+        }
+    }
+
+    set(index, value) {
+        switch (index) {
+            case 0: this.position.x = value; break;
+            case 1: this.position.y = value; break;
+            case 2: this.position.z = value; break;
+            case 3: this.velocity.x = value; break;
+            case 4: this.velocity.y = value; break;
+            case 5: this.velocity.z = value; break;
+            default: throw new Error(`Index ${index} out of range`);
+        }
+    }
+}
+
+/**
+ * Complete Ballistic Propagator Implementation
+ * Refactored to use pious-squid Vector3D operations
+ */
+class BallisticPropagatorUtils {
+    /**
+     * Kepler solver - exact port from C#
+     * Now uses pious-squid Vector3D operations
+     * @param {*} planet
+     * @param {*} t0
+     * @param {*} x0
+     * @param {*} t1
+     * @return {{x1: PosVelVec, xxx: number}} Object with propagated state and auxiliary value
+     */
+    static kepler1(planet, t0, x0, t1) {
+        const muqr = 1;
+        const tlimit = 1.0e-10;
+        const kn = 10;
+
+        const rex = planet[0];
+        const gmx = planet[1];
+
+        let dt = t1 - t0;
+        let x1 = PosVelVec.zero();
+        let xxx = 0;
+
+        if (Math.abs(dt) < tlimit) {
+            for (let i = 0; i < 6; i++) {
+                x1.set(i, x0.get(i));
+            }
+            return {x1, xxx: 0};
+        }
+
+        // Change from SI units to astronomical units
+        const timeFactor = Math.sqrt(rex * rex * rex / gmx);
+        const vex = rex / timeFactor;
+        dt /= timeFactor;
+
+        // Use pious-squid Vector3D scale method instead of custom scaleBy
+        const r0 = x0.Position.scale(1 / rex);
+        const v0 = x0.Velocity.scale(1 / vex);
+
+        const r0Mag = r0.magnitude();
+        const v0Mag = v0.magnitude();
+
+        const d0 = r0.dot(v0);
+        const sigma0 = d0 / muqr;
+        const alp0 = 2.0 / r0Mag - v0Mag * v0Mag;
+
+        // Initial guess
+        let x = alp0 * dt;
+        if (alp0 <= 0) x = 0.5 * dt / r0Mag;
+
+        let dfx = 0;
+        let u1 = 0; let u2 = 0; let u3 = 0;
+        let y = 0; let cy = 0; let sy = 0;
+
+        // Newton-Raphson iteration
+        for (let k = 1; k <= kn; k++) {
+            let yqr;
+
+            if (alp0 < 0) {
+                y = alp0 * x * x;
+                yqr = Math.sqrt(-y);
+                cy = (1 - Math.cosh(yqr)) / y;
+                sy = (Math.sinh(yqr) - yqr) / (yqr * yqr * yqr);
+            } else if (alp0 === 0) {
+                y = 0;
+                cy = 0.5;
+                sy = 1.0 / 6.0;
+            } else if (alp0 > 0) {
+                y = alp0 * x * x;
+                yqr = Math.sqrt(y);
+                cy = (1 - Math.cos(yqr)) / y;
+                sy = (yqr - Math.sin(yqr)) / (yqr * yqr * yqr);
+            }
+
+            u1 = x * (1 - y * sy);
+            u2 = x * x * cy;
+            u3 = x * x * x * sy;
+
+            const fx = r0Mag * u1 + sigma0 * u2 + u3 - dt * muqr;
+            dfx = sigma0 * u1 + (1 - alp0 * r0Mag) * u2 + r0Mag;
+            const dfx2 = sigma0 * (1 - y * cy) + (1 - alp0 * r0Mag) * u1;
+            const sdfx = dfx / Math.abs(dfx);
+
+            const dx2 = 16 * dfx * dfx - 20 * fx * dfx2;
+
+            let dx;
+            if (dx2 > 0) {
+                dx = 5 * fx / (dfx + sdfx * Math.sqrt(dx2));
+            } else {
+                dx = 0.5 * x;
+            }
+
+            if (Math.abs(dx) < 1.0e-10) break;
+
+            x -= dx;
+        }
+
+        // Kepler solution converged
+        const rmag = dfx;
+        const f = 1 - u2 / r0Mag;
+        const g = dt - u3 / muqr;
+        const df = -muqr * u1 / (rmag * r0Mag);
+        const dg = 1 - u2 / rmag;
+
+        // Use pious-squid Vector3D operations
+        const finalPos = r0.scale(f).add(v0.scale(g)).scale(rex);
+        const finalVel = r0.scale(df).add(v0.scale(dg)).scale(vex);
+
+        x1 = new PosVelVec(finalPos, finalVel);
+        xxx = x * Math.sqrt(rex);
+
+        return {x1, xxx};
+    }
+
+    /**
+     * Main Vinti Ballistic Propagation Algorithm
+     * Complete implementation with all steps - using pious-squid Vector3D
+     * @param {*} x0
+     * @param {*} span
+     * @param {*} eqrad
+     * @param {*} mu
+     * @param {*} j2
+     * @param {*} j3
+     * @return {PosVelVec} x1
+     */
+    static ballisticProp(x0, span, eqrad, mu, j2, j3) {
+        // Setup
+        // const pi = 3.141592653589793238;
+        const pi = Math.PI;
+        const twopi = 2 * pi;
+        // const degs = 180 / pi; Astrolibrary's use of degs is unusual in that it calculates a value but immediately discards it.
+
+        const ae = eqrad; // Equatorial radius
+        const gm = mu; // Gravitational parameter
+        const xj2 = j2; // J2
+        const xj3 = j3; // J3
+
+        const planet = [ae, gm, xj2, xj3];
+
+        let x1 = PosVelVec.zero();
+
+        // Compute initial guess using Kepler solver
+        const vt0 = 0;
+        const vt1 = span;
+
+        let xhat0 = 0;
+        const keplerResult = this.kepler1(planet, vt0, x0, vt1);
+        x1 = keplerResult.x1;
+        xhat0 = keplerResult.xxx;
+
+        xhat0 /= Math.sqrt(ae); // Change to astronomical units
+
+        // Check Vinti's forbidden zone - using pious-squid Vector3D cross product
+        const h0 = new NodeVector3D(
+            x0.get(1) * x0.get(5) - x0.get(2) * x0.get(4),
+            x0.get(2) * x0.get(3) - x0.get(0) * x0.get(5),
+            x0.get(0) * x0.get(4) - x0.get(1) * x0.get(3),
+        );
+        const h02 = h0.magnitude() * h0.magnitude();
+
+        const r0mag = x0.Position.magnitude();
+        const v0mag = x0.Velocity.magnitude();
+
+        const alp0 = 2.0 / r0mag - v0mag * v0mag / gm;
+
+        let periapsisRadius; let e0;
+        if (Math.abs(alp0) < 1.0e-15) {
+            periapsisRadius = h02 / (2.0 * gm); // Parabolic
+        } else {
+            const a0 = 1.0 / alp0;
+            const e02 = 1 - alp0 * h02 / gm;
+
+            if (e02 <= 0) {
+                e0 = 0;
+            } else {
+                e0 = Math.sqrt(e02);
+            }
+
+            periapsisRadius = a0 * (1.0 - e0);
+        }
+
+        if (periapsisRadius < 210) {
+            throw new Error("Trajectory enters Vinti forbidden zone [WARNING: SPOOKY].");
+        }
+
+        // Change from SI units to astronomical units
+        const timeFactor = Math.sqrt(ae * ae * ae / gm);
+        const ve = ae / timeFactor;
+        const t0 = vt0 / timeFactor;
+
+        // Use pious-squid Vector3D scale method
+        const pin = x0.Position.scale(1 / ae);
+        const vin = x0.Velocity.scale(1 / ve);
+
+        const tf = span / timeFactor;
+
+        // ========== STEP 1: Initial coordinate transformation ==========
+        const delta = -xj3 / (2 * xj2);
+        const csq = xj2 * (1 - delta * delta / xj2);
+        const d0 = Math.sqrt(pin.x * pin.x + pin.y * pin.y);
+        let alph0 = Math.atan2(pin.y, pin.x);
+
+        if (alph0 < 0) alph0 = twopi + alph0;
+
+        const r02 = d0 * d0 + pin.z * pin.z;
+        const zpdelta = pin.z + delta;
+        const rhotemp = r02 - csq + delta * (zpdelta + pin.z);
+        const rho0 = Math.sqrt(
+            rhotemp + Math.sqrt(rhotemp * rhotemp + 4 * csq * (zpdelta * zpdelta)))
+            / Math.sqrt(2.0);
+        const rho02 = rho0 * rho0;
+        const sigma0 = zpdelta / rho0;
+        const rrd = pin.dot(vin); // Using pious-squid dot product
+        const delsig0 = delta * sigma0;
+        const csqsig0 = csq * sigma0;
+        let rcs = rho02 + csqsig0 * sigma0;
+        const v = -(rho0 + delsig0) / rcs;
+        const v0 = vin.magnitude(); // Using pious-squid magnitude method
+
+        // ========== STEP 2: First three Jacobi constants ==========
+        const alph3 = pin.x * vin.y - pin.y * vin.x;
+        const alph32 = alph3 * alph3;
+        const alph1 = 0.5 * v0 * v0 + v;
+        const sqrf = rho0 * rrd + (csqsig0 + delta * rho0) * vin.z;
+        const sqrg = -sigma0 * rrd - (delsig0 - rho0) * vin.z;
+        const alph22 = 2 * rho0 + 2 * alph1 * rho02 + (csq * alph32 - sqrf * sqrf) / (rho02 + csq);
+        const alph2 = Math.sqrt(alph22);
+        const gamma0 = 2 * alph1;
+        const csgam0 = csq * gamma0;
+        const p0 = alph22;
+        const s0 = 1 - alph32 / alph22;
+        const pcsgam0 = p0 - csgam0;
+        const csqs0p0 = csq * s0 * p0;
+
+        // ========== STEP 3: Factorizing F and G quartics ==========
+        let a1p = 0;
+        let b1 = csqs0p0 / pcsgam0;
+        let a1 = (csq - b1) / pcsgam0;
+
+        let p = 0; let p1 = 0; let q1 = 0;
+        let gam1 = 0; let pgam1 = 0; let gamma = 0;
+        let cneca = 0; let sneca = 0;
+
+        // Factorize F(rho) quartic
+        for (let icf = 1; icf <= 5; icf++) {
+            gam1 = 1 + gamma0 * a1;
+            pgam1 = pcsgam0 + b1 * gamma0 - 4 * a1 * gam1;
+            gamma = gamma0 / gam1;
+            p = pgam1 / gam1;
+            b1 = csqs0p0 / pgam1;
+            a1 = (csq - gam1 * b1) / pgam1;
+            const dela1 = a1 - a1p;
+
+            if (Math.abs(dela1) < 1.0e-15) break;
+            a1p = a1;
+        }
+
+        const oe = [];
+        oe[0] = p; // Vinti mean element (conic parameter)
+
+        let smgam;
+        if (gamma < 0) {
+            smgam = Math.sqrt(-gamma);
+        } else {
+            smgam = Math.sqrt(gamma);
+        }
+
+        // Factorize G(sigma) quartic
+        let s1p = 0;
+        let px = 0;
+        let s1 = 1;
+
+        for (let icg = 1; icg <= 5; icg++) {
+            const p0s1 = p0 * s1;
+            q1 = -csgam0 / p0s1;
+            p1 = 2 * delta / p0s1 - 2 * q1 * px;
+            px = delta / p0s1 - s0 * p1 / (2 * s1);
+            s1 = (pcsgam0 - s0 * p0 * q1) / ((1 - 2 * px * p1) * p0);
+            const dels1 = s1 - s1p;
+
+            if (Math.abs(dels1) < 1.0e-15) break;
+            s1p = s1;
+        }
+
+        // ========== STEP 4: Initialize R and N integral coefficients ==========
+        const gams3 = gamma * smgam;
+        const s = s0 / s1;
+        const pxs = px * px + s;
+        oe[2] = pxs; // Vinti mean element (sin^2(I))
+
+        let q;
+        if (pxs < 0) {
+            q = 0;
+        } else {
+            q = Math.sqrt(pxs);
+        }
+
+        let xinc = Math.asin(q);
+
+        // Check inclination quadrant - CRITICAL FIX from C#
+        if (alph3 * Math.cos(xinc) < 0) xinc = pi - xinc;
+
+        const q2 = q * q;
+        const q4 = q2 * q2;
+        const betad = 1 + p1 * px - q1 * px * px - q1 * q2;
+        const beta = (p1 - 2 * q1 * px) / betad;
+        const betasq = beta * beta;
+        const g = -beta / (1 + Math.sqrt(1 - betasq * q2));
+        const a = px + g * q2;
+        const b = 1 + g * px;
+
+        const g2 = g * g;
+        const asq = a * a;
+        const bsq = b * b;
+        const ab = a * b;
+        const d5 = 1 + p1 * a - q1 * asq;
+        const xm = (q1 * bsq - p1 * b * g - g2) / d5;
+        const xk1 = xm * q2;
+        const d1 = Math.sqrt((1 - g2 * q2) / (s1 * d5));
+        const ecc2 = 1 + p * gamma;
+        const ecc = Math.sqrt(ecc2);
+        oe[1] = ecc; // Vinti mean element (eccentricity)
+        const rho1 = p / (1 + ecc);
+
+        // Coefficients for R-integrals
+        // A0 = 1, A1 from factorization, A2 to A6
+        const a1sq = a1 * a1;
+        const b1sq = b1 * b1;
+
+        const a2 = (3 * a1sq - b1) / 2;
+        const a3 = 2.5 * a1sq * a1 - 1.50 * a1 * b1;
+        const a4 = 0.375 * (b1sq - 10 * a1sq * b1);
+        const a5 = 1.875 * a1 * b1sq;
+        const a6 = -0.3125 * b1sq * b1;
+
+        // W1, W2 ... W6 for the R-integrals
+        const e3 = ecc2 * ecc;
+        const e4 = ecc2 * ecc2;
+        const e5 = e3 * ecc2;
+        const e6 = e3 * e3;
+
+        const psq = p * p;
+
+        const p3 = psq * p;
+        const p4 = psq * psq;
+        const p5 = p3 * psq;
+        const p6 = p4 * psq;
+
+        const x21 = 1 / p;
+        const x22 = ecc / p;
+
+        const x33 = 0.5 * ecc2 / psq;
+        const x32 = 2 * ecc / psq;
+        const x31 = 1 / psq + x33;
+
+        const x44 = e3 / (3 * p3);
+        const x43 = 1.5 * ecc2 / p3;
+        const x42 = 3 * ecc / p3 + 2 * x44;
+        const x41 = 1 / p3 + x43;
+
+        const x55 = x33 * x33;
+        const x54 = 4 * x44 * x21;
+        const x53 = 3 * ecc2 / p4 + 1.5 * x55;
+        const x52 = 4 * ecc / p4 + 2 * x54;
+        const x51 = 1 / p4 + x53;
+
+        const x66 = 0.2 * e5 / p5;
+        const x65 = 1.25 * e4 / p5;
+        const x64 = 10 * e3 / (3 * p5) + 4 * x66 / 3;
+        const x63 = 5 * ecc2 / p5 + 1.5 * x65;
+        const x62 = 5 * ecc / p5 + 2 * x64;
+        const x61 = 1 / p5 + x63;
+
+        const x77 = e6 / (6 * p6);
+        const x76 = 1.2 * e5 / p6;
+        const x75 = 3.75 * e4 / p6 + 1.25 * x77;
+        const x74 = 20 * e3 / (3 * p6) + x76 / 0.75;
+        const x73 = 7.5 * ecc2 / p6 + 1.5 * x75;
+        const x72 = 6 * ecc / p6 + 2 * x74;
+        const x71 = 1 / p6 + x73;
+
+        const gg1si = 1.0 / Math.sqrt(gam1);
+        const gg1psi = gg1si / Math.sqrt(p);
+
+        // R1 coefficients
+        const cr11 = (rho1 + a1) * gg1si;
+        const cr12 = ecc * gg1si;
+        const cr13 = a2 * gg1psi;
+        const cr14 = a3 * gg1psi;
+        const cr15 = a4 * gg1psi;
+        const cr16 = a5 * gg1psi;
+        const cr17 = a6 * gg1psi;
+
+        // R2 coefficients
+        const cr21 = Math.sqrt(p0 / pgam1);
+        const cr22 = a1 * cr21;
+        const cr23 = a2 * cr21;
+        const cr24 = a3 * cr21;
+        const cr25 = a4 * cr21;
+        const cr26 = a5 * cr21;
+        const cr27 = a6 * cr21;
+
+        // R3 coefficients
+        const cr31 = alph3 * gg1psi;
+        const cr32 = a1 * cr31;
+        const cr33 = (a2 - csq) * cr31;
+        const cr34 = (a3 - a1 * csq) * cr31;
+        const cr35 = a4 * cr31 - csq * cr33;
+
+        // Coefficients for N-integrals
+
+        // N3 coefficients
+        const bmg = b - g;
+        const bpg = b + g;
+        const d1ma = 1 - a;
+        const d1pa = 1 + a;
+        const beta1 = bmg / d1ma;
+        const beta2 = -bpg / d1pa;
+        const b12 = beta1 * beta1;
+        const b13 = b12 * beta1;
+        const b22 = beta2 * beta2;
+        const b23 = b22 * beta2;
+        let xmm1 = Math.sqrt(1 - b12 * q2);
+
+        if (xmm1 * alph3 < 0) xmm1 = -xmm1;
+
+        let xmm2 = Math.sqrt(1 - b22 * q2);
+
+        if (xmm2 * alph3 < 0) xmm2 = -xmm2;
+
+        const d2 = delta / (p0 * (s1 - s0 * q1));
+        const d3 = q1 + 2 * p1 * d2;
+        const d4 = d1 * alph3 / (2 * alph2);
+
+        const d1md3 = 1 - d3;
+        const bmag = b - a * g;
+
+        const d10 = bmag / bmg * Math.sqrt(d1md3 / (d5 * (1 - xm / b12) * (1 - 2 * d2)));
+        const d20 = bmag / bpg * Math.sqrt(d1md3 / (d5 * (1 - xm / b22) * (1 + 2 * d2)));
+
+        const dd2 = xm / 2;
+        const dd3 = dd2 * g;
+        const dd4 = 1.5 * dd2 * dd2;
+        const dd5 = dd4 * g;
+        const dd6 = dd2 * dd4 / 0.6;
+
+        const c15 = dd6 / (b13 * b13);
+        const c14 = c15 + dd5 / (b12 * b13);
+        const c13 = c14 + dd4 / (b12 * b12);
+        const c12 = c13 + dd3 / b13;
+        const c11 = c12 + dd2 / b12;
+        const c10 = c11 + g / beta1;
+
+        const c25 = dd6 / (b23 * b23);
+        const c24 = c25 + dd5 / (b22 * b23);
+        const c23 = c24 + dd4 / (b22 * b22);
+        const c22 = c23 + dd3 / b23;
+        const c21 = c22 + dd2 / b22;
+        const c20 = c21 + g / beta2;
+
+        const b1q = beta1 * q;
+        const b1q2 = b1q * b1q;
+        const b1q4 = b1q2 * b1q2;
+        const b2q = beta2 * q;
+        const b2q2 = b2q * b2q;
+        const b2q4 = b2q2 * b2q2;
+
+        // N1 and N2 coefficients
+        const xk12 = xk1 * xk1;
+        const xk13 = xk12 * xk1;
+
+        // Byrd and Friedman formula for elliptic integral
+        const sq = xk1 / 16 + xk12 / 32 + 21 * xk13 / 1024;
+        const sq2 = sq * sq;
+        const sq3 = sq2 * sq;
+
+        const ucf1 = 2 * sq / (1 + sq2);
+        const ucf2 = sq2 / (1 + sq2 * sq2);
+        const ucf3 = 2.0 * sq3 / (3.0 * (1 + sq3 * sq3));
+
+        const denystt = 1 + sq + sq;
+        const denyst = denystt * denystt * d1;
+
+        // N1 coefficients
+        const d1a2 = d1 / alph2;
+        const cn11 = d1a2 * asq;
+        const cn12 = d1a2 * 2 * ab * q;
+        const cn13 = d1a2 * (bsq - 4 * ab * g) * q2;
+        const cn14 = d1a2 * (xm * ab - 2 * bsq * g) * q2 * q;
+        const cn15 = d1a2 * (3 * bsq * g2 + xm * bsq / 2) * q4;
+        const cn16 = -d1a2 * xm * bsq * g * q4 * q;
+        const cn17 = 0.375 * d1a2 * xm * xm * bsq * q4 * q2;
+
+        // N2 coefficients
+        const cn22 = 0.5 * xk1 * d1;
+        const cn24 = 0.375 * xk12 * d1;
+        const cn26 = 0.3125 * xk13 * d1;
+
+        // N3 coefficients
+        const d41ma = d4 / d1ma;
+        const d41pa = d4 / d1pa;
+
+        const cn31 = -d41ma * c10 - d41pa * c20;
+        const cn32 = -d41ma * c11 * b1q - d41pa * c21 * b2q;
+        const cn33 = -d41ma * c12 * b1q2 - d41pa * c22 * b2q2;
+        const cn34 = -d41ma * c13 * b1q2 * b1q - d41pa * c23 * b2q2 * b2q;
+        const cn35 = -d41ma * c14 * b1q4 - d41pa * c24 * b2q4;
+        const cn36 = -d41ma * c15 * b1q4 * b1q - d41pa * c25 * b2q4 * b2q;
+
+        // Avoid singularity at zero inclination
+        let u;
+        if (q === 0.0) {
+            u = 0;
+        } else {
+            const d5sq = Math.sqrt(s1 * p0 * (1 + p1 * sigma0 - q1 * sigma0 * sigma0));
+            const utn = (sigma0 - a) * d5sq;
+            const utd = sqrg * Math.sqrt(1 - g2 * q2);
+
+            u = Math.atan2(utn, utd);
+        }
+
+        // Calculate Tk = tk, k = 0, T0 = t0 = u. Here k = 1, ... ,6
+        let csu = Math.cos(u);
+        let snu = Math.sin(u);
+        let snu2 = snu * snu;
+        let snu4 = snu2 * snu2;
+
+        let t1 = 1 - csu;
+        let t2 = (u - csu * snu) / 2;
+        let t3 = (2 * t1 - csu * snu2) / 3;
+        let t4 = (3 * t2 - csu * snu2 * snu) / 4;
+        let t5 = (4 * t3 - csu * snu4) / 5;
+        let t6 = (5 * t4 - csu * snu4 * snu) / 6;
+
+        // Compute xhat at initial time
+        let xhat;
+        if (gamma < -1.0e-14) { // Ellipse
+            if (Math.abs(ecc) < 1.0e-10
+                || Math.abs(sqrf) < 1.0e-10
+                || Math.abs(rho0 - rho1) < 1e-5) {
+                xhat = 0;
+            } else {
+                const shat = Math.abs(sqrf) / sqrf * Math.sqrt(gamma * rho02 + 2 * rho0 - p) / ecc;
+                const cacs = (rho0 - rho1) * gamma / ecc + 1;
+                let acs = Math.atan2(shat * smgam, cacs);
+
+                if (acs < 0) acs = twopi + acs;
+
+                xhat = acs / smgam;
+            }
+        } else if (gamma > 1.0e-14) { // Hyperbola
+            if (Math.abs(ecc) < 1.0e-10 || Math.abs(sqrf) < 1.0e-10) {
+                xhat = 0.0;
+            } else {
+                const chat = (rho0 - rho1) / ecc;
+                const zz = gamma * chat + 1;
+                xhat = Math.log(zz + Math.sqrt(zz * zz - 1)) / Math.sqrt(gamma);
+
+                if (sqrf < 0) xhat = -xhat;
+            }
+        } else { // Parabola
+            xhat = rrd;
+        }
+
+        // ========== STEP 5: Last three Jacobi constants ==========
+        // Determine true anomaly from xhat at t0
+        let eca = smgam * xhat;
+        let tra; let chat; let shat;
+
+        if (gamma < -1.0e-14) { // Ellipse
+            sneca = Math.sin(eca);
+            cneca = Math.cos(eca);
+            const s1mes = Math.sqrt(1 - ecc2);
+            const temp3 = 2 * Math.atan(ecc * sneca / (1 + s1mes - ecc * cneca));
+            tra = eca + temp3;
+        } else if (gamma > 1.0e-14) { // Hyperbola
+            sneca = Math.sinh(eca);
+            cneca = Math.cosh(eca);
+
+            chat = (cneca - 1) / gamma;
+            shat = sneca / smgam;
+            tra = Math.atan2(Math.sqrt(p) * shat, rho1 - chat);
+        } else { // Parabola
+            tra = 2 * Math.atan(xhat / Math.sqrt(p));
+        }
+
+        let snw = Math.sin(tra);
+        let cnw = Math.cos(tra);
+        let ecccnw = ecc * cnw;
+
+        // const dw1dx = (1 + ecccnw) / p;
+        // const dw2dx = dw1dx * dw1dx; same case. Astrolibrary does not use this instance of dw2dx here but does so later in the code after it is redeclared
+
+        const v3 = snw * cnw;
+        const v4 = v3 * cnw;
+        const v5 = v4 * cnw;
+        const v6 = v5 * cnw;
+        const v7 = v6 * cnw;
+
+        let w1 = x21 * tra + x22 * snw;
+        let w2 = x31 * tra + x32 * snw + x33 * v3;
+        let w3 = x41 * tra + x42 * snw + x43 * v3 + x44 * v4;
+        let w4 = x51 * tra + x52 * snw + x53 * v3 + x54 * v4 + x55 * v5;
+        let w5 = x61 * tra + x62 * snw + x63 * v3 + x64 * v4 + x65 * v5 + x66 * v6;
+        let w6 = x71 * tra + x72 * snw + x73 * v3 + x74 * v4 + x75 * v5 + x76 * v6 + x77 * v7;
+
+        let uhat;
+        if (Math.abs(gamma) >= 1.0e-14) { // Circle, ellipse, hyperbola
+            chat = (cneca - 1) / gamma;
+            uhat = (sneca - eca) / gams3;
+        } else { // Parabola
+            chat = xhat * xhat / 2;
+            uhat = xhat * xhat * xhat / 6;
+        }
+
+        const r1 = cr11 * xhat + cr12 * uhat + cr13 * tra
+            + cr14 * w1 + cr15 * w2 + cr16 * w3 + cr17 * w4;
+        const r2 = cr21 * tra + cr22 * w1 + cr23 * w2 + cr24
+            * w3 + cr25 * w4 + cr26 * w5 + cr27 * w6;
+
+        let sstar = Math.sin(0.5 * u);
+        let cstar = Math.cos(0.5 * u);
+        let cb1qs = cstar - b1q * sstar;
+        let psi1 = Math.atan(xmm1 * sstar / cb1qs);
+
+        if (cb1qs * Math.cos(psi1) < 0.0) psi1 = pi + psi1;
+
+        let cb2qs = cstar - b2q * sstar;
+        let psi2 = Math.atan(xmm2 * sstar / cb2qs);
+
+        if (cb2qs * Math.cos(psi2) < 0.0) psi2 = pi + psi2;
+
+        let r3 = cr31 * w2 + cr32 * w3 + cr33 * w4 + cr34 * w5 + cr35 * w6;
+
+        let en3 = d10 * psi1 + d20 * psi2 + cn31 * u + cn32
+            * t1 + cn33 * t2 + cn34 * t3 + cn35 * t4 + cn36 * t5;
+        const en1 = cn11 * u + cn12 * t1 + cn13 * t2 + cn14
+            * t3 + cn15 * t4 + cn16 * t5 + cn17 * t6;
+        const en2 = d1 * u + cn22 * t2 + cn24 * t4 + cn26 * t6;
+
+        const somega = en2 - r2; // beta2
+        const capt = t0 - r1 - csq * en1; // -beta1
+        const deltat = tf - capt;
+        const comega = alph0 + csq * r3 - en3; // beta3
+
+        oe[3] = -capt * timeFactor; // Vinti mean element "beta1"
+        oe[4] = somega; // Vinti mean element "beta2"
+        oe[5] = comega; // Vinti mean element "beta3"
+
+        // ========== STEP 6: Solve kinematical equations ==========
+        // The generalized Kepler equation is solved by iteration
+        xhat += xhat0;
+
+        // Variables already declared earlier, will be reassigned in loop
+
+        for (let ick = 1; ick <= 10; ick++) {
+            eca = smgam * xhat;
+
+            if (gamma < -1.0e-14) { // Ellipse
+                sneca = Math.sin(eca);
+                cneca = Math.cos(eca);
+                const s1mes = Math.sqrt(1 - ecc2);
+                const temp3 = 2 * Math.atan(ecc * sneca / (1 + s1mes - ecc * cneca));
+                tra = eca + temp3;
+            } else if (gamma > 1.0e-14) { // Hyperbola
+                sneca = Math.sinh(eca);
+                cneca = Math.cosh(eca);
+                chat = (cneca - 1) / gamma;
+                shat = sneca / smgam;
+                tra = Math.atan2(Math.sqrt(p) * shat, rho1 - chat);
+            } else { // Parabola
+                tra = 2 * Math.atan(xhat / Math.sqrt(p));
+            }
+
+            snw = Math.sin(tra);
+            cnw = Math.cos(tra);
+            ecccnw = ecc * cnw;
+
+            const dwdx = (1 + ecccnw) / Math.sqrt(p);
+            const dw1dx = (1 + ecccnw) / p;
+            const dw2dx = dw1dx * dw1dx;
+            const dw3dx = dw1dx * dw2dx;
+            const dw4dx = dw2dx * dw2dx;
+
+            const v3 = snw * cnw;
+            const v4 = v3 * cnw;
+            const v5 = v4 * cnw;
+            const v6 = v5 * cnw;
+            const v7 = v6 * cnw;
+
+            w1 = x21 * tra + x22 * snw;
+            w2 = x31 * tra + x32 * snw + x33 * v3;
+            w3 = x41 * tra + x42 * snw + x43 * v3 + x44 * v4;
+            w4 = x51 * tra + x52 * snw + x53 * v3 + x54 * v4 + x55 * v5;
+            w5 = x61 * tra + x62 * snw + x63 * v3 + x64 * v4 + x65 * v5 + x66 * v6;
+            w6 = x71 * tra + x72 * snw + x73 * v3 + x74 * v4 + x75 * v5 + x76 * v6 + x77 * v7;
+
+            if (Math.abs(gamma) >= 1.0e-14) {
+                chat = (cneca - 1) / gamma;
+                uhat = (sneca - eca) / gams3;
+            } else { // Parabola
+                chat = xhat * xhat / 2;
+                uhat = xhat * xhat * xhat / 6;
+            }
+
+            const r1 = cr11 * xhat
+                + cr12 * uhat
+                + cr13 * tra
+                + cr14 * w1
+                + cr15 * w2
+                + cr16 * w3
+                + cr17 * w4;
+            const r2
+                = cr21 * tra
+                + cr22 * w1
+                + cr23 * w2
+                + cr24 * w3
+                + cr25 * w4
+                + cr26 * w5
+                + cr27 * w6;
+
+            const ystar = (r2 + somega) / denyst;
+            u = ystar
+                + ucf1 * Math.sin(2 * ystar)
+                + ucf2 * Math.sin(4 * ystar)
+                + ucf3 * Math.sin(6 * ystar);
+
+            csu = Math.cos(u);
+            snu = Math.sin(u);
+            snu2 = snu * snu;
+            snu4 = snu2 * snu2;
+
+            t1 = 1 - csu;
+            t2 = (u - csu * snu) / 2;
+            t3 = (2 * t1 - csu * snu2) / 3;
+            t4 = (3 * t2 - csu * snu2 * snu) / 4;
+            t5 = (4 * t3 - csu * snu4) / 5;
+            t6 = (5 * t4 - csu * snu4 * snu) / 6;
+
+            const en1 = cn11 * u
+                + cn12 * t1
+                + cn13 * t2
+                + cn14 * t3
+                + cn15 * t4
+                + cn16 * t5
+                + cn17 * t6;
+
+            const cn1r1 = csq * en1 + r1;
+            const psixhat = cn1r1 - deltat; // Function
+
+            const dpsx1 = cr13 + cr14 * dw1dx + cr15 * dw2dx + cr16 * dw3dx + cr17 * dw4dx;
+            const dpsx = cr11 + cr12 * chat + dpsx1 * dwdx; // 1st derivative
+            const delx = psixhat / dpsx;
+
+            xhat -= delx;
+
+            if (Math.abs(delx) < 1.0e-14) break;
+        }
+
+        // ========== STEP 7: Final coordinate transformation ==========
+        // OSC state vector is (rhof, sigmaf, alphaf, drhof, dsigf, dalphf)
+        // ECI state vector is (pf, vf)
+
+        sstar = Math.sin(0.5 * u);
+        cstar = Math.cos(0.5 * u);
+        cb1qs = cstar - b1q * sstar;
+        psi1 = Math.atan(xmm1 * sstar / cb1qs);
+
+        if (cb1qs * Math.cos(psi1) < 0) psi1 = pi + psi1;
+
+        cb2qs = cstar - b2q * sstar;
+        psi2 = Math.atan(xmm2 * sstar / cb2qs);
+
+        if (cb2qs * Math.cos(psi2) < 0) psi2 = pi + psi2;
+
+        r3 = cr31 * w2 + cr32 * w3 + cr33 * w4 + cr34 * w5 + cr35 * w6;
+        en3 = d10 * psi1
+            + d20 * psi2
+            + cn31 * u
+            + cn32 * t1
+            + cn33 * t2
+            + cn34 * t3
+            + cn35 * t4
+            + cn36 * t5;
+        const qsnu = q * snu;
+        const alphaf = comega - csq * r3 + en3;
+        const rhof = rho1 + ecc * chat;
+        const sigmaf = (a + b * qsnu) / (1 + g * qsnu);
+
+        const rhof2 = rhof * rhof;
+        const sigf2 = sigmaf * sigmaf;
+
+        const rhocsq = rhof2 + csq;
+        const df = Math.sqrt(rhocsq * (1 - sigf2));
+        const snalp = Math.sin(alphaf);
+        const csalp = Math.cos(alphaf);
+
+        const pf = new NodeVector3D(df * csalp, df * snalp, rhof * sigmaf - delta);
+
+        shat = xhat + gamma * uhat;
+        rcs = rhof2 + csq * sigf2;
+
+        const rhoqd = rhof2 - 2 * a1 * rhof + b1;
+        const drhofp = Math.sqrt(gam1 * rhoqd) / rcs;
+        const drhof = ecc * shat * drhofp;
+        const temp12 = (1 + p1 * sigmaf - q1 * sigf2) * (1 - g2 * q2) * s1;
+        const dsigf = alph2 * q * Math.sqrt(temp12) / rcs * csu / (1 + g * qsnu);
+        const temp20 = (1 - sigf2) * (rhof * drhof);
+        const temp21 = rhocsq * sigmaf * dsigf;
+        const dd = (temp20 - temp21) / df;
+        const dalphf = alph3 / (df * df);
+
+        const vf = new NodeVector3D(
+            dd * csalp - pf.y * dalphf,
+            dd * snalp + pf.x * dalphf,
+            sigmaf * drhof + rhof * dsigf,
+        );
+
+        // Change from astronomical units to SI units - using pious-squid Vector3D scale method
+        x1.position = pf.scale(ae);
+        x1.velocity = vf.scale(ve);
+
+        return x1;
+    }
+}
+
+/**
+ * Main Ballistic Propagator class
+ * Refactored to use existing constants and Vector3D class
+ */
+class BallisticPropagator {
+    constructor(baseStateVector, options = {}) {
+        this.baseStateVector = baseStateVector;
+        this.planetEquatorialRadiusKm
+            = options.equatorialRadius || EarthConstants.EquatorialRadiusKm;
+        this.mu = options.mu || EarthConstants.Mu;
+        this.j2 = options.j2 || EarthConstants.J2;
+        this.j3 = options.j3 || EarthConstants.J3;
+        this.referenceFrame = options.referenceFrame || "J2000";
+    }
+
+    /**
+     * Propagate state vector to target time
+     * @param {Date|number} targetTime - Target time as Date or seconds from epoch
+     * @return {Object} Propagated state with position and velocity
+     */
+    propagate(targetTime) {
+        let spanSeconds;
+
+        if (targetTime instanceof Date) {
+            spanSeconds = (targetTime - this.baseStateVector.epochUtc) / 1000;
+        } else {
+            spanSeconds = targetTime;
+        }
+
+        // Create PosVelVec using pious-squid Vector3D
+        // Handle both lowercase and uppercase property names, but check for undefined specifically
+        const getComponent = (vector, lowerProp, upperProp) => {
+            return vector[lowerProp] !== undefined ? vector[lowerProp] : vector[upperProp];
+        };
+
+        const x0 = new PosVelVec(
+            new NodeVector3D(
+                getComponent(this.baseStateVector.position, "x", "X"),
+                getComponent(this.baseStateVector.position, "y", "Y"),
+                getComponent(this.baseStateVector.position, "z", "Z"),
+            ),
+            new NodeVector3D(
+                getComponent(this.baseStateVector.velocity, "x", "X"),
+                getComponent(this.baseStateVector.velocity, "y", "Y"),
+                getComponent(this.baseStateVector.velocity, "z", "Z"),
+            ),
+        );
+
+        const x1 = BallisticPropagatorUtils.ballisticProp(
+            x0,
+            spanSeconds,
+            this.planetEquatorialRadiusKm,
+            this.mu,
+            this.j2,
+            this.j3,
+        );
+
+        return {
+            position: x1.position,
+            velocity: x1.velocity,
+            epochUtc: targetTime instanceof Date
+                ? targetTime
+                : new Date(this.baseStateVector.epochUtc.getTime() + spanSeconds * 1000),
+            referenceFrame: this.referenceFrame,
+        };
+    }
+}
+
+// Export for Node.js
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = {
+        BallisticPropagator,
+        BallisticPropagatorUtils,
+        PosVelVec,
+        EarthConstants,
+    };
+}
+
+/**
+ * REFACTORING SUMMARY:
+ * ===================
+ *
+ * REPLACED IMPLEMENTATIONS:
+ * 1. EarthConstants - Now uses values from ./constants.js:
+ *    - EquatorialRadiusKm: WGS84_EARTH_EQUATORIAL_RADIUS_KM (6378.137 km)
+ *    - Mu: MU converted from m³/s² to km³/s² (398600.4418)
+ *    - J2 and J3: Kept original values as they're specific to Vinti propagator
+ *
+ * 2. Vector3D - Now imports and uses pious-squid's Vector3D class:
+ *    - Uses magnitude() instead of length property
+ *    - Uses scale() instead of scaleBy() method
+ *    - Uses add() and dot() methods directly from pious-squid
+ *    - All vector operations now use the robust pious-squid implementation
+ *
+ * 3. Mathematical operations:
+ *    - Vector magnitude calculations use pious-squid's magnitude() method
+ *    - Vector scaling uses pious-squid's scale() method
+ *    - Vector addition uses pious-squid's add() method
+ *    - Dot product uses pious-squid's dot() method
+ *
+ * BENEFITS:
+ * - Reduced code duplication (removed ~100 lines of custom Vector3D implementation)
+ * - Uses standardized, well-tested vector operations from pious-squid
+ * - Uses standardized Earth constants from node-common constants.js
+ * - Maintains 100% functional compatibility with original implementation
+ * - Better maintainability through shared library usage
+ *
+ * EXAMPLE USAGE (unchanged):
+ * ==========================
+ *
+ * // ISS-like circular orbit
+ * const initialState = {
+ *     position: new Vector3D(6778.137, 0, 0),  // km
+ *     velocity: new Vector3D(0, 7.66779, 0),   // km/s
+ *     epochUtc: new Date('2025-01-01T00:00:00Z'),
+ *     referenceFrame: 'J2000'
+ * };
+ *
+ * const propagator = new BallisticPropagator(initialState);
+ *
+ * // Propagate for 5 minutes (300 seconds)
+ * const result = propagator.propagate(300);
+ *
+ * console.log('Position after 300s:', result.position);
+ * console.log('Velocity after 300s:', result.velocity);
+ */