ootk 3.0.0 → 4.0.0-1

package/src/orbit_determination/HerrickGibbsIOD.ts

@@ -0,0 +1,51 @@
+/**
+ * @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, Vector3D } from 'ootk-core';
+
+/**
+ * Herrik-Gibbs 3-position initial orbit determination.
+ *
+ * Possibly better than regular Gibbs IOD for closely spaced position
+ * vectors (less than 5°).
+ */
+export class HerrickGibbsIOD {
+  /**
+   * Create a new [HerrickGibbsIOD] object with optional
+   * gravitational parameter [mu].
+   * @param mu Gravitational parameter (default: Earth.mu)
+   */
+  constructor(public mu: number = Earth.mu) {
+    // Nothing to do here.
+  }
+
+  // / Attempt to create a state estimate from three inertial position vectors.
+  solve(r1: Vector3D, t1: EpochUTC, r2: Vector3D<Kilometers>, t2: EpochUTC, r3: Vector3D, t3: EpochUTC): J2000 {
+    const dt31 = t3.difference(t1);
+    const dt32 = t3.difference(t2);
+    const dt21 = t2.difference(t1);
+    const r1m = r1.magnitude();
+    const r2m = r2.magnitude();
+    const r3m = r3.magnitude();
+    const vA = r1.scale(-dt32 * (1.0 / (dt21 * dt31) + this.mu / (12.0 * r1m * r1m * r1m)));
+    const vB = r2.scale((dt32 - dt21) * (1.0 / (dt21 * dt32) + this.mu / (12.0 * r2m * r2m * r2m)));
+    const vC = r3.scale(dt21 * (1.0 / (dt32 * dt31) + this.mu / (12.0 * r3m * r3m * r3m)));
+    const v2 = vA.add(vB).add(vC) as Vector3D<KilometersPerSecond>;
+
+    return new J2000(t2, r2, v2);
+  }
+}

package/src/orbit_determination/LambertIOD.ts

@@ -0,0 +1,260 @@
+/**
+ * @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, Radians, Vector3D } from 'ootk-core';
+
+// / Lambert two-position and time initial orbit determination.
+export class LambertIOD {
+  constructor(public mu: number = Earth.mu) {
+    // Nothing to do here.
+  }
+
+  /**
+   * Try to guess the short path argument given an [interceptor] and
+   * [target] state.
+   * @param interceptor Interceptor
+   * @param target Target
+   * @returns True if the short path should be used, false otherwise.
+   */
+  static useShortPath(interceptor: J2000, target: J2000): boolean {
+    const transN = interceptor.position.cross(target.position);
+    const h = interceptor.position.cross(interceptor.velocity);
+
+    return h.dot(transN) >= 0;
+  }
+
+  private static timeOfFlight_(
+    x: number,
+    longway: number,
+    mrev: number,
+    minSma: number,
+    speri: number,
+    chord: number,
+  ): number {
+    const a = minSma / (1.0 - x * x);
+    let tof: number;
+
+    if (Math.abs(x) < 1) {
+      const beta = longway * 2.0 * Math.asin(Math.sqrt((speri - chord) / (2.0 * a)));
+      const alpha = 2.0 * Math.acos(x);
+
+      tof = a * Math.sqrt(a) * (alpha - Math.sin(alpha) - (beta - Math.sin(beta)) + 2.0 * Math.PI * mrev);
+    } else {
+      const alpha = 2.0 * Math.acosh(x);
+      const beta = longway * 2.0 * Math.asinh(Math.sqrt((speri - chord) / (-2.0 * a)));
+
+      tof = -a * Math.sqrt(-a) * (Math.sinh(alpha) - alpha - (Math.sinh(beta) - beta));
+    }
+
+    return tof;
+  }
+
+  /**
+   * Attempt to solve output velocity [v1] _(km/s)_ given radii [r1] and
+   * [r2] _(canonical)_, sweep angle [dth] _(rad)_, time of flight [tau]
+   * _(canonical)_, and number of revolutions _(mRev)_.
+   * @param r1 Radius 1
+   * @param r2 Radius 2
+   * @param dth Sweep angle
+   * @param tau Time of flight
+   * @param mRev Number of revolutions
+   * @param v1 Output velocity
+   * @returns True if successful, false otherwise.
+   */
+  static solve(r1: number, r2: number, dth: number, tau: number, mRev: number, v1: Float64Array): boolean {
+    const leftBranch = dth < Math.PI;
+    let longway = 1;
+
+    if (dth > Math.PI) {
+      longway = -1;
+    }
+
+    const m = Math.abs(mRev);
+    const rtof = Math.abs(tau);
+    const theta = dth;
+
+    const chord = Math.sqrt(r1 * r1 + r2 * r2 - 2.0 * r1 * r2 * Math.cos(theta));
+    const speri = 0.5 * (r1 + r2 + chord);
+
+    const minSma = 0.5 * speri;
+    const lambda = longway * Math.sqrt(1.0 - chord / speri);
+    const logt = Math.log(rtof);
+
+    let in1: number;
+    let in2: number;
+    let x1: number;
+    let x2: number;
+
+    if (m === 0) {
+      in1 = -0.6523333;
+      in2 = 0.6523333;
+      x1 = Math.log(1.0 + in1);
+      x2 = Math.log(1.0 + in2);
+    } else {
+      if (!leftBranch) {
+        in1 = -0.523334;
+        in2 = -0.223334;
+      } else {
+        in1 = 0.723334;
+        in2 = 0.523334;
+      }
+      x1 = Math.tan((in1 * Math.PI) / 2);
+      x2 = Math.tan((in2 * Math.PI) / 2);
+    }
+    const tof1 = LambertIOD.timeOfFlight_(in1, longway, m, minSma, speri, chord);
+    const tof2 = LambertIOD.timeOfFlight_(in2, longway, m, minSma, speri, chord);
+
+    let y1: number;
+    let y2: number;
+
+    if (m === 0) {
+      y1 = Math.log(tof1) - logt;
+      y2 = Math.log(tof2) - logt;
+    } else {
+      y1 = tof1 - rtof;
+      y2 = tof2 - rtof;
+    }
+    let err = 1e20;
+    let iterations = 0;
+    const tol = 1e-13;
+    const maxiter = 50;
+    let xnew = 0.0;
+
+    while (err > tol && iterations < maxiter) {
+      xnew = (x1 * y2 - y1 * x2) / (y2 - y1);
+      let xt: number;
+
+      if (m === 0) {
+        xt = Math.exp(xnew) - 1.0;
+      } else {
+        xt = (Math.atan(xnew) * 2.0) / Math.PI;
+      }
+
+      const tof = LambertIOD.timeOfFlight_(xt, longway, m, minSma, speri, chord);
+
+      let ynew: number;
+
+      if (m === 0) {
+        ynew = Math.log(tof) - logt;
+      } else {
+        ynew = tof - rtof;
+      }
+
+      x1 = x2;
+      x2 = xnew;
+      y1 = y2;
+      y2 = ynew;
+
+      err = Math.abs(x1 - xnew);
+      ++iterations;
+    }
+
+    if (err > tol) {
+      return false;
+    }
+
+    let x: number;
+
+    if (m === 0) {
+      x = Math.exp(xnew) - 1.0;
+    } else {
+      x = (Math.atan(xnew) * 2.0) / Math.PI;
+    }
+
+    const sma = minSma / (1.0 - x * x);
+
+    let eta: number;
+
+    if (x < 1) {
+      const alfa = 2.0 * Math.acos(x);
+      const beta = longway * 2.0 * Math.asin(Math.sqrt((speri - chord) / (2.0 * sma)));
+      const psi = (alfa - beta) / 2.0;
+      const sinPsi = Math.sin(psi);
+      const etaSq = (2.0 * sma * sinPsi * sinPsi) / speri;
+
+      eta = Math.sqrt(etaSq);
+    } else {
+      const gamma = 2.0 * Math.acosh(x);
+      const delta = longway * 2.0 * Math.asinh(Math.sqrt((chord - speri) / (2.0 * sma)));
+      const psi = (gamma - delta) / 2.0;
+      const sinhPsi = Math.sinh(psi);
+      const etaSq = (-2.0 * sma * sinhPsi * sinhPsi) / speri;
+
+      eta = Math.sqrt(etaSq);
+    }
+
+    const vr1 = (1.0 / eta) * Math.sqrt(1.0 / minSma) * ((2.0 * lambda * minSma) / r1 - (lambda + x * eta));
+    const vt1 = (1.0 / eta) * Math.sqrt(1.0 / minSma) * Math.sqrt(r2 / r1) * Math.sin(dth / 2.0);
+
+    v1[0] = vr1;
+    v1[1] = vt1;
+
+    return true;
+  }
+
+  /**
+   * Estimate a state vector for inertial position [p1] _(km)_ given the
+   * two epoch and positions.
+   * @param p1 Position vector 1
+   * @param p2 Position vector 2
+   * @param t1 Epoch 1
+   * @param t2 Epoch 2
+   * @param root0 Optional parameters
+   * @param root0.posigrade If true, use the positive root (default: true)
+   * @param root0.nRev Number of revolutions (default: 0)
+   * @returns A [J2000] object with the estimated state vector.
+   */
+  estimate(
+    p1: Vector3D<Kilometers>,
+    p2: Vector3D<Kilometers>,
+    t1: EpochUTC,
+    t2: EpochUTC,
+    { posigrade = true, nRev = 0 }: { posigrade?: boolean; nRev?: number } = {},
+  ): J2000 | null {
+    const r1 = p1.magnitude();
+    const r2 = p2.magnitude();
+    const tof = t2.difference(t1);
+
+    const r = Math.max(r1, r2);
+    const v = Math.sqrt(this.mu / r);
+    const t = r / v;
+
+    let dth = p1.angle(p2);
+
+    if (!posigrade) {
+      dth = 2 * Math.PI - dth as Radians;
+    }
+
+    const vDep = new Float64Array(2);
+    const exitFlag = LambertIOD.solve(r1 / r, r2 / r, dth, tof / t, nRev, vDep);
+
+    if (exitFlag) {
+      const pn = p1.cross(p2);
+      const pt = pn.cross(p1);
+      let rt = pt.magnitude();
+
+      if (!posigrade) {
+        rt = -rt as Kilometers;
+      }
+      const vel1 = p1.scale((v * vDep[0]) / r1).add(pt.scale((v * vDep[1]) / rt)) as Vector3D<KilometersPerSecond>;
+
+      return new J2000(t1, p1, vel1);
+    }
+
+    return null;
+  }
+}

package/src/orbit_determination/ModifiedGoodingIOD.ts

@@ -0,0 +1,133 @@
+/**
+ * @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, RadecTopocentric, Vector3D } from 'ootk-core';
+import { ForceModel } from '../force/ForceModel';
+import { RungeKutta89Propagator } from '../propagator/RungeKutta89Propagator';
+import { ObservationOptical } from './../observation/ObservationOptical';
+import { DownhillSimplex } from './../optimize/DownhillSimplex';
+import { CostFunction } from './../optimize/SimplexEntry';
+import { GoodingIOD } from './GoodingIOD';
+
+type SolveOptions = {
+  nRev?: number;
+  direction?: boolean;
+  posSearch?: number;
+  velSearch?: number;
+  tolerance?: number;
+  printIter?: boolean;
+};
+
+/**
+ * Gooding angles-only initial orbit determination.
+ *
+ * Used for orbit determination from multiple optical observations.
+ */
+export class ModifiedGoodingIOD {
+  private observations_: ObservationOptical[];
+  private mu_: number;
+
+  constructor(observations: ObservationOptical[], mu: number = Earth.mu) {
+    this.observations_ = observations;
+    this.mu_ = mu;
+  }
+
+  private createInitial_(r0: Kilometers, rN: Kilometers, nRev: number, direction: boolean): J2000 {
+    const iod = new GoodingIOD(
+      this.observations_[0],
+      this.observations_[Math.floor(this.observations_.length / 2)],
+      this.observations_[this.observations_.length - 1],
+      this.mu_,
+    );
+
+    return iod.solve(r0, rN, nRev, direction);
+  }
+
+  private _createErrorFunction(aprioriEpoch: EpochUTC): CostFunction {
+    const forceModel = new ForceModel().setGravity(this.mu_);
+    const scoreFn = (x: Float64Array): number => {
+      const position = new Vector3D(x[0] as Kilometers, x[1] as Kilometers, x[2] as Kilometers);
+      const velocity = new Vector3D(
+        x[3] as KilometersPerSecond,
+        x[4] as KilometersPerSecond,
+        x[5] as KilometersPerSecond,
+      );
+      const state = new J2000(aprioriEpoch, position, velocity);
+      const propagator = new RungeKutta89Propagator(state, forceModel);
+      let total = 0;
+
+      for (const oC of this.observations_) {
+        const sC = propagator.propagate(oC.epoch);
+        const pC = oC.site;
+        const expected = oC.observation.lineOfSight();
+        const actual = RadecTopocentric.fromStateVector(sC, pC).lineOfSight();
+        const error = expected.angle(actual);
+
+        total += error;
+      }
+
+      return total;
+    };
+
+    return scoreFn;
+  }
+
+  solve(
+    r0: Kilometers,
+    rN: Kilometers,
+    {
+      nRev = 0,
+      direction = true,
+      posSearch = 10.0,
+      velSearch = 0.1,
+      tolerance = 1e-6,
+      printIter = false,
+    }: SolveOptions,
+  ): J2000 {
+    if (this.observations_.length < 3) {
+      throw new Error('At least 3 observations required for Gooding IOD.');
+    }
+    const init = this.createInitial_(r0, rN, nRev, direction);
+    const guess = Float64Array.from([...init.position.toArray(), ...init.velocity.toArray()]);
+    const solveFn = this._createErrorFunction(init.epoch);
+    const simplex = [
+      Float64Array.from(guess),
+      Float64Array.from([guess[0] + posSearch, guess[1], guess[2], guess[3], guess[4], guess[5]]),
+      Float64Array.from([guess[0], guess[1] + posSearch, guess[2], guess[3], guess[4], guess[5]]),
+      Float64Array.from([guess[0], guess[1], guess[2] + posSearch, guess[3], guess[4], guess[5]]),
+      Float64Array.from([guess[0], guess[1], guess[2], guess[3] + velSearch, guess[4], guess[5]]),
+      Float64Array.from([guess[0], guess[1], guess[2], guess[3], guess[4] + velSearch, guess[5]]),
+      Float64Array.from([guess[0], guess[1], guess[2], guess[3], guess[4], guess[5] + velSearch]),
+    ];
+    const result = DownhillSimplex.solveSimplex(solveFn, simplex, {
+      adaptive: true,
+      xTolerance: tolerance,
+      fTolerance: tolerance,
+      printIter,
+    });
+
+    return new J2000(
+      init.epoch,
+      new Vector3D(result[0] as Kilometers, result[1] as Kilometers, result[2] as Kilometers),
+      new Vector3D(
+        result[3] as KilometersPerSecond,
+        result[4] as KilometersPerSecond,
+        result[5] as KilometersPerSecond,
+      ),
+    );
+  }
+}

package/src/propagator/DormandPrince54Propagator.ts

@@ -0,0 +1,73 @@
+/**
+ * @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 { RungeKuttaAdaptive } from './RungeKuttaAdaptive';
+
+export class DormandPrince54Propagator extends RungeKuttaAdaptive {
+  private _a: Float64Array = Float64Array.from([0.0, 1.0 / 5.0, 3.0 / 10.0, 4.0 / 5.0, 8.0 / 9.0, 1.0, 1.0]);
+
+  private _b: Float64Array[] = [
+    new Float64Array(),
+    Float64Array.from([1.0 / 5.0]),
+    Float64Array.from([3.0 / 40.0, 9.0 / 40.0]),
+    Float64Array.from([44.0 / 45.0, -56.0 / 15.0, 32.0 / 9.0]),
+    Float64Array.from([19372.0 / 6561.0, -25360.0 / 2187.0, 64448.0 / 6561.0, -212.0 / 729.0]),
+    Float64Array.from([9017.0 / 3168.0, -355.0 / 33.0, 46732.0 / 5247.0, 49.0 / 176.0, -5103.0 / 18656.0]),
+    Float64Array.from([35.0 / 384.0, 0.0, 500.0 / 1113.0, 125.0 / 192.0, -2187.0 / 6784.0, 11.0 / 84.0]),
+  ];
+
+  private _ch: Float64Array = Float64Array.from([
+    35.0 / 384.0,
+    0.0,
+    500.0 / 1113.0,
+    125.0 / 192.0,
+    -2187.0 / 6784.0,
+    11.0 / 84.0,
+    0.0,
+  ]);
+
+  private _c: Float64Array = Float64Array.from([
+    5179.0 / 57600.0,
+    0.0,
+    7571.0 / 16695.0,
+    393.0 / 640.0,
+    -92097.0 / 339200.0,
+    187.0 / 2100.0,
+    1.0 / 40.0,
+  ]);
+
+  get a(): Float64Array {
+    return this._a;
+  }
+
+  get b(): Float64Array[] {
+    return this._b;
+  }
+
+  get ch(): Float64Array {
+    return this._ch;
+  }
+
+  get c(): Float64Array {
+    return this._c;
+  }
+
+  get order(): number {
+    return 5;
+  }
+}

package/src/propagator/KeplerPropagator.ts

@@ -0,0 +1,102 @@
+/**
+ * @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 { ClassicalElements, EpochUTC, J2000, Seconds } from 'ootk-core';
+import { Thrust } from '../force/Thrust';
+import { VerletBlendInterpolator } from '../interpolator/VerletBlendInterpolator';
+import { Propagator } from './Propagator';
+
+// / Kepler analytical two-body propagator.
+export class KeplerPropagator extends Propagator {
+  private _initElements: ClassicalElements;
+  private _elements: ClassicalElements;
+  private _cacheState: J2000;
+  private _checkpoints: J2000[];
+
+  constructor(initElements: ClassicalElements) {
+    super();
+    this._initElements = initElements;
+    this._elements = initElements;
+    this._cacheState = J2000.fromClassicalElements(initElements);
+    this._checkpoints = [];
+  }
+
+  get state(): J2000 {
+    return this._cacheState;
+  }
+
+  propagate(epoch: EpochUTC): J2000 {
+    this._cacheState = J2000.fromClassicalElements(this._elements.propagate(epoch));
+
+    return this._cacheState;
+  }
+
+  reset(): void {
+    this._elements = this._initElements;
+    this._cacheState = J2000.fromClassicalElements(this._elements);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  maneuver(maneuver: Thrust, interval = 60): J2000[] {
+    this._cacheState = maneuver.apply(this.propagate(maneuver.center));
+    this._elements = this._cacheState.toClassicalElements();
+
+    return [this._cacheState];
+  }
+
+  ephemerisManeuver(start: EpochUTC, finish: EpochUTC, maneuvers: Thrust[], interval = 60.0): VerletBlendInterpolator {
+    const tMvr = maneuvers.slice(0).filter((mvr) => mvr.center >= start || mvr.center <= finish);
+    const ephemeris: J2000[] = [];
+
+    if (tMvr[0].start > start) {
+      ephemeris.push(this.propagate(start));
+    }
+    for (const mvr of tMvr) {
+      while (this._cacheState.epoch < mvr.center) {
+        const step = Math.min(mvr.center.difference(this._cacheState.epoch), interval) as Seconds;
+
+        this.propagate(this._cacheState.epoch.roll(step));
+        if (this._cacheState.epoch.posix !== mvr.center.posix) {
+          ephemeris.push(this._cacheState);
+        }
+      }
+      ephemeris.push(...this.maneuver(mvr, interval));
+    }
+    while (this._cacheState.epoch < finish) {
+      const step = Math.min(finish.difference(this._cacheState.epoch), interval) as Seconds;
+
+      this.propagate(this._cacheState.epoch.roll(step));
+      ephemeris.push(this._cacheState);
+    }
+
+    return new VerletBlendInterpolator(ephemeris);
+  }
+
+  checkpoint(): number {
+    this._checkpoints.push(this._cacheState);
+
+    return this._checkpoints.length - 1;
+  }
+
+  clearCheckpoints(): void {
+    this._checkpoints = [];
+  }
+
+  restore(index: number): void {
+    this._cacheState = this._checkpoints[index];
+  }
+}