ootk 1.8.1 → 2.0.1

package/.asc/assembly/index.ts

@@ -1,1143 +0,0 @@
-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