ootk 1.0.3 → 1.0.7

package/asc/assembly/index.ts

@@ -0,0 +1,1143 @@
+const PI: f64 = Math.PI;
+const TAU: f64 = PI * 2;
+const DEG2RAD: f64 = PI / 180.0;
+
+class StateVector {
+  error: f64;
+  p1: f64;
+  p2: f64;
+  p3: f64;
+  v1: f64;
+  v2: f64;
+  v3: f64;
+}
+
+class DspaceResults {
+  atime: f64 = atime;
+  em: f64 = em;
+  argpm: f64 = argpm;
+  inclm: f64 = inclm;
+  xli: f64 = xli;
+  mm: f64 = mm;
+  xni: f64 = xni;
+  nodem: f64 = nodem;
+  dndt: f64 = dndt;
+  nm: f64 = nm;
+  constructor(
+    atime: f64,
+    em: f64,
+    argpm: f64,
+    inclm: f64,
+    xli: f64,
+    mm: f64,
+    xni: f64,
+    nodem: f64,
+    dndt: f64,
+    nm: f64,
+  ) {
+    this.atime = atime;
+    this.em = em;
+    this.argpm = argpm;
+    this.inclm = inclm;
+    this.xli = xli;
+    this.mm = mm;
+    this.xni = xni;
+    this.nodem = nodem;
+    this.dndt = dndt;
+    this.nm = nm;
+  }
+}
+
+class DpperResult {
+  ep: f64;
+  inclp: f64;
+  nodep: f64;
+  argpp: f64;
+  mp: f64;
+  constructor(ep: f64, inclp: f64, nodep: f64, argpp: f64, mp: f64) {
+    this.ep = ep;
+    this.inclp = inclp;
+    this.nodep = nodep;
+    this.argpp = argpp;
+    this.mp = mp;
+  }
+}
+
+/*----------------------------------------------------------------------------
+ *
+ *                             procedure sgp4
+ *
+ *  this procedure is the sgp4 prediction model from space command. this is an
+ *    updated and combined version of sgp4 and sdp4, which were originally
+ *    published separately in spacetrack report //3. this version follows the
+ *    methodology from the aiaa paper (2006) describing the history and
+ *    development of the code.
+ *
+ *  author        : david vallado                  719-573-2600   28 jun 2005
+ *
+ *  inputs        :
+ *    satrec  - initialised structure from sgp4init() call.
+ *    tsince  - time since epoch (minutes)
+ *
+ *  outputs       :
+ *    r           - position vector                     km
+ *    v           - velocity                            km/sec
+ *  return code - non-zero on error.
+ *                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
+ *                   2 - mean motion less than 0.0
+ *                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
+ *                   4 - semi-latus rectum < 0.0
+ *                   5 - epoch elements are sub-orbital
+ *                   6 - satellite has decayed
+ *
+ *  locals        :
+ *    am          -
+ *    axnl, aynl        -
+ *    betal       -
+ *    cosim   , sinim   , cosomm  , sinomm  , cnod    , snod    , cos2u   ,
+ *    sin2u   , coseo1  , sineo1  , cosi    , sini    , cosip   , sinip   ,
+ *    cosisq  , cossu   , sinsu   , cosu    , sinu
+ *    delm        -
+ *    delomg      -
+ *    dndt        -
+ *    eccm        -
+ *    emsq        -
+ *    ecose       -
+ *    el2         -
+ *    eo1         -
+ *    eccp        -
+ *    esine       -
+ *    argpm       -
+ *    argpp       -
+ *    omgadf      -
+ *    pl          -
+ *    r           -
+ *    rtemsq      -
+ *    rdotl       -
+ *    rl          -
+ *    rvdot       -
+ *    rvdotl      -
+ *    su          -
+ *    t2  , t3   , t4    , tc
+ *    tem5, temp , temp1 , temp2  , tempa  , tempe  , templ
+ *    u   , ux   , uy    , uz     , vx     , vy     , vz
+ *    inclm       - inclination
+ *    mm          - mean anomaly
+ *    nm          - mean motion
+ *    nodem       - right asc of ascending node
+ *    xinc        -
+ *    xincp       -
+ *    xl          -
+ *    xlm         -
+ *    mp          -
+ *    xmdf        -
+ *    xmx         -
+ *    xmy         -
+ *    nodedf      -
+ *    xnode       -
+ *    nodep       -
+ *    np          -
+ *
+ *  coupling      :
+ *    getgravconst-
+ *    dpper
+ *    dspace
+ *
+ *  references    :
+ *    hoots, roehrich, norad spacetrack report //3 1980
+ *    hoots, norad spacetrack report //6 1986
+ *    hoots, schumacher and glover 2004
+ *    vallado, crawford, hujsak, kelso  2006
+ ----------------------------------------------------------------------------*/
+
+/* -----------------------------------------------------------------------------
+  *
+  *                           function getgravconst
+  *
+  *  this function gets constants for the propagator. note that mu is identified to
+  *    facilitiate comparisons with newer models. the common useage is wgs72.
+  *
+  *  author        : david vallado                  719-573-2600   21 jul 2006
+  *
+  *  inputs        :
+  *    whichconst  - which set of constants to use  wgs72old, wgs72, wgs84
+  *
+  *  outputs       :
+  *    tumin       - minutes in one time unit
+  *    mu          - earth gravitational parameter
+  *    radiusearthkm - radius of the earth in km
+  *    xke         - reciprocal of tumin
+  *    j2, j3, j4  - un-normalized zonal harmonic values
+  *    j3oj2       - j3 divided by j2
+  *
+  *  locals        :
+  *
+  *  coupling      :
+  *    none
+  *
+  *  references    :
+  *    norad spacetrack report #3
+  *    vallado, crawford, hujsak, kelso  2006
+  --------------------------------------------------------------------------- */
+export function propagate(
+  a: f64,
+  am: f64,
+  alta: f64,
+  altp: f64,
+  argpdot: f64,
+  argpo: f64,
+  aycof: f64,
+  bstar: f64,
+  cc1: f64,
+  cc4: f64,
+  cc5: f64,
+  con41: f64,
+  d2: f64,
+  d3: f64,
+  d4: f64,
+  d5232: f64,
+  d5421: f64,
+  d5433: f64,
+  dedt: f64,
+  delmo: f64,
+  del1: f64,
+  ecco: f64,
+  em: f64,
+  epochdays: f64,
+  epochyr: f64,
+  error: f64,
+  eta: f64,
+  gsto: f64,
+  im: f64,
+  inclo: f64,
+  init: string,
+  isimp: f64,
+  jdsatepoch: f64,
+  mdot: f64,
+  method: string,
+  mo: f64,
+  mm: f64,
+  nddot: f64,
+  ndot: f64,
+  no: f64,
+  nodecf: f64,
+  nodedot: f64,
+  nodeo: f64,
+  om: f64,
+  Om: f64,
+  omgcof: f64,
+  operationmode: string,
+  satnum: string,
+  sinmao: f64,
+  t: f64,
+  t2cof: f64,
+  t3cof: f64,
+  t4cof: f64,
+  t5cof: f64,
+  x1mth2: f64,
+  x7thm1: f64,
+  xlcof: f64,
+  xmcof: f64,
+  xfact: f64,
+  xlamo: f64,
+  xli: f64,
+  xgh4: f64,
+  xgh3: f64,
+  xh2: f64,
+  xi2: f64,
+  xi3: f64,
+  xl2: f64,
+  xl3: f64,
+  xl4: f64,
+  zmol: f64,
+  zmos: f64,
+  dmdt: f64,
+  dnodt: f64,
+  domdt: f64,
+  e3: f64,
+  ee2: f64,
+  peo: f64,
+  pgho: f64,
+  pho: f64,
+  PInco: f64,
+  plo: f64,
+  se2: f64,
+  se3: f64,
+  sgh2: f64,
+  sgh3: f64,
+  sgh4: f64,
+  sh2: f64,
+  sh3: f64,
+  si2: f64,
+  si3: f64,
+  sl2: f64,
+  sl3: f64,
+  sl4: f64,
+  xgh2: f64,
+  xh3: f64,
+  tumin: f64,
+  radiusearthkm: f64,
+  irez: f64,
+  d3210: f64,
+  d3222: f64,
+  d4410: f64,
+  d4422: f64,
+  d5220: f64,
+  del2: f64,
+  del3: f64,
+  didt: f64,
+  atime: f64,
+  j2: f64,
+  j3: f64,
+  j4: f64,
+  mus: f64,
+  xke: f64,
+  j3oj2: f64,
+  xni: f64,
+  d2201: f64,
+  d2211: f64,
+  nm: f64,
+  tsince: f64,
+): StateVector {
+  /* ------------------ set mathematical constants --------------- */
+  // sgp4fix divisor for divide by zero check on inclination
+  // the old check used 1.0 + cos(PI-1.0e-9), but then compared it to
+  // 1.5 e-12, so the threshold was changed to 1.5e-12 for consistency
+
+  const x2o3 = 2.0 / 3.0;
+  const temp4 = 1.5e-12;
+
+  // sgp4fix identify constants and allow alternate values
+  // getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+  const vkmpersec = (radiusearthkm * xke) / 60.0;
+
+  // --------------------- clear sgp4 error flag -----------------
+  t = tsince;
+  error = 0;
+
+  //  ------- update for secular gravity and atmospheric drag -----
+  let xmdf = mo + mdot * t;
+  let argpdf = argpo + argpdot * t;
+  let nodedf = nodeo + nodedot * t;
+  let argpm = argpdf;
+  let mm = xmdf;
+  let t2 = t * t;
+  let nodem = nodedf + nodecf * t2;
+  let tempa = 1.0 - cc1 * t;
+  let tempe = bstar * cc4 * t;
+  let templ = t2cof * t2;
+
+  if (isimp !== 1) {
+    let delomg = omgcof * t;
+    //  sgp4fix use mutliply for speed instead of pow
+    let delmtemp = 1.0 + eta * Math.cos(xmdf);
+    let delm = xmcof * (delmtemp * delmtemp * delmtemp - delmo);
+    let temp = delomg + delm;
+    mm = xmdf + temp;
+    argpm = argpdf - temp;
+    let t3 = t2 * t;
+    let t4 = t3 * t;
+    tempa = tempa - d2 * t2 - d3 * t3 - d4 * t4;
+    tempe += bstar * cc5 * (Math.sin(mm) - sinmao);
+    templ = templ + t3cof * t3 + t4 * (t4cof + t * t5cof);
+  }
+  let nm = no;
+  let em = ecco;
+  let inclm = inclo;
+  if (method === 'd') {
+    let tc = t;
+
+    const dspaceResult = dspace(
+      irez,
+      d2201,
+      d2211,
+      d3210,
+      d3222,
+      d4410,
+      d4422,
+      d5220,
+      d5232,
+      d5421,
+      d5433,
+      dedt,
+      del1,
+      del2,
+      del3,
+      didt,
+      dmdt,
+      dnodt,
+      domdt,
+      argpo,
+      argpdot,
+      t,
+      tc,
+      gsto,
+      xfact,
+      xlamo,
+      no,
+      atime,
+      em,
+      argpm,
+      inclm,
+      xli,
+      mm,
+      xni,
+      nodem,
+      nm,
+    );
+
+    em = dspaceResult.em;
+    argpm = dspaceResult.argpm;
+    inclm = dspaceResult.inclm;
+    mm = dspaceResult.mm;
+    nodem = dspaceResult.nodem;
+    nm = dspaceResult.nm;
+  } // if methjod = d
+
+  if (nm <= 0.0) {
+    // printf("// error nm %f\n", nm);
+    error = 2;
+    // sgp4fix add return
+    return {
+      error: error,
+      p1: 0.0,
+      p2: 0.0,
+      p3: 0.0,
+      v1: 0.0,
+      v2: 0.0,
+      v3: 0.0,
+    };
+  }
+
+  let am = (xke / nm) ** x2o3 * tempa * tempa;
+  nm = xke / am ** 1.5;
+  em -= tempe;
+
+  // fix tolerance for error recognition
+  // sgp4fix am is fixed from the previous nm check
+  /* istanbul ignore next | This is no longer possible*/
+  if (em >= 1.0 || em < -0.001) {
+    // || (am < 0.95)
+    // printf("// error em %f\n", em);
+    error = 1;
+    // sgp4fix to return if there is an error in eccentricity
+    return {
+      error: error,
+      p1: 0.0,
+      p2: 0.0,
+      p3: 0.0,
+      v1: 0.0,
+      v2: 0.0,
+      v3: 0.0,
+    };
+  }
+
+  //  sgp4fix fix tolerance to avoid a divide by zero
+  if (em < 1.0e-6) {
+    em = 1.0e-6;
+  }
+  mm += no * templ;
+  let xlm = mm + argpm + nodem;
+
+  nodem %= TAU;
+  argpm %= TAU;
+  xlm %= TAU;
+  mm = (xlm - argpm - nodem) % TAU;
+
+  // sgp4fix recover singly averaged mean elements
+  am = am;
+  em = em;
+  im = inclm;
+  Om = nodem;
+  om = argpm;
+  mm = mm;
+  nm = nm;
+
+  // ----------------- compute extra mean quantities -------------
+  let sinim = Math.sin(inclm);
+  let cosim = Math.cos(inclm);
+
+  // -------------------- add lunar-solar periodics --------------
+  let ep = em;
+  let xincp = inclm;
+  let argpp = argpm;
+  let nodep = nodem;
+  let mp = mm;
+  let sinip = sinim;
+  let cosip = cosim;
+  if (method === 'd') {
+    const dpperResult = dpper(
+      e3,
+      ee2,
+      peo,
+      pgho,
+      pho,
+      PInco,
+      plo,
+      se2,
+      se3,
+      sgh2,
+      sgh3,
+      sgh4,
+      sh2,
+      sh3,
+      si2,
+      si3,
+      sl2,
+      sl3,
+      sl4,
+      t,
+      xgh2,
+      xgh3,
+      xgh4,
+      xh2,
+      xh3,
+      xi2,
+      xi3,
+      xl2,
+      xl3,
+      xl4,
+      zmol,
+      zmos,
+      ep,
+      xincp,
+      nodep,
+      argpp,
+      mp,
+      operationmode,
+      'n',
+    );
+
+    ep = dpperResult.ep;
+    xincp = dpperResult.inclp;
+    nodep = dpperResult.nodep;
+    argpp = dpperResult.argpp;
+    mp = dpperResult.mp;
+
+    if (xincp < 0.0) {
+      xincp = -xincp;
+      nodep += PI;
+      argpp -= PI;
+    }
+    if (ep < 0.0 || ep > 1.0) {
+      //  printf("// error ep %f\n", ep);
+      error = 3;
+      //  sgp4fix add return
+      return {
+        error: error,
+        p1: 0.0,
+        p2: 0.0,
+        p3: 0.0,
+        v1: 0.0,
+        v2: 0.0,
+        v3: 0.0,
+      };
+    }
+  }
+
+  //  -------------------- long period periodics ------------------
+  if (method === 'd') {
+    sinip = Math.sin(xincp);
+    cosip = Math.cos(xincp);
+    aycof = -0.5 * j3oj2 * sinip;
+
+    //  sgp4fix for divide by zero for xincp = 180 deg
+    /* istanbul ignore next | This is no longer possible*/
+    if (Math.abs(cosip + 1.0) > 1.5e-12) {
+      xlcof = (-0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip)) / (1.0 + cosip);
+    } else {
+      xlcof = (-0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip)) / temp4;
+    }
+  }
+
+  let axnl = ep * Math.cos(argpp);
+  let temp = 1.0 / (am * (1.0 - ep * ep));
+  let aynl = ep * Math.sin(argpp) + temp * aycof;
+  let xl = mp + argpp + nodep + temp * xlcof * axnl;
+
+  // --------------------- solve kepler's equation ---------------
+  let u = (xl - nodep) % TAU;
+  let eo1 = u;
+  let tem5 = 9999.9;
+  let ktr = 1;
+  //    sgp4fix for kepler iteration
+  //    the following iteration needs better limits on corrections
+  let sineo1: f64;
+  let coseo1: f64;
+  while (Math.abs(tem5) >= 1.0e-12 && ktr <= 10) {
+    sineo1 = Math.sin(eo1);
+    coseo1 = Math.cos(eo1);
+    tem5 = 1.0 - coseo1 * axnl - sineo1 * aynl;
+    tem5 = (u - aynl * coseo1 + axnl * sineo1 - eo1) / tem5;
+    if (Math.abs(tem5) >= 0.95) {
+      if (tem5 > 0.0) {
+        tem5 = 0.95;
+      } else {
+        tem5 = -0.95;
+      }
+    }
+    eo1 += tem5;
+    ktr += 1;
+  }
+
+  //  ------------- short period preliminary quantities -----------
+  let ecose = axnl * coseo1 + aynl * sineo1;
+  let esine = axnl * sineo1 - aynl * coseo1;
+  let el2 = axnl * axnl + aynl * aynl;
+  let pl = am * (1.0 - el2);
+  if (pl < 0.0) {
+    //  printf("// error pl %f\n", pl);
+    error = 4;
+    //  sgp4fix add return
+    return {
+      error: error,
+      p1: 0.0,
+      p2: 0.0,
+      p3: 0.0,
+      v1: 0.0,
+      v2: 0.0,
+      v3: 0.0,
+    };
+  }
+
+  let rl = am * (1.0 - ecose);
+  let rdotl = (Math.sqrt(am) * esine) / rl;
+  let rvdotl = Math.sqrt(pl) / rl;
+  let betal = Math.sqrt(1.0 - el2);
+  temp = esine / (1.0 + betal);
+  let sinu = (am / rl) * (sineo1 - aynl - axnl * temp);
+  let cosu = (am / rl) * (coseo1 - axnl + aynl * temp);
+  let su = Math.atan2(sinu, cosu);
+  let sin2u = (cosu + cosu) * sinu;
+  let cos2u = 1.0 - 2.0 * sinu * sinu;
+  temp = 1.0 / pl;
+  let temp1 = 0.5 * j2 * temp;
+  let temp2 = temp1 * temp;
+
+  // -------------- update for short period periodics ------------
+  if (method === 'd') {
+    let cosisq = cosip * cosip;
+    con41 = 3.0 * cosisq - 1.0;
+    x1mth2 = 1.0 - cosisq;
+    x7thm1 = 7.0 * cosisq - 1.0;
+  }
+
+  let mrt = rl * (1.0 - 1.5 * temp2 * betal * con41) + 0.5 * temp1 * x1mth2 * cos2u;
+
+  /** Moved this up to reduce unnecessary computation if you are going to return false anyway */
+  // sgp4fix for decaying satellites
+  if (mrt < 1.0) {
+    // printf("// decay condition %11.6f \n",mrt);
+    error = 6;
+    return {
+      error: error,
+      p1: 0.0,
+      p2: 0.0,
+      p3: 0.0,
+      v1: 0.0,
+      v2: 0.0,
+      v3: 0.0,
+    };
+  }
+
+  su -= 0.25 * temp2 * x7thm1 * sin2u;
+  let xnode = nodep + 1.5 * temp2 * cosip * sin2u;
+  let xinc = xincp + 1.5 * temp2 * cosip * sinip * cos2u;
+  let mvt = rdotl - (nm * temp1 * x1mth2 * sin2u) / xke;
+  let rvdot = rvdotl + (nm * temp1 * (x1mth2 * cos2u + 1.5 * con41)) / xke;
+
+  // --------------------- orientation vectors -------------------
+  let sinsu = Math.sin(su);
+  let cossu = Math.cos(su);
+  let snod = Math.sin(xnode);
+  let cnod = Math.cos(xnode);
+  let sini = Math.sin(xinc);
+  let cosi = Math.cos(xinc);
+  let xmx = -snod * cosi;
+  let xmy = cnod * cosi;
+  let ux = xmx * sinsu + cnod * cossu;
+  let uy = xmy * sinsu + snod * cossu;
+  let uz = sini * sinsu;
+  let vx = xmx * cossu - cnod * sinsu;
+  let vy = xmy * cossu - snod * sinsu;
+  let vz = sini * cossu;
+
+  // --------- position and velocity (in km and km/sec) ----------
+  let r = [mrt * ux * radiusearthkm, mrt * uy * radiusearthkm, mrt * uz * radiusearthkm];
+
+  let v = [
+    (mvt * ux + rvdot * vx) * vkmpersec,
+    (mvt * uy + rvdot * vy) * vkmpersec,
+    (mvt * uz + rvdot * vz) * vkmpersec,
+  ];
+
+  return {
+    error: error,
+    p1: r[0],
+    p2: r[1],
+    p3: r[2],
+    v1: v[0],
+    v2: v[1],
+    v3: v[2],
+  };
+}
+
+/*-----------------------------------------------------------------------------
+ *
+ *                           procedure dspace
+ *
+ *  this procedure provides deep space contributions to mean elements for
+ *    perturbing third body.  these effects have been averaged over one
+ *    revolution of the sun and moon.  for earth resonance effects, the
+ *    effects have been averaged over no revolutions of the satellite.
+ *    (mean motion)
+ *
+ *  author        : david vallado                  719-573-2600   28 jun 2005
+ *
+ *  inputs        :
+ *    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433 -
+ *    dedt        -
+ *    del1, del2, del3  -
+ *    didt        -
+ *    dmdt        -
+ *    dnodt       -
+ *    domdt       -
+ *    irez        - flag for resonance           0-none, 1-one day, 2-half day
+ *    argpo       - argument of perigee
+ *    argpdot     - argument of perigee dot (rate)
+ *    t           - time
+ *    tc          -
+ *    gsto        - gst
+ *    xfact       -
+ *    xlamo       -
+ *    no          - mean motion
+ *    atime       -
+ *    em          - eccentricity
+ *    ft          -
+ *    argpm       - argument of perigee
+ *    inclm       - inclination
+ *    xli         -
+ *    mm          - mean anomaly
+ *    xni         - mean motion
+ *    nodem       - right ascension of ascending node
+ *
+ *  outputs       :
+ *    atime       -
+ *    em          - eccentricity
+ *    argpm       - argument of perigee
+ *    inclm       - inclination
+ *    xli         -
+ *    mm          - mean anomaly
+ *    xni         -
+ *    nodem       - right ascension of ascending node
+ *    dndt        -
+ *    nm          - mean motion
+ *
+ *  locals        :
+ *    delt        -
+ *    ft          -
+ *    theta       -
+ *    x2li        -
+ *    x2omi       -
+ *    xl          -
+ *    xldot       -
+ *    xnddt       -
+ *    xndt        -
+ *    xomi        -
+ *
+ *  coupling      :
+ *    none        -
+ *
+ *  references    :
+ *    hoots, roehrich, norad spacetrack report #3 1980
+ *    hoots, norad spacetrack report #6 1986
+ *    hoots, schumacher and glover 2004
+ *    vallado, crawford, hujsak, kelso  2006
+ ----------------------------------------------------------------------------*/
+function dspace(
+  irez: f64,
+  d2201: f64,
+  d2211: f64,
+  d3210: f64,
+  d3222: f64,
+  d4410: f64,
+  d4422: f64,
+  d5220: f64,
+  d5232: f64,
+  d5421: f64,
+  d5433: f64,
+  dedt: f64,
+  del1: f64,
+  del2: f64,
+  del3: f64,
+  didt: f64,
+  dmdt: f64,
+  dnodt: f64,
+  domdt: f64,
+  argpo: f64,
+  argpdot: f64,
+  t: f64,
+  tc: f64,
+  gsto: f64,
+  xfact: f64,
+  xlamo: f64,
+  no: f64,
+  atime: f64,
+  em: f64,
+  argpm: f64,
+  inclm: f64,
+  xli: f64,
+  mm: f64,
+  xni: f64,
+  nodem: f64,
+  nm: f64,
+): DspaceResults {
+  /** Ootk -- Declared at the top of the file instead */
+  const fasx2 = 0.13130908;
+  const fasx4 = 2.8843198;
+  const fasx6 = 0.37448087;
+  const g22 = 5.7686396;
+  const g32 = 0.95240898;
+  const g44 = 1.8014998;
+  const g52 = 1.050833;
+  const g54 = 4.4108898;
+  const rptim = 4.37526908801129966e-3; // equates to 7.29211514668855e-5 rad/sec
+  const stepp = 720.0;
+  const stepn = -720.0;
+  const step2 = 259200.0;
+
+  //  ----------- calculate deep space resonance effects -----------
+  let dndt = 0.0;
+  let theta = (gsto + tc * rptim) % TAU;
+  em += dedt * t;
+
+  inclm += didt * t;
+  argpm += domdt * t;
+  nodem += dnodt * t;
+  mm += dmdt * t;
+
+  // sgp4fix for negative inclinations
+  // the following if statement should be commented out
+  // if (inclm < 0.0)
+  // {
+  //   inclm = -inclm;
+  //   argpm = argpm - PI;
+  //   nodem = nodem + PI;
+  // }
+  /* - update resonances : numerical (euler-maclaurin) integration - */
+  /* ------------------------- epoch restart ----------------------  */
+  //   sgp4fix for propagator problems
+  //   the following integration works for negative time steps and periods
+  //   the specific changes are unknown because the original code was so convoluted
+  // sgp4fix take out atime = 0.0 and fix for faster operation
+  // ft = 0.0; /** Ootk -- This has no value */
+  if (irez !== 0) {
+    //  sgp4fix streamline check
+    if (atime === 0.0 || t * atime <= 0.0 || Math.abs(t) < Math.abs(atime)) {
+      atime = 0.0;
+      xni = no;
+      xli = xlamo;
+    }
+
+    // sgp4fix move check outside loop
+    let delt: f64;
+    if (t > 0.0) {
+      delt = stepp;
+    } else {
+      delt = stepn;
+    }
+
+    let xndt: f64, xldot: f64, xnddt: f64, xomi: f64, x2omi: f64, x2li: f64, ft: f64;
+    let iretn = 381; // added for do loop
+    while (iretn === 381) {
+      //  ------------------- dot terms calculated -------------
+      //  ----------- near - synchronous resonance terms -------
+      if (irez !== 2) {
+        xndt =
+          del1 * Math.sin(xli - fasx2) + del2 * Math.sin(2.0 * (xli - fasx4)) + del3 * Math.sin(3.0 * (xli - fasx6));
+        xldot = xni + xfact;
+        xnddt =
+          del1 * Math.cos(xli - fasx2) +
+          2.0 * del2 * Math.cos(2.0 * (xli - fasx4)) +
+          3.0 * del3 * Math.cos(3.0 * (xli - fasx6));
+        xnddt *= xldot;
+      } else {
+        // --------- near - half-day resonance terms --------
+        xomi = argpo + argpdot * atime;
+        x2omi = xomi + xomi;
+        x2li = xli + xli;
+        xndt =
+          d2201 * Math.sin(x2omi + xli - g22) +
+          d2211 * Math.sin(xli - g22) +
+          d3210 * Math.sin(xomi + xli - g32) +
+          d3222 * Math.sin(-xomi + xli - g32) +
+          d4410 * Math.sin(x2omi + x2li - g44) +
+          d4422 * Math.sin(x2li - g44) +
+          d5220 * Math.sin(xomi + xli - g52) +
+          d5232 * Math.sin(-xomi + xli - g52) +
+          d5421 * Math.sin(xomi + x2li - g54) +
+          d5433 * Math.sin(-xomi + x2li - g54);
+        xldot = xni + xfact;
+        xnddt =
+          d2201 * Math.cos(x2omi + xli - g22) +
+          d2211 * Math.cos(xli - g22) +
+          d3210 * Math.cos(xomi + xli - g32) +
+          d3222 * Math.cos(-xomi + xli - g32) +
+          d5220 * Math.cos(xomi + xli - g52) +
+          d5232 * Math.cos(-xomi + xli - g52) +
+          2.0 * d4410 * Math.cos(x2omi + x2li - g44) +
+          d4422 * Math.cos(x2li - g44) +
+          d5421 * Math.cos(xomi + x2li - g54) +
+          d5433 * Math.cos(-xomi + x2li - g54);
+        xnddt *= xldot;
+      }
+
+      //  ----------------------- integrator -------------------
+      //  sgp4fix move end checks to end of routine
+      if (Math.abs(t - atime) >= stepp) {
+        // iret = 0; /** Ootk -- This has no value */
+        iretn = 381;
+      } else {
+        ft = t - atime;
+        iretn = 0;
+      }
+
+      if (iretn === 381) {
+        xli += xldot * delt + xndt * step2;
+        xni += xndt * delt + xnddt * step2;
+        atime += delt;
+      }
+    } // while iretn = 381
+
+    nm = xni + xndt * ft + xnddt * ft * ft * 0.5;
+    let xl = xli + xldot * ft + xndt * ft * ft * 0.5;
+    if (irez !== 1) {
+      mm = xl - 2.0 * nodem + 2.0 * theta;
+      dndt = nm - no;
+    } else {
+      mm = xl - nodem - argpm + theta;
+      dndt = nm - no;
+    }
+    nm = no + dndt;
+  }
+
+  return new DspaceResults(atime, em, argpm, inclm, xli, mm, xni, nodem, dndt, nm);
+} // dspace
+
+/* -----------------------------------------------------------------------------
+ *
+ *                           procedure dpper
+ *
+ *  this procedure provides deep space long period periodic contributions
+ *    to the mean elements.  by design, these periodics are zero at epoch.
+ *    this used to be dscom which included initialization, but it's really a
+ *    recurring function.
+ *
+ *  author        : david vallado                  719-573-2600   28 jun 2005
+ *
+ *  inputs        :
+ *    e3          -
+ *    ee2         -
+ *    peo         -
+ *    pgho        -
+ *    pho         -
+ *    PInco       -
+ *    plo         -
+ *    se2 , se3 , sgh2, sgh3, sgh4, sh2, sh3, si2, si3, sl2, sl3, sl4 -
+ *    t           -
+ *    xh2, xh3, xi2, xi3, xl2, xl3, xl4 -
+ *    zmol        -
+ *    zmos        -
+ *    ep          - eccentricity                           0.0 - 1.0
+ *    inclo       - inclination - needed for lyddane modification
+ *    nodep       - right ascension of ascending node
+ *    argpp       - argument of perigee
+ *    mp          - mean anomaly
+ *
+ *  outputs       :
+ *    ep          - eccentricity                           0.0 - 1.0
+ *    inclp       - inclination
+ *    nodep        - right ascension of ascending node
+ *    argpp       - argument of perigee
+ *    mp          - mean anomaly
+ *
+ *  locals        :
+ *    alfdp       -
+ *    betdp       -
+ *    cosip  , sinip  , cosop  , sinop  ,
+ *    dalf        -
+ *    dbet        -
+ *    dls         -
+ *    f2, f3      -
+ *    pe          -
+ *    pgh         -
+ *    ph          -
+ *    PInc        -
+ *    pl          -
+ *    sel   , ses   , sghl  , sghs  , shl   , shs   , sil   , sinzf , sis   ,
+ *    sll   , sls
+ *    xls         -
+ *    xnoh        -
+ *    zf          -
+ *    zm          -
+ *
+ *  coupling      :
+ *    none.
+ *
+ *  references    :
+ *    hoots, roehrich, norad spacetrack report #3 1980
+ *    hoots, norad spacetrack report #6 1986
+ *    hoots, schumacher and glover 2004
+ *    vallado, crawford, hujsak, kelso  2006
+ ----------------------------------------------------------------------------*/
+function dpper(
+  e3: f64,
+  ee2: f64,
+  peo: f64,
+  pgho: f64,
+  pho: f64,
+  PInco: f64,
+  plo: f64,
+  se2: f64,
+  se3: f64,
+  sgh2: f64,
+  sgh3: f64,
+  sgh4: f64,
+  sh2: f64,
+  sh3: f64,
+  si2: f64,
+  si3: f64,
+  sl2: f64,
+  sl3: f64,
+  sl4: f64,
+  t: f64,
+  xgh2: f64,
+  xgh3: f64,
+  xgh4: f64,
+  xh2: f64,
+  xh3: f64,
+  xi2: f64,
+  xi3: f64,
+  xl2: f64,
+  xl3: f64,
+  xl4: f64,
+  zmol: f64,
+  zmos: f64,
+  ep: f64,
+  inclp: f64,
+  nodep: f64,
+  argpp: f64,
+  mp: f64,
+  opsmode: string,
+  init: string,
+): DpperResult {
+  //  ---------------------- constants -----------------------------
+  /** Ootk -- Declared outside the class at the top */
+  const zns = 1.19459e-5;
+  const zes = 0.01675;
+  const znl = 1.5835218e-4;
+  const zel = 0.0549;
+
+  //  --------------- calculate time varying periodics -----------
+  let zm = zmos + zns * t;
+  // be sure that the initial call has time set to zero
+  if (init === 'y') {
+    zm = zmos;
+  }
+  let zf = zm + 2.0 * zes * Math.sin(zm);
+  let sinzf = Math.sin(zf);
+  let f2 = 0.5 * sinzf * sinzf - 0.25;
+  let f3 = -0.5 * sinzf * Math.cos(zf);
+  let ses = se2 * f2 + se3 * f3;
+  let sis = si2 * f2 + si3 * f3;
+  let sls = sl2 * f2 + sl3 * f3 + sl4 * sinzf;
+  let sghs = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf;
+  let shs = sh2 * f2 + sh3 * f3;
+  zm = zmol + znl * t;
+  if (init === 'y') {
+    zm = zmol;
+  }
+  zf = zm + 2.0 * zel * Math.sin(zm);
+  sinzf = Math.sin(zf);
+  f2 = 0.5 * sinzf * sinzf - 0.25;
+  f3 = -0.5 * sinzf * Math.cos(zf);
+  let sel = ee2 * f2 + e3 * f3;
+  let sil = xi2 * f2 + xi3 * f3;
+  let sll = xl2 * f2 + xl3 * f3 + xl4 * sinzf;
+  let sghl = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf;
+  let shll = xh2 * f2 + xh3 * f3;
+  let pe = ses + sel;
+  let PInc = sis + sil;
+  let pl = sls + sll;
+  let pgh = sghs + sghl;
+  let ph = shs + shll;
+
+  if (init === 'n') {
+    pe -= peo;
+    PInc -= PInco;
+    pl -= plo;
+    pgh -= pgho;
+    ph -= pho;
+    inclp += PInc;
+    ep += pe;
+    let sinip = Math.sin(inclp);
+    let cosip = Math.cos(inclp);
+
+    /* ----------------- apply periodics directly ------------ */
+    // sgp4fix for lyddane choice
+    // strn3 used original inclination - this is technically feasible
+    // gsfc used perturbed inclination - also technically feasible
+    // probably best to readjust the 0.2 limit value and limit discontinuity
+    // 0.2 rad = 11.45916 deg
+    // use next line for original strn3 approach and original inclination
+    // if (inclo >= 0.2)
+    // use next line for gsfc version and perturbed inclination
+    if (inclp >= 0.2) {
+      ph /= sinip;
+      pgh -= cosip * ph;
+      argpp += pgh;
+      nodep += ph;
+      mp += pl;
+    } else {
+      //  ---- apply periodics with lyddane modification ----
+      let sinop = Math.sin(nodep);
+      let cosop = Math.cos(nodep);
+      let alfdp = sinip * sinop;
+      let betdp = sinip * cosop;
+      let dalf = ph * cosop + PInc * cosip * sinop;
+      let dbet = -ph * sinop + PInc * cosip * cosop;
+      alfdp += dalf;
+      betdp += dbet;
+      nodep %= TAU;
+      //  sgp4fix for afspc written intrinsic functions
+      //  nodep used without a trigonometric function ahead
+      /* istanbul ignore next */
+      if (nodep < 0.0 && opsmode === 'a') {
+        nodep += TAU;
+      }
+      let xls = mp + argpp + cosip * nodep;
+      let dls = pl + pgh - PInc * nodep * sinip;
+      xls += dls;
+      let xnoh = nodep;
+      nodep = Math.atan2(alfdp, betdp);
+      //  sgp4fix for afspc written intrinsic functions
+      //  nodep used without a trigonometric function ahead
+      /* istanbul ignore next */
+      if (nodep < 0.0 && opsmode === 'a') {
+        nodep += TAU;
+      }
+      if (Math.abs(xnoh - nodep) > PI) {
+        /* istanbul ignore next */
+        if (nodep < xnoh) {
+          nodep += TAU;
+        } else {
+          nodep -= TAU;
+        }
+      }
+      mp += pl;
+      argpp = xls - mp - cosip * nodep;
+    }
+  } // if init == 'n'
+
+  return new DpperResult(ep, inclp, nodep, argpp, mp);
+} // dpper