dsgp4 0.0.2__tar.gz

dsgp4-0.0.2/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: dsgp4
+Version: 0.0.2
+Summary: Differentiable SGP4 prototype
+Author: Acciarini & Baydin
+Author-email: giacomo.acciarini@gmail.com
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: numpy
+Requires-Dist: torch
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: sgp4>=2.21; extra == "dev"

dsgp4-0.0.2/README.md

@@ -0,0 +1,42 @@
+# dSGP4
+[![build](https://github.com/esa/dSGP4/actions/workflows/build.yml/badge.svg)](https://github.com/esa/dSGP4/actions/workflows/build.yml)
+[![codecov](https://codecov.io/gh/esa/dSGP4/graph/badge.svg?token=K3py7YT8UR)](https://codecov.io/gh/esa/dSGP4)
+
+Differentiable SGP4.
+<!-- PROJECT LOGO -->
+<br />
+<p align="center">
+  <a href="https://github.com/esa/dSGP4">
+    <img src="doc/_static/logo_dsgp4.png" alt="Logo" width="280">
+  </a>
+  <p align="center">
+    Differentiable SGP4
+    <br />
+    <a href="https://esa.github.io/dSGP4"><strong>Explore the docs »</strong></a>
+    <br />
+    <br />
+    <a href="https://github.com/esa/dSGP4/issues/new/choose">Report bug</a>
+    ·
+    <a href="https://github.com/esa/dSGP4/issues/new/choose">Request feature</a>
+  </p>
+</p>
+
+## Goals
+
+* Differentiable version of SGP4
+
+## Installation, documentation, and examples
+
+
+## Authors:
+* [Giacomo Acciarini](https://www.esa.int/gsp/ACT/team/giacomo_acciarini/)
+* [Atılım Güneş Baydin](http://gbaydin.github.io/)
+* [Dario Izzo](https://www.esa.int/gsp/ACT/team/dario_izzo/)
+
+The project originated after the work of the authors at the [University of Oxford OX4AI Lab](https://oxai4science.github.io/).
+
+## Acknowledgements:
+
+
+## Contact:
+* `giacomo.acciarini@gmail.com`

dsgp4-0.0.2/dsgp4/__init__.py

@@ -0,0 +1,9 @@
+__version__ = '0.0.2'
+
+from .sgp4 import sgp4
+from .initl import initl
+from .sgp4init import sgp4init
+from .newton_method import newton_method, update_TLE
+from .sgp4_batched import sgp4_batched
+from . import tle
+from .tle import TLE

dsgp4-0.0.2/dsgp4/initl.py

@@ -0,0 +1,64 @@
+import numpy
+import torch
+
+from . import util
+
+#torch.set_default_dtype(torch.float64)
+
+def initl(
+       xke, j2,
+       ecco,   epoch,  inclo,   no,
+       method,
+       opsmode,
+       ):
+
+     x2o3   = torch.tensor(2.0 / 3.0);
+
+     eccsq  = ecco * ecco;
+     omeosq = 1.0 - eccsq;
+     rteosq = omeosq.sqrt();
+     cosio  = inclo.cos();
+     cosio2 = cosio * cosio;
+
+     ak    = torch.pow(xke / no, x2o3);
+     d1    = 0.75 * j2 * (3.0 * cosio2 - 1.0) / (rteosq * omeosq);
+     del_  = d1 / (ak * ak);
+     adel  = ak * (1.0 - del_ * del_ - del_ *
+             (1.0 / 3.0 + 134.0 * del_ * del_ / 81.0));
+     del_  = d1/(adel * adel);
+     no    = no / (1.0 + del_);
+
+     ao    = torch.pow(xke / no, x2o3);
+     sinio = inclo.sin();
+     po    = ao * omeosq;
+     con42 = 1.0 - 5.0 * cosio2;
+     con41 = -con42-cosio2-cosio2;
+     ainv  = 1.0 / ao;
+     posq  = po * po;
+     rp    = ao * (1.0 - ecco);
+     method = 'n';
+
+     if opsmode == 'a':
+         #  gst time
+         ts70  = epoch - 7305.0;
+         ds70 = torch.floor_divide(ts70 + 1.0e-8,1);
+         tfrac = ts70 - ds70;
+         #  find greenwich location at epoch
+         c1    = torch.tensor(1.72027916940703639e-2);
+         thgr70= torch.tensor(1.7321343856509374);
+         fk5r  = torch.tensor(5.07551419432269442e-15);
+         c1p2p = c1 + (2*numpy.pi);
+         gsto  = (thgr70 + c1*ds70 + c1p2p*tfrac + ts70*ts70*fk5r) % (2*numpy.pi)
+         if gsto < 0.0:
+             gsto = gsto + (2*numpy.pi);
+
+     else:
+        gsto = util.gstime(epoch + 2433281.5);
+
+     return (
+       no,
+       method,
+       ainv,  ao,    con41,  con42, cosio,
+       cosio2,eccsq, omeosq, posq,
+       rp,    rteosq,sinio , gsto,
+       )

dsgp4-0.0.2/dsgp4/newton_method.py

@@ -0,0 +1,207 @@
+import numpy as np
+import torch
+import datetime
+from .sgp4 import sgp4
+from .sgp4init import sgp4init
+from . import util
+from .tle import TLE
+#torch.set_default_dtype(torch.float64)
+
+def initial_guess(tle_0, time_mjd, target_state=None):
+    """
+    This method takes an initial TLE and the time at which we want to propagate it, and returns
+    a set of parameter related to an initial guess useful to find the TLE observation that corresponds to the propagated state
+
+    Args:
+        - tle_0 (``dsgp4.tle.TLE``): starting TLE at time0
+        - new_date (``datetime.datetime``): new date of the TLE, as a datetime object
+        - target_state (``torch.tensor``): a 2x3 tensor for the position and velocity of the state. If None, then this is computed
+                                           by propagating `tle_0` at the `new_date`.
+
+    Returns:
+        - y0 (``torch.tensor``): initial guess for the TLE elements. In particular, y0 contains
+                                 the following elements (see SGP4 for a thorough description of these parameters):
+                                * y0[0]: bstar (B* parameter)
+                                * y0[1]: ndot (mean motion first derivative)
+                                * y0[2]: nddot (mean motion second derivative)
+                                * y0[3]: ecco (eccentricity)
+                                * y0[4]: argpo (argument of perigee)
+                                * y0[5]: inclo (inclination)
+                                * y0[6]: mo (mean anomaly)
+                                * y0[7]: no_kozai (mean anomaly in certain units)
+                                * y0[8]: nodeo (right ascension of the ascending node)
+        - target_state (``torch.tensor``): this expresses the cartesian state as position & velocity in km & km/s, at the propagated time.
+                                            The objective of the Newton method is to find the TLE observation that corresponds to that, at the propagated
+                                            time.
+        - new_tle (``dsgp4.tle.TLE``): TLE constructed with `y0`, in order to find the TLE that corresponds to `target_state`
+        - tle_elements_0 (``dict``): dictionary used to construct `new_tle`
+
+    """
+    new_date=util.from_mjd_to_datetime(time_mjd)
+    if target_state is None:
+        whichconst=util.get_gravity_constants("wgs-84")
+        sgp4init(whichconst=whichconst,
+                            opsmode=tle_0._opsmode,
+                            satn=tle_0.satellite_catalog_number,
+                            epoch=(tle_0._jdsatepoch+tle_0._jdsatepochF)-2433281.5,
+                            xbstar=tle_0._bstar,
+                            xndot=tle_0._ndot,
+                            xnddot=tle_0._nddot,
+                            xecco=tle_0._ecco,
+                            xargpo=tle_0._argpo,
+                            xinclo=tle_0._inclo,
+                            xmo=tle_0._mo,
+                            xno_kozai=tle_0._no_kozai,
+                            xnodeo=tle_0._nodeo,
+                            satellite=tle_0)
+        tsince=(time_mjd-util.from_datetime_to_mjd(tle_0._epoch))*1440.
+        x=tsince*torch.ones(1,1,requires_grad=True)#torch.rand(1,1, requires_grad=True)
+        target_state=sgp4(tle_0, x)
+    #print(target_state.size(), target_state)
+    tle_elements_0=util.from_cartesian_to_tle_elements(target_state.detach().numpy()*1e3)
+    #you need to transform it to the appropriate units
+    xpdotp=1440.0 / (2.0 *np.pi)
+    tle_elements_0['epoch_year']=new_date.year
+    tle_elements_0['epoch_days']=util.from_datetime_to_fractional_day(new_date)
+    #tle_elements_0['no_kozai']=tle_elements_0['mean_motion']/(np.pi/43200.0)/xpdotp
+    #tle_elements_0['inclo']=tle_elements_0['inclination']
+    #tle_elements_0['nodeo']=tle_elements_0['raan']
+    #tle_elements_0['argpo']=tle_elements_0['argument_of_perigee']
+    #tle_elements_0['mo']=tle_elements_0['mean_anomaly']
+    #tle_elements_0['ecco']=tle_elements_0['eccentricity']
+    tle_elements_0['mean_motion_first_derivative']=tle_0.mean_motion_first_derivative
+    tle_elements_0['mean_motion_second_derivative']=tle_0.mean_motion_second_derivative
+    tle_elements_0['classification']=tle_0.classification
+    tle_elements_0['international_designator']=tle_0.international_designator
+    tle_elements_0['satellite_catalog_number']=tle_0.satellite_catalog_number
+    tle_elements_0['ephemeris_type']=tle_0.ephemeris_type
+    tle_elements_0['element_number']=tle_0.element_number
+    tle_elements_0['b_star']=tle_0.b_star
+    tle_elements_0['revolution_number_at_epoch']=tle_0.revolution_number_at_epoch
+    new_tle=TLE(tle_elements_0)
+    y0=torch.tensor([new_tle._bstar,
+                     new_tle._ndot,
+                     new_tle._nddot,
+                     new_tle._ecco,
+                     new_tle._argpo,
+                     new_tle._inclo,
+                     new_tle._mo,
+                     new_tle._no_kozai,
+                     new_tle._nodeo,
+                     0.],requires_grad=True)
+    return y0, target_state, new_tle, tle_elements_0
+
+def update_TLE(old_tle,y0):
+    """
+    This method takes a TLE and an initial guess, and returns a TLE updated accordingly. It
+    is useful while doing Newton iterations.
+
+    Args:
+        - old_tle (``dsgp4.tle.TLE``): TLE corresponding to previous guess
+        - y0 (``torch.tensor``): initial guess (see the docstrings for `initial_guess` to know the content of `y0`)
+
+    Returns:
+        - new_tle (``dsgp4.tle.TLE``): updated TLE
+
+    """
+    tle_elements={}
+    xpdotp=1440.0/(2.0 *np.pi)
+    #I need to convert no_kozai to consistent units for what is expected by TLE class:
+    no_kozai=float(y0[7])*xpdotp
+    tle_elements['mean_motion']=no_kozai*np.pi/43200.0
+
+    #the rest is consistent:
+    tle_elements['b_star']=float(y0[0])
+    tle_elements['raan']=float(y0[8])
+    tle_elements['eccentricity']=float(y0[3])
+    tle_elements['argument_of_perigee']=float(y0[4])
+    tle_elements['inclination']=float(y0[5])
+    tle_elements['mean_anomaly']=float(y0[6])
+
+    #now the ones that stay the same:
+    tle_elements['mean_motion_first_derivative']=old_tle.mean_motion_first_derivative
+    tle_elements['mean_motion_second_derivative']=old_tle.mean_motion_second_derivative
+    tle_elements['epoch_days']=old_tle.epoch_days
+    tle_elements['epoch_year']=old_tle.epoch_year
+    tle_elements['classification']=old_tle.classification
+    tle_elements['satellite_catalog_number']=old_tle.satellite_catalog_number
+    tle_elements['ephemeris_type']=old_tle.ephemeris_type
+    tle_elements['international_designator']=old_tle.international_designator
+    tle_elements['revolution_number_at_epoch']=old_tle.revolution_number_at_epoch
+    tle_elements['element_number']=old_tle.element_number
+    return TLE(tle_elements)
+
+def newton_method(tle_0, time_mjd, target_state=None, new_tol=1e-12,max_iter=50):
+    """
+    This method performs Newton method starting from an initial TLE and a given propagation time. The objective
+    is to find a TLE that accurately reconstructs the propagated state, at observation time.
+
+    Args:
+        - tle_0 (``dsgp4.tle.TLE``): starting TLE (i.e., TLE at a given initial time)
+        - new_date (``datetime.datetime``): time (as a datetime object) at which we want the state to be propagated, and we want the TLE at that time
+        - target_state (``torch.tensor``): 2x3 tensor representing target state. If None, then this is directly computed by propagating the TLE at `new_date`
+        - new_tol (``float``): newton tolerance
+        - max_iter (``int``): maximum iterations for Newton's method
+
+    Returns:
+        - tle (``dsgp4.tle.TLE``): found TLE
+        - y (``torch.tensor``): returns the solution that satisfied F(y)=0 (with a given tolerance)
+                                or (in case no convergence is reached within the tolerance) the best
+                                guess found in `max_iter` iterations
+    """
+    i=0
+    tol=1e9
+    y0, state_target, next_tle, tle_elements_0=initial_guess(tle_0=tle_0,time_mjd=time_mjd,target_state=target_state)
+    #print(y0,states)
+    #newton iterations:
+    while i<max_iter and tol>new_tol:
+        #print(f"y0: {y0}")
+        propagate=lambda x: util.propagate(x,next_tle,(time_mjd-util.from_datetime_to_mjd(next_tle._epoch))*1440.)
+        y1=util.clone_w_grad(y0)
+        y2=util.clone_w_grad(y0)
+        y3=util.clone_w_grad(y0)
+        y4=util.clone_w_grad(y0)
+        y5=util.clone_w_grad(y0)
+        r_x=propagate(y0)[0][0]
+        r_x.backward()
+        gradient_rx=y0.grad
+        r_y=propagate(y1)[0][1]
+        r_y.backward()
+        gradient_ry=y1.grad
+        r_z=propagate(y2)[0][2]
+        r_z.backward()
+        gradient_rz=y2.grad
+        v_x=propagate(y3)[1][0]
+        v_x.backward()
+        gradient_vx=y3.grad
+        v_y=propagate(y4)[1][1]
+        v_y.backward()
+        gradient_vy=y4.grad
+        v_z=propagate(y5)[1][2]
+        v_z.backward()
+        gradient_vz=y5.grad
+        F=np.array([float(r_x)-float(state_target[0][0]),float(r_y)-float(state_target[0][1]), float(r_z)-float(state_target[0][2]), float(v_x)-float(state_target[1][0]), float(v_y)-float(state_target[1][1]), float(v_z)-float(state_target[1][2])])
+        tol=np.linalg.norm(F)
+        #print(f"|F|: {tol}")
+        DF=np.stack((gradient_rx, gradient_ry, gradient_rz, gradient_vx, gradient_vy, gradient_vz))
+        #we remove the first three columns (they are all zeros):
+        DF=DF[:,3:]
+        DF=DF[:,:-1]
+        dY=-np.matmul(np.matmul(np.linalg.pinv(np.matmul(DF.T,DF)),DF.T),F)
+        #we make sure the eccentricity does not go to negative values:
+        if float(y0[3])+dY[0]<0:
+            dY[0]=-float(y0[3])*0.9999
+        dY=torch.tensor([0.,0.,0.]+list(dY)+[0.], requires_grad=True)
+        if tol<new_tol:
+            print(f"F(y): {np.linalg.norm(F)}")
+            print(f"Solution found, at iter: {i}")
+            return next_tle, y0#+dY
+        else:
+            #Newton update:
+            #y0=y0+dY
+            y0=torch.tensor([float(el1)+float(el2) for el1, el2 in zip(list(y0),list(dY))],requires_grad=True)
+            next_tle=update_TLE(next_tle, y0)
+        i+=1
+    print("Solution not found, returning best found so far")
+    print(f"F(y): {np.linalg.norm(F)}")
+    return next_tle, y0

dsgp4-0.0.2/dsgp4/sgp4.py

@@ -0,0 +1,185 @@
+import numpy
+import torch
+#torch.set_default_dtype(torch.float64)
+
+#@torch.jit.script
+def sgp4(satellite, tsince):
+    """
+    This function represents the SGP4 propagator. Having created the TLE object, and
+    initialized the propagator (using `dsgp4.sgp4.sgp4init`), one can use this method
+    to propagate the TLE at future times. The method returns the satellite position and velocity
+    in km and km/s, respectively, after `tsince` minutes.
+
+    Args:
+        - satellite (``dsgp4.tle.TLE``): TLE object
+        - tsince (``torch.tensor``): time to propagate, since the TLE epoch, in minutes
+
+    Returns:
+        - state (``torch.tensor``): a 2x3 tensor, where the first row represents the spacecraft
+                                    position (in km) and the second the spacecraft velocity (in km/s)
+    """
+    mrt = torch.zeros(tsince.size())
+    temp4 = torch.ones(tsince.size())*1.5e-12
+    x2o3  = torch.tensor(2.0 / 3.0)
+
+    vkmpersec    = torch.ones(tsince.size())*(satellite._radiusearthkm * satellite._xke/60.0)
+
+    # sgp4 error flag
+    satellite._t    = tsince.clone()
+    satellite._error = torch.tensor(0)
+
+    #  secular gravity and atmospheric drag
+    xmdf    = satellite._mo + satellite._mdot * satellite._t
+    argpdf  = satellite._argpo + satellite._argpdot * satellite._t
+    nodedf  = satellite._nodeo + satellite._nodedot * satellite._t
+    argpm   = argpdf
+    mm     = xmdf
+    t2     = satellite._t * satellite._t
+    nodem   = nodedf + satellite._nodecf * t2
+    tempa   = 1.0 - satellite._cc1 * satellite._t
+    tempe   = satellite._bstar * satellite._cc4 * satellite._t
+    templ   = satellite._t2cof * t2
+
+    if satellite._isimp != 1:
+        delomg = satellite._omgcof * satellite._t
+        delmtemp =  1.0 + satellite._eta * xmdf.cos()
+        delm   = satellite._xmcof * \
+                  (delmtemp * delmtemp * delmtemp -
+                  satellite._delmo)
+        temp   = delomg + delm
+        mm     = xmdf + temp
+        argpm  = argpdf - temp
+        t3     = t2 * satellite._t
+        t4     = t3 * satellite._t
+        tempa  = tempa - satellite._d2 * t2 - satellite._d3 * t3 - \
+                          satellite._d4 * t4
+        tempe  = tempe + satellite._bstar * satellite._cc5 * (mm.sin() -
+                          satellite._sinmao)
+        templ  = templ + satellite._t3cof * t3 + t4 * (satellite._t4cof +
+                          satellite._t * satellite._t5cof)
+
+    nm    = satellite._no_unkozai.clone()
+    em    = satellite._ecco.clone()
+    inclm = satellite._inclo.clone()
+
+    satellite._error=torch.any(nm<=0)*2
+
+    am = torch.pow((satellite._xke / nm),x2o3) * tempa * tempa
+    nm = satellite._xke / torch.pow(am, 1.5)
+    em = em - tempe
+
+    if satellite._error==0.:
+        satellite._error=torch.any((em>=1.0) | (em<-0.001))*1
+
+    #  sgp4fix fix tolerance to avoid a divide by zero
+    em=torch.where(em<1.0e-6,1.0e-6,em)
+    mm     = mm + satellite._no_unkozai * templ
+    xlm    = mm + argpm + nodem
+    emsq   = em * em
+    temp   = 1.0 - emsq
+
+    nodem = torch.fmod(nodem, torch.tensor(2*numpy.pi))
+
+    argpm  = argpm % (2*numpy.pi)
+    xlm    = xlm % (2*numpy.pi)
+    mm     = (xlm - argpm - nodem) % (2*numpy.pi)
+
+    satellite._am = am.clone()
+    satellite._em = em.clone()
+    satellite._im = inclm.clone()
+    satellite._Om = nodem.clone()
+    satellite._om = argpm.clone()
+    satellite._mm = mm.clone()
+    satellite._nm = nm.clone()
+
+    # compute extra mean quantities
+    sinim = inclm.sin()
+    cosim = inclm.cos()
+
+    # add lunar-solar periodics
+    ep     = em
+    xincp  = inclm
+    argpp  = argpm
+    nodep  = nodem
+    mp     = mm
+    sinip  = sinim
+    cosip  = cosim
+
+    axnl = ep * argpp.cos()
+    temp = 1.0 / (am * (1.0 - ep * ep))
+    aynl = ep* argpp.sin() + temp * satellite._aycof
+    xl   = mp + argpp + nodep + temp * satellite._xlcof * axnl
+
+    # solve kepler's equation
+    u    = (xl - nodep) % (2*numpy.pi)
+    eo1  = u
+    tem5 = torch.ones(tsince.size())
+    # kepler iteration
+    for _ in range(10):
+        coseo1=eo1.cos()
+        sineo1=eo1.sin()
+        tem5   = 1.0 - coseo1 * axnl - sineo1 * aynl
+        tem5   = (u - aynl * coseo1 + axnl * sineo1 - eo1) / tem5
+        tem5=torch.where(tem5>=0.95, 0.95, tem5)
+        tem5=torch.where(tem5<=-0.95, -0.95, tem5)
+        eo1    = eo1 + tem5
+
+    #  short period preliminary quantities
+    ecose = axnl*coseo1 + aynl*sineo1
+    esine = axnl*sineo1 - aynl*coseo1
+    el2   = axnl*axnl + aynl*aynl
+    pl    = am*(1.0-el2)
+    if satellite._error==0.:
+        satellite._error=torch.any(pl<0.)*4
+
+    rl     = am * (1.0 - ecose)
+    rdotl  = am.sqrt() * esine/rl
+    rvdotl = pl.sqrt() / rl
+    betal  = (1.0 - el2).sqrt()
+    temp   = esine / (1.0 + betal)
+    sinu   = am / rl * (sineo1 - aynl - axnl * temp)
+    cosu   = am / rl * (coseo1 - axnl + aynl * temp)
+    su     = torch.atan2(sinu, cosu)
+    sin2u  = (cosu + cosu) * sinu
+    cos2u  = 1.0 - 2.0 * sinu * sinu
+    temp   = 1.0 / pl
+    temp1  = 0.5 * satellite._j2 * temp
+    temp2  = temp1 * temp
+
+    mrt   = rl * (1.0 - 1.5 * temp2 * betal * satellite._con41) + \
+             0.5 * temp1 * satellite._x1mth2 * cos2u
+    su    = su - 0.25 * temp2 * satellite._x7thm1 * sin2u
+    xnode = nodep + 1.5 * temp2 * cosip * sin2u
+    xinc  = xincp + 1.5 * temp2 * cosip * sinip * cos2u
+    mvt   = rdotl - nm * temp1 * satellite._x1mth2 * sin2u / satellite._xke
+    rvdot = rvdotl + nm * temp1 * (satellite._x1mth2 * cos2u +
+             1.5 * satellite._con41) / satellite._xke
+
+    # orientation vectors
+    sinsu =  su.sin()
+    cossu =  su.cos()
+    snod  =  xnode.sin()
+    cnod  =  xnode.cos()
+    sini  =  xinc.sin()
+    cosi  =  xinc.cos()
+    xmx   = -snod * cosi
+    xmy   =  cnod * cosi
+    ux    =  xmx * sinsu + cnod * cossu
+    uy    =  xmy * sinsu + snod * cossu
+    uz    =  sini * sinsu
+    vx    =  xmx * cossu - cnod * sinsu
+    vy    =  xmy * cossu - snod * sinsu
+    vz    =  sini * cossu
+
+    # position and velocity (in km and km/sec)
+    _mr = mrt * satellite._radiusearthkm
+
+    r = torch.stack((_mr * ux, _mr * uy, _mr * uz))
+    v = torch.stack(((mvt * ux + rvdot * vx) * vkmpersec,
+          (mvt * uy + rvdot * vy) * vkmpersec,
+          (mvt * uz + rvdot * vz) * vkmpersec))
+
+    # decaying satellites
+    if satellite._error==0.:
+        satellite._error=torch.any(mrt<1.0)*6
+    return torch.transpose(torch.stack((r.squeeze(),v.squeeze()),1),0,-1)#torch.cat((r.swapaxes(0,2),v.swapaxes(0,2)),1)#torch.stack(list(r)+list(v)).reshape(2,3)