ootk 4.0.0-0 → 4.0.0-2

package/package.json

@@ -1,23 +1,20 @@
 {
   "name": "ootk",
-  "version": "4.0.0-0",
+  "version": "4.0.0-2",
+  "type": "module",
+  "module": "dist/main.js",
   "description": "Orbital Object Toolkit including Multiple Propagators, Initial Orbit Determination, and Maneuver Calculations.",
   "scripts": {
-    "build": "node ./scripts/cleanup.mjs && ttsc -p tsconfig.build.json",
-    "lcov": "node ./scripts/openLcov.mjs",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
-    "lint:test": "eslint test",
-    "test": "npm run build && jest",
+    "build": "npm run clean && npx tsc -p tsconfig.build.json -m esnext",
+    "clean": "node ./scripts/cleanup.mjs",
+    "lint": "npx eslint src",
+    "lint:fix": "npx eslint src --fix",
+    "test": "jest",
     "test:coverage": "jest --coverage",
-    "test:performance": "node test/performance/timing.test.mjs",
-    "version": "auto-changelog -p && git add CHANGELOG.md"
-  },
-  "main": "./lib/ootk.js",
-  "exports": {
-    "import": "./lib/ootk.js",
-    "require": "./lib/ootk.js"
+    "version": "npm run build && auto-changelog && git add CHANGELOG.md"
   },
+  "main": "dist/main.js",
+  "typings": "dist/main.d.ts",
   "repository": {
     "type": "git",
     "url": "git://github.com/thkruz/ootk"
@@ -27,7 +24,9 @@
     "orbit",
     "toolkit",
     "space",
-    "satellite"
+    "satellite",
+    "radar",
+    "iod"
   ],
   "author": "Theodore Kruczek <theodore.kruczek@gmail.com> (https://github.com/ootk/)",
   "license": "APGL-3.0",
@@ -35,35 +34,26 @@
     "url": "https://github.com/thkruz/ootk/issues"
   },
   "devDependencies": {
-    "@babel/core": "^7.22.9",
-    "@babel/plugin-transform-runtime": "^7.22.9",
-    "@babel/preset-env": "^7.22.9",
-    "@babel/preset-typescript": "^7.22.5",
-    "@types/jest": "^28.1.8",
-    "@types/node-fetch": "^2.6.2",
-    "@typescript-eslint/eslint-plugin": "^5.54.0",
-    "@typescript-eslint/parser": "^5.54.0",
-    "auto-changelog": "^2.2.1",
+    "@babel/core": "^7.23.7",
+    "@babel/plugin-transform-runtime": "^7.23.7",
+    "@babel/preset-env": "^7.23.8",
+    "@babel/preset-typescript": "^7.23.3",
+    "@types/jest": "^29.5.11",
+    "@typescript-eslint/eslint-plugin": "^6.18.1",
+    "@typescript-eslint/parser": "^6.18.1",
+    "auto-changelog": "^2.4.0",
+    "auto-changelog-thkruz": "^1.0.0",
     "babel-eslint": "^10.1.0",
-    "babel-loader": "^8.3.0",
-    "codecov": "^3.8.1",
-    "copy-webpack-plugin": "^11.0.0",
-    "eslint": "^7.32.0",
+    "babel-jest": "^29.7.0",
+    "babel-loader": "^9.1.3",
+    "eslint": "^8.56.0",
+    "eslint-plugin-jsdoc": "^48.0.2",
     "jest": "^28.1.3",
-    "node-fetch": "^2.6.7",
-    "opener": "^1.5.2",
-    "prettier": "^2.8.8",
-    "prettier-plugin-organize-imports": "^3.2.3",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
-    "ttypescript": "^1.5.15",
-    "typescript": "^4.9.5",
-    "typescript-transform-paths": "^3.4.6",
-    "webpack": "^5.11.1",
-    "webpack-cli": "^4.10.0"
+    "tsx": "^4.7.0",
+    "typescript": "^4.9.5"
   },
-  "homepage": "https://github.com/thkruz/ootk",
   "dependencies": {
-    "ootk-core": "^1.0.0-0"
-  }
+    "ootk-core": "^1.0.8"
+  },
+  "homepage": "https://github.com/thkruz/ootk"
 }

package/src/coordinate/Hill.ts

@@ -0,0 +1,326 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * 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,
+  EpochUTC,
+  J2000,
+  Kilometers,
+  KilometersPerSecond,
+  Matrix,
+  MetersPerSecond,
+  RadiansPerSecond,
+  RelativeState,
+  Seconds,
+  Vector3D,
+} from 'ootk-core';
+import { Thrust } from './../force/Thrust';
+import { Waypoint } from './../maneuver/Waypoint';
+
+// / Hill Modified Equidistant Cyllindrical _(EQCM)_ coordinates.
+export class Hill {
+  private semimajorAxis_: Kilometers;
+  private meanMotion_: RadiansPerSecond;
+
+  constructor(
+    public epoch: EpochUTC,
+    public position: Vector3D<Kilometers>,
+    public velocity: Vector3D<KilometersPerSecond>,
+    semimajorAxis: Kilometers,
+  ) {
+    this.semimajorAxis_ = semimajorAxis;
+    this.meanMotion_ = Earth.smaToMeanMotion(this.semimajorAxis_);
+  }
+
+  static fromState(
+    origin: J2000,
+    radialPosition: Kilometers,
+    intrackPosition: Kilometers,
+    nodeVelocity: KilometersPerSecond,
+    nodeOffsetTime: Seconds,
+  ): Hill {
+    const a = origin.semimajorAxis;
+    const n = Earth.smaToMeanMotion(a);
+    const yDot = -3.0 * radialPosition * n * 0.5 as KilometersPerSecond;
+    const z = (nodeVelocity / n) * Math.sin(n * -nodeOffsetTime) as Kilometers;
+    const zDot = nodeVelocity * Math.cos(n * -nodeOffsetTime) as KilometersPerSecond;
+    const r = new Vector3D(radialPosition, intrackPosition, z);
+    const v = new Vector3D(0.0 as KilometersPerSecond, yDot, zDot);
+
+    return new Hill(origin.epoch, r, v, a);
+  }
+
+  static fromNmc(
+    origin: J2000,
+    majorAxisRange: Kilometers,
+    nodeVelocity: KilometersPerSecond,
+    nodeOffsetTime: Seconds,
+    translation = 0.0,
+  ): Hill {
+    const a = origin.semimajorAxis;
+    const n = Earth.smaToMeanMotion(a);
+    const xDot = majorAxisRange * n * 0.5 as KilometersPerSecond;
+    const z = (nodeVelocity / n) * Math.sin(n * -nodeOffsetTime) as Kilometers;
+    const zDot = nodeVelocity * Math.cos(n * -nodeOffsetTime) as KilometersPerSecond;
+    const r = new Vector3D(0.0 as Kilometers, majorAxisRange + translation as Kilometers, z);
+    const v = new Vector3D(xDot, 0.0 as KilometersPerSecond, zDot);
+
+    return new Hill(origin.epoch, r, v, a);
+  }
+
+  static fromPerch(
+    origin: J2000,
+    perchRange: Kilometers,
+    nodeVelocity: KilometersPerSecond,
+    nodeOffsetTime: Seconds,
+  ): Hill {
+    const a = origin.semimajorAxis;
+    const n = Earth.smaToMeanMotion(a);
+    const z = (nodeVelocity / n) * Math.sin(n * -nodeOffsetTime) as Kilometers;
+    const zDot = nodeVelocity * Math.cos(n * -nodeOffsetTime) as KilometersPerSecond;
+    const r = new Vector3D(0.0 as Kilometers, perchRange, z);
+    const v = new Vector3D(0.0 as KilometersPerSecond, 0.0 as KilometersPerSecond, zDot);
+
+    return new Hill(origin.epoch, r, v, a);
+  }
+
+  get semimajorAxis(): Kilometers {
+    return this.semimajorAxis_;
+  }
+
+  set semimajorAxis(sma: Kilometers) {
+    this.semimajorAxis_ = sma;
+    this.meanMotion_ = Earth.smaToMeanMotion(this.semimajorAxis_);
+  }
+
+  get meanMotion(): RadiansPerSecond {
+    return this.meanMotion_;
+  }
+
+  toJ2000Matrix(origin: J2000, transform: Matrix): J2000 {
+    const magrtgt = origin.position.magnitude();
+    const magrint = magrtgt + this.position.x;
+    const vtgtrsw = transform.multiplyVector3D(origin.velocity);
+
+    const lambdadottgt = vtgtrsw.y / magrtgt;
+    const lambdaint = this.position.y / magrtgt;
+    const phiint = this.position.z / magrtgt;
+    const sinphiint = Math.sin(phiint);
+    const cosphiint = Math.cos(phiint);
+    const sinlambdaint = Math.sin(lambdaint);
+    const coslambdaint = Math.cos(lambdaint);
+
+    const rotRswSez = new Matrix([
+      [sinphiint * coslambdaint, sinphiint * sinlambdaint, -cosphiint],
+      [-sinlambdaint, coslambdaint, 0],
+      [cosphiint * coslambdaint, cosphiint * sinlambdaint, sinphiint],
+    ]);
+
+    const rdotint = this.velocity.x + vtgtrsw.x;
+    const lambdadotint = this.velocity.y / magrtgt + lambdadottgt;
+    const phidotint = this.velocity.z / magrtgt;
+    const vintsez = new Vector3D(-magrint * phidotint, magrint * lambdadotint * cosphiint, rdotint);
+    const vintrsw = rotRswSez.transpose().multiplyVector3D(vintsez);
+    const vinteci = transform.transpose().multiplyVector3D(vintrsw) as Vector3D<KilometersPerSecond>;
+
+    const rintrsw = new Vector3D(
+      cosphiint * magrint * coslambdaint,
+      cosphiint * magrint * sinlambdaint,
+      sinphiint * magrint,
+    );
+
+    const rinteci = transform.transpose().multiplyVector3D(rintrsw) as Vector3D<Kilometers>;
+
+    return new J2000(origin.epoch, rinteci, vinteci);
+  }
+
+  toJ2000(origin: J2000): J2000 {
+    return this.toJ2000Matrix(origin, RelativeState.createMatrix(origin.position, origin.velocity));
+  }
+
+  static transitionMatrix(t: number, meanMotion: number): Matrix {
+    const n = meanMotion;
+    const sn = Math.sin(n * t);
+    const cs = Math.cos(n * t);
+
+    return new Matrix([
+      [4.0 - 3.0 * cs, 0.0, 0.0, sn / n, (2.0 * (1.0 - cs)) / n, 0.0],
+      [6.0 * (sn - n * t), 1.0, 0.0, (-2.0 * (1.0 - cs)) / n, (4.0 * sn - 3.0 * n * t) / n, 0.0],
+      [0.0, 0.0, cs, 0.0, 0.0, sn / n],
+      [3.0 * n * sn, 0.0, 0.0, cs, 2.0 * sn, 0.0],
+      [-6.0 * n * (1.0 - cs), 0.0, 0.0, -2.0 * sn, 4.0 * cs - 3.0, 0.0],
+      [0.0, 0.0, -n * sn, 0.0, 0.0, cs],
+    ]);
+  }
+
+  transition(t: Seconds): Hill {
+    const sysMat = Hill.transitionMatrix(t, this.meanMotion_);
+    const res = sysMat.multiplyVector(this.position.join(this.velocity)).elements;
+
+    return new Hill(
+      this.epoch.roll(t),
+      new Vector3D(res[0] as Kilometers, res[1] as Kilometers, res[2] as Kilometers),
+      new Vector3D(res[3] as KilometersPerSecond, res[4] as KilometersPerSecond, res[5] as KilometersPerSecond),
+      this.semimajorAxis_,
+    );
+  }
+
+  transitionWithMatrix(stm: Matrix, t: Seconds): Hill {
+    const res = stm.multiplyVector(this.position.join(this.velocity)).elements;
+
+    return new Hill(
+      this.epoch.roll(t),
+      new Vector3D(res[0] as Kilometers, res[1] as Kilometers, res[2] as Kilometers),
+      new Vector3D(res[3] as KilometersPerSecond, res[4] as KilometersPerSecond, res[5] as KilometersPerSecond),
+      this.semimajorAxis_,
+    );
+  }
+
+  propagate(newEpoch: EpochUTC): Hill {
+    return this.transition(newEpoch.difference(this.epoch));
+  }
+
+  propagateWithMatrix(stm: Matrix, newEpoch: EpochUTC): Hill {
+    return this.transitionWithMatrix(stm, newEpoch.difference(this.epoch));
+  }
+
+  maneuver(maneuver: Thrust): Hill {
+    const state = this.propagate(maneuver.center);
+
+    return new Hill(state.epoch, state.position, state.velocity.add(maneuver.deltaV), state.semimajorAxis_);
+  }
+
+  ephemeris(start: EpochUTC, stop: EpochUTC, step = 60.0 as Seconds): Hill[] {
+    const output: Hill[] = [];
+    let current = start;
+
+    while (stop >= current) {
+      output.push(this.propagate(current));
+      current = current.roll(step);
+    }
+
+    return output;
+  }
+
+  get period(): Seconds {
+    return (2 * Math.PI) / this.meanMotion_ as Seconds;
+  }
+
+  nextRadialTangent(): Hill {
+    const x = this.position.x;
+    const xDot = this.velocity.x;
+    const yDot = this.velocity.y;
+    let t = Math.atan(-xDot / (3.0 * this.meanMotion_ * x + 2.0 * yDot)) / this.meanMotion_ as Seconds;
+
+    if (t <= 0) {
+      t = t + 0.5 * this.period as Seconds;
+    } else if (isNaN(t)) {
+      t = 0.5 * this.period as Seconds;
+    }
+
+    return this.propagate(this.epoch.roll(t));
+  }
+
+  solveManeuver(waypoint: Waypoint, ignoreCrosstrack = false): Thrust {
+    const t = waypoint.epoch.difference(this.epoch);
+    const w = waypoint.relativePosition;
+    const sysMat = Hill.transitionMatrix(t, this.meanMotion_);
+    const posEquationMat = new Matrix([
+      [sysMat.elements[0][0], sysMat.elements[0][1], sysMat.elements[0][2]],
+      [sysMat.elements[1][0], sysMat.elements[1][1], sysMat.elements[1][2]],
+      [sysMat.elements[2][0], sysMat.elements[2][1], sysMat.elements[2][2]],
+    ]);
+    const solnVector = w
+      .subtract(posEquationMat.multiplyVector3D(this.position)) as unknown as Vector3D<KilometersPerSecond>;
+    const velEquationMat = new Matrix([
+      [sysMat.elements[0][3], sysMat.elements[0][4], sysMat.elements[0][5]],
+      [sysMat.elements[1][3], sysMat.elements[1][4], sysMat.elements[1][5]],
+      [sysMat.elements[2][3], sysMat.elements[2][4], sysMat.elements[2][5]],
+    ]);
+    let result = velEquationMat
+      .inverse()
+      .multiplyVector3D(solnVector)
+      .subtract(this.velocity);
+
+    if (ignoreCrosstrack) {
+      result = new Vector3D(
+        result.x,
+        result.y,
+        0 as KilometersPerSecond,
+      );
+    }
+
+    return new Thrust(
+      this.epoch,
+      result.x * 1000 as MetersPerSecond,
+      result.y * 1000 as MetersPerSecond,
+      result.z * 1000 as MetersPerSecond,
+    );
+  }
+
+  maneuverSequence(
+    pivot: EpochUTC,
+    waypoints: Waypoint[],
+    preManeuvers: Thrust[] = [],
+    postManeuvers: Thrust[] = [],
+  ): Thrust[] {
+    let state = new Hill(this.epoch, this.position, this.velocity, this.semimajorAxis_);
+
+    preManeuvers = preManeuvers.slice();
+    postManeuvers = postManeuvers.slice();
+    let output = preManeuvers;
+
+    // Note difference was once compareTo
+    output.sort((a, b) => a.center.difference(b.center));
+    output = output.filter((mvr) => mvr.center >= this.epoch && mvr.center >= pivot);
+    for (const mvr of output) {
+      state = state.maneuver(mvr);
+    }
+    state = state.propagate(pivot);
+    for (const wpt of waypoints) {
+      const mvr = state.solveManeuver(wpt);
+
+      state = state.maneuver(mvr);
+      output.push(mvr);
+    }
+    output.push(...postManeuvers);
+
+    return output;
+  }
+
+  maneuverOrigin(maneuver: Thrust): Hill {
+    const state = this.propagate(maneuver.center);
+    const vInit = Math.sqrt(Earth.mu / this.semimajorAxis_);
+    const vFinal = vInit - maneuver.intrack * 1e-3;
+    const aFinal = Earth.mu / (vFinal * vFinal) as Kilometers;
+
+    return new Hill(state.epoch, state.position, state.velocity.subtract(maneuver.deltaV), aFinal);
+  }
+
+  get name(): string {
+    return 'Hill';
+  }
+
+  toString(): string {
+    return [
+      `[${this.name}]`,
+      `  Epoch: ${this.epoch}`,
+      `  Position: ${this.position.toString(6)} km`,
+      `  Velocity: ${this.velocity.toString(9)} km/s`,
+    ].join('\n');
+  }
+}

package/src/coordinate/index.ts

@@ -0,0 +1 @@
+export { Hill } from './Hill';

package/src/covariance/CovarianceSample.ts

@@ -0,0 +1,194 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * 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 {
+  Epoch,
+  EpochUTC,
+  J2000,
+  Kilometers,
+  KilometersPerSecond,
+  Matrix,
+  RelativeState,
+  RIC,
+  Vector,
+  Vector3D,
+} from 'ootk-core';
+import { ForceModel } from '../force/ForceModel';
+import { Thrust } from '../force/Thrust';
+import { RungeKutta89Propagator } from '../propagator/RungeKutta89Propagator';
+import { CovarianceFrame, StateCovariance } from './StateCovariance';
+
+// / Sigma point covariance sample.
+export class CovarianceSample {
+  private _origin: RungeKutta89Propagator;
+  private _samples: RungeKutta89Propagator[] = [];
+  private matrix_ = Matrix.zero(6, 12);
+
+  /**
+   * Create a new [CovarianceSample] object from an inertial state, covariance
+   * and optional force models for the origin state and samples.
+   *
+   * Two-body physics will be used if a force model is not provided.
+   * @param state The origin state.
+   * @param covariance The covariance.
+   * @param originForceModel The force model for the origin state.
+   * @param sampleForceModel The force model for the samples.
+   */
+  constructor(state: J2000, covariance: StateCovariance, originForceModel?: ForceModel, sampleForceModel?: ForceModel) {
+    originForceModel ??= new ForceModel().setGravity();
+    sampleForceModel ??= new ForceModel().setGravity();
+    this._origin = new RungeKutta89Propagator(state, originForceModel);
+    const s = covariance.matrix.cholesky().elements;
+    const sqrt6 = Math.sqrt(6.0);
+
+    for (let i = 0; i < 6; i++) {
+      for (let j = 0; j < 6; j++) {
+        s[i][j] *= sqrt6;
+      }
+    }
+
+    // 6 x 12 matrix
+    const sigmapts = Matrix.zero(6, 12).elements;
+
+    for (let i = 0; i < 6; i++) {
+      const jj = (i - 1) * 2 + 2;
+
+      for (let j = 0; j < 3; j++) {
+        sigmapts[j][jj] = s[j][i];
+        sigmapts[j + 3][jj] = s[j + 3][i];
+
+        sigmapts[j][jj + 1] = -s[j][i];
+        sigmapts[j + 3][jj + 1] = -s[j + 3][i];
+      }
+    }
+
+    for (let i = 0; i < 12; i++) {
+      const sampleR = new Vector3D(
+        sigmapts[0][i] as Kilometers,
+        sigmapts[1][i] as Kilometers,
+        sigmapts[2][i] as Kilometers,
+      );
+      const sampleV = new Vector3D(
+        sigmapts[3][i] as KilometersPerSecond,
+        sigmapts[4][i] as KilometersPerSecond,
+        sigmapts[5][i] as KilometersPerSecond,
+      );
+
+      if (covariance.frame === CovarianceFrame.ECI) {
+        const sample = new J2000(state.epoch, state.position.add(sampleR), state.velocity.add(sampleV));
+
+        this._samples.push(new RungeKutta89Propagator(sample, sampleForceModel));
+      } else if (covariance.frame === CovarianceFrame.RIC) {
+        const sample = new RIC(sampleR, sampleV).toJ2000(state);
+
+        this._samples.push(new RungeKutta89Propagator(sample, sampleForceModel));
+      }
+    }
+  }
+
+  // / Current covariance sample epoch.
+  get epoch(): Epoch {
+    return this._origin.state.epoch;
+  }
+
+  // / Current covariance sample origin state.
+  get state(): J2000 {
+    return this._origin.state;
+  }
+
+  // / Rebuild covariance from sigma points.
+  private _rebuildCovariance(matrix: Matrix): Matrix {
+    const pts = matrix.elements;
+    const c = 1.0 / 12.0;
+    const yu = new Vector([0, 0, 0, 0, 0, 0]).elements;
+    const y = Matrix.zero(6, 12);
+
+    for (let i = 0; i < 12; i++) {
+      for (let j = 0; j < 6; j++) {
+        yu[j] += pts[j][i];
+      }
+    }
+
+    for (let j = 0; j < 6; j++) {
+      yu[j] *= c;
+    }
+
+    for (let i = 0; i < 12; i++) {
+      for (let j = 0; j < 6; j++) {
+        y.elements[j][i] = pts[j][i] - yu[j];
+      }
+    }
+
+    const yt = y.transpose();
+    const tmp = y.multiply(yt);
+
+    return tmp.scale(c);
+  }
+
+  // / Propagate covariance to a new epoch.
+  propagate(epoch: EpochUTC): void {
+    this._origin.propagate(epoch);
+    for (const sample of this._samples) {
+      sample.propagate(epoch);
+    }
+  }
+
+  // / Apply a maneuver to this covariance.
+  maneuver(maneuver: Thrust): void {
+    this._origin.maneuver(maneuver);
+    for (const sample of this._samples) {
+      sample.maneuver(maneuver);
+    }
+  }
+
+  // / Desample covariance in J2000 frame.
+  desampleJ2000(): StateCovariance {
+    for (let i = 0; i < 12; i++) {
+      const state = this._samples[i].state;
+
+      this.matrix_.elements[0][i] = state.position.x;
+      this.matrix_.elements[1][i] = state.position.y;
+      this.matrix_.elements[2][i] = state.position.z;
+      this.matrix_.elements[3][i] = state.velocity.x;
+      this.matrix_.elements[4][i] = state.velocity.y;
+      this.matrix_.elements[5][i] = state.velocity.z;
+    }
+    const matrix = this._rebuildCovariance(this.matrix_);
+
+    return new StateCovariance(matrix, CovarianceFrame.ECI);
+  }
+
+  // / Desample covariance in RIC frame.
+  desampleRIC(): StateCovariance {
+    const rot = RelativeState.createMatrix(this._origin.state.position, this._origin.state.velocity);
+
+    for (let i = 0; i < 12; i++) {
+      const state = RIC.fromJ2000Matrix(this._samples[i].state, this._origin.state, rot);
+
+      this.matrix_.elements[0][i] = state.position.x;
+      this.matrix_.elements[1][i] = state.position.y;
+      this.matrix_.elements[2][i] = state.position.z;
+      this.matrix_.elements[3][i] = state.velocity.x;
+      this.matrix_.elements[4][i] = state.velocity.y;
+      this.matrix_.elements[5][i] = state.velocity.z;
+    }
+    const matrix = this._rebuildCovariance(this.matrix_);
+
+    return new StateCovariance(matrix, CovarianceFrame.RIC);
+  }
+}

package/src/covariance/StateCovariance.ts

@@ -0,0 +1,69 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * 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 { Matrix, Vector } from 'ootk-core';
+
+/** Covariance Frame */
+export enum CovarianceFrame {
+  /** Earth-centered inertial */
+  ECI = 'eci',
+  /** Radial-Intrack-Crosstrack */
+  RIC = 'ric',
+}
+
+// / State covariance.
+export class StateCovariance {
+  /**
+   * Create a new [StateCovariance] object given its covariance [matrix] and
+   * [CovarianceFrame].
+   * @param matrix The covariance matrix.
+   * @param frame The covariance frame.
+   * @returns A new [StateCovariance] object.
+   */
+  constructor(public matrix: Matrix, public frame: CovarianceFrame) {
+    // Nothing to do here.
+  }
+
+  // / Create a new [StateCovariance] object from 1-sigma values.
+  static fromSigmas(sigmas: number[], frame: CovarianceFrame): StateCovariance {
+    const n = sigmas.length;
+    const output = Matrix.zero(n, n);
+
+    for (let i = 0; i < n; i++) {
+      output.elements[i][i] = Math.max(sigmas[i] * sigmas[i], 1e-32);
+    }
+
+    return new StateCovariance(output, frame);
+  }
+
+  /**
+   * Calculates the standard deviations (sigmas) of each element in the covariance matrix.
+   * @returns A vector containing the standard deviations of each element in the covariance matrix.
+   */
+  sigmas(): Vector {
+    const c = this.matrix.columns;
+    const result = new Float64Array(c);
+
+    for (let i = 0; i < c; i++) {
+      const variance = this.matrix.elements[i][i];
+
+      result[i] = Math.sqrt(variance);
+    }
+
+    return new Vector(result);
+  }
+}