ootk 4.0.0-0 → 4.0.0-2

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

package/src/force/SolarRadiationPressure.ts

@@ -0,0 +1,42 @@
+/**
+ * @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 { astronomicalUnit, J2000, Sun, Vector3D } from 'ootk-core';
+import { Force } from './Force';
+
+// / Solar radiation pressure model.
+export class SolarRadiationPressure extends Force {
+  // / Create a new [SolarRadiationPressure] object.
+  constructor(public mass: number, public area: number, public reflectCoeff: number) {
+    super();
+  }
+
+  // / Solar pressure _(N/m²)_;
+  private static readonly _kRef: number = 4.56e-6 * astronomicalUnit ** 2;
+
+  acceleration(state: J2000): Vector3D {
+    const rSun = Sun.positionApparent(state.epoch);
+    const r = state.position.subtract(rSun);
+    const rMag = r.magnitude();
+    const r2 = rMag * rMag;
+    const ratio = Sun.lightingRatio(state.position, rSun);
+    const p = (ratio * SolarRadiationPressure._kRef) / r2;
+    const flux = r.scale(p / rMag);
+
+    return flux.scale(((this.area * this.reflectCoeff) / this.mass) * 1e-3);
+  }
+}

package/src/force/ThirdBodyGravity.ts

@@ -0,0 +1,62 @@
+/**
+ * @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, Moon, Sun, Vector3D } from 'ootk-core';
+import { Force } from './Force';
+
+// / Third-body gravity model.
+export class ThirdBodyGravity implements Force {
+  // / Create a new [ThirdBodyGravity] object with the selected bodies enabled.
+  constructor(public moon: boolean = false, public sun: boolean = false) {
+    // Nothing to do here.
+  }
+
+  private static _moonGravity(state: J2000): Vector3D {
+    const rMoon = Moon.eci(state.epoch);
+    const aNum = rMoon.subtract(state.position);
+    const aDen = aNum.magnitude() ** 3;
+    const bNum = rMoon;
+    const bDen = rMoon.magnitude() ** 3;
+    const gravity = aNum.scale(1 / aDen).add(bNum.scale(-1 / bDen));
+
+    return gravity.scale(Moon.mu);
+  }
+
+  private static _sunGravity(state: J2000): Vector3D {
+    const rSun = Sun.positionApparent(state.epoch);
+    const aNum = rSun.subtract(state.position);
+    const aDen = aNum.magnitude() ** 3;
+    const bNum = rSun;
+    const bDen = rSun.magnitude() ** 3;
+    const gravity = aNum.scale(1 / aDen).add(bNum.scale(-1 / bDen));
+
+    return gravity.scale(Sun.mu);
+  }
+
+  acceleration(state: J2000): Vector3D {
+    let accVec = Vector3D.origin;
+
+    if (this.moon) {
+      accVec = accVec.add(ThirdBodyGravity._moonGravity(state));
+    }
+    if (this.sun) {
+      accVec = accVec.add(ThirdBodyGravity._sunGravity(state));
+    }
+
+    return accVec;
+  }
+}

package/src/force/Thrust.ts

@@ -0,0 +1,83 @@
+/**
+ * @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 {
+  EpochUTC,
+  J2000,
+  Kilometers,
+  KilometersPerSecond,
+  MetersPerSecond,
+  RIC,
+  Seconds,
+  SecondsPerMeterPerSecond,
+  Vector3D,
+} from 'ootk-core';
+import { Force } from './Force';
+
+// / Thrust force model.
+export class Thrust implements Force {
+  constructor(
+    public center: EpochUTC,
+    public radial: MetersPerSecond,
+    public intrack: MetersPerSecond,
+    public crosstrack: MetersPerSecond,
+    public durationRate = 0.0 as SecondsPerMeterPerSecond,
+  ) {
+    this.deltaV = new Vector3D<KilometersPerSecond>(
+      radial * 1e-3 as KilometersPerSecond,
+      intrack * 1e-3 as KilometersPerSecond,
+      crosstrack * 1e-3 as KilometersPerSecond,
+    );
+  }
+
+  deltaV: Vector3D<KilometersPerSecond>;
+
+  get magnitude(): MetersPerSecond {
+    return this.deltaV.magnitude() * 1000.0 as MetersPerSecond;
+  }
+
+  get duration(): Seconds {
+    return this.magnitude * this.durationRate as Seconds;
+  }
+
+  get start(): EpochUTC {
+    return this.center.roll(-0.5 * this.duration as Seconds);
+  }
+
+  get stop(): EpochUTC {
+    return this.center.roll(0.5 * this.duration as Seconds);
+  }
+
+  acceleration(state: J2000): Vector3D {
+    const relative = new RIC(
+      Vector3D.origin as Vector3D<Kilometers>,
+      this.deltaV.scale(1.0 / this.duration as KilometersPerSecond),
+    );
+
+    return relative.toJ2000(state).velocity.subtract(state.velocity);
+  }
+
+  apply(state: J2000): J2000 {
+    const relative = new RIC(Vector3D.origin as Vector3D<Kilometers>, this.deltaV);
+
+    return relative.toJ2000(state);
+  }
+
+  get isImpulsive(): boolean {
+    return this.duration <= 0;
+  }
+}

package/src/interfaces/RfSensorParams.ts

@@ -0,0 +1,30 @@
+/**
+ * @author Theodore Kruczek.
+ * @license MIT
+ * @copyright (c) 2022-2024 Theodore Kruczek Permission is
+ * hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the "Software"), to deal in the
+ * Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Degrees, SensorParams } from 'ootk-core';
+
+export interface RfSensorParams extends SensorParams {
+  coneHalfAngle: Degrees;
+  boresightAz: Degrees;
+  boresightEl: Degrees;
+}

package/src/interfaces/index.ts

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