satkit 0.3.1__tar.gz → 0.3.2__tar.gz

{satkit-0.3.1 → satkit-0.3.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satkit"
-version = "0.3.1"
+version = "0.3.2"
 edition = "2021"
 description = "Satellite Toolkit"
 readme = "README.md"
@@ -20,7 +20,7 @@ name = "satkit"
 
 
 [dependencies]
-nalgebra = "0.33.0"
+nalgebra = { version = "0.33.0", features = ["serde-serialize"] }
 ndarray = "0.15.4"
 libc = "0.2.158"
 chrono = "0.4.19"
@@ -34,6 +34,8 @@ pyo3 = { version = "0.21", features = ["extension-module"], optional = true }
 ureq = "2.10.1"
 json = "0.12.4"
 process_path = "0.1.4"
+serde = { version = "1.0.130", features = ["derive"] }
+serde-pickle = "1.1.1"
 
 [build-dependencies]
 cc = { version = "1.1.15", features = ["parallel"] }

{satkit-0.3.1/python/satkit.egg-info → satkit-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.3.1
+Version: 0.3.2
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>

{satkit-0.3.1 → satkit-0.3.2}/pyproject.toml

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

{satkit-0.3.1 → satkit-0.3.2}/python/satkit/__init__.pyi

@@ -5,7 +5,6 @@ from . import jplephem
 from . import frametransform
 from . import moon
 from . import sun
-from . import satprop
 from . import density
 from . import utils
 from . import planets
@@ -30,8 +29,13 @@ __all__ = [
     "moon",
     "sun",
     "planets",
-    "satprop",
     "satstate",
     "density",
     "utils",
+    "propagate", 
+    "propsettings",
+    "satproperties_static",
+    "propresult", 
+    "propstats",
+    "satstate",
 ]

{satkit-0.3.1 → satkit-0.3.2}/python/satkit/satkit.pyi

@@ -1491,8 +1491,212 @@ class satstate:
             time (satkit.time|satkit.duration): Time or duration from current time to which to propagate the state
 
         Keyword Args:
-            propsettings: satkit.satprop.propsettings object describing settings to use in the propagation. If omitted, default is used 
+            propsettings: satkit.propsettings object describing settings to use in the propagation. If omitted, default is used 
 
         Returns:
             satstate: New satellite state object representing the state at the new time
-        """
+        """
+
+class propstats:
+    @property
+    def num_eval() -> int:
+        """Number of function evaluations"""
+
+    @property
+    def num_accept() -> int:
+        """Number of accepted steps in adaptive RK integrator"""
+
+    @property
+    def num_reject() -> int:
+        """Number of rejected steps in adaptive RK integrator"""
+
+class propresult:
+    """Results of a satellite propagation
+    
+    This class lets the user access results of the satellite propagation
+    """
+
+    @property
+    def pos() -> npt.ArrayLike[float]:
+        """GCRF position of satellite, meters"""
+
+    @property
+    def vel() -> npt.ArrayLike[float]:
+        """GCRF velocity of satellite, meters/second"""
+
+    @property
+    def state() -> npt.ArrayLike[float]:
+        """6-element state (pos + vel) of satellite in meters & meters/second"""
+
+    @property
+    def time() -> satkit.time:
+        """Time at which state is valid"""
+
+    @property
+    def stats() -> propstats:
+        """Statistics of propagation"""
+
+    @property
+    def phi() -> npt.ArrayLike[np.float64]|None:
+        """6x6 State transition matrix 
+        or None if not computed
+        """        
+
+    def interp(time: satkit.time, output_phi: bool=False) -> npt.ArrayLike[np.float64]|typing.Tuple[npt.ArrayLike[np.float64], npt.ArrayLike[np.float64]]:
+        """Interpolate state at given time
+
+        Args:
+            time (satkit.time): Time at which to interpolate state
+
+        Keyword Arguments:
+            output_phi (bool): Output 6x6 state transition matrix at the interpolated time
+
+        Returns:
+            6-element vector representing state at given time
+            if output_phi, also output 6x6 state transition matrix at given time
+        """
+    
+
+class satproperties_static:
+    """Satellite properties relevant for drag and radiation pressure
+
+    This class lets the satellite radiation pressure and drag
+    paramters be set to static values for duration of propagation
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Create a satproperties_static object with given craoverm and cdaoverm in m^2/kg
+
+        Args:
+            cdaroverm (float): Coefficient of drag times area over mass in m^2/kg
+            craoverm (float): Coefficient of radiation pressure times area over mass in m^2/kg
+        
+        Keyword Arguments:
+            craoverm (float): Coefficient of radiation pressure times area over mass in m^2/kg
+            cdaoverm (float): Coefficient of drag times area over mass in m^2/kg
+
+
+        Notes:
+        The two arguments can be passed as positional arguments or as keyword arguments
+            
+        Example:
+
+        >>> properties = satproperties_static(craoverm = 0.5, cdaoverm = 0.4)
+        
+        or with same output
+        
+        >>> properties = satproperties_static(0.5, 0.4)
+
+        """
+
+        @property
+        def cdaoverm() -> float:
+            """Coeffecient of drag times area over mass.  Units are m^2/kg
+            """
+
+        @property
+        def craoverm() -> float:
+            """Coefficient of radiation pressure times area over mass.  Units are m^2/kg
+            """
+
+
+class propsettings:
+    """This class contains settings used in the high-precision orbit propgator part of the "satkit" python toolbox
+    """
+
+    def __init__(self):
+        """ Create default propsetting object
+
+        Notes:
+            * Default settings:
+                * abs_error: 1e-8
+                * rel_error: 1e-8
+                * gravity_order: 4
+                * use_spaceweather: True
+                * use_jplephem: True
+
+
+        Returns:
+            propsettings: New propsettings object with default settings
+        """
+
+    @property
+    def abs_error() -> float:
+        """Maxmum absolute value of error for any element in propagated state following ODE integration
+
+        Default: 1e-8
+        """
+
+    @property
+    def rel_error() -> float:
+        """Maximum relative error of any element in propagated state following ODE integration
+
+        Default: 1e-8
+        """
+
+    @property
+    def gravity_order() -> int:
+        """Earth gravity order to use in ODE integration
+
+        Default: 4
+        """
+
+    @property
+    def use_spaceweather() -> bool:
+        """Use space weather data when computing atmospheric density for drag forces
+
+        Default: true
+
+        Notes:
+            * Space weather data can have a large effect on the density of the atmosphere
+            * This can be important for accurate drag force calculations
+            * Space weather data is updated every 3 hours.  Most-recent data can be downloaded with ``satkit.utils.update_datafiles()``
+
+        """
+
+    @property
+    def use_jplephem() -> bool:
+        """Use high-precision but computationally expensive JPL ephemerides for sun and mun when computing their gravitational force
+        """
+
+def propagate(
+    pos: npt.ArrayLike[float],
+    vel: npt.ArrayLike[float],
+    start: time,
+    **kwargs,
+) -> propresult:
+    """High-precision orbit propagator
+
+    Notes:
+        * Propagator uses advanced Runga-Kutta integrators and includes the following forces:
+            * Earth gravity with higher-order zonal terms
+            * Sun, Moon gravity
+            * Radiation pressure
+            * Atmospheric drag: NRL-MISE 2000 density model, with option to include space weather effects (can be large)
+        * Stop time must be set by keyword argument, either explicitely or by duration
+        * Solid Earth tides are not (yet) included in the model
+
+
+    Propagate statellite ephemeris (position, velocity in gcrs & time) to new time
+    and output new position and velocity via Runge-Kutta integration.
+
+    Inputs and outputs are all in the Geocentric Celestial Reference Frame (GCRF)
+
+    Args:
+        pos (npt.ArrayLike[float]): 3-element numpy array representing satellite GCRF position in meters
+        vel (npt.ArrayLike[float]): 3-element numpy array representing satellite GCRF velocity in m/s
+        tm (satkit.time): satkit.time object representing instant at which satellite is at "pos" & "vel"
+
+    Keyword Args: 
+        stop_time (satkit.time): satkit.time object representing instant at which new position and velocity will be computed
+        duration_secs (float): duration in seconds from "tm" for at which new position and velocity will be computed.
+        duration_days (float): duration in days from "tm" at which new position and velocity will be computed.
+        duration (satkit.duration): duration from "tm" at which new position & velocity will be computed.
+        output_phi (bool): Output 6x6 state transition matrix between "starttime" and "stoptime" (and at intervals, if specified)
+        propsettings (propsettings): "propsettings" object with input settings for the propagation. if left out, default will be used.
+        satproperties (satproperties_static): "SatPropertiesStatic" object with drag and radiation pressure succeptibility of satellite. If left out, drag and radiation pressure are neglected
+        output_dense: boolean indicting whether or not dense output should be recorded.  Default is false.  If true, this will allow for calling the "interp" function to query states at arbitrary times between the start time and the stop time
+
+    Returns:
+        (propresult): Propagation result object holding state outputs, statistics, and dense output if requested
+    """

{satkit-0.3.1 → satkit-0.3.2/python/satkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.3.1
+Version: 0.3.2
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>

{satkit-0.3.1 → satkit-0.3.2}/python/test/test.py

@@ -595,7 +595,7 @@ class TestHighPrecisionPropagation:
             ),
             axis=0,
         )
-        settings = sk.satprop.propsettings()
+        settings = sk.propsettings()
         settings.use_jplephem = False
 
         # Determined by orbitprop_gps_fit.py
@@ -605,10 +605,10 @@ class TestHighPrecisionPropagation:
 
 
         # Values for craoverm and velocity come from orbitprop_gps_fit.py
-        satprops = sk.satprop.satproperties_static()
+        satprops = sk.satproperties_static()
         satprops.craoverm = fitparam[3]
 
-        res = sk.satprop.propagate(
+        res = sk.propagate(
             pgcrf[0, :],
             fitparam[0:3],
             timearr[0],

{satkit-0.3.1 → satkit-0.3.2}/src/astrotime.rs

@@ -35,7 +35,11 @@
 //!
 //! For a good description, see [here](https://www.stjarnhimlen.se/comp/time.html)
 //!
-#[derive(PartialEq, PartialOrd, Copy, Clone, Debug)]
+//!
+
+use serde::{Deserialize, Serialize};
+
+#[derive(PartialEq, PartialOrd, Copy, Clone, Debug, Serialize, Deserialize)]
 pub struct AstroTime {
     pub(crate) mjd_tai: f64,
 }

{satkit-0.3.1 → satkit-0.3.2}/src/ode/types.rs

@@ -3,6 +3,8 @@ use std::ops::{Add, Div, Mul, Sub};
 use std::fmt::Debug;
 use thiserror::Error;
 
+use serde::{Deserialize, Serialize};
+
 pub type ODEResult<T> = Result<T, Box<dyn std::error::Error + Send + Sync>>;
 
 pub trait ODEState:
@@ -57,7 +59,7 @@ pub enum ODEError {
     InterpNotImplemented,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DenseOutput<S>
 where
     S: ODEState,
@@ -68,7 +70,7 @@ where
     pub y: Vec<S>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ODESolution<S>
 where
     S: ODEState,

{satkit-0.3.1 → satkit-0.3.2}/src/orbitprop/propagator.rs

@@ -27,7 +27,9 @@ use thiserror::Error;
 
 use nalgebra as na;
 
-#[derive(Debug)]
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct PropagationResult<const T: usize> {
     pub time_start: AstroTime,
     pub state_start: Matrix<6, T>,

{satkit-0.3.1 → satkit-0.3.2}/src/pybindings/mod.rs

@@ -112,16 +112,6 @@ fn frametransform(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     Ok(())
 }
 
-#[pymodule]
-fn satprop(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<PyPropSettings>()?;
-    m.add_class::<pysatproperties::PySatProperties>()?;
-    m.add_function(wrap_pyfunction!(pypropagate::propagate, m)?)
-        .unwrap();
-
-    Ok(())
-}
-
 #[pymodule]
 pub fn satkit(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyAstroTime>()?;
@@ -153,12 +143,18 @@ pub fn satkit(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyKepler>()?;
     m.add_class::<PySatState>()?;
 
+    m.add_class::<PyPropSettings>()?;
+    m.add_class::<pysatproperties::PySatProperties>()?;
+    m.add_class::<pypropresult::PyPropResult>()?;
+    m.add_class::<pypropresult::PyPropStats>()?;
+    m.add_function(wrap_pyfunction!(pypropagate::propagate, m)?)
+        .unwrap();
+
     m.add_wrapped(wrap_pymodule!(frametransform))?;
     m.add_wrapped(wrap_pymodule!(jplephem))?;
     m.add_wrapped(wrap_pymodule!(sun))?;
     m.add_wrapped(wrap_pymodule!(moon))?;
     m.add_wrapped(wrap_pymodule!(planets))?;
-    m.add_wrapped(wrap_pymodule!(satprop))?;
 
     m.add_wrapped(wrap_pymodule!(mod_utils::utils))?;
     m.add_wrapped(wrap_pymodule!(pydensity::density))?;

{satkit-0.3.1 → satkit-0.3.2}/src/pybindings/pypropresult.rs

@@ -3,11 +3,18 @@ use pyo3::prelude::*;
 use super::pyastrotime::PyAstroTime;
 use super::pyutils::*;
 
+use pyo3::types::{PyBytes, PyDict, PyTuple};
+
 use numpy::PyArrayMethods;
 use numpy::{self as np, ToPyArray};
 
 use crate::orbitprop::PropagationResult;
+use crate::types::*;
+use crate::AstroTime;
+
+use serde::{Deserialize, Serialize};
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum PyPropResultType {
     R1(PropagationResult<1>),
     R7(PropagationResult<7>),
@@ -32,6 +39,7 @@ impl PyPropStats {
 }
 
 #[pyclass(name = "propresult", module = "satkit")]
+#[derive(Debug, Clone)]
 pub struct PyPropResult {
     pub inner: PyPropResultType,
 }
@@ -68,6 +76,23 @@ fn to_string<const T: usize>(r: &PropagationResult<T>) -> String {
 
 #[pymethods]
 impl PyPropResult {
+    #[new]
+    /// This should never be called and is here only for pickle support
+    pub fn new() -> Self {
+        PyPropResult {
+            inner: PyPropResultType::R1(PropagationResult::<1> {
+                time_start: AstroTime::new(),
+                state_start: Vector::<6>::zeros(),
+                time_end: AstroTime::new(),
+                state_end: Vector::<6>::zeros(),
+                num_eval: 0,
+                accepted_steps: 0,
+                rejected_steps: 0,
+                odesol: None,
+            }),
+        }
+    }
+
     // Get start time
     #[getter]
     fn time_start(&self) -> PyAstroTime {
@@ -185,6 +210,29 @@ impl PyPropResult {
         }
     }
 
+    fn __getnewargs_ex__<'a>(&self, py: Python<'a>) -> (Bound<'a, PyTuple>, Bound<'a, PyDict>) {
+        let d = PyDict::new_bound(py);
+        let tp = PyTuple::empty_bound(py);
+        (tp, d)
+    }
+
+    fn __setstate__(&mut self, py: Python, state: PyObject) -> PyResult<()> {
+        match state.extract::<&pyo3::types::PyBytes>(py) {
+            Ok(s) => {
+                self.inner =
+                    serde_pickle::from_slice(s.as_bytes(), serde_pickle::DeOptions::default())
+                        .unwrap();
+                Ok(())
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    fn __getstate__(&mut self, py: Python) -> PyResult<PyObject> {
+        let p = serde_pickle::to_vec(&self.inner, serde_pickle::SerOptions::default()).unwrap();
+        Ok(PyBytes::new_bound(py, p.as_slice()).to_object(py))
+    }
+
     #[pyo3(signature=(time, output_phi=false))]
     fn interp(&self, time: PyAstroTime, output_phi: bool) -> PyResult<PyObject> {
         match &self.inner {
@@ -215,3 +263,21 @@ impl PyPropResult {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_ser() {
+        let sol = PyPropResult::new();
+        print!("sol = {:?}\n", sol);
+        let v = serde_pickle::to_vec(&sol.inner, serde_pickle::SerOptions::default()).unwrap();
+        //print!("v = {:?}", v);
+        let sol2 = PyPropResult {
+            inner: serde_pickle::from_slice(v.as_slice(), serde_pickle::DeOptions::default())
+                .unwrap(),
+        };
+        print!("sol2 = {:?}", sol2);
+    }
+}