ootk 3.0.0 → 4.0.0-1

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);
+  }
+}

package/src/force/AtmosphericDrag.ts

@@ -0,0 +1,101 @@
+/**
+ * @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 {
+  DataHandler,
+  DEG2RAD,
+  Earth,
+  ITRF,
+  J2000,
+  Kilometers,
+  KilometersPerSecond,
+  Radians,
+  Sun,
+  Vector3D,
+} from 'ootk-core';
+import { Force } from './Force';
+
+/**
+ * Harris-Priester atmospheric drag force model.
+ * Atmospheric density model assumes mean solar flux.
+ */
+export class AtmosphericDrag implements Force {
+  mass: number;
+  area: number;
+  dragCoeff: number;
+  cosine: number;
+
+  constructor(mass: number, area: number, dragCoeff: number, cosine: number) {
+    this.mass = mass;
+    this.area = area;
+    this.dragCoeff = dragCoeff;
+    this.cosine = cosine;
+  }
+
+  private static _getHPDensity(state: ITRF, n: number): number {
+    const hpa = DataHandler.getInstance().getHpAtmosphere(state.height);
+
+    if (hpa === null) {
+      return 0.0;
+    }
+    const sunPos = Sun.positionApparent(state.epoch);
+    const sunVec = new J2000(
+      state.epoch,
+      sunPos,
+      Vector3D.origin as Vector3D<KilometersPerSecond>,
+    ).toITRF().position.normalize();
+    const bulVec = sunVec.rotZ(-30.0 * DEG2RAD as Radians);
+    const cosPsi = bulVec.normalize().dot(state.position.normalize());
+    const c2Psi2 = 0.5 * (1.0 + cosPsi);
+    const cPsi2 = Math.sqrt(c2Psi2);
+    const cosPow = cPsi2 > 1e-12 ? c2Psi2 * cPsi2 ** (n - 2) : 0.0;
+    const altitude = hpa.height;
+    const [h0, min0, max0] = hpa.hp0;
+    const [h1, min1, max1] = hpa.hp1;
+    const dH = (h0 - altitude) / (h0 - h1);
+    const rhoMin = min0 * (min1 / min0) ** dH;
+
+    if (cosPow === 0) {
+      return rhoMin;
+    }
+    const rhoMax = max0 * (max1 / max0) ** dH;
+
+    return rhoMin + (rhoMax - rhoMin) * cosPow;
+  }
+
+  acceleration(state: J2000): Vector3D {
+    const itrfState = state.toITRF();
+    const density = AtmosphericDrag._getHPDensity(itrfState, this.cosine);
+
+    if (density === 0) {
+      return Vector3D.origin;
+    }
+    const rotation = new ITRF(
+      state.epoch,
+      // TODO: #26 This is a bit of a hack to get Radians/Second to work with StateVector class
+      Earth.rotation as unknown as Vector3D<Kilometers>,
+      Vector3D.origin as Vector3D<KilometersPerSecond>,
+    ).toJ2000().position;
+    // TODO: #26 This is a bit of a hack to get Radians/Second to work with StateVector class
+    const vRel = state.velocity.subtract(rotation.cross(state.position) as unknown as Vector3D<KilometersPerSecond>)
+      .scale(1000.0 as KilometersPerSecond);
+    const vm = vRel.magnitude();
+    const fScale = -0.5 * density * ((this.dragCoeff * this.area) / this.mass) * vm;
+
+    return vRel.scale(fScale / 1000.0);
+  }
+}

package/src/force/EarthGravity.ts

@@ -0,0 +1,157 @@
+/**
+ * @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 { DataHandler, Earth, ITRF, J2000, Kilometers, KilometersPerSecond, Vector3D } from 'ootk-core';
+/* eslint-disable class-methods-use-this */
+// / Complex Earth gravity model, accounting for EGM-96 zonal, sectoral, and
+
+import { Force } from './Force';
+
+// / tesseral geopotential perturbations.
+export class EarthGravity implements Force {
+  degree: number;
+  order: number;
+  _asphericalFlag: boolean;
+
+  constructor(degree: number, order: number) {
+    this.degree = Math.min(Math.max(degree, 0), 36);
+    this.order = Math.min(Math.max(order, 0), 36);
+    this._asphericalFlag = degree >= 2;
+  }
+
+  _spherical(state: J2000): Vector3D {
+    const rMag = state.position.magnitude();
+
+    return state.position.scale(-Earth.mu / (rMag * rMag * rMag));
+  }
+
+  // eslint-disable-next-line max-statements
+  _aspherical(state: J2000): Vector3D {
+    const posEcef = state.toITRF().position;
+    const ri = 1.0 / posEcef.magnitude();
+    const xor = posEcef.x * ri;
+    const yor = posEcef.y * ri;
+    const zor = posEcef.z * ri;
+
+    const ep = zor;
+    const reor = Earth.radiusEquator * ri;
+    let reorn = reor;
+    const muor2 = Earth.mu * ri * ri;
+
+    let sumH = 0.0;
+    let sumGm = 0.0;
+    let sumJ = 0.0;
+    let sumK = 0.0;
+
+    const cTil = new Float64Array(this.order + 4);
+    const sTil = new Float64Array(this.order + 4);
+
+    const pN = new Float64Array(this.order + 4);
+    const pNm1 = new Float64Array(this.order + 4);
+    const pNm2 = new Float64Array(this.order + 4);
+
+    pNm2[0] = 1.0;
+    pNm1[0] = ep;
+    pNm1[1] = 1.0;
+    cTil[0] = 1.0;
+    cTil[1] = xor;
+    sTil[1] = yor;
+
+    const dh = DataHandler.getInstance();
+
+    for (let n = 2, nm1 = 1, nm2 = 0, np1 = 3; n <= this.degree; nm2++, nm1++, n++, np1++) {
+      const twonm1 = 2.0 * n - 1.0;
+
+      reorn *= reor;
+      const cN0 = dh.getEgm96Coeffs(n, 0)[2];
+
+      pN[0] = (twonm1 * ep * pNm1[0] - nm1 * pNm2[0]) / n;
+      pN[1] = pNm2[1] + twonm1 * pNm1[0];
+      pN[2] = pNm2[2] + twonm1 * pNm1[1];
+
+      let sumHn = pN[1] * cN0;
+      let sumGmn = pN[0] * cN0 * np1;
+
+      if (this.order > 0) {
+        let sumJn = 0.0;
+        let sumKn = 0.0;
+
+        cTil[n] = cTil[1] * cTil[nm1] - sTil[1] * sTil[nm1];
+        sTil[n] = sTil[1] * cTil[nm1] + cTil[1] * sTil[nm1];
+
+        const lim = n < this.order ? n : this.order;
+
+        for (let m = 1, mm1 = 0, mm2 = -1, mp1 = 2, mp2 = 3; m <= lim; mm2++, mm1++, m++, mp1++, mp2++) {
+          pN[mp1] = pNm2[mp1] + twonm1 * pNm1[m];
+
+          const dm = m;
+          const npmp1 = n + mp1;
+
+          const pNm = pN[m];
+          const pNmp1 = pN[mp1];
+
+          const coefs = dh.getEgm96Coeffs(n, m);
+          const cNm = coefs[2];
+          const sNm = coefs[3];
+
+          const mxPnm = dm * pNm;
+          const bNmtil = cNm * cTil[m] + sNm * sTil[m];
+          const pNmBnm = pNm * bNmtil;
+          const bNmtm1 = cNm * cTil[mm1] + sNm * sTil[mm1];
+          const aNmtm1 = cNm * sTil[mm1] - sNm * cTil[mm1];
+
+          sumHn += pNmp1 * bNmtil;
+          sumGmn += npmp1 * pNmBnm;
+          sumJn += mxPnm * bNmtm1;
+          sumKn -= mxPnm * aNmtm1;
+        }
+
+        sumJ += reorn * sumJn;
+        sumK += reorn * sumKn;
+      }
+
+      sumH += reorn * sumHn;
+      sumGm += reorn * sumGmn;
+
+      if (n < this.degree) {
+        for (let i = 0; i <= n; i++) {
+          pNm2[i] = pNm1[i];
+          pNm1[i] = pN[i];
+        }
+      }
+    }
+
+    const lambda = sumGm + ep * sumH;
+    const g = new Vector3D<Kilometers>(
+      -muor2 * (lambda * xor - sumJ) as Kilometers,
+      -muor2 * (lambda * yor - sumK) as Kilometers,
+      -muor2 * (lambda * zor - sumH) as Kilometers,
+    );
+
+    return new ITRF(state.epoch, g, Vector3D.origin as Vector3D<KilometersPerSecond>).toJ2000().position;
+  }
+
+  acceleration(state: J2000): Vector3D {
+    let accVec = this._spherical(state);
+
+    if (this._asphericalFlag) {
+      accVec = accVec.add(this._aspherical(state));
+    }
+
+    return accVec;
+  }
+}

package/src/force/Force.ts

@@ -0,0 +1,33 @@
+/**
+ * @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 { J2000, Vector3D } from 'ootk-core';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable class-methods-use-this */
+
+// / Base class for perturbation forces.
+export abstract class Force {
+  /**
+   * Calculate the acceleration due to the perturbing force on a given
+   * state vector.
+   * @param state The state vector.
+   * @throws If the force cannot be calculated.
+   */
+  acceleration(state: J2000): Vector3D {
+    throw Error('Not implemented');
+  }
+}

package/src/force/ForceModel.ts

@@ -0,0 +1,91 @@
+/**
+ * @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, J2000, Vector, Vector3D } from 'ootk-core';
+import { AtmosphericDrag } from './AtmosphericDrag';
+import { EarthGravity } from './EarthGravity';
+import { Force } from './Force';
+import { Gravity } from './Gravity';
+import { SolarRadiationPressure } from './SolarRadiationPressure';
+import { ThirdBodyGravity } from './ThirdBodyGravity';
+import { Thrust } from './Thrust';
+
+// / Force model for spacecraft propagation.
+
+export class ForceModel {
+  private _centralGravity?: Force;
+  private _thirdBodyGravity?: Force;
+  private _solarRadiationPressure?: Force;
+  private _atmosphericDrag?: Force;
+  private _maneuverThrust: Force | null = null;
+
+  setGravity(mu: number = Earth.mu): this {
+    this._centralGravity = new Gravity(mu);
+
+    return this;
+  }
+
+  setEarthGravity(degree: number, order: number): void {
+    this._centralGravity = new EarthGravity(degree, order);
+  }
+
+  setThirdBodyGravity({ moon = false, sun = false }): void {
+    this._thirdBodyGravity = new ThirdBodyGravity(moon, sun);
+  }
+
+  setSolarRadiationPressure(mass: number, area: number, coeff = 1.2): void {
+    this._solarRadiationPressure = new SolarRadiationPressure(mass, area, coeff);
+  }
+
+  setAtmosphericDrag(mass: number, area: number, coeff = 2.2, cosine = 4): void {
+    this._atmosphericDrag = new AtmosphericDrag(mass, area, coeff, cosine);
+  }
+
+  loadManeuver(maneuver: Thrust): void {
+    this._maneuverThrust = maneuver;
+  }
+
+  clearManeuver(): void {
+    this._maneuverThrust = null;
+  }
+
+  acceleration(state: J2000): Vector3D {
+    let accVec = Vector3D.origin;
+
+    if (this._centralGravity) {
+      accVec = accVec.add(this._centralGravity.acceleration(state));
+    }
+    if (this._thirdBodyGravity) {
+      accVec = accVec.add(this._thirdBodyGravity.acceleration(state));
+    }
+    if (this._solarRadiationPressure) {
+      accVec = accVec.add(this._solarRadiationPressure.acceleration(state));
+    }
+    if (this._atmosphericDrag) {
+      accVec = accVec.add(this._atmosphericDrag.acceleration(state));
+    }
+    if (this._maneuverThrust) {
+      accVec = accVec.add(this._maneuverThrust.acceleration(state));
+    }
+
+    return accVec;
+  }
+
+  derivative(state: J2000): Vector {
+    return state.velocity.join(this.acceleration(state));
+  }
+}

package/src/force/Gravity.ts

@@ -0,0 +1,53 @@
+/**
+ * @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, J2000, Vector3D } from 'ootk-core';
+import { Force } from './Force';
+
+// / Simple central-body gravity model.
+export class Gravity implements Force {
+  // / Gravitational parameter _(km²/s³)_.
+  mu: number;
+
+  /**
+   * Create a new [Gravity] object with optional gravitational
+   * @param mu Gravitational parameter _(km²/s³)_.
+   */
+  constructor(mu: number = Earth.mu) {
+    this.mu = mu;
+  }
+
+  /**
+   * Calculates the gravitational force in spherical coordinates.
+   * @param state The J2000 state containing the position and velocity vectors.
+   * @returns The gravitational force vector in spherical coordinates.
+   */
+  private _spherical(state: J2000): Vector3D {
+    const rMag = state.position.magnitude();
+
+    return state.position.scale(-this.mu / (rMag * rMag * rMag));
+  }
+
+  /**
+   * Calculates the acceleration due to gravity at a given state.
+   * @param state The J2000 state at which to calculate the acceleration.
+   * @returns The acceleration vector.
+   */
+  acceleration(state: J2000): Vector3D {
+    return this._spherical(state);
+  }
+}