@saber-usa/node-common 1.6.207

package/src/FrameConverter.js

@@ -0,0 +1,1071 @@
+// FrameConverter.js - Port from C# FrameConverter.cs
+const {Matrix3D,
+    Vector3D,
+} = require("pious-squid");
+const {LLA} = require("./LLA.js");
+const {TimeConverter, RaDec} = require("./TimeConverter.js");
+const {norm, cross} = require("mathjs");
+
+
+// Enums (assuming these exist elsewhere)
+const ReferenceFrame = {
+    J2000: "J2000",
+    TEME: "TEME",
+    GCRF: "GCRF",
+    ITRF: "ITRF",
+};
+
+// Constants (assuming these exist elsewhere)
+const Constants = {
+    TwoPi: 2 * Math.PI,
+    RadToDeg: 180 / Math.PI,
+    DegToRad: Math.PI / 180,
+    ArcsecToRad: Math.PI / (180 * 3600),
+    SecondToRad: Math.PI / (180 * 3600),
+    SecPerSolarDay: 86400,
+};
+
+// Earth constants (assuming these exist elsewhere)
+const Earth = {
+    EquatorialRadiusKm: 6378.137,
+    EccentricityWgs84: 0.0818191908426,
+    SpinRateRadSec: 7.2921159e-5,
+};
+
+class FrameConverter {
+    /**
+     * Helper to transpose a Matrix3D
+     * @param {Matrix3D} m - The matrix to transpose
+     * @return {Matrix3D} The transposed matrix
+     */
+    static transposeMatrix(m) {
+        return new Matrix3D(
+            m.get(0, 0), m.get(1, 0), m.get(2, 0),
+            m.get(0, 1), m.get(1, 1), m.get(2, 1),
+            m.get(0, 2), m.get(1, 2), m.get(2, 2),
+        );
+    }
+
+    /**
+     * Helper to invert a 3x3 matrix
+     * @param {Matrix3D} m - The matrix to invert
+     * @return {Matrix3D} The inverted matrix
+     */
+    static invertMatrix(m) {
+        const a = m.get(0, 0); const b = m.get(0, 1); const c = m.get(0, 2);
+        const d = m.get(1, 0); const e = m.get(1, 1); const f = m.get(1, 2);
+        const g = m.get(2, 0); const h = m.get(2, 1); const i = m.get(2, 2);
+
+        const det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+
+        if (Math.abs(det) < 1e-10) {
+            throw new Error("Matrix is not invertible");
+        }
+
+        const invDet = 1 / det;
+
+        return new Matrix3D(
+            new Vector3D(
+                (e * i - f * h) * invDet,
+                (c * h - b * i) * invDet,
+                (b * f - c * e) * invDet,
+            ),
+            new Vector3D(
+                (f * g - d * i) * invDet,
+                (a * i - c * g) * invDet,
+                (c * d - a * f) * invDet,
+            ),
+            new Vector3D(
+                (d * h - e * g) * invDet,
+                (b * g - a * h) * invDet,
+                (a * e - b * d) * invDet,
+            ),
+        );
+    }
+
+    /**
+     * Helper to multiply two matrices
+     * @param {Matrix3D} m1 - The first matrix
+     * @param {Matrix3D} m2 - The second matrix
+     * @return {Matrix3D} The product of the two matrices
+     */
+    static multiplyMatrices(m1, m2) {
+        // for (let i = 0; i < 3; i++) {
+        //     for (let j = 0; j < 3; j++) {
+        //         let sum = 0;
+        //         for (let k = 0; k < 3; k++) {
+        //             sum += m1.get(i, k) * m2.get(k, j);
+        //         }
+        //         // Matrix3D doesn't have a set method, so we need to create a new one
+        //         // This is a limitation - we'll work around it
+        //     }
+        // }
+        // Create new matrix with computed values
+        return new Matrix3D(
+            new Vector3D(
+                m1.get(0, 0) * m2.get(0, 0)
+                + m1.get(0, 1) * m2.get(1, 0) + m1.get(0, 2) * m2.get(2, 0),
+                m1.get(0, 0) * m2.get(0, 1)
+                + m1.get(0, 1) * m2.get(1, 1) + m1.get(0, 2) * m2.get(2, 1),
+                m1.get(0, 0) * m2.get(0, 2)
+                + m1.get(0, 1) * m2.get(1, 2) + m1.get(0, 2) * m2.get(2, 2)),
+            new Vector3D(
+                m1.get(1, 0) * m2.get(0, 0)
+                + m1.get(1, 1) * m2.get(1, 0) + m1.get(1, 2) * m2.get(2, 0),
+                m1.get(1, 0) * m2.get(0, 1)
+                + m1.get(1, 1) * m2.get(1, 1) + m1.get(1, 2) * m2.get(2, 1),
+                m1.get(1, 0) * m2.get(0, 2)
+                + m1.get(1, 1) * m2.get(1, 2) + m1.get(1, 2) * m2.get(2, 2)),
+            new Vector3D(
+                m1.get(2, 0) * m2.get(0, 0)
+                + m1.get(2, 1) * m2.get(1, 0) + m1.get(2, 2) * m2.get(2, 0),
+                m1.get(2, 0) * m2.get(0, 1)
+                + m1.get(2, 1) * m2.get(1, 1) + m1.get(2, 2) * m2.get(2, 1),
+                m1.get(2, 0) * m2.get(0, 2)
+                + m1.get(2, 1) * m2.get(1, 2) + m1.get(2, 2) * m2.get(2, 2)),
+        );
+    }
+
+    /**
+     * Get transform from a frame to a destination frame at a given time.
+     * Apply this to a position vector using: vec3d.TransformBy(matrix)
+     * @param {string} from - Source reference frame
+     * @param {string} to - Destination reference frame
+     * @param {Date} utc - UTC time for the transformation
+     * @return {Matrix3D} The transformation matrix
+     */
+    static getTransform(from, to, utc) {
+        switch (from) {
+            case ReferenceFrame.J2000:
+                switch (to) {
+                    case ReferenceFrame.J2000:
+                        break;
+                    case ReferenceFrame.TEME:
+                        return this.j2000ToTEME(utc);
+                    case ReferenceFrame.GCRF:
+                        return this.j2000ToGCRF();
+                    case ReferenceFrame.ITRF:
+                        return this.j2000ToITRF(utc);
+                    default:
+                        break;
+                }
+                break;
+            case ReferenceFrame.TEME:
+                switch (to) {
+                    case ReferenceFrame.J2000:
+                        return this.temeToJ2000(utc);
+                    case ReferenceFrame.TEME:
+                        break;
+                    case ReferenceFrame.GCRF:
+                        return this.multiplyMatrices(this.j2000ToGCRF(), this.temeToJ2000(utc));
+                    case ReferenceFrame.ITRF:
+                        return this.multiplyMatrices(this.j2000ToITRF(utc), this.temeToJ2000(utc));
+                    default:
+                        break;
+                }
+                break;
+            case ReferenceFrame.GCRF:
+                switch (to) {
+                    case ReferenceFrame.J2000:
+                        return this.gcrfToJ2000();
+                    case ReferenceFrame.TEME:
+                        return this.multiplyMatrices(this.j2000ToTEME(utc), this.gcrfToJ2000());
+                    case ReferenceFrame.GCRF:
+                        break;
+                    case ReferenceFrame.ITRF:
+                        return this.multiplyMatrices(this.j2000ToITRF(utc), this.gcrfToJ2000());
+                    default:
+                        break;
+                }
+                break;
+            case ReferenceFrame.ITRF:
+                switch (to) {
+                    case ReferenceFrame.J2000:
+                        return this.itrfToJ2000(utc);
+                    case ReferenceFrame.TEME:
+                        return this.multiplyMatrices(this.j2000ToTEME(utc), this.itrfToJ2000(utc));
+                    case ReferenceFrame.GCRF:
+                        return this.multiplyMatrices(this.j2000ToGCRF(), this.itrfToJ2000(utc));
+                    case ReferenceFrame.ITRF:
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            default:
+                break; // TODO: custom frame xforms, RIC, etc
+        }
+
+        // Return identity matrix
+        return new Matrix3D(
+            new Vector3D(1, 0, 0),
+            new Vector3D(0, 1, 0),
+            new Vector3D(0, 0, 1),
+        );
+    }
+
+    /**
+     * Convert from ITRF/ECEF to azimuth, elevation, range.
+     * Optional velocity component will yield AzElRange rates, however this will slow down the computation.
+     * @param {LLA} site - Ground site in LLA
+     * @param {Vector3D} r - Position vector in ECEF frame
+     * @param {Vector3D} [v=null] - Velocity vector in ECEF frame
+     * @param {number} [planetRadius=Earth.EquatorialRadiusKm] - Planet radius
+     * @param {number} [planetEccentricity=Earth.EccentricityWgs84] - Planet eccentricity
+     * @return {AzElRange} Azimuth, elevation, and range
+     */
+    static itrfToAzElRange(site, r, v = null,
+        planetRadius = Earth.EquatorialRadiusKm, planetEccentricity = Earth.EccentricityWgs84) {
+        // Transform
+        const ecef2sez = this.ecefToSEZ(site);
+
+        // To SEZ
+        const siteEcef = this.llaToECEF(site, planetRadius, planetEccentricity);
+        const rhoEcef = r.subtract(siteEcef);
+        const rhoDotEcef = v === null ? new Vector3D(0, 0, 0) : v;
+        const rhoSez = ecef2sez.multiplyVector3D(rhoEcef);
+        const rhoDotSez = ecef2sez.multiplyVector3D(rhoDotEcef);
+
+        // AER
+        const rho = rhoSez.magnitude();
+        let sinBeta; let cosBeta;
+        const el = Math.asin(rhoSez.z / rho);
+
+        if (el * Constants.RadToDeg !== 90 || v === null) {
+            sinBeta = rhoSez.y / Math.sqrt(Math.pow(rhoSez.x, 2) + Math.pow(rhoSez.y, 2));
+            cosBeta = -rhoSez.x / Math.sqrt(Math.pow(rhoSez.x, 2) + Math.pow(rhoSez.y, 2));
+        } else { // use rates
+            sinBeta = rhoDotSez.y / Math.sqrt(Math.pow(rhoDotSez.x, 2) + Math.pow(rhoDotSez.y, 2));
+            cosBeta = -rhoDotSez.x / Math.sqrt(Math.pow(rhoDotSez.x, 2) + Math.pow(rhoDotSez.y, 2));
+        }
+
+        let az = Math.atan2(sinBeta, cosBeta);
+        // Wrap to [0, 2π]
+        while (az < 0) az += Constants.TwoPi;
+        while (az >= Constants.TwoPi) az -= Constants.TwoPi;
+
+        // Rates
+        if (v !== null) {
+            const rhoDot = rhoSez.dot(rhoDotSez) / rho;
+            const azDot = (
+                rhoDotSez.x * rhoSez.y - rhoDotSez.y * rhoSez.x) / (
+                Math.pow(rhoSez.x, 2) + Math.pow(rhoSez.y, 2));
+            const elDot = (rhoDotSez.z - rhoDot * Math.sin(el)) / Math.sqrt(
+                Math.pow(rhoSez.x, 2) + Math.pow(rhoSez.y, 2));
+
+            return {
+                azimuth: az,
+                elevation: el,
+                range: rho,
+                azimuthDot: azDot,
+                elevationDot: elDot,
+                rangeDot: rhoDot,
+            };
+        }
+
+        return {
+            azimuth: az,
+            elevation: el,
+            range: rho,
+        };
+    }
+
+    /**
+     * Convert from azimuth, elevation, and range to ITRF/ECEF.
+     * Will return velocity if AzElRange rates are not zero.
+     * @param {AzElRange} aer - Azimuth, elevation, and range
+     * @param {LLA} site - Ground site in LLA
+     * @param {number} [planetRadius=Earth.EquatorialRadiusKm] - Planet radius
+     * @param {number} [planetEccentricity=Earth.EccentricityWgs84] - Planet eccentricity
+     * @return {Object} Position and velocity in ECEF
+     */
+    static azElRangeToITRF(aer, site, planetRadius = Earth.EquatorialRadiusKm,
+        planetEccentricity = Earth.EccentricityWgs84) {
+        const Ce = planetRadius / Math.sqrt(
+            1 - Math.pow(planetEccentricity, 2)
+            * Math.pow(Math.sin(site.Latitude.Radians), 2));
+
+        const Se = Ce * (1 - Math.pow(planetEccentricity, 2));
+        const rd = (Ce + site.AltitudeKm) * Math.cos(site.Latitude.Radians);
+        const rK = (Se + site.AltitudeKm) * Math.sin(site.Latitude.Radians);
+
+        const rSiteEcef = new Vector3D(
+            rd * Math.cos(site.Longitude.Radians),
+            rd * Math.sin(site.Longitude.Radians),
+            rK);
+
+        const rho = aer.RangeKm;
+        const drho = aer.RangeRatePerSec || 0;
+        const daz = aer.AzimuthRatePerSec ? aer.AzimuthRatePerSec.Radians : 0;
+        const del = aer.ElevationRatePerSec ? aer.ElevationRatePerSec.Radians : 0;
+        const saz = Math.sin(aer.Azimuth.Radians);
+        const caz = Math.cos(aer.Azimuth.Radians);
+        const sel = Math.sin(aer.Elevation.Radians);
+        const cel = Math.cos(aer.Elevation.Radians);
+
+        const rhoSez = new Vector3D(-rho * cel * caz, rho * cel * saz, rho * sel);
+        const rhoDotSez = new Vector3D(
+            -drho * cel * caz + rho * sel * caz * del + rho * cel * saz * daz,
+            drho * cel * saz - rho * sel * saz * del + rho * cel * caz * daz,
+            drho * sel + rho * cel * del);
+
+        const s2e = this.sezToECEF(site);
+
+        const rhoEcef = s2e.multiplyVector3D(rhoSez);
+        const rhoDotEcef = s2e.multiplyVector3D(rhoDotSez);
+        const rEcef = rhoEcef.add(rSiteEcef);
+        const vEcef = rhoDotEcef;
+
+        return {Position: rEcef, Velocity: vEcef};
+    }
+
+    /**
+     * Convert position and velocity in J2000 to Azimuth, elevation, and range and each of their rates.
+     * @param {LLA} site - Ground site in LLA
+     * @param {Date} utc - UTC time
+     * @param {Vector3D} r - Position vector in J2000
+     * @param {Vector3D} [v=null] - Velocity vector in J2000
+     * @return {AzElRange} Azimuth, elevation, and range and their rates
+     */
+    static J2000ToAzElRange(site, utc, r, v = null) {
+        // Transform
+        const j2k2itrf = this.j2000ToITRF(utc);
+
+        // SEZ vectors
+        const rEcef = j2k2itrf.multiplyVector3D(r);
+        const vEcef = v === null ? new Vector3D(0, 0, 0) : j2k2itrf.multiplyVector3D(v);
+
+        return this.itrfToAzElRange(site, rEcef, v === null ? v : vEcef);
+    }
+
+    /**
+     * Convert Az, El, Range to J2000 position and velocity.
+     * @param {AzElRange} aer - Azimuth, elevation, and range
+     * @param {LLA} site - Ground site in LLA
+     * @param {Date} utc - UTC time
+     * @return {Object} Position and velocity in J2000
+     */
+    static AzElRangeToJ2000(aer, site, utc) {
+        const {Position: rEcef, Velocity: vEcef} = this.azElRangeToITRF(aer, site);
+
+        return this.itrfToJ2000(utc, rEcef, vEcef === null ? new Vector3D(0, 0, 0) : vEcef);
+    }
+
+    /**
+     * Converts a TEME position vector from an SGP4 propagation to Lat, Lon, Alt.
+     * @param {Vector3D} r - Position vector in TEME
+     * @param {Date} utc - UTC time
+     * @return {LLA} Latitude, longitude, and altitude
+     */
+    static TEMEToLLA(r, utc) {
+        return this.j2000ToLLA(this.temeToJ2000(utc).multiplyVector3D(r), utc);
+    }
+
+    /**
+     * Convert Lat, Lon, Alt to a TEME position vector.
+     * @param {LLA} lla - Latitude, longitude, and altitude
+     * @param {Date} utc - UTC time
+     * @return {Vector3D} Position vector in TEME
+     */
+    static LLAToTEME(lla, utc) {
+        return this.j2000ToTEME(utc).multiplyVector3D(this.llaToJ2000(lla, utc));
+    }
+
+    /**
+     * Converts a J2000 position vector to Lat, Lon, Alt.
+     * J2000 is the default reference frame of the UDL and many other applications.
+     * @param {Vector3D} r - Position vector in J2000
+     * @param {Date} utc - UTC time
+     * @return {LLA} Latitude, longitude, and altitude
+     */
+    static j2000ToLLA(r, utc) {
+        return this.ecefToLLA(this.j2000ToITRF(utc).multiplyVector3D(r));
+    }
+
+    /**
+     * Converts Lat, Lon, Alt to J2000 position vector.
+     * @param {LLA} lla - Latitude, longitude, and altitude
+     * @param {Date} utc - UTC time
+     * @return {Vector3D} Position vector in J2000
+     */
+    static llaToJ2000(lla, utc) {
+        return this.itrfToJ2000(utc).multiplyVector3D(this.llaToECEF(lla));
+    }
+
+    /**
+     * Convert ECEF coordinates to Lat, Lon, Alt.
+     * ECEF includes ITRF and WGS frames.
+     * Vallado Fundamentals, p. 172
+     * @param {Vector3D} r The vector r must be in ITRF frame (see j2000ToITRF()).
+     * @param {number} planetRadKm
+     * @param {number} planetEcc
+     * @param {number} tol
+     * @return {LLA} Latitude, longitude, and altitude
+     */
+    static ecefToLLA(r, planetRadKm = Earth.EquatorialRadiusKm,
+        planetEcc = Earth.EccentricityWgs84, tol = 1e-6) {
+        const rdels = Math.sqrt(Math.pow(r.x, 2) + Math.pow(r.y, 2));
+        const lambda = Math.acos(r.x / rdels) * Math.sign(Math.asin(r.y / rdels));
+        let phigd = Math.atan2(r.z, rdels);
+        const rdel = rdels;
+        const phigdOld = phigd;
+        let C;
+
+        let iter = 0;
+
+        do {
+            C = planetRadKm / Math.sqrt(1 - Math.pow(planetEcc, 2) * Math.pow(Math.sin(phigd), 2));
+            phigd = Math.atan2(r.z + C * Math.pow(planetEcc, 2) * Math.sin(phigd), rdel);
+            iter++;
+        } while (phigd - phigdOld > tol && iter < 10);
+
+        const nearPoles = r.angle(new Vector3D(0, 0, 1)) * Constants.RadToDeg < 1
+                         || r.angle(new Vector3D(0, 0, -1)) * Constants.RadToDeg < 1;
+        const S = C * (1 - Math.pow(planetEcc, 2));
+        const hEllip = nearPoles ? r.z / Math.sin(phigd) - S : rdel / Math.cos(phigd) - C;
+
+        return new LLA(phigd * Constants.RadToDeg, lambda * Constants.RadToDeg, hEllip);
+    }
+
+    /**
+     * Convert Lat, Lon, Alt to ECEF position.
+     * ECEF includes ITRF and WGS frames.
+     * Vallado Fundamentals, p. 144
+     * @param {LLA} lla - Latitude, longitude, and altitude
+     * @param {number} [planetRad=Earth.EquatorialRadiusKm] - Planet radius
+     * @param {number} [planetEcc=Earth.EccentricityWgs84] - Planet eccentricity
+     * @return {Vector3D} Position vector in ECEF
+     */
+    static llaToECEF(lla, planetRad = Earth.EquatorialRadiusKm,
+        planetEcc = Earth.EccentricityWgs84) {
+        const phigd = lla.Latitude.Radians;
+        const lamba = lla.Longitude.Radians;
+        const h = lla.AltitudeKm;
+
+        const C = planetRad / Math.sqrt(1
+            - Math.pow(planetEcc, 2) * Math.pow(Math.sin(phigd), 2));
+        const S = planetRad * (1
+            - Math.pow(planetEcc, 2)) / Math.sqrt(1
+                - Math.pow(planetEcc, 2) * Math.pow(Math.sin(phigd), 2));
+
+        return new Vector3D(
+            (C + h) * Math.cos(phigd) * Math.cos(lamba),
+            (C + h) * Math.cos(phigd) * Math.sin(lamba),
+            (S + h) * Math.sin(phigd));
+    }
+
+    /**
+     * Converts Azimuth and Elevation (Topocentric Coordinates) to Right Ascension
+     * and Declination (Spherical Coordinates) at a given time.
+     * @param {Date} utc - The UTC time
+     * @param {Site} site - The observer's location
+     * @param {AzEl} azel - The azimuth and elevation angles
+     * @return {RaDec} The right ascension and declination
+     */
+    static AzElToRaDec(utc, site, azel) {
+        const t = new TimeConverter(utc);
+        const latRads = site.Latitude.Radians;
+        const azRads = azel.Azimuth.Radians;
+        const elRads = azel.Elevation.Radians;
+
+        const dec = Math.asin(Math.sin(elRads) * Math.sin(latRads)
+            + Math.cos(elRads) * Math.cos(latRads) * Math.cos(azRads));
+
+        // Get local siderial time from longitude
+        const {lmst} = TimeConverter.getLMST(site.Longitude.Degrees, t.JulianUT1);
+
+        // Get local hour angle, the angle between the zenith and north polar distance of the object
+        const H = Math.atan2(
+            -Math.sin(azRads) * Math.cos(elRads) * Math.cos(latRads),
+            Math.sin(elRads) - Math.sin(latRads) * Math.sin(dec));
+
+        const ra = (lmst - H) % Constants.TwoPi;
+
+        return new RaDec(ra * Constants.RadToDeg, dec * Constants.RadToDeg);
+    }
+
+    /**
+     * Convert ECEF to SEZ frame for a given ground site.
+     * @param {Site} site - The observer's location
+     * @return {Matrix3D} The transformation matrix from ECEF to SEZ
+     */
+    static ecefToSEZ(site) {
+        const sinLat = Math.sin(site.Latitude.Radians);
+        const cosLat = Math.cos(site.Latitude.Radians);
+        const sinLon = Math.sin(site.Longitude.Radians);
+        const cosLon = Math.cos(site.Longitude.Radians);
+
+        return new Matrix3D(
+            sinLat * cosLon, sinLat * sinLon, -cosLat,
+            -sinLon, cosLon, 0,
+            cosLat * cosLon, cosLat * sinLon, sinLat,
+        );
+    }
+
+    /**
+     * Convert SEZ to ECEF frame for a given ground site.
+     * @param {Site} site - The observer's location
+     * @return {Matrix3D} The transformation matrix from SEZ to ECEF
+     */
+    static sezToECEF(site) {
+        // SEZ to ECEF is the transpose of ECEF to SEZ for orthogonal matrices
+        const sinLat = Math.sin(site.Latitude.Radians);
+        const cosLat = Math.cos(site.Latitude.Radians);
+        const sinLon = Math.sin(site.Longitude.Radians);
+        const cosLon = Math.cos(site.Longitude.Radians);
+
+        // This is the transpose of ecefToSEZ matrix
+        return new Matrix3D(
+            new Vector3D(sinLat * cosLon, -sinLon, cosLat * cosLon),
+            new Vector3D(sinLat * sinLon, cosLon, cosLat * sinLon),
+            new Vector3D(-cosLat, 0, sinLat),
+        );
+    }
+
+    /**
+     * Convert GCRF to J2000 (frame bias).
+     * @return {Matrix3D} The transformation matrix from GCRF to J2000
+     */
+    static gcrfToJ2000() {
+        // https://github.com/skyfielders/python-skyfield/blob/master/skyfield/framelib.py
+        // 'xi0', 'eta0', and 'da0' are ICRS frame biases in arcseconds taken
+        // from IERS (2003) Conventions, Chapter 5.
+        const xi0 = -0.0166170 * Constants.ArcsecToRad;
+        const eta0 = -0.0068192 * Constants.ArcsecToRad;
+        const da0 = -0.01460 * Constants.ArcsecToRad;
+
+        // Compute elements of rotation matrix.
+        const yx = -da0;
+        const zx = xi0;
+        const xy = da0;
+        const zy = eta0;
+        const xz = -xi0;
+        const yz = -eta0;
+
+        // Include second-order corrections to diagonal elements.
+        const xx = 1 - 0.5 * (yx * yx + zx * zx);
+        const yy = 1 - 0.5 * (yx * yx + zy * zy);
+        const zz = 1 - 0.5 * (zy * zy + zx * zx);
+
+        return new Matrix3D(
+            xx, xy, xz,
+            yx, yy, yz,
+            zx, zy, zz,
+        );
+    }
+
+    /**
+     * Convert J2000 to GCRF (inverse frame bias).
+     * Vallado Fundamentals
+     * @return {Matrix3D} The transformation matrix from J2000 to GCRF
+     */
+    static j2000ToGCRF() {
+        return this.invertMatrix(this.gcrfToJ2000());
+    }
+
+    /**
+     * Convert ITRF to J2000 using IAU-1980 FK5 reduction. This only works for position vectors, not velocity.
+     * Vallado Fundamentals
+     * @param {number} utc - Julian centuries of TT
+     * @return {Matrix3D} The transformation matrix from ITRF to J2000
+     */
+    static itrfToJ2000(utc) {
+        const t = new TimeConverter(utc);
+
+        const prc = this.precessionFk5(t.JulianCenturiesTT);
+        const {nut, nutLon, raan, meanObliq} = this.nutationFk5(t.JulianCenturiesTT);
+        const sid = this.siderealFk5(t.JulianUT1, nutLon, meanObliq, raan, 2);
+        const pol = this.polarMotionFk5(TimeConverter.XP * Constants.SecondToRad,
+            TimeConverter.YP * Constants.SecondToRad);
+
+        return this.multiplyMatrices(this.multiplyMatrices(
+            this.multiplyMatrices(prc, nut), sid), pol);
+    }
+
+    /**
+     * ITRF to J2000 with velocity component.
+     * @param {Date} utc - UTC time
+     * @param {Vector3D} r - Position vector in ITRF
+     * @param {Vector3D} v - Velocity vector in ITRF
+     * @return {Object} Position and velocity in J2000
+     */
+    static itrfToJ2000WithVelocity(utc, r, v) {
+        const t = new TimeConverter(utc);
+
+        const omega = new Vector3D(0, 0, Earth.SpinRateRadSec * (1
+            - TimeConverter.LOD / Constants.SecPerSolarDay));
+
+        const prc = this.precessionFk5(t.JulianCenturiesTT);
+        const {nut, raan} = this.nutationFk5(t.JulianCenturiesTT);
+        const sid = this.siderealFk5(t.JulianUT1, nut.nutLon, nut.meanObliq, raan, 2);
+        const pol = this.polarMotionFk5(TimeConverter.XP * Constants.SecondToRad,
+            TimeConverter.YP * Constants.SecondToRad);
+        const temp = this.multiplyMatrices(prc, nut);
+        const trans = this.multiplyMatrices(temp, sid);
+
+        const rpef = pol.multiplyVector3D(r);
+        const vpef = pol.multiplyVector3D(v);
+        const crossr = omega.cross(rpef);
+        const reci = trans.multiplyVector3D(rpef);
+        const veci = trans.multiplyVector3D(vpef.add(crossr));
+
+        return {Position: reci, Velocity: veci};
+    }
+
+    /**
+     * J2000 to ITRF with velocity component.
+     * @param {Date} utc - UTC time
+     * @param {Vector3D} r - Position vector in J2000
+     * @param {Vector3D} v - Velocity vector in J2000
+     * @return {Object} Position and velocity in ITRF
+     */
+    static j2000ToITRFWithVelocity(utc, r, v) {
+        const t = new TimeConverter(utc);
+
+        const omega = new Vector3D(0, 0, Earth.SpinRateRadSec * (1
+            - TimeConverter.LOD / Constants.SecPerSolarDay));
+
+        let prc = this.precessionFk5(t.JulianCenturiesTT);
+        const {nut, raan} = this.nutationFk5(t.JulianCenturiesTT);
+        let sid = this.siderealFk5(t.JulianUT1, nut.nutLon, nut.meanObliq, raan, 2);
+        let pol = this.polarMotionFk5(TimeConverter.XP * Constants.SecondToRad,
+            TimeConverter.YP * Constants.SecondToRad);
+
+        prc = this.transposeMatrix(prc);
+        const nutTranspose = this.transposeMatrix(nut.matrix);
+        sid = this.transposeMatrix(sid);
+        pol = this.transposeMatrix(pol);
+
+        const temp = this.multiplyMatrices(sid, nutTranspose);
+        const trans = this.multiplyMatrices(temp, prc);
+
+        const rpef = trans.multiplyVector3D(r);
+        const recef = pol.multiplyVector3D(rpef);
+        const tempvec1 = trans.multiplyVector3D(v);
+        const crossr = omega.cross(rpef);
+        const vpef = tempvec1.subtract(crossr);
+        const vecef = pol.multiplyVector3D(vpef);
+
+        return {Position: recef, Velocity: vecef};
+    }
+
+    /**
+     * Convert J2000 to ITRF using IAU-1980 FK5 reduction. This only works for position vectors, not velocity.
+     * Vallado Fundamentals
+     * @param {number} utc - Julian centuries of TT
+     * @return {Matrix3D} The transformation matrix from J2000 to ITRF
+     */
+    static j2000ToITRF(utc) {
+        return this.invertMatrix(this.itrfToJ2000(utc));
+    }
+
+    /**
+     * Convert TEME to J2000 at some UTC time.
+     * Vallado Fundamentals
+     * @param {Date} utc - UTC time
+     * @return {Matrix3D} The transformation matrix from TEME to J2000
+     */
+    static temeToJ2000(utc) {
+        const t = new TimeConverter(utc);
+        const ttt = t.JulianCenturiesTT;
+
+        let eqeTemp = Matrix3D.zeros();
+        let eqeg;
+
+        const prec = this.precessionFk5(ttt);
+        // const { nut } = this.nutationFk5(ttt);
+        const nut = this.nutationFk5(ttt);
+
+        // Rotate teme through just geometric terms
+        eqeg = nut.nutLon * Math.cos(nut.meanObliq);
+        eqeg %= Constants.TwoPi;
+
+        eqeTemp = new Matrix3D(new Vector3D(Math.cos(eqeg), Math.sin(eqeg), 0),
+            new Vector3D(-Math.sin(eqeg), Math.cos(eqeg), 0), new Vector3D(0, 0, 1));
+
+        const eqe = new Matrix3D(eqeTemp);
+        const eqep = eqe.matrix[0].transpose();
+        const temp = this.multiplyMatrices(nut.nut, eqep);
+        const returnMat = this.multiplyMatrices(prec, temp);
+        return returnMat;
+        // return prec.multiply(temp);
+    }
+
+    /**
+     * Convert J2000 to TEME at some UTC time.
+     * @param {Date} utc - UTC time
+     * @return {Matrix3D} The transformation matrix from J2000 to TEME
+     */
+    static j2000ToTEME(utc) {
+        return this.invertMatrix(this.temeToJ2000(utc));
+    }
+
+    /**
+     * Get nutation transformation according to FK5.
+     * This matrix is also TOD to MOD.
+     * Vallado Fundamentals
+     * @param {number} ttt - Julian centuries of TT
+     * @return {Matrix3D} The transformation matrix from J2000 to ITRF
+     *
+     */
+    static nutationFk5(ttt) {
+        // Compute the mean obliquity of the ecliptic
+        let me1980 = ((0.001813 * ttt - 0.00059) * ttt - 46.8150) * ttt + 84381.448;
+        me1980 = me1980 / 3600 % 360;
+        me1980 *= Constants.DegToRad;
+
+        // Evaluate the Delaunay parameters associated with the Moon and the Sun in the interval [0,2π]°
+        const oo3600 = 1 / 3600;
+        let Mm = ((0.064 * ttt + 31.310) * ttt + 1717915922.6330) * ttt * oo3600 + 134.96298139;
+        let Ms = (((-0.012) * ttt - 0.577) * ttt + 129596581.2240) * ttt * oo3600 + 357.52772333;
+        let uMm = ((0.011 * ttt - 13.257) * ttt + 1739527263.1370) * ttt * oo3600 + 93.27191028;
+        let Ds = ((0.019 * ttt - 6.891) * ttt + 1602961601.3280) * ttt * oo3600 + 297.85036306;
+        let Omegam = ((0.008 * ttt + 7.455) * ttt - 6962890.5390) * ttt * oo3600 + 125.04452222;
+
+        Mm = Mm % 360 * Constants.DegToRad;
+        Ms = Ms % 360 * Constants.DegToRad;
+        uMm = uMm % 360 * Constants.DegToRad;
+        Ds = Ds % 360 * Constants.DegToRad;
+        Omegam = Omegam % 360 * Constants.DegToRad;
+
+        // Compute nutation in longitude and in obliquity
+        let dPsi1980 = 0;
+        let dEp1980 = 0;
+
+        // Compute the nutation in the longitude and in obliquity
+        for (const row of this.NUT_COEFF) {
+            const ap = row[0] * Mm + row[1] * Ms + row[2] * uMm + row[3] * Ds + row[4] * Omegam;
+            dPsi1980 += (row[5] + row[6] * ttt) * Math.sin(ap);
+            dEp1980 += (row[7] + row[8] * ttt) * Math.cos(ap);
+        }
+
+        // The nutation coefficients lead to angles with unit 0.0001. Hence, we must convert to [rad]
+        dPsi1980 *= 0.0001 / 3600 * Constants.DegToRad;
+        dEp1980 *= 0.0001 / 3600 * Constants.DegToRad;
+
+        const meanObliq = me1980;
+        const nutObliq = dEp1980;
+        const nutLon = dPsi1980;
+        const raan = Omegam;
+        const trueObliq = meanObliq + nutObliq;
+
+        const cospsi = Math.cos(nutLon);
+        const sinpsi = Math.sin(nutLon);
+        const coseps = Math.cos(meanObliq);
+        const sineps = Math.sin(meanObliq);
+        const costrueeps = Math.cos(trueObliq);
+        const sintrueeps = Math.sin(trueObliq);
+
+        // const nut = new Matrix3D(
+        //     cospsi, costrueeps * sinpsi, sintrueeps * sinpsi,
+        //     -coseps * sinpsi, costrueeps * coseps * cospsi + sintrueeps * sineps, sintrueeps * coseps * cospsi - sineps * costrueeps,
+        //     -sineps * sinpsi, costrueeps * sineps * cospsi - sintrueeps * coseps, sintrueeps * sineps * cospsi + costrueeps * coseps
+        // );
+
+        const nut = new Matrix3D(
+            new Vector3D(cospsi, costrueeps * sinpsi, sintrueeps * sinpsi),
+            new Vector3D(-coseps * sinpsi, costrueeps * coseps * cospsi + sintrueeps * sineps,
+                sintrueeps * coseps * cospsi - sineps * costrueeps),
+            new Vector3D(-sineps * sinpsi, costrueeps * sineps * cospsi - sintrueeps * coseps,
+                sintrueeps * sineps * cospsi + costrueeps * coseps),
+        );
+
+        return {
+            nut,
+            meanObliq,
+            nutObliq,
+            nutLon,
+            trueObliq,
+            raan,
+        };
+    }
+
+    /**
+     * Get precession transformation based on FK5.
+     * This matrix is also MOD to GCRF.
+     * Vallado Fundamentals
+     * @param {number} ttt - Julian centuries of TT
+     * @return {Matrix3D} Precession transformation matrix
+     */
+    static precessionFk5(ttt) {
+        const convrt = Math.PI / (180 * 3600); // " to rad
+
+        let zeta = ((0.017998 * ttt + 0.30188) * ttt + 2306.2181) * ttt; // "
+        let theta = ((-0.041833 * ttt - 0.42665) * ttt + 2004.3109) * ttt;
+        let z = ((0.018203 * ttt + 1.09468) * ttt + 2306.2181) * ttt;
+
+        zeta *= convrt;
+        theta *= convrt;
+        z *= convrt;
+
+        const coszeta = Math.cos(zeta);
+        const sinzeta = Math.sin(zeta);
+        const costheta = Math.cos(theta);
+        const sintheta = Math.sin(theta);
+        const cosz = Math.cos(z);
+        const sinz = Math.sin(z);
+
+        // // Form matrix mod to gcrf
+        // return new Matrix3D(
+        //     coszeta * costheta * cosz - sinzeta * sinz, coszeta * costheta * sinz + sinzeta * cosz, coszeta * sintheta,
+        //     -sinzeta * costheta * cosz - coszeta * sinz, -sinzeta * costheta * sinz + coszeta * cosz, -sinzeta * sintheta,
+        //     -sintheta * cosz, -sintheta * sinz, costheta
+        // );
+
+        return new Matrix3D(
+            new Vector3D(coszeta * costheta * cosz - sinzeta * sinz,
+                coszeta * costheta * sinz + sinzeta * cosz, coszeta * sintheta),
+            new Vector3D(-sinzeta * costheta * cosz - coszeta * sinz,
+                -sinzeta * costheta * sinz + coszeta * cosz, -sinzeta * sintheta),
+            new Vector3D(-sintheta * cosz, -sintheta * sinz, costheta));
+    }
+
+    /**
+     * Get transformation matrix associated with sidereal time.
+     * Thie matrix is also PEF/GTOD to TOD.
+     * Vallado Fundamentals
+     * @param {number} jdut1 - Julian date of UT1
+     * @param {number} deltapsi - Nutation in longitude (rad)
+     * @param {number} meaneps - Mean obliquity (rad)
+     * @param {number} raan - Right ascension of ascending node (rad)
+     * @param {number} eqeterms - Equatorial terms (rad)
+     * @return {Matrix3D} Sidereal transformation matrix
+     */
+    static siderealFk5(jdut1, deltapsi, meaneps, raan, eqeterms) {
+        // FK5 approach
+        const gmst = TimeConverter.getGMST(jdut1).Radians;
+
+        // Find mean ast
+        let ast = (jdut1 > 2450449.5) && (eqeterms > 0)
+            ? gmst + deltapsi * Math.cos(meaneps)
+                + 0.00264 * Constants.SecondToRad * Math.sin(raan)
+                    + 0.000063 * Constants.SecondToRad * Math.sin(2 * raan)
+            : gmst + deltapsi * Math.cos(meaneps);
+
+        ast %= 2.0 * Math.PI;
+
+        const sinast = Math.sin(ast);
+        const cosast = Math.cos(ast);
+
+        // return new Matrix3D(
+        //     cosast, -sinast, 0,
+        //     sinast, cosast, 0,
+        //     0, 0, 1
+        // );
+
+        return new Matrix3D(
+            new Vector3D(cosast, -sinast, 0), new Vector3D(sinast, cosast, 0),
+            new Vector3D(0, 0, 1),
+        );
+    }
+
+    /**
+     * Get transformation associated with polar motion of Earth.
+     * This matrix is also ITRF to PEF/GTOD.
+     * xp and yp are the polar motion coefficients (rad).
+     * Vallado Fundamentals
+     * @param {number} xp - Polar motion coefficient in x (rad)
+     * @param {number} yp - Polar motion coefficient in y (rad)
+     * @return {Matrix3D} Polar motion transformation matrix
+     */
+    static polarMotionFk5(xp, yp) {
+        const cosxp = Math.cos(xp);
+        const sinxp = Math.sin(xp);
+        const cosyp = Math.cos(yp);
+        const sinyp = Math.sin(yp);
+
+        // // FK5 approach
+        // return new Matrix3D(
+        //     cosxp, 0, -sinxp,
+        //     sinxp * sinyp, cosyp, cosxp * sinyp,
+        //     sinxp * cosyp, -sinyp, cosxp * cosyp
+        // );
+
+        return new Matrix3D(
+            new Vector3D(cosxp, 0, -sinxp),
+            new Vector3D(sinxp * sinyp, cosyp, cosxp * sinyp),
+            new Vector3D(sinxp * cosyp, -sinyp, cosxp * cosyp),
+        );
+    }
+
+    /**
+     * Check if a frame is inertially defined.
+     * @param {ReferenceFrame} frame - The reference frame to check
+     * @param {boolean} throwError - Whether to throw an error if the frame is non-inertial
+     * @return {boolean} True if the frame is inertial, false otherwise
+     */
+    static CheckIfInertial(frame, throwError = false) {
+        if (frame === ReferenceFrame.ITRF) {
+            if (throwError) {
+                throw new Error(
+                    "Cannot use a non-inertial frame for this method."
+                    + " Try converting to an ECI frame.");
+            }
+            return false;
+        }
+        return true;
+    }
+
+    static perifocalToInertial(keplerianElements) {
+        const cosi = Math.cos(keplerianElements.inclination);
+        const sini = Math.sin(keplerianElements.inclination);
+        const cosRaan = Math.cos(keplerianElements.raan);
+        const sinRaan = Math.sin(keplerianElements.raan);
+        const cosw = Math.cos(keplerianElements.argOfPeriapsis);
+        const sinw = Math.sin(keplerianElements.argOfPeriapsis);
+
+        // The matrix elements
+        const r11 = cosRaan * cosw - sinRaan * sinw * cosi;
+        const r12 = -cosRaan * sinw - sinRaan * cosw * cosi;
+        const r13 = sinRaan * sini;
+
+        const r21 = sinRaan * cosw + cosRaan * sinw * cosi;
+        const r22 = -sinRaan * sinw + cosRaan * cosw * cosi;
+        const r23 = -cosRaan * sini;
+
+        const r31 = sinw * sini;
+        const r32 = cosw * sini;
+        const r33 = cosi;
+
+        // Packing
+        return new Matrix3D(
+            new Vector3D(r11, r12, r13),
+            new Vector3D(r21, r22, r23),
+            new Vector3D(r31, r32, r33),
+        );
+    }
+
+    static eciToRtn(r, v) {
+        const rTemp = [r.x, r.y, r.z];
+        const vTemp = [v.x, v.y, v.z];
+        const rHat = rTemp.map((component) => component / norm(rTemp));
+        const vHat = vTemp.map((component) => component / norm(vTemp));
+        const nHat = cross(rHat, vHat).map((component) => component / norm(cross(rHat, vHat)));
+        const tHat = cross(nHat, rHat).map((component) => component / norm(cross(nHat, rHat)));
+
+        return new Matrix3D(
+            new Vector3D(rHat[0], rHat[1], rHat[2]),
+            new Vector3D(tHat[0], tHat[1], tHat[2]),
+            new Vector3D(nHat[0], nHat[1], nHat[2]),
+        );
+    }
+
+    static rtnToEci(r, v) {
+        const eciToRtn = this.eciToRtn(r, v);
+        return this.invertMatrix(eciToRtn);
+    }
+
+    // 1980 IAU Theory of Nutation Coefficients
+    static NUT_COEFF = [
+        [0, 0, 0, 0, 1, -171996.0, -174.2, 92025.0, 8.9],
+        [0, 0, 2, -2, 2, -13187.0, -1.6, 5736.0, -3.1],
+        [0, 0, 2, 0, 2, -2274.0, -0.2, 977.0, -0.5],
+        [0, 0, 0, 0, 2, 2062.0, 0.2, -895.0, 0.5],
+        [0, 1, 0, 0, 0, 1426.0, -3.4, 54.0, -0.1],
+        [1, 0, 0, 0, 0, 712.0, 0.1, -7.0, 0.0],
+        [0, 1, 2, -2, 2, -517.0, 1.2, 224.0, -0.6],
+        [0, 0, 2, 0, 1, -386.0, -0.4, 200.0, 0.0],
+        [1, 0, 2, 0, 2, -301.0, 0.0, 129.0, -0.1],
+        [0, -1, 2, -2, 2, 217.0, -0.5, -95.0, 0.3],
+        [1, 0, 0, -2, 0, -158.0, 0.0, -1.0, 0.0],
+        [0, 0, 2, -2, 1, 129.0, 0.1, -70.0, 0.0],
+        [-1, 0, 2, 0, 2, 123.0, 0.0, -53.0, 0.0],
+        [1, 0, 0, 0, 1, 63.0, 0.1, -33.0, 0.0],
+        [0, 0, 0, 2, 0, 63.0, 0.0, -2.0, 0.0],
+        [-1, 0, 2, 2, 2, -59.0, 0.0, 26.0, 0.0],
+        [-1, 0, 0, 0, 1, -58.0, -0.1, 32.0, 0.0],
+        [1, 0, 2, 0, 1, -51.0, 0.0, 27.0, 0.0],
+        [2, 0, 0, -2, 0, 48.0, 0.0, 1.0, 0.0],
+        [-2, 0, 2, 0, 1, 46.0, 0.0, -24.0, 0.0],
+        [0, 0, 2, 2, 2, -38.0, 0.0, 16.0, 0.0],
+        [2, 0, 2, 0, 2, -31.0, 0.0, 13.0, 0.0],
+        [2, 0, 0, 0, 0, 29.0, 0.0, -1.0, 0.0],
+        [1, 0, 2, -2, 2, 29.0, 0.0, -12.0, 0.0],
+        [0, 0, 2, 0, 0, 26.0, 0.0, -1.0, 0.0],
+        [0, 0, 2, -2, 0, -22.0, 0.0, 0.0, 0.0],
+        [-1, 0, 2, 0, 1, 21.0, 0.0, -10.0, 0.0],
+        [0, 2, 0, 0, 0, 17.0, -0.1, 0.0, 0.0],
+        [0, 2, 2, -2, 2, -16.0, 0.1, 7.0, 0.0],
+        [-1, 0, 0, 2, 1, 16.0, 0.0, -8.0, 0.0],
+        [0, 1, 0, 0, 1, -15.0, 0.0, 9.0, 0.0],
+        [1, 0, 0, -2, 1, -13.0, 0.0, 7.0, 0.0],
+        [0, -1, 0, 0, 1, -12.0, 0.0, 6.0, 0.0],
+        [2, 0, -2, 0, 0, 11.0, 0.0, 0.0, 0.0],
+        [-1, 0, 2, 2, 1, -10.0, 0.0, 5.0, 0.0],
+        [1, 0, 2, 2, 2, -8.0, 0.0, 3.0, 0.0],
+        [0, -1, 2, 0, 2, -7.0, 0.0, 3.0, 0.0],
+        [0, 0, 2, 2, 1, -7.0, 0.0, 3.0, 0.0],
+        [1, 1, 0, -2, 0, -7.0, 0.0, 0.0, 0.0],
+        [0, 1, 2, 0, 2, 7.0, 0.0, -3.0, 0.0],
+        [-2, 0, 0, 2, 1, -6.0, 0.0, 3.0, 0.0],
+        [0, 0, 0, 2, 1, -6.0, 0.0, 3.0, 0.0],
+        [2, 0, 2, -2, 2, 6.0, 0.0, -3.0, 0.0],
+        [1, 0, 0, 2, 0, 6.0, 0.0, 0.0, 0.0],
+        [1, 0, 2, -2, 1, 6.0, 0.0, -3.0, 0.0],
+        [0, 0, 0, -2, 1, -5.0, 0.0, 3.0, 0.0],
+        [0, -1, 2, -2, 1, -5.0, 0.0, 3.0, 0.0],
+        [2, 0, 2, 0, 1, -5.0, 0.0, 3.0, 0.0],
+        [1, -1, 0, 0, 0, 5.0, 0.0, 0.0, 0.0],
+        [1, 0, 0, -1, 0, -4.0, 0.0, 0.0, 0.0],
+        [0, 0, 0, 1, 0, -4.0, 0.0, 0.0, 0.0],
+        [0, 1, 0, -2, 0, -4.0, 0.0, 0.0, 0.0],
+        [1, 0, -2, 0, 0, 4.0, 0.0, 0.0, 0.0],
+        [2, 0, 0, -2, 1, 4.0, 0.0, -2.0, 0.0],
+        [0, 1, 2, -2, 1, 4.0, 0.0, -2.0, 0.0],
+        [1, 1, 0, 0, 0, -3.0, 0.0, 0.0, 0.0],
+        [1, -1, 0, -1, 0, -3.0, 0.0, 0.0, 0.0],
+        [-1, -1, 2, 2, 2, -3.0, 0.0, 1.0, 0.0],
+        [0, -1, 2, 2, 2, -3.0, 0.0, 1.0, 0.0],
+        [1, -1, 2, 0, 2, -3.0, 0.0, 1.0, 0.0],
+        [3, 0, 2, 0, 2, -3.0, 0.0, 1.0, 0.0],
+        [-2, 0, 2, 0, 2, -3.0, 0.0, 1.0, 0.0],
+        [1, 0, 2, 0, 0, 3.0, 0.0, 0.0, 0.0],
+        [-1, 0, 2, 4, 2, -2.0, 0.0, 1.0, 0.0],
+        [1, 0, 0, 0, 2, -2.0, 0.0, 1.0, 0.0],
+        [-1, 0, 2, -2, 1, -2.0, 0.0, 1.0, 0.0],
+        [0, -2, 2, -2, 1, -2.0, 0.0, 1.0, 0.0],
+        [-2, 0, 0, 0, 1, -2.0, 0.0, 1.0, 0.0],
+        [2, 0, 0, 0, 1, 2.0, 0.0, -1.0, 0.0],
+        [3, 0, 0, 0, 0, 2.0, 0.0, 0.0, 0.0],
+        [1, 1, 2, 0, 2, 2.0, 0.0, -1.0, 0.0],
+        [0, 0, 2, 1, 2, 2.0, 0.0, -1.0, 0.0],
+        [1, 0, 0, 2, 1, -1.0, 0.0, 0.0, 0.0],
+        [1, 0, 2, 2, 1, -1.0, 0.0, 1.0, 0.0],
+        [1, 1, 0, -2, 1, -1.0, 0.0, 0.0, 0.0],
+        [0, 1, 0, 2, 0, -1.0, 0.0, 0.0, 0.0],
+        [0, 1, 2, -2, 0, -1.0, 0.0, 0.0, 0.0],
+        [0, 1, -2, 2, 0, -1.0, 0.0, 0.0, 0.0],
+        [1, 0, -2, 2, 0, -1.0, 0.0, 0.0, 0.0],
+        [1, 0, -2, -2, 0, -1.0, 0.0, 0.0, 0.0],
+        [1, 0, 2, -2, 0, -1.0, 0.0, 0.0, 0.0],
+        [1, 0, 0, -4, 0, -1.0, 0.0, 0.0, 0.0],
+        [2, 0, 0, -4, 0, -1.0, 0.0, 0.0, 0.0],
+        [0, 0, 2, 4, 2, -1.0, 0.0, 0.0, 0.0],
+        [0, 0, 2, -1, 2, -1.0, 0.0, 0.0, 0.0],
+        [-2, 0, 2, 4, 2, -1.0, 0.0, 1.0, 0.0],
+        [2, 0, 2, 2, 2, -1.0, 0.0, 0.0, 0.0],
+        [0, -1, 2, 0, 1, -1.0, 0.0, 0.0, 0.0],
+        [0, 0, -2, 0, 1, -1.0, 0.0, 0.0, 0.0],
+        [0, 0, 4, -2, 2, 1.0, 0.0, 0.0, 0.0],
+        [0, 1, 0, 0, 2, 1.0, 0.0, 0.0, 0.0],
+        [1, 1, 2, -2, 2, 1.0, 0.0, -1.0, 0.0],
+        [3, 0, 2, -2, 2, 1.0, 0.0, 0.0, 0.0],
+        [-2, 0, 2, 2, 2, 1.0, 0.0, -1.0, 0.0],
+        [-1, 0, 0, 0, 2, 1.0, 0.0, -1.0, 0.0],
+        [0, 0, -2, 2, 1, 1.0, 0.0, 0.0, 0.0],
+        [0, 1, 2, 0, 1, 1.0, 0.0, 0.0, 0.0],
+        [-1, 0, 4, 0, 2, 1.0, 0.0, 0.0, 0.0],
+        [2, 1, 0, -2, 0, 1.0, 0.0, 0.0, 0.0],
+        [2, 0, 0, 2, 0, 1.0, 0.0, 0.0, 0.0],
+        [2, 0, 2, -2, 1, 1.0, 0.0, -1.0, 0.0],
+        [2, 0, -2, 0, 1, 1.0, 0.0, 0.0, 0.0],
+        [1, -1, 0, -2, 0, 1.0, 0.0, 0.0, 0.0],
+        [-1, 0, 0, 1, 1, 1.0, 0.0, 0.0, 0.0],
+        [-1, -1, 0, 2, 1, 1.0, 0.0, 0.0, 0.0],
+        [0, 1, 0, 1, 0, 1.0, 0.0, 0.0, 0.0],
+    ];
+}
+
+module.exports.FrameConverter = FrameConverter;
+module.exports.ReferenceFrame = ReferenceFrame;
+module.exports.EarthParams = Earth;