@saber-usa/node-common 1.6.207

package/src/LaunchNominalClass.js

@@ -0,0 +1,822 @@
+const {degreesToRadians, radiansToDegrees} = require("satellite.js");
+const {Vector3D, J2000, EpochUTC} = require("pious-squid");
+const {NodeVector3D} = require("./NodeVector3D.js");
+const constants = require("./constants.js");
+const {FrameConverter} = require("./FrameConverter.js");
+const {OrbitUtils} = require("./OrbitUtils.js");
+const {wrapOneRevUnsigned} = require("./utils.js");
+const {BallisticPropagator} = require("./ballisticPropagator/ballisticPropagator.js");
+const {norm, cross, dot} = require("mathjs");
+
+// Reference frames enum
+const ReferenceFrame = {
+    ITRF: "ITRF",
+    J2000: "J2000",
+    TEME: "TEME",
+    GCRF: "GCRF",
+};
+
+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
+     *
+     * @param {Date} utc - UTC time
+     * @param {Vector3D} posITRF Position in ITRF frame
+     * @return {Vector3D} Position in J2000 frame
+     */
+    static getPositionJ2000(utc, posITRF) {
+        const transformMatrix = FrameConverter.itrfToJ2000(utc);
+
+        return this.transformVector(posITRF, transformMatrix);
+    }
+
+    /** Generate a circular launch nominal.
+     *
+     * @param {number} lat - The latitude of the ground site (degrees)
+     * @param {number} lon - The longitude of the ground site (degrees)
+     * @param {number} alt - The altitude of the ground site (km)
+     * @param {Date} T0 - The Liftoff Time
+     * @param {number} bearingDeg - The bearing the launch vehicle headed in (degrees)
+     * @param {number} leoAltKm - The LEO Parking Altitude (km)
+     * @param {number} flyoutTimeSecs - How long the launch vehicle takes to reach the leoAltKm (seconds)
+     * @return {Object} Satellite object
+     */
+    static generateLaunchNominalCircular(lat, lon, alt, T0, bearingDeg, leoAltKm, flyoutTimeSecs) {
+        const llaVals = {
+            Latitude: {Degrees: lat, Radians: degreesToRadians(lat)},
+            Longitude: {Degrees: lon, Radians: degreesToRadians(lon)},
+            AltitudeKm: alt,
+        };
+
+        let bearingRad = degreesToRadians(bearingDeg);
+        bearingRad = wrapOneRevUnsigned(bearingRad);
+
+        // const latRad = degreesToRadians(this.groundSiteLat);
+        const latRad = llaVals.Latitude.Radians;
+        const targetInclination = OrbitUtils.getInclination(bearingRad, latRad);
+
+        // Convergence parameters
+        const inclinationThreshold = 0.001;
+        let inclinationDelta = Number.POSITIVE_INFINITY;
+        let oldInclinationDelta;
+        let stepSize = 0.1; // Initialize step size
+        const maxIter = 100;
+
+        // Time at orbit insertion
+        const orbitInsertionTime = new Date(T0.getTime() + flyoutTimeSecs * 1000);
+
+        const initialStateVector = this.generateStateOverGroundsite(
+            orbitInsertionTime,
+            radiansToDegrees(bearingRad),
+            leoAltKm,
+            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],
+                initialStateVector.position[1], initialStateVector.position[2]),
+            new Vector3D(initialStateVector.velocity[0],
+                initialStateVector.velocity[1], initialStateVector.velocity[2]),
+        );
+
+        const initialTemeState = initialJ2000State.toTEME();
+
+        let sat = {
+            stateVector: initialStateVector,
+            elements: OrbitUtils.stateVectorToElements(
+                [initialTemeState.position.x, initialTemeState.position.y,
+                    initialTemeState.position.z],
+                [initialTemeState.velocity.x, initialTemeState.velocity.y,
+                    initialTemeState.velocity.z]),
+            epoch: orbitInsertionTime,
+        };
+
+        // Create initial propagator
+        let propagator = null;
+
+        for (let i = 1; i <= maxIter; i++) {
+            if (inclinationDelta > inclinationThreshold) {
+                // Generate state vector at orbit insertion
+                const sv = this.generateStateOverGroundsite(
+                    orbitInsertionTime,
+                    radiansToDegrees(bearingRad),
+                    leoAltKm,
+                    ReferenceFrame.J2000,
+                    llaVals,
+                );
+
+                // Create J2000 state for pious-squid
+                const state = {
+                    position: new NodeVector3D(sv.position[0], sv.position[1], sv.position[2]), // km
+                    velocity: new NodeVector3D(sv.velocity[0], sv.velocity[1], sv.velocity[2]), // km/s
+                    epochUtc: orbitInsertionTime,
+                    referenceFrame: "J2000",
+                };
+
+                // Create propagator
+                propagator = new BallisticPropagator(state);
+
+                // Propagate to T0 to get the state at liftoff
+                const propagated = propagator.propagate(T0);
+
+                const propagatedJ2000State = new J2000(
+                    EpochUTC.fromDateString(T0.toISOString()),
+                    new Vector3D(propagated.position.x, propagated.position.y,
+                        propagated.position.z),
+                    new Vector3D(propagated.velocity.x, propagated.velocity.y,
+                        propagated.velocity.z),
+                );
+
+                const temeState = propagatedJ2000State.toTEME();
+
+                // Convert to orbital elements
+                const elements = OrbitUtils.stateVectorToElements(
+                    [temeState.position.x, temeState.position.y,
+                        temeState.position.z],
+                    [temeState.velocity.x, temeState.velocity.y,
+                        temeState.velocity.z]);
+
+                sat = {
+                    stateVector: propagated,
+                    elements: elements,
+                    epoch: T0,
+                };
+
+                // Calculate current inclination
+                oldInclinationDelta = inclinationDelta;
+                inclinationDelta = Math.abs(radiansToDegrees(sat.elements.inclination)
+                    - radiansToDegrees(targetInclination));
+
+                if (oldInclinationDelta < inclinationDelta) {
+                    // If getting farther away, reverse direction and make smaller steps
+                    stepSize *= -0.5;
+                }
+
+                // Update bearing
+                bearingRad = wrapOneRevUnsigned(bearingRad + degreesToRadians(stepSize));
+            } else {
+                break;
+            }
+
+            if (i === maxIter) {
+                throw new Error(
+                    "Launch Nominal inclination did not converge within max iterations");
+            }
+        }
+
+        const out = new LaunchNominalOutput("CIRCULAR")
+            .addState(sat.stateVector, sat.elements, sat.epoch);
+        return out.toJSON();
+    }
+
+
+    /** Generate an elliptical launch nominal.
+     *
+     * @param {number} lat - The latitude of the ground site (degrees)
+     * @param {number} lon - The longitude of the ground site (degrees)
+     * @param {number} alt - The altitude of the ground site (km)
+     * @param {Date} T0 - The Liftoff Time
+     * @param {number} bearingDeg - The bearing the launch vehicle headed in (degrees)
+     * @param {number} flyoutTimeSecs - How long the launch vehicle takes to reach orbit (seconds)
+     * @param {number} targetEcc - Target Eccentricity
+     * @param {number} targetArgOfPeriapsisDeg - Target Argument of Periapsis (degrees)
+     * @param {number} targetPerigeeKm - Target Perigee (km)
+     * @return {Object} Satellite object
+     */
+    static generateLaunchNominalElliptical(lat, lon, alt, T0, bearingDeg, flyoutTimeSecs,
+        targetEcc, targetArgOfPeriapsisDeg, targetPerigeeKm) {
+        // First get circular nominal
+        const initialNominal = this.generateLaunchNominalCircular(lat, lon, alt, T0,
+            bearingDeg, targetPerigeeKm, flyoutTimeSecs);
+
+        // Time at orbit insertion
+        const orbitInsertionTime = new Date(T0.getTime() + flyoutTimeSecs * 1000);
+
+        // Create J2000 state from initialNominal state vector
+        const initialNominalPos = initialNominal.states[0].sv.r;
+        const initialNominalVel = initialNominal.states[0].sv.v;
+
+        const state = {
+            position: new NodeVector3D(
+                initialNominalPos[0], initialNominalPos[1], initialNominalPos[2]),
+            velocity: new NodeVector3D(
+                initialNominalVel[0], initialNominalVel[1], initialNominalVel[2]),
+            epochUtc: T0,
+            referenceFrame: "J2000",
+        };
+
+        // Propagate state to orbit insertion time
+        const propagator = new BallisticPropagator(state);
+        const propagated = propagator.propagate(orbitInsertionTime);
+        const svInitial = {
+            position: [propagated.position.x, propagated.position.y, propagated.position.z],
+            velocity: [propagated.velocity.x, propagated.velocity.y, propagated.velocity.z],
+            epoch: orbitInsertionTime,
+        };
+
+        // Transform to elliptical orbit
+        const ellipticalElements = OrbitUtils.transformElliptical(
+            svInitial,
+            initialNominal.states[0].elements.inc,
+            initialNominal.states[0].elements.raan,
+            targetEcc,
+            degreesToRadians(targetArgOfPeriapsisDeg),
+            targetPerigeeKm + constants.WGS84_EARTH_EQUATORIAL_RADIUS_KM,
+        );
+
+        // Convert elliptical elements to cartesian state
+        const ellipticalStateVector = OrbitUtils.elementsToStateVector(ellipticalElements);
+
+        const ellipticalPos = ellipticalStateVector.position;
+        const ellipticalVel = ellipticalStateVector.velocity;
+
+        const ellipticalState = {
+            position: new NodeVector3D(ellipticalPos[0], ellipticalPos[1], ellipticalPos[2]),
+            velocity: new NodeVector3D(ellipticalVel[0], ellipticalVel[1], ellipticalVel[2]),
+            epochUtc: orbitInsertionTime,
+            referenceFrame: "J2000",
+        };
+
+        // Propagate state to T0 (back propagate)
+        const propagator2 = new BallisticPropagator(ellipticalState);
+        const ellipticalNominal = propagator2.propagate(T0);
+
+        const ellipNomPos = ellipticalNominal.position;
+        const ellipNomVel = ellipticalNominal.velocity;
+
+        // Convert to orbital elements
+        const elements = OrbitUtils.stateVectorToElements(
+            [ellipNomPos.x, ellipNomPos.y, ellipNomPos.z],
+            [ellipNomVel.x, ellipNomVel.y, ellipNomVel.z]);
+
+        // Return satellite object with elements and propagator
+        const out = new LaunchNominalOutput("ELLIPTICAL")
+            .addState(ellipticalNominal, elements, T0);
+        return out.toJSON();
+    }
+
+    static generateLaunchNominalGtoCircular(
+        lat, lon, alt, T0, bearingDeg, leoAltKm, flyoutTimeSecs, burnAtNodes = 1) {
+        const circLaunchNom = this.generateLaunchNominalCircular(
+            lat, lon, alt, T0, bearingDeg, leoAltKm, flyoutTimeSecs);
+        const transfer = this.hohmannTransferWithIncZeroing(
+            {
+                position: new NodeVector3D(
+                    circLaunchNom.states[0].sv.r[0],
+                    circLaunchNom.states[0].sv.r[1],
+                    circLaunchNom.states[0].sv.r[2],
+                ),
+                velocity: new NodeVector3D(
+                    circLaunchNom.states[0].sv.v[0],
+                    circLaunchNom.states[0].sv.v[1],
+                    circLaunchNom.states[0].sv.v[2],
+                ),
+                epochUtc: new Date(circLaunchNom.states[0].epoch),
+            },
+            42157.137,
+            burnAtNodes);
+
+        const out = new LaunchNominalOutput("CIRCULAR_GTO");
+        out
+            .addState(transfer.state0, null, transfer.state0.epochUtc)
+            .addBurn(transfer.burn1.time, transfer.burn1.dv)
+            .addState(transfer.state1, null, transfer.state1.epochUtc)
+            .addBurn(transfer.burn2.time, transfer.burn2.dv)
+            .addState(transfer.state2, null, transfer.state2.epochUtc);
+        return out.toJSON();
+    }
+
+    static generateLaunchNominalGtoEliptical(
+        lat, lon, alt, T0, bearingDeg, flyoutTimeSecs, targetEcc,
+        targetAop, targetPerigee, burnAtNodes = 1) {
+        const ellipLaunchNom = this.generateLaunchNominalElliptical(
+            lat, lon, alt, T0, bearingDeg, flyoutTimeSecs,
+            targetEcc, targetAop, targetPerigee);
+        const transfer = this.hohmannTransferWithIncZeroing(
+            {
+                position: new NodeVector3D(
+                    ellipLaunchNom.states[0].sv.r[0],
+                    ellipLaunchNom.states[0].sv.r[1],
+                    ellipLaunchNom.states[0].sv.r[2],
+                ),
+                velocity: new NodeVector3D(
+                    ellipLaunchNom.states[0].sv.v[0],
+                    ellipLaunchNom.states[0].sv.v[1],
+                    ellipLaunchNom.states[0].sv.v[2],
+                ),
+                epochUtc: new Date(ellipLaunchNom.states[0].epoch),
+            },
+            42157.137,
+            burnAtNodes);
+        const out = new LaunchNominalOutput("ELLIPTICAL_GTO");
+        out
+            .addState(transfer.state0, null, transfer.state0.epochUtc)
+            .addBurn(transfer.burn1.time, transfer.burn1.dv)
+            .addState(transfer.state1, null, transfer.state1.epochUtc)
+            .addBurn(transfer.burn2.time, transfer.burn2.dv)
+            .addState(transfer.state2, null, transfer.state2.epochUtc);
+        return out.toJSON();
+    }
+
+    /**
+     *
+     * Create the initial state vector of a launch from this GroundSite
+     * Matches C# implementation exactly
+     * @param {Date} orbitInsertionTime - Orbit Insertion Time: Launch Time + Flyout Time.
+     * @param {number} azimuthDeg - Azimuth in degrees
+     * @param {number} orbitAltitudeKm - Orbit altitude in km
+     * @param {string} frame - Reference frame (default: J2000)
+     * @param {Object} llaVals - LLA values of the ground site
+     * @return {Object} State vector {position, velocity}
+     */
+    static generateStateOverGroundsite(
+        orbitInsertionTime, azimuthDeg, orbitAltitudeKm, frame = ReferenceFrame.J2000, llaVals) {
+        const minAltitudeKm = 1.0; // minimum launch altitude. Lowest recoded is about 440m.
+        if (orbitAltitudeKm < minAltitudeKm) {
+            throw new Error(`Altitude cannot be less than ${minAltitudeKm} km.`);
+        }
+
+        const azimuthRad = degreesToRadians(azimuthDeg);
+        const earthRadius = constants.WGS84_EARTH_EQUATORIAL_RADIUS_KM;
+        const mu = constants.GRAV_CONST * constants.EARTH_MASS / 1e9; // km^3/s^2
+
+        // Get transformation from ITRF to J2000
+        const itrf2j2000 = FrameConverter.itrfToJ2000(orbitInsertionTime);
+
+        // Transform North and Nadir to J2000 - derive unit direction vectors from SEZ -> ITRF/ECEF -> J2000/ECI
+
+        // Calculate ITRF position using the site
+        const positionITRF = FrameConverter.llaToECEF(llaVals);
+
+        // Get transformation matrices
+        const sez2ecef = FrameConverter.sezToECEF(llaVals);
+
+        // 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 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 nadir = zenith.scale(-1);
+
+        const northJ2000 = this.transformVector(north, itrf2j2000).normalized();
+        const nadirJ2000 = this.transformVector(nadir, itrf2j2000).normalized();
+
+        // Position of site in J2000 scaled by the orbit altitude
+        const siteJ2000 = this.getPositionJ2000(orbitInsertionTime, positionITRF);
+        const scaleFactor = (orbitAltitudeKm + earthRadius) / earthRadius;
+        const r = siteJ2000.scale(scaleFactor);
+
+        // 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 v = velocityDirection.scale(velocityMagnitude);
+
+        return {
+            position: [r.x, r.y, r.z],
+            velocity: [v.x, v.y, v.z],
+            epoch: orbitInsertionTime,
+            frame: ReferenceFrame.J2000,
+        };
+    }
+
+    static hohmannTransferWithIncZeroing(state0, targetSMA,
+        burnAtNodes = 1, mu = constants.MU / 1e9) {
+        let t0 = state0.epochUtc;
+        let i = null;
+
+        const prop = new BallisticPropagator(state0);
+
+        for (i = 1; i <= burnAtNodes; i++) {
+            const temp = prop.propagate(new Date(t0.getTime() + 1 * 1000));
+            t0 = this.#getNextNodeCrossingGeoOrbit(temp);
+            // here
+        }
+
+        const stateAtM1 = prop.propagate(t0);
+
+        // Initialize coords
+        const r0 = [stateAtM1.position.x, stateAtM1.position.y, stateAtM1.position.z];
+        const v0 = [stateAtM1.velocity.x, stateAtM1.velocity.y, stateAtM1.velocity.z];
+        const r0mag = norm(r0);
+        const v0mag = norm(v0);
+        const r1 = r0.map((component) => component * -1.0 * targetSMA / r0mag);
+        const r1mag = norm(r1);
+        const v1mag = Math.sqrt(mu / targetSMA);
+        const v1 = v0.map((component) => component * -1.0 * v1mag / v0mag);
+
+        // v0 and v1  unit vectors
+        const v0unit = v0.map((component) => component / v0mag);
+        const v1unit = v1.map((component) => component / v1mag);
+
+        // Transfer orbit
+        const smaTrans = (r0mag + r1mag) / 2;
+        const v0transMag = Math.sqrt(mu * (2 / r0mag - 1 / smaTrans));
+        const v1transMag = Math.sqrt(mu * (2 / r1mag - 1 / smaTrans));
+        const dv0 = v0unit.map((component) => component * (v0transMag - v0mag));
+        const dv1 = v1unit.map((component) => component * (v1mag - v1transMag));
+
+        // Transfer time
+        const t1 = new Date(t0.getTime()
+            + (Math.PI * Math.sqrt(Math.pow(smaTrans, 3) / mu)) * 1000);
+        const burn1 = {
+            time: t0,
+            dv: {x: 0, y: norm(dv0), z: 0}, // RTN/RIC frame!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        };
+
+        const rtnToEci = FrameConverter.rtnToEci(stateAtM1.position, stateAtM1.velocity);
+        const dv1eci = this.transformVector(burn1.dv, rtnToEci);
+
+        const state1 = {
+            position: new NodeVector3D(
+                stateAtM1.position.x,
+                stateAtM1.position.y,
+                stateAtM1.position.z,
+            ),
+            velocity: new NodeVector3D(
+                stateAtM1.velocity.x + dv1eci.x,
+                stateAtM1.velocity.y + dv1eci.y,
+                stateAtM1.velocity.z + dv1eci.z,
+            ),
+            epochUtc: t0,
+        };
+
+        const prop2 = new BallisticPropagator(state1);
+        const stateAtM2 = prop2.propagate(t1);
+
+        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 h = cross([state0.position.x, state0.position.y, state0.position.z],
+            [state0.velocity.x, state0.velocity.y, state0.velocity.z]);
+        const hUnit = h.map((component) => component / norm(h));
+        const node = cross([0, 0, 1], h);
+        let argLat = null;
+
+        function getAngleAligned(v1, v2, vN, rightHand) {
+            if (rightHand) {
+                return Math.atan2(dot(cross(v1, v2), vN), dot(v1, v2));
+            } else {
+                return Math.atan2(dot(cross(v2, v1), vN), dot(v1, v2));
+            }
+        }
+
+        const rightHand = true;
+        const initialPos = [state0.position.x, state0.position.y, state0.position.z];
+        argLat = getAngleAligned(node, initialPos, hUnit, rightHand);
+
+        if (burnAtNodes % 2 === 0) {
+            if (argLat >= 0 && argLat <= 180) {
+                argLat -= 180.0;
+            } else {
+                argLat += 180.0;
+            }
+        }
+
+        let dvC = -1 * v1mag * Math.sin(incDiff);
+        const dvI = -1 * v1mag * (1 - Math.cos(incDiff));
+        if (!(argLat >= 0 && argLat <= 180)) {
+            dvC *= -1;
+        }
+
+        const burn2 = {
+            time: t1,
+            dv: {x: 0, y: norm(dv1) + dvI, z: dvC},
+        };
+
+        const rtnToEci2 = FrameConverter.rtnToEci(stateAtM2.position, stateAtM2.velocity);
+        const dv1eci2 = this.transformVector(burn2.dv, rtnToEci2);
+
+        const state2 = {
+            position: new NodeVector3D(
+                stateAtM2.position.x,
+                stateAtM2.position.y,
+                stateAtM2.position.z,
+            ),
+            velocity: new NodeVector3D(
+                stateAtM2.velocity.x + dv1eci2.x,
+                stateAtM2.velocity.y + dv1eci2.y,
+                stateAtM2.velocity.z + dv1eci2.z,
+            ),
+            epochUtc: t1,
+        };
+
+        return {
+            state0,
+            burn1,
+            state1,
+            burn2,
+            state2,
+        };
+    }
+
+    static #getNextNodeCrossingGeoOrbit(sv) {
+        const geoElements = {
+            semiMajorAxis: 35786.0 + constants.EARTH_RADIUS_KM,
+            eccentricity: 0,
+            inclination: 0,
+            raan: 0,
+            argOfPeriapsis: 0,
+            trueAnomaly: 0,
+        };
+        const geoOrbitState = {
+            state: OrbitUtils.elementsToStateVector(geoElements),
+            epochUtc: sv.epochUtc,
+        };
+        const nextNode = this.#findMutualNodeTimes(sv, geoOrbitState);
+        return nextNode.nextNodeTime;
+    }
+
+    static #findMutualNodeTimes(sv1, sv2, muEarth = constants.MU / 1e9) {
+        // Implementation for finding mutual node times between two state vectors
+
+        if (!(sv1.epochUtc === sv2.epochUtc)) {
+            return "lol what on earth";
+        }
+
+        const orbit1 = OrbitUtils.stateVectorToElements(
+            [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);
+
+        const state1 = OrbitUtils.elementsToStateVector(orbit1);
+        const state2 = OrbitUtils.elementsToStateVector(orbit2);
+
+        const h1 = cross(state1.position, state1.velocity);
+        const h2 = cross(state2.position, state2.velocity);
+        const h1Norm = norm(h1);
+        const h2Norm = norm(h2);
+
+        const h1unit = h1.map((component) => component / h1Norm);
+        const h2unit = h2.map((component) => component / h2Norm);
+
+        function getAngleBetween2Vectors(vec1, vec2) {
+            const dotProduct = dot(vec1, vec2);
+            const normsProduct = norm(vec1) * norm(vec2);
+            return Math.acos(dotProduct / normsProduct);
+        }
+
+        const ascendingFirst = getAngleBetween2Vectors(state1.position, h2unit) > Math.PI / 2;
+
+        const nodalLine = cross(h1unit, h2unit);
+        const nodalLineUnit = nodalLine.map((component) => component / norm(nodalLine));
+        const nodalLineUnitVector3D = new Vector3D(
+            nodalLineUnit[0],
+            nodalLineUnit[1],
+            nodalLineUnit[2],
+        );
+
+        const rTilde1 = FrameConverter.perifocalToInertial(orbit1);
+        const rTilde1inverse = FrameConverter.invertMatrix(rTilde1);
+
+        const mutualNodeLinePerifocal = rTilde1inverse.multiplyVector3D(nodalLineUnitVector3D);
+        const slopeMutualNodalLinePerifocal = mutualNodeLinePerifocal.y / mutualNodeLinePerifocal.x;
+        const mutualNode = this.#findIntersectionEllipseLine( // inputs here are causing an error increase
+            slopeMutualNodalLinePerifocal,
+            orbit1.semiMajorAxis,
+            orbit1.eccentricity);
+
+        const q1 = mutualNode.vec1;
+        const q2 = mutualNode.vec2;
+        const q1unit = q1.map((component) => component / norm(q1));
+        const q2unit = q2.map((component) => component / norm(q2));
+
+        function mod(n, m) {
+            return ((n % m) + m) % m;
+        }
+
+        const n0 = mod(orbit1.trueAnomaly, 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
+
+        if (e1 < 0) {
+            e1 += 2 * Math.PI;
+        }
+
+        if (e2 < 0) {
+            e2 += 2 * Math.PI;
+        }
+
+        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 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)));
+        let first = null;
+        let second = null;
+
+        if (dt2 > dt1) {
+            first = new Date(sv1.epochUtc.getTime() + dt1 * 1000);
+            second = new Date(sv2.epochUtc.getTime() + dt2 * 1000);
+        } else {
+            first = new Date(sv2.epochUtc.getTime() + dt2 * 1000);
+            second = new Date(sv1.epochUtc.getTime() + dt1 * 1000);
+        }
+
+        const next = first < second ? first : second;
+        const previous = first < second ? second : first;
+
+        if (ascendingFirst) {
+            return {
+                ascendingNodeTime: first,
+                descendingNodeTime: second,
+                nextNodeTime: next,
+                previousNodeTime: previous,
+            };
+        } else {
+            return {
+                ascendingNodeTime: second,
+                descendingNodeTime: first,
+                nextNodeTime: next,
+                previousNodeTime: previous,
+            };
+        }
+    }
+
+    static #findIntersectionEllipseLine(m, a, e) {
+        // Squares of inputs
+        const m2 = Math.pow(m, 2);
+        const a2 = Math.pow(a, 2);
+        const e2 = Math.pow(e, 2);
+
+        // The b constant, as found in the classic ellipse formulation.
+        const b = a * Math.sqrt(1 - Math.pow(e, 2));
+        const b2 = Math.pow(b, 2);
+
+        // Solving the quadratic equation (αx2 + βx + γ = 0)
+        const alpha = (a2 * m2) + b2;
+        const beta = 2 * a * b2 * e;
+        const gamma = (a2 * b2 * e2) - (a2 * b2);
+
+        const discriminant = Math.sqrt(Math.pow(beta, 2) - 4 * alpha * gamma);
+
+        if (discriminant < 0) {
+            return (new Vector3D(0, 0, 0), new Vector3D(0, 0, 0));
+        }
+
+        const x1 = (-beta + discriminant) / (2 * alpha);
+        const x2 = (-beta - discriminant) / (2 * alpha);
+        const y1 = m * x1;
+        const y2 = m * x2;
+
+        return {
+            vec1: [x1, y1, 0],
+            vec2: [x2, y2, 0],
+        };
+    }
+}
+
+class LaunchNominalOutput {
+    constructor(launchNominalType) {
+        this.launchNominalType = launchNominalType;
+        this.states = [];
+        this.burns = [];
+    }
+
+    addState(stateVector, elements, epoch) {
+        const pos = stateVector.position;
+        const vel = stateVector.velocity;
+
+        if (!elements) {
+            const j2000ToTeme = FrameConverter.getTransform("J2000", "TEME", epoch);
+            const posTeme = LaunchNominalClass.transformVector(pos, j2000ToTeme);
+            const velTeme = LaunchNominalClass.transformVector(vel, j2000ToTeme);
+            elements = OrbitUtils.stateVectorToElements(
+                [posTeme.x, posTeme.y, posTeme.z],
+                [velTeme.x, velTeme.y, velTeme.z]);
+        }
+
+        this.states.push({
+            epoch: epoch,
+            sv: {
+                r: [pos.x, pos.y, pos.z],
+                v: [vel.x, vel.y, vel.z],
+            },
+            elements: {
+                sma: elements.semiMajorAxis,
+                ecc: elements.eccentricity,
+                inc: elements.inclination,
+                raan: elements.raan,
+                argp: elements.argOfPeriapsis,
+                ta: elements.trueAnomaly,
+            },
+            // Placeholder for tle
+        });
+
+        return this;
+    }
+
+    addBurn(epoch, dv) {
+        this.burns.push({
+            epoch: epoch,
+            dv: [dv.x, dv.y, dv.z],
+        });
+
+        return this;
+    }
+
+    toJSON() {
+        if (this.burns.length === 0) {
+            return {
+                launchNominalType: this.launchNominalType,
+                states: this.states,
+            };
+        } else {
+            return {
+                launchNominalType: this.launchNominalType,
+                states: this.states,
+                burns: this.burns,
+            };
+        }
+    }
+}
+
+module.exports = {
+    LaunchNominalClass: LaunchNominalClass,
+};