open-space-toolkit-astrodynamics 15.0.0__py313-none-manylinux2014_x86_64.whl → 15.2.0__py313-none-manylinux2014_x86_64.whl

ostk/astrodynamics/solver.pyi

@@ -3,7 +3,7 @@ import numpy
 import ostk.core.type
 import ostk.physics.time
 import typing
-__all__ = ['FiniteDifferenceSolver', 'TemporalConditionSolver']
+__all__ = ['FiniteDifferenceSolver', 'LeastSquaresSolver', 'TemporalConditionSolver']
 class FiniteDifferenceSolver:
     """
     
@@ -166,6 +166,214 @@ class FiniteDifferenceSolver:
                         Returns:
                             FiniteDifferenceSolver.Type: The type.
         """
+class LeastSquaresSolver:
+    """
+    
+                Class to solve non-linear least squares problems.
+            
+    """
+    class Analysis:
+        """
+        
+                    Class representing the analysis of the least squares solver.
+                
+        """
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __init__(self, termination_criteria: ostk.core.type.String, estimated_state: typing.Any, estimated_covariance: numpy.ndarray[numpy.float64[m, n]], estimated_frisbee_covariance: numpy.ndarray[numpy.float64[m, n]], computed_observations: list[...], steps: list[LeastSquaresSolver.Step]) -> None:
+            """
+                            Constructor.
+            
+                            Args:
+                                termination_criteria (str): The termination criteria.
+                                estimated_state (State): The estimated state.
+                                estimated_covariance (np.ndarray): The estimated covariance matrix.
+                                estimated_frisbee_covariance (np.ndarray): The estimated Frisbee covariance matrix.
+                                computed_observations (list[State]): The computed observations of the final iteration.
+                                steps (list[LeastSquaresSolver.Step]): The steps.
+            """
+        def __repr__(self) -> str:
+            ...
+        def __str__(self) -> str:
+            ...
+        def compute_residual_states(self, observations: list[...]) -> list[...]:
+            """
+                        Compute the residual states.
+            
+                        Args:
+                            observations (list[State]): The observations.
+            
+                        Returns:
+                            list[State]: The residuals.
+            """
+        @property
+        def computed_observations(self) -> list[...]:
+            """
+                            The computed observations of the final iteration.
+            
+                            :type: np.ndarray
+            """
+        @property
+        def estimated_covariance(self) -> numpy.ndarray[numpy.float64[m, n]]:
+            """
+                            The estimated covariance matrix.
+            
+                            :type: np.ndarray
+            """
+        @property
+        def estimated_frisbee_covariance(self) -> numpy.ndarray[numpy.float64[m, n]]:
+            """
+                            The estimated Frisbee covariance matrix.
+            
+                            :type: np.ndarray
+            """
+        @property
+        def estimated_state(self) -> ...:
+            """
+                            The estimated state.
+            
+                            :type: State
+            """
+        @property
+        def iteration_count(self) -> int:
+            """
+                            The iteration count.
+            
+                            :type: int
+            """
+        @property
+        def observation_count(self) -> int:
+            """
+                            The observation count.
+            
+                            :type: int
+            """
+        @property
+        def rms_error(self) -> ostk.core.type.Real:
+            """
+                            The RMS error.
+            
+                            :type: float
+            """
+        @property
+        def steps(self) -> list[LeastSquaresSolver.Step]:
+            """
+                            The steps.
+            
+                            :type: list[LeastSquaresSolver.Step]
+            """
+        @property
+        def termination_criteria(self) -> ostk.core.type.String:
+            """
+                            The termination criteria.
+            
+                            :type: str
+            """
+    class Step:
+        """
+        
+                    Class representing a step in the least squares solver.
+                
+        """
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __init__(self, rms_error: ostk.core.type.Real, x_hat: numpy.ndarray[numpy.float64[m, 1]]) -> None:
+            """
+                            Constructor.
+            
+                            Args:
+                                rms_error (float): The RMS error.
+                                x_hat (np.ndarray): The X hat vector.
+            """
+        def __repr__(self) -> str:
+            ...
+        def __str__(self) -> str:
+            ...
+        @property
+        def rms_error(self) -> ostk.core.type.Real:
+            """
+                            The RMS error.
+            
+                            :type: float
+            """
+        @property
+        def x_hat(self) -> numpy.ndarray[numpy.float64[m, 1]]:
+            """
+                            The X hat vector.
+            
+                            :type: np.ndarray
+            """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @staticmethod
+    def calculate_empirical_covariance(residuals: list[...]) -> numpy.ndarray[numpy.float64[m, n]]:
+        """
+                        Calculate the empirical covariance matrix from an array of state residuals.
+        
+                        Args:
+                            residuals (list[State]): A list of state residuals.
+        
+                        Returns:
+                            np.ndarray: The empirical covariance matrix.
+        
+                        Throws:
+                            ostk::core::error::runtime::Undefined: If the residual array is empty.
+        """
+    @staticmethod
+    def default() -> LeastSquaresSolver:
+        """
+                        Create a default instance of LeastSquaresSolver.
+        
+                        Returns:
+                            LeastSquaresSolver: A default instance of LeastSquaresSolver.
+        """
+    def __init__(self, maximum_iteration_count: int, rms_update_threshold: ostk.core.type.Real, finite_difference_solver: FiniteDifferenceSolver = ...) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            maximum_iteration_count (int): Maximum number of iterations.
+                            rms_update_threshold (float): Minimum RMS threshold.
+                            finite_difference_solver (FiniteDifferenceSolver): Finite difference solver. Defaults to FiniteDifferenceSolver.Default().
+        """
+    def get_finite_difference_solver(self) -> FiniteDifferenceSolver:
+        """
+                        Get the finite difference solver.
+        
+                        Returns:
+                            FiniteDifferenceSolver: The finite difference solver.
+        """
+    def get_max_iteration_count(self) -> int:
+        """
+                        Get the maximum iteration count.
+        
+                        Returns:
+                            int: The maximum iteration count.
+        """
+    def get_rms_update_threshold(self) -> ostk.core.type.Real:
+        """
+                        Get the RMS update threshold.
+        
+                        Returns:
+                            float: The RMS update threshold.
+        """
+    def solve(self, initial_guess: typing.Any, observations: list[...], state_generator: typing.Callable[[..., list[ostk.physics.time.Instant]], list[...]], initial_guess_sigmas: dict[..., numpy.ndarray[numpy.float64[m, 1]]] = {}, observation_sigmas: dict[..., numpy.ndarray[numpy.float64[m, 1]]] = {}) -> LeastSquaresSolver.Analysis:
+        """
+                        Solve the non-linear least squares problem.
+        
+                        Args:
+                            initial_guess (State): Initial guess state (the Estimated State is of the same domain as this state).
+                            observations (list[State]): List of observations.
+                            state_generator (callable[list[State],[State, list[Instant]]]): Function to generate states.
+                            initial_guess_sigmas (dict[CoordinateSubset, np.ndarray], optional): Dictionary of sigmas for initial guess.
+                            observation_sigmas (dict[CoordinateSubset, np.ndarray], optional): Dictionary of sigmas for observations.
+        
+                        Returns:
+                            LeastSquaresSolver::Analysis: The analysis of the estimate.
+        """
 class TemporalConditionSolver:
     """
     

ostk/astrodynamics/test/access/test_visibility_criterion.py

@@ -9,6 +9,7 @@ from ostk.physics import Environment
 from ostk.physics.time import Instant
 from ostk.physics.time import DateTime
 from ostk.physics.time import Scale
+from ostk.physics.unit import Angle
 
 from ostk.astrodynamics.access import VisibilityCriterion
 
@@ -152,9 +153,11 @@ class TestVisibilityCriterion:
         elevation_criterion = VisibilityCriterion.ElevationInterval(elevation_interval)
         elevation_valid = np.pi / 8  # 22.5 degrees
         assert elevation_criterion.is_satisfied(elevation_valid) is True
+        assert elevation_criterion.is_satisfied(Angle.radians(elevation_valid)) is True
 
         elevation_invalid = np.pi / 2  # 90 degrees
         assert elevation_criterion.is_satisfied(elevation_invalid) is False
+        assert elevation_criterion.is_satisfied(Angle.radians(elevation_invalid)) is False
 
     def test_line_of_sight_is_satisfied(
         self,

ostk/astrodynamics/test/estimator/test_orbit_determination_solver.py

@@ -0,0 +1,261 @@
+# Apache License 2.0
+
+import pytest
+
+import pandas as pd
+
+import numpy as np
+
+from ostk.physics import Environment
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+from ostk.physics.environment.object.celestial import Earth
+
+from ostk.astrodynamics.solver import LeastSquaresSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory import Propagator
+from ostk.astrodynamics.trajectory.state import NumericalSolver
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+from ostk.astrodynamics.estimator import OrbitDeterminationSolver
+from ostk.astrodynamics.dataframe import generate_states_from_dataframe
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment(central_celestial_object=Earth.EGM96(10, 10), objects=[])
+
+
+@pytest.fixture
+def numerical_solver() -> NumericalSolver:
+    return NumericalSolver.default()
+
+
+@pytest.fixture
+def least_squares_solver() -> LeastSquaresSolver:
+    return LeastSquaresSolver.default()
+
+
+@pytest.fixture
+def orbit_determination_solver(
+    environment: Environment,
+    numerical_solver: NumericalSolver,
+    least_squares_solver: LeastSquaresSolver,
+) -> OrbitDeterminationSolver:
+    return OrbitDeterminationSolver(
+        environment=environment,
+        numerical_solver=numerical_solver,
+        solver=least_squares_solver,
+    )
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+    ]
+
+
+@pytest.fixture
+def initial_guess(
+    observations: list[State],
+) -> State:
+    return observations[0]
+
+
+@pytest.fixture
+def observations() -> list[State]:
+    return generate_states_from_dataframe(
+        pd.read_csv(
+            "/app/test/OpenSpaceToolkit/Astrodynamics/Estimator/OrbitDeterminationSolverData/gnss_data.csv"
+        ),
+        reference_frame=Frame.ITRF(),
+    )
+
+
+@pytest.fixture
+def initial_guess_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1, 1e-1, 1e-1],
+        coordinate_subsets[1]: [1e-2, 1e-2, 1e-2],
+    }
+
+
+@pytest.fixture
+def observation_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1, 1e-1, 1e-1],
+        coordinate_subsets[1]: [1e-2, 1e-2, 1e-2],
+    }
+
+
+@pytest.fixture
+def rms_error() -> float:
+    return 1.0
+
+
+@pytest.fixture
+def x_hat() -> np.ndarray:
+    return np.array([1.0, 0.0])
+
+
+@pytest.fixture
+def step(
+    rms_error: float,
+    x_hat: np.ndarray,
+) -> LeastSquaresSolver.Step:
+    return LeastSquaresSolver.Step(
+        rms_error=rms_error,
+        x_hat=x_hat,
+    )
+
+
+@pytest.fixture
+def observation_count() -> int:
+    return 5
+
+
+@pytest.fixture
+def termination_criteria() -> str:
+    return "RMS Update Threshold"
+
+
+@pytest.fixture
+def estimated_state() -> State:
+    return State(
+        Instant.J2000(),
+        [1.0, 0.0],
+        Frame.GCRF(),
+        [CoordinateSubset("Position", 1), CoordinateSubset("Velocity", 1)],
+    )
+
+
+@pytest.fixture
+def estimated_covariance() -> np.ndarray:
+    return np.array([[1.0, 0.0], [0.0, 1.0]])
+
+
+@pytest.fixture
+def estimated_frisbee_covariance() -> np.ndarray:
+    return np.array([[1.0, 0.0], [0.0, 1.0]])
+
+
+@pytest.fixture
+def computed_observations(
+    observations: list[State],
+) -> list[State]:
+    return observations
+
+
+@pytest.fixture
+def steps(step: LeastSquaresSolver.Step) -> list[LeastSquaresSolver.Step]:
+    return [step]
+
+
+@pytest.fixture
+def solver_analysis(
+    termination_criteria: str,
+    estimated_state: State,
+    estimated_covariance: np.ndarray,
+    estimated_frisbee_covariance: np.ndarray,
+    computed_observations: list[State],
+    steps: list[LeastSquaresSolver.Step],
+) -> LeastSquaresSolver.Analysis:
+    return LeastSquaresSolver.Analysis(
+        termination_criteria=termination_criteria,
+        estimated_state=estimated_state,
+        estimated_covariance=estimated_covariance,
+        estimated_frisbee_covariance=estimated_frisbee_covariance,
+        computed_observations=computed_observations,
+        steps=steps,
+    )
+
+
+@pytest.fixture
+def analysis(
+    initial_guess: State,
+    solver_analysis: LeastSquaresSolver.Analysis,
+) -> OrbitDeterminationSolver.Analysis:
+    return OrbitDeterminationSolver.Analysis(
+        estimated_state=initial_guess,
+        solver_analysis=solver_analysis,
+    )
+
+
+class TestOrbitDeterminationSolverAnalysis:
+    def test_constructor(
+        self,
+        analysis: OrbitDeterminationSolver.Analysis,
+    ):
+        assert isinstance(analysis, OrbitDeterminationSolver.Analysis)
+
+    def test_properties(
+        self,
+        analysis: OrbitDeterminationSolver.Analysis,
+    ):
+        assert isinstance(analysis.estimated_state, State)
+        assert isinstance(analysis.solver_analysis, LeastSquaresSolver.Analysis)
+
+
+class TestOrbitDeterminationSolver:
+    def test_constructor(
+        self,
+        orbit_determination_solver: OrbitDeterminationSolver,
+    ):
+        assert isinstance(orbit_determination_solver, OrbitDeterminationSolver)
+
+    def test_access_methods(
+        self,
+        orbit_determination_solver: OrbitDeterminationSolver,
+    ):
+        assert isinstance(orbit_determination_solver.access_environment(), Environment)
+        assert isinstance(orbit_determination_solver.access_propagator(), Propagator)
+        assert isinstance(orbit_determination_solver.access_solver(), LeastSquaresSolver)
+        assert isinstance(orbit_determination_solver.access_estimation_frame(), Frame)
+
+    def test_estimate(
+        self,
+        orbit_determination_solver: OrbitDeterminationSolver,
+        initial_guess: State,
+        observations: list[State],
+        coordinate_subsets: list[CoordinateSubset],
+        initial_guess_sigmas: dict[CoordinateSubset, list[float]],
+        observation_sigmas: dict[CoordinateSubset, list[float]],
+    ):
+        analysis: OrbitDeterminationSolver.Analysis = orbit_determination_solver.estimate(
+            initial_guess=initial_guess,
+            observations=observations,
+            estimation_coordinate_subsets=coordinate_subsets,
+            initial_guess_sigmas=initial_guess_sigmas,
+            observation_sigmas=observation_sigmas,
+        )
+
+        assert isinstance(analysis, OrbitDeterminationSolver.Analysis)
+        assert isinstance(analysis.estimated_state, State)
+        assert isinstance(analysis.solver_analysis, LeastSquaresSolver.Analysis)
+
+    def test_estimate_orbit(
+        self,
+        orbit_determination_solver: OrbitDeterminationSolver,
+        initial_guess: State,
+        observations: list[State],
+        coordinate_subsets: list[CoordinateSubset],
+        initial_guess_sigmas: dict[CoordinateSubset, list[float]],
+        observation_sigmas: dict[CoordinateSubset, list[float]],
+    ):
+        orbit: Orbit = orbit_determination_solver.estimate_orbit(
+            initial_guess=initial_guess,
+            observations=observations,
+            estimation_coordinate_subsets=coordinate_subsets,
+            initial_guess_sigmas=initial_guess_sigmas,
+            observation_sigmas=observation_sigmas,
+        )
+
+        assert isinstance(orbit, Orbit)