satkit 0.2.7__tar.gz → 0.2.9__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.2.7
+Version: 0.2.9
 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.9}/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.9}/pyproject.toml

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

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

@@ -8,6 +8,7 @@ from . import sun
 from . import satprop
 from . import density
 from . import utils
+from . import planets
 
 __all__ = [
     "time",
@@ -21,12 +22,14 @@ __all__ = [
     "solarsystem",
     "TLE",
     "itrfcoord",
+    "kepler",
     "consts",
     "frametransform",
     "jplephem",
     "utils",
     "moon",
     "sun",
+    "planets",
     "satprop",
     "density",
     "utils"

{satkit-0.2.7 → satkit-0.2.9}/python/satkit/jplephem.pyi

@@ -1,7 +1,7 @@
 """
 High-precision JPL ephemerides for solar-system bodies
 
-For details, see:
+For details, see: https://ssd.jpl.nasa.gov/
 """
 
 from __future__ import annotations

satkit-0.2.9/python/satkit/planets.pyi

@@ -0,0 +1,28 @@
+"""
+Low-precision planetary ephemerides from https://ssd.jpl.nasa.gov/?planet_pos
+"""
+
+from __future__ import annotations
+import typing
+import numpy.typing as npt
+import numpy as np
+
+import satkit
+
+def heliocentric_pos(body: satkit.solarsystem, tm: satkit.time|list[satkit.time]|npt.ArrayLike[satkit.time]) -> npt.ArrayLike[np.float64]:
+    """Return the position of the given body in the Heliocentric coordinate system (origin is the Sun)
+    
+    Note: This function is only valid for the Sun and the 8 planets
+
+    Note: This is less accurate than using the jpl ephemeris, but involves fewer calculations
+    
+    Note: See https://ssd.jpl.nasa.gov/?planet_pos for more information and accuracy details
+
+    Args:
+        body (satkit.solarsystem): Solar system body for which to return position
+        tm (satkit.time|numpy.ndarray|list): Time[s] at which to return position
+    
+    Returns:
+        numpy.ndarray: 3-vector of Cartesian position in meters, with the origin at the Sun. 
+                       If input is list or numpy array of N times, then r will be Nx3 array
+    """

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

@@ -1050,6 +1050,104 @@ 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
+
+        # Keyword Args:
+            true_anomaly (float) : True anomaly, radians
+            mean_anomaly (float) : Mean anomaly, radians
+            eccentric_anomaly (float) : Eccentric anomaly, radians
+
+        # Notes:
+            * If "nu" is provided (6th argument), it will be used as the true anomaly
+            * Anomaly may also be set via keyword arguments; if so, the there should only be
+              5 input arguments
+            
+        # 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 propagate(self, dt: duration|float) -> kepler:
+        """Propagate Keplerian element set by input duration
+
+        Args:
+            dt (duration | float): Duration by which to propagate the Keplerian element set
+                                   If float, value is seconds
+
+        Returns:
+            satkit.kepler: Keplerian element set object after propagation
+        """
+
+    @property
+    def mean_motion(self) -> float:
+        """Mean motion, radians / second
+        """
+
+    @property
+    def true_anomaly(self) -> float:
+        """True anomaly, radians
+        """
+
+    @property
+    def eccentric_anomaly(self) -> float:
+        """Eccentric anomaly, radians
+        """
+
+    @property
+    def mean_anomaly(self) -> float:
+        """Mean anomaly, radians
+        """
+
+    @property
+    def mean_motion(self) -> float:
+        """Mean motion, radians / second
+        """
+
+    @property
+    def period(self) -> float:
+        """Orbital period, seconds
+        """
+
+    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.9}/python/satkit/satprop.pyi

@@ -113,7 +113,7 @@ class satstate:
         """
 
     @property
-    def pos(self) -> npt.ArrayLike[np.float64]:
+    def pos_gcrf(self) -> npt.ArrayLike[np.float64]:
         """state position in meters in GCRF frame
         
         Returns:
@@ -121,7 +121,7 @@ class satstate:
         """
 
     @property
-    def vel(self) -> npt.ArrayLike[np.float64]:
+    def vel_gcrf(self) -> npt.ArrayLike[np.float64]:
         """Return this state velocity in meters / second in GCRF
 
         Returns:
@@ -154,9 +154,12 @@ class satstate:
             satkit.time: Time instant of this state
         """
 
-    def propagate(self, time: satkit.time, propsettings=None) -> satstate:
+    def propagate(self, time: satkit.time|satkit.duration, propsettings=None) -> satstate:
         """Propagate this state to a new time, specified by the "time" input, updating the position, the velocity, and the covariance if set
 
+        Args:
+            time (satkit.time|satkit.duration): Time or duration from current time to which to propagate the state
+
         Keyword Arguments:
             propsettings: satkit.satprop.propsettings object describing settings to use in the propagation. If omitted, default is used 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.2.7
+Version: 0.2.9
 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.9}/python/satkit.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ python/satkit/density.pyi
 python/satkit/frametransform.pyi
 python/satkit/jplephem.pyi
 python/satkit/moon.pyi
+python/satkit/planets.pyi
 python/satkit/py.typed
 python/satkit/satkit.pyi
 python/satkit/satprop.pyi
@@ -20,7 +21,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
@@ -32,8 +32,10 @@ src/consts.rs
 src/duration.rs
 src/earth_orientation_params.rs
 src/earthgravity.rs
+src/frames.rs
 src/itrfcoord.rs
 src/jplephem.rs
+src/kepler.rs
 src/lib.rs
 src/nrlmsise.rs
 src/solarsystem.rs
@@ -45,6 +47,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
@@ -76,11 +79,14 @@ src/pybindings/pyastrotime.rs
 src/pybindings/pyconsts.rs
 src/pybindings/pydensity.rs
 src/pybindings/pyduration.rs
+src/pybindings/pyframes.rs
 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_planets.rs
 src/pybindings/pylpephem_sun.rs
 src/pybindings/pynrlmsise.rs
 src/pybindings/pypropagate.rs

{satkit-0.2.7 → satkit-0.2.9}/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.9}/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.9}/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.9/src/frames.rs

@@ -0,0 +1,52 @@
+
+
+#[derive(Clone, Debug)]
+pub enum Frame {
+    /// International Terrestrial Reference Frame
+    ITRF,
+    /// Terrestrial Intermediate Reference System
+    TIRS,
+    /// Celestial Intermediate Reference System
+    CIRS,
+    /// Geocentric Celestial Reference Frame
+    GCRF,
+    /// True Equator Mean Equinox
+    TEME,
+    /// Earth Mean Equator 2000
+    EME2000,
+    /// International Celestial Reference Frame
+    ICRF,
+    /// Local Vertical Local Horizontal
+    LVLH,
+}
+
+impl std::fmt::Display for Frame {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Frame::ITRF => write!(f, "ITRF"),
+            Frame::TIRS => write!(f, "TIRS"),
+            Frame::CIRS => write!(f, "CIRS"),
+            Frame::GCRF => write!(f, "GCRF"),
+            Frame::TEME => write!(f, "TEME"),
+            Frame::EME2000 => write!(f, "EME2000"),
+            Frame::ICRF => write!(f, "ICRF"),
+            Frame::LVLH => write!(f, "LVLH"),
+        }
+    }
+}
+
+impl Frame {
+    pub fn from_str(s: &str) -> Result<Self, &'static str> {
+        match s {
+            "ITRF" => Ok(Frame::ITRF),
+            "TIRS" => Ok(Frame::TIRS),
+            "CIRS" => Ok(Frame::CIRS),
+            "GCRF" => Ok(Frame::GCRF),
+            "TEME" => Ok(Frame::TEME),
+            "EME2000" => Ok(Frame::EME2000),
+            "ICRF" => Ok(Frame::ICRF),
+            "LVLH" => Ok(Frame::LVLH),
+            _ => Err("Invalid frame"),
+        }
+    }
+}

{satkit-0.2.7 → satkit-0.2.9}/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.9}/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);