ootk 4.0.9 → 5.1.0

package/src/coordinate/FormatTle.ts

@@ -0,0 +1,214 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025 Kruczek Labs LLC
+ *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { Tle, StringifiedNumber, TleParams, TleLine1, TleLine2 } from '../main.js';
+
+/**
+ * A class containing static methods for formatting TLEs (Two-Line Elements).
+ */
+export abstract class FormatTle {
+  private constructor() {
+    // Static class
+  }
+
+  /**
+   * Creates a TLE (Two-Line Element) string based on the provided TleParams.
+   * @param tleParams - The parameters used to generate the TLE.
+   * @returns An object containing the TLE strings tle1 and tle2.
+   */
+  static createTle(tleParams: TleParams): { tle1: TleLine1; tle2: TleLine2 } {
+    const { inc, meanmo, rasc, argPe, meana, ecen, epochyr, epochday, intl } = tleParams;
+    const scc = Tle.convert6DigitToA5(tleParams.scc);
+    const epochYrStr = epochyr.padStart(2, '0');
+    const epochdayStr = parseFloat(epochday).toFixed(8).padStart(12, '0');
+    const incStr = FormatTle.inclination(inc);
+    const meanmoStr = FormatTle.meanMotion(meanmo);
+    const rascStr = FormatTle.rightAscension(rasc);
+    const argPeStr = FormatTle.argumentOfPerigee(argPe);
+    const meanaStr = FormatTle.meanAnomaly(meana);
+    const ecenStr = FormatTle.eccentricity(ecen);
+    const intlStr = intl.padEnd(8, ' ');
+
+    // M' and M'' are both set to 0 to put the object in a perfect stable orbit
+    let TLE1Ending = tleParams.sat ? tleParams.sat.tle1.substring(32, 71) : ' +.00000000 +00000+0 +00000-0 0  9990';
+
+    // Add explicit positive/negative signs
+    TLE1Ending = TLE1Ending[1] === ' ' ? FormatTle.setCharAt(TLE1Ending, 1, '+') : TLE1Ending;
+    TLE1Ending = TLE1Ending[12] === ' ' ? FormatTle.setCharAt(TLE1Ending, 12, '+') : TLE1Ending;
+    TLE1Ending = TLE1Ending[21] === ' ' ? FormatTle.setCharAt(TLE1Ending, 21, '+') : TLE1Ending;
+    TLE1Ending = TLE1Ending[32] === ' ' ? FormatTle.setCharAt(TLE1Ending, 32, '0') : TLE1Ending;
+
+    const tle1 = `1 ${scc}U ${intlStr} ${epochYrStr}${epochdayStr}${TLE1Ending}`;
+    const tle2 = `2 ${scc} ${incStr} ${rascStr} ${ecenStr} ${argPeStr} ${meanaStr} ${meanmoStr} 00010`;
+
+    return { tle1: tle1 as TleLine1, tle2: tle2 as TleLine2 };
+  }
+
+  /**
+   * Converts the argument of perigee to a stringified number.
+   * @param argPe - The argument of perigee to be converted. Can be either a number or a string.
+   * @returns The argument of perigee as a stringified number.
+   * @throws Error if the length of the argument of perigee is not 8.
+   */
+  static argumentOfPerigee(argPe: number | string): StringifiedNumber {
+    if (typeof argPe === 'number') {
+      argPe = argPe.toString();
+    }
+
+    const argPeNum = parseFloat(argPe).toFixed(4);
+    const argPe0 = argPeNum.padStart(8, '0');
+
+    if (argPe0.length !== 8) {
+      throw new Error('argPe length is not 8');
+    }
+
+    return argPe0 as StringifiedNumber;
+  }
+
+  /**
+   * Returns the eccentricity value of a given string.
+   * @param ecen - The string representing the eccentricity.
+   * @returns The eccentricity value.
+   * @throws Error if the length of the eccentricity string is not 7.
+   */
+  static eccentricity(ecen: string): string {
+    let ecen0 = ecen.padEnd(9, '0');
+
+    if (ecen0[1] === '.') {
+      ecen0 = ecen0.substring(2);
+    } else {
+      ecen0 = ecen0.substring(0, 7);
+    }
+    if (ecen0.length !== 7) {
+      throw new Error('ecen length is not 7');
+    }
+
+    return ecen0;
+  }
+
+  /**
+   * Converts the inclination value to a string representation.
+   * @param inc - The inclination value to be converted.
+   * @returns The string representation of the inclination value.
+   * @throws Error if the length of the converted value is not 8.
+   */
+  static inclination(inc: number | string): StringifiedNumber {
+    if (typeof inc === 'number') {
+      inc = inc.toString();
+    }
+
+    const incNum = parseFloat(inc).toFixed(4);
+    const inc0 = incNum.padStart(8, '0');
+
+    if (inc0.length !== 8) {
+      throw new Error('inc length is not 8');
+    }
+
+    return inc0 as StringifiedNumber;
+  }
+
+  /**
+   * Converts the mean anomaly to a string representation with 8 digits, padded with leading zeros.
+   * @param meana - The mean anomaly to be converted. Can be either a number or a string.
+   * @returns The mean anomaly as a string with 8 digits, padded with leading zeros.
+   * @throws Error if the length of the mean anomaly is not 8.
+   */
+  static meanAnomaly(meana: number | string): StringifiedNumber {
+    if (typeof meana === 'number') {
+      meana = meana.toString();
+    }
+
+    const meanaNum = parseFloat(meana).toFixed(4);
+    const meana0 = meanaNum.padStart(8, '0');
+
+    if (meana0.length !== 8) {
+      throw new Error('meana length is not 8');
+    }
+
+    return meana0 as StringifiedNumber;
+  }
+
+  /**
+   * Converts the mean motion value to a string representation with 8 decimal
+   * places. If the input is a number, it is converted to a string. If the input
+   * is already a string, it is parsed as a float and then converted to a string
+   * with 8 decimal places. The resulting string is padded with leading zeros to
+   * ensure a length of 11 characters. Throws an error if the resulting string
+   * does not have a length of 11 characters.
+   * @param meanmo - The mean motion value to be converted.
+   * @returns The string representation of the mean motion value with 8 decimal
+   * places and padded with leading zeros.
+   * @throws Error if the resulting string does not have a length of 11
+   * characters.
+   */
+  static meanMotion(meanmo: number | string): StringifiedNumber {
+    if (typeof meanmo === 'number') {
+      meanmo = meanmo.toString();
+    }
+
+    const meanmoNum = parseFloat(meanmo).toFixed(8);
+    const meanmo0 = meanmoNum.padStart(11, '0');
+
+    if (meanmo0.length !== 11) {
+      throw new Error('meanmo length is not 11');
+    }
+
+    return meanmo0 as StringifiedNumber;
+  }
+
+  /**
+   * Converts the right ascension value to a stringified number.
+   * @param rasc - The right ascension value to convert.
+   * @returns The stringified number representation of the right ascension.
+   * @throws Error if the length of the converted right ascension is not 8.
+   */
+  static rightAscension(rasc: number | string): StringifiedNumber {
+    if (typeof rasc === 'number') {
+      rasc = rasc.toString();
+    }
+
+    const rascNum = parseFloat(rasc).toFixed(4);
+    const rasc0 = rascNum.padStart(8, '0');
+
+    if (rasc0.length !== 8) {
+      throw new Error('rasc length is not 8');
+    }
+
+    return rasc0 as StringifiedNumber;
+  }
+
+  /**
+   * Sets a character at a specific index in a string. If the index is out of range, the original string is returned.
+   * @param str - The input string.
+   * @param index - The index at which to set the character.
+   * @param chr - The character to set at the specified index.
+   * @returns The modified string with the character set at the specified index.
+   */
+  static setCharAt(str: string, index: number, chr: string): string {
+    if (index > str.length - 1) {
+      return str;
+    }
+
+    return `${str.substring(0, index)}${chr}${str.substring(index + 1)}`;
+  }
+}

package/src/coordinate/Geodetic.ts

@@ -0,0 +1,186 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025 Kruczek Labs LLC
+ *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { Earth } from '../body/Earth.js';
+import { AngularDistanceMethod, Degrees, GroundObject, Kilometers, KilometersPerSecond, Radians } from '../main.js';
+import { Vector3D } from '../operations/Vector3D.js';
+import { EpochUTC } from '../time/EpochUTC.js';
+import { DEG2RAD, RAD2DEG } from '../utils/constants.js';
+import { angularDistance } from '../utils/functions.js';
+import { ITRF } from './ITRF.js';
+
+/**
+ * This Geodetic class represents a geodetic coordinate in three-dimensional
+ * space, consisting of latitude, longitude, and altitude. It provides various
+ * methods to perform calculations and operations related to geodetic
+ * coordinates.
+ *
+ * This is a class for geodetic coordinates. This is related to the GroundObject
+ * class, which is used to represent an object on the surface of the Earth.
+ */
+export class Geodetic {
+  lat: Radians;
+  lon: Radians;
+  alt: Kilometers;
+
+  constructor(latitude: Radians, longitude: Radians, altitude: Kilometers) {
+    if (Math.abs(latitude) > Math.PI / 2) {
+      throw new RangeError('Latitude must be between -90° and 90° in Radians.');
+    }
+
+    if (Math.abs(longitude) > Math.PI) {
+      throw new RangeError('Longitude must be between -180° and 180° in Radians.');
+    }
+
+    if (altitude < -Earth.radiusMean) {
+      throw new RangeError(`Altitude must be greater than ${-Earth.radiusMean} km. Got ${altitude} km.`);
+    }
+
+    this.lat = latitude;
+    this.lon = longitude;
+    this.alt = altitude;
+  }
+
+  /**
+   * Creates a Geodetic object from latitude, longitude, and altitude values in
+   * degrees.
+   * @param latitude The latitude value in degrees.
+   * @param longitude The longitude value in degrees.
+   * @param altitude The altitude value in kilometers.
+   * @returns A Geodetic object representing the specified latitude, longitude,
+   * and altitude.
+   */
+  static fromDegrees(latitude: Degrees, longitude: Degrees, altitude: Kilometers): Geodetic {
+    return new Geodetic((latitude * DEG2RAD) as Radians, (longitude * DEG2RAD) as Radians, altitude);
+  }
+
+  /**
+   * Returns a string representation of the Geodetic object.
+   * @returns A string containing the latitude, longitude, and altitude of the Geodetic object.
+   */
+  toString(): string {
+    return [
+      'Geodetic',
+      `  Latitude:  ${this.latDeg.toFixed(4)}°`,
+      `  Longitude: ${this.lonDeg.toFixed(4)}°`,
+      `  Altitude:  ${this.alt.toFixed(3)} km`,
+    ].join('\n');
+  }
+
+  /**
+   * Gets the latitude in degrees.
+   * @returns The latitude in degrees.
+   */
+  get latDeg(): number {
+    return this.lat * RAD2DEG;
+  }
+
+  /**
+   * Gets the longitude in degrees.
+   * @returns The longitude in degrees.
+   */
+  get lonDeg(): number {
+    return this.lon * RAD2DEG;
+  }
+
+  /**
+   * Converts the geodetic coordinates to a ground position.
+   * @returns The ground position object.
+   */
+  toGroundObject(): GroundObject {
+    return new GroundObject({
+      lat: this.latDeg as Degrees,
+      lon: this.lonDeg as Degrees,
+      alt: this.alt,
+    });
+  }
+
+  /**
+   * Converts the geodetic coordinates to the International Terrestrial
+   * Reference Frame (ITRF) coordinates.
+   * @param epoch The epoch in UTC.
+   * @returns The ITRF coordinates.
+   */
+  toITRF(epoch: EpochUTC): ITRF {
+    const sLat = Math.sin(this.lat);
+    const cLat = Math.cos(this.lat);
+    const nVal = Earth.radiusEquator / Math.sqrt(1 - Earth.eccentricitySquared * sLat * sLat);
+    const r = new Vector3D<Kilometers>(
+      ((nVal + this.alt) * cLat * Math.cos(this.lon)) as Kilometers,
+      ((nVal + this.alt) * cLat * Math.sin(this.lon)) as Kilometers,
+      ((nVal * (1 - Earth.eccentricitySquared) + this.alt) * sLat) as Kilometers,
+    );
+
+    return new ITRF(epoch, r, Vector3D.origin as Vector3D<KilometersPerSecond>);
+  }
+
+  /**
+   * Calculates the angle between two geodetic coordinates.
+   * @param g The geodetic coordinate to calculate the angle to.
+   * @param method The method to use for calculating the angular distance (optional, default is Haversine).
+   * @returns The angle between the two geodetic coordinates in radians.
+   */
+  angle(g: Geodetic, method: AngularDistanceMethod = AngularDistanceMethod.Haversine): Radians {
+    return angularDistance(this.lon, this.lat, g.lon, g.lat, method);
+  }
+
+  /**
+   * Calculates the angle in degrees between two Geodetic coordinates.
+   * @param g The Geodetic coordinate to calculate the angle with.
+   * @param method The method to use for calculating the angular distance (optional, default is Haversine).
+   * @returns The angle in degrees.
+   */
+  angleDeg(g: Geodetic, method: AngularDistanceMethod = AngularDistanceMethod.Haversine): Degrees {
+    return (this.angle(g, method) * RAD2DEG) as Degrees;
+  }
+
+  /**
+   * Calculates the distance between two geodetic coordinates.
+   * @param g The geodetic coordinates to calculate the distance to.
+   * @param method The method to use for calculating the angular distance. Default is Haversine.
+   * @returns The distance between the two geodetic coordinates in kilometers.
+   */
+  distance(g: Geodetic, method: AngularDistanceMethod = AngularDistanceMethod.Haversine): Kilometers {
+    return (this.angle(g, method) * Earth.radiusMean) as Kilometers;
+  }
+
+  /**
+   * Calculates the field of view based on the altitude of the Geodetic object.
+   * @returns The field of view in radians.
+   */
+  fieldOfView(): Radians {
+    return Math.acos(Earth.radiusMean / (Earth.radiusMean + this.alt)) as Radians;
+  }
+
+  /**
+   * Determines if the current geodetic coordinate can see another geodetic coordinate.
+   * @param g The geodetic coordinate to check for visibility.
+   * @param method The method to use for calculating the angular distance (optional, default is Haversine).
+   * @returns A boolean indicating if the current coordinate can see the other coordinate.
+   */
+  isInView(g: Geodetic, method: AngularDistanceMethod = AngularDistanceMethod.Haversine): boolean {
+    const fov = Math.max(this.fieldOfView(), g.fieldOfView());
+
+    return this.angle(g, method) <= fov;
+  }
+}

package/src/coordinate/Hill.ts

@@ -1,7 +1,7 @@
 /**
  * @author @thkruz Theodore Kruczek
  * @license AGPL-3.0-or-later
- * @copyright (c) 2020-2024 Theodore Kruczek
+ * @copyright (c) 2025 Kruczek Labs LLC
  *
  * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Affero General Public License as published by the Free Software
@@ -27,7 +27,7 @@ import {
   RelativeState,
   Seconds,
   Vector3D,
-} from 'ootk-core';
+} from '../main.js';
 import { Thrust } from './../force/Thrust.js';
 import { Waypoint } from './../maneuver/Waypoint.js';
 

package/src/coordinate/ITRF.ts

@@ -0,0 +1,146 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025 Kruczek Labs LLC
+ *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* eslint-disable class-methods-use-this */
+import { Kilometers, KilometersPerSecond, Radians, Vector3D } from '../main.js';
+import { Earth } from '../body/Earth.js';
+import { Geodetic } from './Geodetic.js';
+import { J2000 } from './J2000.js';
+import { StateVector } from './StateVector.js';
+
+/**
+ * The International Terrestrial Reference Frame (ITRF) is a geocentric reference frame for the Earth. It is the
+ * successor to the International Terrestrial Reference System (ITRS). The ITRF definition is maintained by the
+ * International Earth Rotation and Reference Systems Service (IERS). Several versions of ITRF exist, each with a
+ * different epoch, to address the issue of crustal motion. The latest version is ITRF2014, based on data collected from
+ * 1980 to 2014.
+ * @see https://en.wikipedia.org/wiki/International_Terrestrial_Reference_Frame
+ *
+ * This is a geocentric coordinate system, also referenced as ECF/ECEF (Earth Centered Earth Fixed). It is a Cartesian
+ * coordinate system with the origin at the center of the Earth. The x-axis intersects the sphere of the Earth at 0°
+ * latitude (the equator) and 0° longitude (the Prime Meridian). The z-axis goes through the North Pole. The y-axis goes
+ * through 90° East longitude.
+ * @see https://en.wikipedia.org/wiki/Earth-centered,_Earth-fixed_coordinate_system
+ */
+export class ITRF extends StateVector {
+  /**
+   * Gets the name of the ITRF coordinate system.
+   * @returns The name of the coordinate system.
+   */
+  get name(): string {
+    return 'ITRF';
+  }
+
+  /**
+   * Gets a value indicating whether the coordinate system is inertial.
+   * @returns A boolean value indicating whether the coordinate system is inertial.
+   */
+  get inertial(): boolean {
+    return false;
+  }
+
+  /**
+   * Gets the height of the ITRF coordinate above the surface of the Earth in kilometers.
+   * @returns The height in kilometers.
+   */
+  get height(): Kilometers {
+    const a = Earth.radiusEquator;
+    const e2 = Earth.eccentricitySquared;
+    const r = this.position.magnitude();
+    const sl = this.position.z / r;
+    const cl2 = 1 - sl * sl;
+    const coeff = Math.sqrt((1 - e2) / (1 - e2 * cl2));
+
+    return (r - a * coeff) as Kilometers;
+  }
+
+  /**
+   * Gets the altitude in kilometers.
+   * @returns The altitude in kilometers.
+   */
+  get alt(): Kilometers {
+    return this.height;
+  }
+
+  /**
+   * Converts the current coordinate to the J2000 coordinate system. This is an Earth-Centered Inertial (ECI) coordinate
+   * system with the origin at the center of the Earth.
+   * @see https://en.wikipedia.org/wiki/Epoch_(astronomy)#Julian_years_and_J2000
+   * @returns The coordinate in the J2000 coordinate system.
+   */
+  toJ2000(): J2000 {
+    const p = Earth.precession(this.epoch);
+    const n = Earth.nutation(this.epoch);
+    const ast = this.epoch.gmstAngle() + n.eqEq;
+    const rTOD = this.position.rotZ(-ast as Radians);
+    const vTOD = this.velocity
+      .add(Earth.rotation.cross(this.position) as unknown as Vector3D<KilometersPerSecond>)
+      .rotZ(-ast as Radians);
+    const rMOD = rTOD.rotX(n.eps).rotZ(n.dPsi).rotX(-n.mEps);
+    const vMOD = vTOD.rotX(n.eps).rotZ(n.dPsi).rotX(-n.mEps);
+    const rJ2000 = rMOD
+      .rotZ(p.zed)
+      .rotY(-p.theta as Radians)
+      .rotZ(p.zeta) as Vector3D<Kilometers>;
+    const vJ2000 = vMOD
+      .rotZ(p.zed)
+      .rotY(-p.theta as Radians)
+      .rotZ(p.zeta) as Vector3D<KilometersPerSecond>;
+
+    return new J2000(this.epoch, rJ2000, vJ2000);
+  }
+
+  /**
+   * Converts the current ITRF coordinate to Geodetic coordinate. This is a coordinate system for latitude, longitude,
+   * and altitude.
+   * @returns The converted Geodetic coordinate.
+   */
+  toGeodetic(): Geodetic {
+    const sma = Earth.radiusEquator;
+    const esq = Earth.eccentricitySquared;
+    const x = this.position.x;
+    const y = this.position.y;
+    const z = this.position.z;
+    const lon = Math.atan2(y, x);
+    const r = Math.sqrt(x * x + y * y);
+    const phi = Math.atan(z / r);
+    let lat = phi;
+    let alt: Kilometers;
+    let c = 0.0;
+
+    if (x === 0 && y === 0) {
+      lat = phi;
+      alt = z > 0 ? ((z - Earth.radiusPolar) as Kilometers) : ((z + Earth.radiusPolar) as Kilometers);
+    } else {
+      for (let i = 0; i < 20; i++) {
+        const slat = Math.sin(lat);
+
+        c = 1 / Math.sqrt(1 - esq * slat * slat);
+        lat = Math.atan((z + sma * c * esq * slat) / r);
+      }
+      alt = (r / Math.cos(lat) - sma * c) as Kilometers;
+    }
+
+    return new Geodetic(lat as Radians, lon as Radians, alt);
+  }
+}

package/src/coordinate/J2000.ts

@@ -0,0 +1,130 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025 Kruczek Labs LLC
+ *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { Kilometers, KilometersPerSecond, Radians, Vector3D } from '../main.js';
+import { Earth } from '../body/Earth.js';
+import { ClassicalElements } from './ClassicalElements.js';
+import { ITRF } from './ITRF.js';
+import { StateVector } from './StateVector.js';
+import { TEME } from './TEME.js';
+
+/**
+ * Represents a position and velocity in the J2000 coordinate system. This is an Earth-centered inertial (ECI)
+ * coordinate system.
+ *
+ * Commonly used ECI frame is defined with the Earth's Mean Equator and Mean Equinox (MEME) at 12:00 Terrestrial Time on
+ * 1 January 2000. It can be referred to as J2K, J2000 or EME2000. The x-axis is aligned with the mean vernal equinox.
+ * The z-axis is aligned with the Earth's rotation axis (or equivalently, the celestial North Pole) as it was at that
+ * time. The y-axis is rotated by 90° East about the celestial equator.
+ * @see https://en.wikipedia.org/wiki/Earth-centered_inertial
+ */
+export class J2000 extends StateVector {
+  /**
+   * Creates a J2000 coordinate from classical elements.
+   * @param elements The classical elements.
+   * @returns The J2000 coordinate.
+   */
+  static fromClassicalElements(elements: ClassicalElements): J2000 {
+    const rv = elements.toPositionVelocity();
+
+    return new J2000(elements.epoch, rv.position, rv.velocity);
+  }
+
+  /**
+   * Gets the name of the coordinate system.
+   * @returns The name of the coordinate system.
+   */
+  get name(): string {
+    return 'J2000';
+  }
+
+  /**
+   * Gets a value indicating whether the coordinate system is inertial.
+   * @returns A boolean value indicating whether the coordinate system is inertial.
+   */
+  get inertial(): boolean {
+    return true;
+  }
+
+  /**
+   * Converts the coordinates from J2000 to the International Terrestrial Reference Frame (ITRF).
+   * This is an ECI to ECF transformation.
+   * @returns The ITRF coordinates.
+   */
+  toITRF(): ITRF {
+    const p = Earth.precession(this.epoch);
+    const n = Earth.nutation(this.epoch);
+    const ast = (this.epoch.gmstAngle() + n.eqEq) as Radians;
+    const rMOD = this.position
+      .rotZ(-p.zeta as Radians)
+      .rotY(p.theta)
+      .rotZ(-p.zed as Radians);
+    const vMOD = this.velocity
+      .rotZ(-p.zeta as Radians)
+      .rotY(p.theta)
+      .rotZ(-p.zed as Radians);
+    const rTOD = rMOD
+      .rotX(n.mEps)
+      .rotZ(-n.dPsi as Radians)
+      .rotX(-n.eps);
+    const vTOD = vMOD
+      .rotX(n.mEps)
+      .rotZ(-n.dPsi as Radians)
+      .rotX(-n.eps);
+    const rPEF = rTOD.rotZ(ast) as Vector3D<Kilometers>;
+    const vPEF = vTOD.rotZ(ast).add(Earth.rotation.negate().cross(rPEF)) as Vector3D<KilometersPerSecond>;
+
+    return new ITRF(this.epoch, rPEF, vPEF);
+  }
+
+  /**
+   * Converts the J2000 coordinate to the TEME coordinate.
+   * @returns The TEME coordinate.
+   */
+  toTEME(): TEME {
+    const p = Earth.precession(this.epoch);
+    const n = Earth.nutation(this.epoch);
+    const eps = n.mEps + n.dEps;
+    const dPsiCosEps = (n.dPsi * Math.cos(eps)) as Radians;
+    const rMOD = this.position
+      .rotZ(-p.zeta as Radians)
+      .rotY(p.theta)
+      .rotZ(-p.zed as Radians);
+    const vMOD = this.velocity
+      .rotZ(-p.zeta as Radians)
+      .rotY(p.theta)
+      .rotZ(-p.zed as Radians);
+    const rTEME = rMOD
+      .rotX(n.mEps)
+      .rotZ(-n.dPsi as Radians)
+      .rotX(-eps)
+      .rotZ(dPsiCosEps) as Vector3D<Kilometers>;
+    const vTEME = vMOD
+      .rotX(n.mEps)
+      .rotZ(-n.dPsi as Radians)
+      .rotX(-eps)
+      .rotZ(dPsiCosEps) as Vector3D<KilometersPerSecond>;
+
+    return new TEME(this.epoch, rTEME, vTEME);
+  }
+}