satkit 0.2.7__tar.gz → 0.2.8__tar.gz

{satkit-0.2.7 → satkit-0.2.8}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satkit"
-version = "0.2.7"
+version = "0.2.8"
 edition = "2021"
 description = "Satellite Toolkit"
 readme = "README.md"

{satkit-0.2.7/python/satkit.egg-info → satkit-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.2.7
+Version: 0.2.8
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>
@@ -21,6 +21,7 @@ Requires-Dist: numpy>=1.20.0
 
 An accurate, high-performance satellite orbital kinematics toolkit, written in Rust with a sensible interface.
 <br/>
+Also includes python bindings for *all* functions via via [pyo3](https://pyo3.rs/)
 
 ### Github
 
@@ -48,7 +49,7 @@ An accurate, high-performance satellite orbital kinematics toolkit, written in R
 - **Native Rust** bindings
 - **Python bindings** for compiled rust code ... speed of Rust with convenience of Python<br/>
   Install with `pip install satkit`<br/>
-  PyPi includes binaries for windows, macos (Intel & arm), and linux
+  PyPi includes binary packages for windows, macos (Intel & ARM), and linux.  Python documentation is at: <https://satellite-toolkit.readthedocs.io/latest/>
 
 ## Features
 

{satkit-0.2.7 → satkit-0.2.8}/README.md

@@ -2,6 +2,7 @@
 
 An accurate, high-performance satellite orbital kinematics toolkit, written in Rust with a sensible interface.
 <br/>
+Also includes python bindings for *all* functions via via [pyo3](https://pyo3.rs/)
 
 ### Github
 
@@ -29,7 +30,7 @@ An accurate, high-performance satellite orbital kinematics toolkit, written in R
 - **Native Rust** bindings
 - **Python bindings** for compiled rust code ... speed of Rust with convenience of Python<br/>
   Install with `pip install satkit`<br/>
-  PyPi includes binaries for windows, macos (Intel & arm), and linux
+  PyPi includes binary packages for windows, macos (Intel & ARM), and linux.  Python documentation is at: <https://satellite-toolkit.readthedocs.io/latest/>
 
 ## Features
 

{satkit-0.2.7 → satkit-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "satkit"
-version = "0.2.7"
+version = "0.2.8"
 dependencies = ["numpy>=1.20.0"]
 requires-python = ">= 3.8"
 authors = [{ name = "Steven Michael", email = "ssmichael@gmail.com" }]

{satkit-0.2.7 → satkit-0.2.8}/python/satkit/__init__.pyi

@@ -21,6 +21,7 @@ __all__ = [
     "solarsystem",
     "TLE",
     "itrfcoord",
+    "kepler",
     "consts",
     "frametransform",
     "jplephem",

{satkit-0.2.7 → satkit-0.2.8}/python/satkit/satkit.pyi

@@ -1050,6 +1050,53 @@ class quaternion:
             quaternion: Quaternion representing interpolation between self and other
         """
 
+class kepler:
+    """ Represent Keplerian element sets and convert between cartesian
+    
+    
+    Notes:
+        * This class is used to represent Keplerian elements and convert between Cartesian coordinates
+        * The class uses the semi-major axis (a), not the semiparameter
+        * All angle units are radians
+        * All length units are meters
+        * All velocity units are meters / second
+    """
+
+    def __init__(self, *args):
+        """Create Keplerian element set object from input elements
+
+        # Args:
+            a (float) : Semi-major axis, meters
+            e (float) : Eccentricity, unitless
+            i (float) : Inclination, radians
+            raan (float) : Right ascension of ascending node, radians
+            argp (float) : Argument of perigee, radians
+            nu (float) : True anomaly, radians
+
+        # Returns:
+            satkit.kepler: Keplerian element set object
+        """
+
+    def to_pv(self) -> typing.Tuple[npt.ArrayLike[np.float64], npt.ArrayLike[np.float64]]:
+        """Convert Keplerian element set to position and velocity vectors
+
+        Returns:
+            tuple[npt.ArrayLike[np.float64], npt.ArrayLike[np.float64]]: Tuple with two elements representing the position and velocity vectors
+        """
+
+    def from_pv(
+        pos: npt.ArrayLike[np.float64], vel: npt.ArrayLike[np.float64]
+    ) -> kepler:
+        """Create Keplerian element set from input position and velocity vectors
+
+        Args:
+            pos (npt.ArrayLike[np.float64]): 3-element array representing position vector
+            vel (npt.ArrayLike[np.float64]): 3-element array representing velocity vector
+
+        Returns:
+            satkit.kepler: Keplerian element set object
+        """
+
 class itrfcoord:
     """ Representation of a coordinate in the International Terrestrial Reference Frame (ITRF)
 

{satkit-0.2.7 → satkit-0.2.8/python/satkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.2.7
+Version: 0.2.8
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>
@@ -21,6 +21,7 @@ Requires-Dist: numpy>=1.20.0
 
 An accurate, high-performance satellite orbital kinematics toolkit, written in Rust with a sensible interface.
 <br/>
+Also includes python bindings for *all* functions via via [pyo3](https://pyo3.rs/)
 
 ### Github
 
@@ -48,7 +49,7 @@ An accurate, high-performance satellite orbital kinematics toolkit, written in R
 - **Native Rust** bindings
 - **Python bindings** for compiled rust code ... speed of Rust with convenience of Python<br/>
   Install with `pip install satkit`<br/>
-  PyPi includes binaries for windows, macos (Intel & arm), and linux
+  PyPi includes binary packages for windows, macos (Intel & ARM), and linux.  Python documentation is at: <https://satellite-toolkit.readthedocs.io/latest/>
 
 ## Features
 

{satkit-0.2.7 → satkit-0.2.8}/python/satkit.egg-info/SOURCES.txt

@@ -20,7 +20,6 @@ python/satkit.egg-info/SOURCES.txt
 python/satkit.egg-info/dependency_links.txt
 python/satkit.egg-info/requires.txt
 python/satkit.egg-info/top_level.txt
-python/satkit/astro-data/py.typed
 python/test/download_data.py
 python/test/download_from_json.py
 python/test/download_testvecs.py
@@ -34,6 +33,7 @@ src/earth_orientation_params.rs
 src/earthgravity.rs
 src/itrfcoord.rs
 src/jplephem.rs
+src/kepler.rs
 src/lib.rs
 src/nrlmsise.rs
 src/solarsystem.rs
@@ -45,6 +45,7 @@ src/frametransform/mod.rs
 src/frametransform/qcirs2gcrs.rs
 src/lpephem/mod.rs
 src/lpephem/moon.rs
+src/lpephem/planets.rs
 src/lpephem/sun.rs
 src/ode/harmonic_oscillator.rs
 src/ode/mod.rs
@@ -80,6 +81,7 @@ src/pybindings/pyframetransform.rs
 src/pybindings/pygravity.rs
 src/pybindings/pyitrfcoord.rs
 src/pybindings/pyjplephem.rs
+src/pybindings/pykepler.rs
 src/pybindings/pylpephem_moon.rs
 src/pybindings/pylpephem_sun.rs
 src/pybindings/pynrlmsise.rs

{satkit-0.2.7 → satkit-0.2.8}/python/test/orbitprop_gps_fit.py

@@ -1,3 +1,4 @@
+# %%
 """
 This function reads an SP3 file containing precise GPS locaions in the ITRF frame
 
@@ -24,16 +25,30 @@ import os
 basedir = os.getenv(
     "SATKIT_TESTVEC_ROOT", default="../.." + os.path.sep + "satkit-testvecs"
 )
-fname = (
-    basedir
-    + os.path.sep
-    + "orbitprop"
-    + os.path.sep
-    + "ESA0OPSFIN_20233640000_01D_05M_ORB.SP3"
-)
 
-# Get positions and times from SP3 file
-[pitrf, timearr] = read_sp3file(fname)
+sp3names = ['mid22630.sp3', 'mid22631.sp3', 'mid22632.sp3',
+          'mid22633.sp3', 'mid22634.sp3', 'mid22635.sp3',
+          'mid22636.sp3']
+
+sp3names = ['mid22630.sp3', 'mid22631.sp3', 'mid22632.sp3']
+pitrf = np.zeros((0,3), np.float64)
+timearr = np.array([])
+
+for sp3name in sp3names:
+    fname = (
+        basedir
+        + os.path.sep
+        + "orbitprop"
+        + os.path.sep
+        + sp3name
+    )
+    [pitrf1, timearray1] = read_sp3file(fname)
+    pitrf = np.append(pitrf, pitrf1, axis=0)
+    timearr = np.append(timearr, timearray1)
+
+print(pitrf.shape)
+print(timearr.shape)
+print(timearr[0], timearr[-1])
 
 # Rotate positions to the GCRF frame
 pgcrf = np.stack(
@@ -42,13 +57,12 @@ pgcrf = np.stack(
     ),
     axis=0,
 )
-
 # Crude estimation of initial velocity
 vgcrf = (pgcrf[1, :] - pgcrf[0, :]) / (timearr[1] - timearr[0]).seconds()
 
 # Initial state for non-linear least squares is initial velocity
 # and susceptibility to radiation pressuer : Cr A / m
-v0 = np.array([vgcrf[0], vgcrf[1], vgcrf[2], 1 * 10**2 / 5000])
+v0 = np.array([vgcrf[0], vgcrf[1], vgcrf[2], 0.01])
 
 
 def minfunc(v):
@@ -68,6 +82,7 @@ def minfunc(v):
         propsettings=settings,
         satproperties=satprops,
     )
+
     return np.sum(np.sum((res["pos"] - pgcrf) ** 2, axis=1), axis=0)
 
 
@@ -75,3 +90,23 @@ def minfunc(v):
 # by tuning initial velocity and CrAoverM
 r = minimize(minfunc, v0, method="Nelder-Mead")
 print(r)
+
+# %%
+import plotly.graph_objects as go
+
+settings = sk.satprop.propsettings()
+settings.use_jplephem = False
+satprops = sk.satprop.satproperties_static()
+satprops.craoverm = r.x[3]
+res = sk.satprop.propagate(
+    pgcrf[0,:], r.x[0:3], timearr[0],
+    stoptime=timearr[-1], dt=sk.duration(minutes=5),
+    propsettings=settings, satproperties=satprops
+)
+perr = res['pos'] - pgcrf
+fig = go.Figure()
+fig.add_trace(go.Scatter(x=[t.datetime() for t in timearr], y=perr[:,0], mode='lines', name='X'))
+fig.add_trace(go.Scatter(x=[t.datetime() for t in timearr], y=perr[:,1], mode='lines', name='Y'))
+fig.add_trace(go.Scatter(x=[t.datetime() for t in timearr], y=perr[:,2], mode='lines', name='Z'))
+
+# %%

{satkit-0.2.7 → satkit-0.2.8}/python/test/test.py

@@ -121,6 +121,44 @@ class TestTime:
         assert minute == 0
         assert sec == 0
 
+class TestKepler:
+    def test_kepler_from_pv(self):
+        """
+        Test creation of Kepler elements from position and velocity
+        """
+    
+        # Test case from Vallado, example 2-6
+        r = np.array([6524.834, 6862.875, 6448.296])*1.0e3
+        v = np.array([4.901327, 5.533756, -1.976341])*1.0e3
+        kep = sk.kepler.from_pv(r, v)
+        rad2deg = 180.0/m.pi
+        print(kep)
+        assert kep.a == pytest.approx(36127343, 1.0e-3)
+        assert kep.eccen == pytest.approx(0.83285, 1.0e-5)
+        assert kep.inclination*rad2deg == pytest.approx(87.87, 1.0e-3)
+        assert kep.raan*rad2deg == pytest.approx(227.89, 1.0e-3)
+        assert kep.w*rad2deg == pytest.approx(53.38, 1.0e-3)
+        assert kep.nu*rad2deg == pytest.approx(92.335, 1.0e-3)
+
+    def test_kepler_to_pv(self):
+        """
+        Test conversion of Kepler elements to position and velocity
+        """
+        p = 11067790
+        eccen = 0.83285
+        incl = 87.87*m.pi/180
+        raan = 227.89*m.pi/180
+        w = 53.38*m.pi/180
+        nu = 92.335*m.pi/180
+
+        a = p/(1-eccen**2)
+        kep = sk.kepler(a, eccen, incl, raan, w, nu)
+        pos, vel = kep.to_pv()
+        assert pos == pytest.approx(np.array([6525.368, 6861.532, 6449.119])*1.0e3, 1.0e-3)
+        assert vel == pytest.approx(np.array([4.902279, 5.533140, -1.975710])*1.0e3, 1.0e-3)
+
+
+
 class TestJPLEphem:
     def test_jplephem_testvecs(self):
         """

{satkit-0.2.7 → satkit-0.2.8}/src/astrotime.rs

@@ -423,7 +423,7 @@ impl AstroTime {
     /// # Returns
     ///
     /// * AstroTime Object
-    pub fn from_date(year: u32, month: u32, day: u32) -> AstroTime {
+    pub fn from_date(year: i32, month: u32, day: u32) -> AstroTime {
         AstroTime::from_mjd(date2mjd_utc(year, month, day) as f64, Scale::UTC)
     }
 
@@ -500,7 +500,7 @@ impl AstroTime {
     /// * AstroTime object
     #[inline]
     pub fn from_datetime(
-        year: u32,
+        year: i32,
         month: u32,
         day: u32,
         hour: u32,
@@ -526,7 +526,7 @@ impl AstroTime {
     ///
     /// * AstroTime object
     pub fn from_datetime_with_scale(
-        year: u32,
+        year: i32,
         month: u32,
         day: u32,
         hour: u32,
@@ -649,7 +649,7 @@ fn mjd_utc2date(mjd_utc: f64) -> (u32, u32, u32) {
     (year as u32, month as u32, day as u32)
 }
 
-fn date2mjd_utc(year: u32, month: u32, day: u32) -> i32 {
+fn date2mjd_utc(year: i32, month: u32, day: u32) -> i32 {
     // Chapter 15 "Calendars" section 15.11.3 of the
     // Explanatory Suppliment to the Astronomical Almanac
     // Algorithm 3

{satkit-0.2.7 → satkit-0.2.8}/src/frametransform/mod.rs

@@ -210,7 +210,7 @@ pub fn qgcrf2itrf_approx(tm: &AstroTime) -> Quat {
     // Neglecting polar motion
     let qitrf2tod_approx: Quat = qrot_zcoord(-gast(tm));
 
-    qmod2gcrf(tm) * qtod2mod_approx(tm) * qitrf2tod_approx
+    (qmod2gcrf(tm) * qtod2mod_approx(tm) * qitrf2tod_approx).conjugate()
 }
 
 ///

{satkit-0.2.7 → satkit-0.2.8}/src/jplephem.rs

@@ -38,17 +38,17 @@ impl TryFrom<i32> for SolarSystem {
     type Error = ();
     fn try_from(v: i32) -> Result<Self, Self::Error> {
         match v {
-            x if x == SolarSystem::MERCURY as i32 => Ok(SolarSystem::MERCURY),
-            x if x == SolarSystem::VENUS as i32 => Ok(SolarSystem::VENUS),
+            x if x == SolarSystem::Mercury as i32 => Ok(SolarSystem::Mercury),
+            x if x == SolarSystem::Venus as i32 => Ok(SolarSystem::Venus),
             x if x == SolarSystem::EMB as i32 => Ok(SolarSystem::EMB),
-            x if x == SolarSystem::MARS as i32 => Ok(SolarSystem::MARS),
-            x if x == SolarSystem::JUPITER as i32 => Ok(SolarSystem::JUPITER),
-            x if x == SolarSystem::SATURN as i32 => Ok(SolarSystem::SATURN),
-            x if x == SolarSystem::URANUS as i32 => Ok(SolarSystem::URANUS),
-            x if x == SolarSystem::NEPTUNE as i32 => Ok(SolarSystem::NEPTUNE),
-            x if x == SolarSystem::PLUTO as i32 => Ok(SolarSystem::PLUTO),
-            x if x == SolarSystem::MOON as i32 => Ok(SolarSystem::MOON),
-            x if x == SolarSystem::SUN as i32 => Ok(SolarSystem::SUN),
+            x if x == SolarSystem::Mars as i32 => Ok(SolarSystem::Mars),
+            x if x == SolarSystem::Jupiter as i32 => Ok(SolarSystem::Jupiter),
+            x if x == SolarSystem::Saturn as i32 => Ok(SolarSystem::Saturn),
+            x if x == SolarSystem::Uranus as i32 => Ok(SolarSystem::Uranus),
+            x if x == SolarSystem::Neptune as i32 => Ok(SolarSystem::Neptune),
+            x if x == SolarSystem::Pluto as i32 => Ok(SolarSystem::Pluto),
+            x if x == SolarSystem::Moon as i32 => Ok(SolarSystem::Moon),
+            x if x == SolarSystem::Sun as i32 => Ok(SolarSystem::Sun),
             _ => Err(()),
         }
     }
@@ -130,7 +130,7 @@ impl JPLEphem {
     /// let t = AstroTime::from_datetime(2021, 3, 1, 12, 0, 0.0);
     ///
     /// // Find geocentric moon position at this time in the GCRF frame
-    /// let p = jplephem::geocentric_pos(SolarSystem::MOON, &t).unwrap();
+    /// let p = jplephem::geocentric_pos(SolarSystem::Moon, &t).unwrap();
     /// println!("p = {}", p);
     /// ```
     ///
@@ -453,11 +453,11 @@ impl JPLEphem {
     ///    3-vector of cartesian Geocentric position in meters
     ///
     fn geocentric_pos(&self, body: SolarSystem, tm: &AstroTime) -> SKResult<Vec3> {
-        if body == SolarSystem::MOON {
+        if body == SolarSystem::Moon {
             return self.barycentric_pos(body, tm);
         } else {
             let emb: Vec3 = self.barycentric_pos(SolarSystem::EMB, tm)?;
-            let moon: Vec3 = self.barycentric_pos(SolarSystem::MOON, tm)?;
+            let moon: Vec3 = self.barycentric_pos(SolarSystem::Moon, tm)?;
             let b: Vec3 = self.barycentric_pos(body, tm)?;
 
             // Compute the position of the body relative to the Earth-moon
@@ -483,11 +483,11 @@ impl JPLEphem {
     ///       Note: velocity is relative to Earth
     ///
     fn geocentric_state(&self, body: SolarSystem, tm: &AstroTime) -> SKResult<(Vec3, Vec3)> {
-        if body == SolarSystem::MOON {
+        if body == SolarSystem::Moon {
             return self.barycentric_state(body, tm);
         } else {
             let emb: (Vec3, Vec3) = self.barycentric_state(SolarSystem::EMB, tm)?;
-            let moon: (Vec3, Vec3) = self.barycentric_state(SolarSystem::MOON, tm)?;
+            let moon: (Vec3, Vec3) = self.barycentric_state(SolarSystem::Moon, tm)?;
             let b: (Vec3, Vec3) = self.barycentric_state(body, tm)?;
 
             // Compute the position of the body relative to the Earth-moon
@@ -613,7 +613,7 @@ mod tests {
 
         let tm = AstroTime::from_jd(2451545.0, Scale::TT);
         //let tm = &AstroTime::from_jd(2451545.0, Scale::UTC);
-        let (_, _): (Vec3, Vec3) = jpl.geocentric_state(SolarSystem::MOON, &tm).unwrap();
+        let (_, _): (Vec3, Vec3) = jpl.geocentric_state(SolarSystem::Moon, &tm).unwrap();
         println!("au = {:.20}", jpl._au);
     }
 
@@ -672,7 +672,7 @@ mod tests {
                     let (_mpos, mvel): (Vec3, Vec3) = jplephem_singleton()
                         .as_ref()
                         .unwrap()
-                        .geocentric_state(SolarSystem::MOON, &tm)
+                        .geocentric_state(SolarSystem::Moon, &tm)
                         .unwrap();
                     // Scale Earth velocity
                     tvel = tvel - mvel / (1.0 + jplephem_singleton().as_ref().unwrap().emrat);
@@ -682,7 +682,7 @@ mod tests {
                     let (_mpos, mvel): (Vec3, Vec3) = jplephem_singleton()
                         .as_ref()
                         .unwrap()
-                        .geocentric_state(SolarSystem::MOON, &tm)
+                        .geocentric_state(SolarSystem::Moon, &tm)
                         .unwrap();
                     //Scale Earth velocity
                     svel = svel - mvel / (1.0 + jplephem_singleton().as_ref().unwrap().emrat);

satkit-0.2.8/src/kepler.rs

@@ -0,0 +1,159 @@
+//! Keplerian orbital elements module
+//! 
+
+// External library imports
+use nalgebra::{Vector3, UnitQuaternion};
+type Vec3 = Vector3<f64>;
+type Quat = UnitQuaternion<f64>;
+
+/// Keplerian Orbital Elements
+/// 
+/// The 6 Keplerian orbital elements are:
+/// a: semi-major axis, meters
+/// eccen: Eccentricity
+/// incl: Inclination, radians
+/// RAAN: Right Ascension of the Ascending Node, radians
+/// w: Argument of Perigee, radians
+/// nu: True Anomaly, radians
+#[derive(Debug, Clone)]
+pub struct Kepler {
+    pub a: f64,
+    pub eccen: f64,
+    pub incl: f64,
+    pub raan: f64,
+    pub w: f64,
+    pub nu: f64, // True anomaly
+}
+
+impl Kepler {
+    /// Create a new Keplerian orbital element object
+    /// 
+    /// # Arguments
+    /// 
+    /// * `a` - Semi-major axis, meters
+    /// * `e` - Eccentricity
+    /// * `i` - Inclination, radians
+    /// * `raan` - Right Ascension of the Ascending Node, radians
+    /// * `argp` - Argument of Perigee, radians
+    /// * `nu` - True Anomaly, radians
+    /// 
+    /// # Returns
+    /// 
+    /// * `Kepler` - A new Keplerian orbital element object
+    pub fn new(a: f64, e: f64, i: f64, raan: f64, argp: f64, nu: f64) -> Kepler {
+        Kepler {
+            a: a,
+            eccen: e,
+            incl: i,
+            raan: raan,
+            w: argp,
+            nu: nu,
+        }
+    }
+
+    /// Convert Cartesian coordinates to Keplerian orbital elements
+    /// 
+    /// # Arguments
+    /// 
+    /// * `r` - Position vector, meters
+    /// * `v` - Velocity vector, meters/second
+    /// 
+    /// # Returns
+    /// 
+    /// * `Kepler` - A new Keplerian orbital element object
+    /// 
+    pub fn from_pv(r: Vec3, v: Vec3) -> Kepler {
+        let h = r.cross(&v);
+        let n = Vec3::z_axis().cross(&h);
+        let e = 
+        ((v.norm_squared() - 
+            crate::consts::MU_EARTH / r.norm()) * r - r.dot(&v) * v) / crate::consts::MU_EARTH;
+        let eccen = e.norm();
+        let xi = v.norm().powi(2) / 2.0 - crate::consts::MU_EARTH / r.norm();
+        let a = -crate::consts::MU_EARTH / (2.0 * xi);
+        let incl = (h.z/h.norm()).acos();
+        let mut raan = (n.x/n.norm()).acos();
+        if n.y < 0.0 {
+            raan = 2.0 * std::f64::consts::PI - raan;
+        }
+        let mut w = (n.dot(&e)/n.norm()/e.norm()).acos();
+        if e.z < 0.0 {
+            w = 2.0 * std::f64::consts::PI - w;
+        }
+        let mut nu =  (r.dot(&e)/r.norm()/e.norm()).acos();
+        if r.dot(&v) < 0.0 {
+            nu = 2.0 * std::f64::consts::PI - nu;
+        }  
+        Kepler::new(a, eccen, incl, raan, w, nu)
+    }
+
+    /// Convert Keplerian orbital elements to Cartesian coordinates
+    /// 
+    /// # Returns
+    /// 
+    /// * `(Vec3, Vec3)` - Position and velocity vectors, meters and meters/second
+    /// 
+    pub fn to_pv(&self) -> (Vec3, Vec3) {
+        let p = self.a * (1.0 - self.eccen.powi(2));
+        let r = p / (1.0 + self.eccen * self.nu.cos());
+        let r_pqw = Vec3::new(r * self.nu.cos(), r * self.nu.sin(), 0.0);
+        let v_pqw = Vec3::new(
+            -self.nu.sin(),
+            self.eccen + self.nu.cos(),
+             0.0) * (crate::consts::MU_EARTH/p).sqrt();
+        let q = Quat::from_axis_angle(&Vec3::z_axis(), self.raan) * 
+                Quat::from_axis_angle(&Vec3::x_axis(), self.incl) *
+                Quat::from_axis_angle(&Vec3::z_axis(), self.w);
+        (q * r_pqw, q * v_pqw)
+    }
+}
+
+impl std::fmt::Display for Kepler {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, 
+            "Keplerian Elements:\n  a = {:.0} m\n  e = {:.3}\n  i = {:.3} rad\n",
+            self.a, self.eccen, self.incl)?;
+        write!(f, "  Ω = {:.3} rad\n  ω = {:.3} rad\n  ν = {:.3} rad\n", self.raan, self.w, self.nu)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_topv() {
+        // Example 2-6 from Vallado
+        let p = 11067790.0;
+        let eccen = 0.83285_f64;
+        let incl = 87.87_f64.to_radians();
+        let raan = 227.89_f64.to_radians();
+        let w = 53.38_f64.to_radians();
+        let nu = 92.335_f64.to_radians();
+
+        let a = p / (1.0 - eccen.powi(2));
+
+        let k = Kepler::new(a, eccen, incl, raan, w, nu);
+        let (r, v) = k.to_pv();
+        // Note: values below are not incorrect in the book, but are 
+        // corrected in the online errata
+        // See: https://celestrak.org/software/vallado/ErrataVer4.pdf
+        assert!((r*1.0e-3 - Vec3::new(6525.368, 6861.532, 6449.119)).norm() < 1e-3);
+        assert!((v*1.0e-3 - Vec3::new(4.902279, 5.533140, -1.975710)).norm() < 1e-3);
+    }
+
+    #[test]
+    fn test_frompv() {
+        // Vallado example 2-5
+        let r = Vec3::new(6524.834, 6862.875, 6448.296)*1.0e3;
+        let v = Vec3::new(4.901327, 5.533756, -1.976341)*1.0e3;
+        let k = Kepler::from_pv(r, v);
+        assert!((k.a - 36127343_f64).abs() < 1.0e3);
+        assert!((k.eccen - 0.83285).abs() < 1e-3);
+        assert!((k.incl - 87.87_f64.to_radians()).abs() < 1e-3);
+        assert!((k.raan - 227.89_f64.to_radians()).abs() < 1e-3);
+        assert!((k.w - 53.38_f64.to_radians()).abs() < 1e-3);
+        assert!((k.nu - 92.335_f64.to_radians()).abs() < 1e-3);
+    }
+}
+  

{satkit-0.2.7 → satkit-0.2.8}/src/lib.rs

@@ -61,6 +61,8 @@ pub mod spaceweather;
 pub mod tle;
 /// Utility functions
 pub mod utils;
+/// Keplerian orbital elements
+pub mod kepler;
 
 // Integrate ordinary differential equations
 mod ode;

satkit-0.2.8/src/lpephem/mod.rs

@@ -0,0 +1,9 @@
+/// Lunar calculations
+pub mod moon;
+/// Solar calculations
+pub mod sun;
+
+// This part isn't working yet...
+// mod planets;
+// pub use planets::barycentric_pos;
+