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

package/src/LaunchNominalClass.js

@@ -1,753 +1,772 @@
-import {degreesToRadians, radiansToDegrees} from "satellite.js";
-import {Vector3D, J2000, EpochUTC} from "pious-squid";
-import {NodeVector3D} from "./NodeVector3D.js";
-import {WGS84_EARTH_EQUATORIAL_RADIUS_KM,
-    GRAV_CONST,
-    EARTH_MASS,
-    MU,
-    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 = {
-    ITRF: "ITRF",
-    J2000: "J2000",
-    TEME: "TEME",
-    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
-     *
-     * @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 FrameConverter.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 = 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,
-        );
-
-        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: cartesianToKeplerian(
-                [initialTemeState.position.x, initialTemeState.position.y,
-                    initialTemeState.position.z],
-                [initialTemeState.velocity.x, initialTemeState.velocity.y,
-                    initialTemeState.velocity.z], mu),
-            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 - 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], mu);
-
-                sat = {
-                    stateVector: propagated,
-                    elements: elements,
-                    epoch: T0,
-                };
-
-                // Calculate current inclination
-                oldInclinationDelta = inclinationDelta;
-                inclinationDelta = Math.abs((sat.elements.i)
-                    - 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 * DEG2RAD,
-            initialNominal.states[0].elements.raan * DEG2RAD,
-            targetEcc,
-            targetArgOfPeriapsisDeg * DEG2RAD,
-            targetPerigeeKm + WGS84_EARTH_EQUATORIAL_RADIUS_KM,
-        );
-
-        // Convert elliptical elements to cartesian state
-        const ellipticalStateVector = keplerianToCartesian(ellipticalElements, mu);
-
-        const ellipticalPos = ellipticalStateVector.r;
-        const ellipticalVel = ellipticalStateVector.v;
-
-        const ellipticalState = {
-            position: new NodeVector3D(ellipticalPos.x, ellipticalPos.y, ellipticalPos.z),
-            velocity: new NodeVector3D(ellipticalVel.x, ellipticalVel.y, ellipticalVel.z),
-            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 = cartesianToKeplerian(
-            [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 = WGS84_EARTH_EQUATORIAL_RADIUS_KM;
-        const mu = GRAV_CONST * 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 = 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 = FrameConverter.transformVector(zenithSEZ, sez2ecef).normalized();
-        const nadir = zenith.scale(-1);
-
-        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);
-        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 = FrameConverter.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 = MU) {
-        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 = FrameConverter.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 = 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]);
-        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 = FrameConverter.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 = [35786 + EARTH_RADIUS_KM, 0, 0, 0, 0, 0];
-        const geoOrbitState = {
-            state: keplerianToCartesian(geoElements, mu),
-            epochUtc: sv.epochUtc,
-        };
-        const nextNode = this.#findMutualNodeTimes(sv, geoOrbitState);
-        return nextNode.nextNodeTime;
-    }
-
-    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 = cartesianToKeplerian(
-            [sv1.position.x, sv1.position.y, sv1.position.z],
-            [sv1.velocity.x, sv1.velocity.y, sv1.velocity.z], muEarth);
-
-        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 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);
-
-        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(Object.values(state1.r), 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(
-            slopeMutualNodalLinePerifocal,
-            orbit1.a,
-            orbit1.e);
-
-        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.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.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;
-        }
-
-        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.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.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;
-
-        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 = FrameConverter.transformVector(pos, j2000ToTeme);
-            const velTeme = FrameConverter.transformVector(vel, j2000ToTeme);
-            elements = cartesianToKeplerian(
-                [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.a,
-                ecc: elements.e,
-                inc: elements.i,
-                raan: elements.raan,
-                argp: elements.w,
-                ta: elements.f,
-            },
-            // 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,
-            };
-        }
-    }
-}
-
-export {LaunchNominalClass};
+import {degreesToRadians, radiansToDegrees} from "satellite.js";
+import {Vector3D, J2000, EpochUTC} from "pious-squid";
+import {NodeVector3D} from "./NodeVector3D.js";
+import {WGS84_EARTH_EQUATORIAL_RADIUS_KM,
+    GRAV_CONST,
+    EARTH_MASS,
+    MU,
+    EARTH_RADIUS_KM} 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";
+
+// Reference frames enum
+const ReferenceFrame = {
+    ITRF: "ITRF",
+    J2000: "J2000",
+    TEME: "TEME",
+    GCRF: "GCRF",
+};
+
+class LaunchNominalClass {
+    /** 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 FrameConverter.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 + 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 = WGS84_EARTH_EQUATORIAL_RADIUS_KM;
+        const mu = GRAV_CONST * 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 = 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 = FrameConverter.transformVector(zenithSEZ, sez2ecef).normalized();
+        const nadir = zenith.scale(-1);
+
+        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);
+        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 = FrameConverter.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 = 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 = FrameConverter.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 = FrameConverter.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 + 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 = 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 = 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]);
+        }
+
+        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,
+            };
+        }
+    }
+}
+
+export {LaunchNominalClass};