open-space-toolkit-astrodynamics 17.2.0__py312-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/solvers/test_finite_difference_solver.py

@@ -0,0 +1,196 @@
+# Apache License 2.0
+
+from typing import Callable
+
+import pytest
+import math
+
+import numpy as np
+
+from ostk.physics.coordinate import Frame
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+
+from ostk.astrodynamics.solver import FiniteDifferenceSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+
+
+@pytest.fixture
+def step_percentage() -> float:
+    return 1e-3
+
+
+@pytest.fixture
+def step_duration() -> Duration:
+    return Duration.seconds(1e-6)
+
+
+@pytest.fixture(
+    params=[
+        FiniteDifferenceSolver.Type.Forward,
+        FiniteDifferenceSolver.Type.Backward,
+        FiniteDifferenceSolver.Type.Central,
+    ]
+)
+def finite_difference_solver(request, step_percentage: float, step_duration: Duration):
+    return FiniteDifferenceSolver(request.param, step_percentage, step_duration)
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [CoordinateSubset("Position", 1), CoordinateSubset("Velocity", 1)]
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def state(
+    initial_instant: Instant, frame: Frame, coordinate_subsets: list[CoordinateSubset]
+):
+    return State(initial_instant, [1, 0], frame, coordinate_subsets)
+
+
+@pytest.fixture
+def initial_instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def instant(initial_instant: Instant) -> Instant:
+    return initial_instant + Duration.seconds(100.0)
+
+
+@pytest.fixture
+def instants(initial_instant: Instant) -> list[Instant]:
+    return [
+        initial_instant + Duration.seconds(100.0),
+        initial_instant + Duration.seconds(200.0),
+    ]
+
+
+@pytest.fixture
+def generate_states_coordinates() -> Callable:
+    def state_fn(state, instants) -> np.ndarray:
+        x0: float = state.get_coordinates()[0]
+        v0: float = state.get_coordinates()[1]
+        omega: float = 1.0
+
+        states_coordinates: list[list[float]] = []
+
+        for instant in instants:
+            t: float = (instant - state.get_instant()).in_seconds()
+            x: float = x0 * math.cos(omega * t) + v0 / omega * math.sin(omega * t)
+            v: float = -x0 * omega * math.sin(omega * t) + v0 * math.cos(omega * t)
+
+            coordinates: list[float] = list(np.array([x, v]).astype(float))
+
+            states_coordinates.append(coordinates)
+
+        return np.array(states_coordinates).transpose()
+
+    return state_fn
+
+
+@pytest.fixture
+def generate_state_coordinates() -> Callable:
+    def state_fn(state, instant) -> np.ndarray:
+        x0: float = state.get_coordinates()[0]
+        v0: float = state.get_coordinates()[1]
+        omega: float = 1.0
+
+        t: float = (instant - state.get_instant()).in_seconds()
+        x: float = x0 * math.cos(omega * t) + v0 / omega * math.sin(omega * t)
+        v: float = -x0 * omega * math.sin(omega * t) + v0 * math.cos(omega * t)
+
+        return np.array([x, v])
+
+    return state_fn
+
+
+class TestFiniteDifferenceSolver:
+    def test_constructor(self, finite_difference_solver: FiniteDifferenceSolver):
+        assert isinstance(finite_difference_solver, FiniteDifferenceSolver)
+
+    def test_getters(self, finite_difference_solver: FiniteDifferenceSolver):
+        assert isinstance(
+            finite_difference_solver.get_type(), FiniteDifferenceSolver.Type
+        )
+        assert finite_difference_solver.get_step_percentage() is not None
+        assert isinstance(finite_difference_solver.get_step_duration(), Duration)
+
+    def test_string_from_type(self):
+        assert (
+            FiniteDifferenceSolver.string_from_type(FiniteDifferenceSolver.Type.Forward)
+            == "Forward"
+        )
+
+    def test_compute_state_transition_matrix_array(
+        self,
+        finite_difference_solver: FiniteDifferenceSolver,
+        state: State,
+        instants: list[Instant],
+        generate_states_coordinates: Callable,
+    ):
+        stms: list[np.ndarray] = finite_difference_solver.compute_state_transition_matrix(
+            state=state,
+            instants=instants,
+            generate_states_coordinates=generate_states_coordinates,
+        )
+
+        assert len(stms) == len(instants)
+
+        assert stms[0].shape == (
+            len(state.get_coordinates()),
+            len(state.get_coordinates()),
+        )
+
+    def test_compute_state_transition_matrix_single(
+        self,
+        finite_difference_solver: FiniteDifferenceSolver,
+        state: State,
+        generate_state_coordinates: Callable,
+        instant: Instant,
+    ):
+        stm: np.ndarray = finite_difference_solver.compute_state_transition_matrix(
+            state=state,
+            instant=instant,
+            generate_state_coordinates=generate_state_coordinates,
+        )
+        assert isinstance(stm, np.ndarray)
+        assert stm.shape == (
+            len(state.get_coordinates()),
+            len(state.get_coordinates()),
+        )
+
+    def test_compute_gradient(
+        self,
+        finite_difference_solver: FiniteDifferenceSolver,
+        state: State,
+        generate_state_coordinates: Callable,
+    ):
+        gradient = finite_difference_solver.compute_gradient(
+            state=state,
+            generate_state_coordinates=generate_state_coordinates,
+        )
+        assert isinstance(gradient, np.ndarray)
+        assert all(gradient - np.array([0.0, -1.0]) < 1e-6)
+
+    def test_compute_jacobian(
+        self,
+        finite_difference_solver: FiniteDifferenceSolver,
+        state: State,
+        generate_state_coordinates: Callable,
+    ):
+        gradient = finite_difference_solver.compute_jacobian(
+            state=state,
+            generate_state_coordinates=generate_state_coordinates,
+        )
+        assert isinstance(gradient, np.ndarray)
+        assert np.all(gradient - np.array([[0.0, 1.0], [-1.0, 0.0]]) < 1e-6)
+
+    def test_default(self):
+        assert isinstance(FiniteDifferenceSolver.default(), FiniteDifferenceSolver)

ostk/astrodynamics/test/solvers/test_least_squares_solver.py

@@ -0,0 +1,334 @@
+# Apache License 2.0
+
+from typing import Callable
+
+import pytest
+import numpy as np
+
+from ostk.core.type import Real
+from ostk.core.type import String
+
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.solver import LeastSquaresSolver
+from ostk.astrodynamics.solver import FiniteDifferenceSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+
+
+@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 termination_criteria() -> str:
+    return "RMS Update Threshold"
+
+
+@pytest.fixture
+def estimated_state(coordinate_subsets: list[CoordinateSubset]) -> State:
+    return State(
+        Instant.J2000(),
+        [1.0, 0.0],
+        Frame.GCRF(),
+        coordinate_subsets,
+    )
+
+
+@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 observation_count() -> int:
+    return 10
+
+
+@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 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 max_iteration_count() -> int:
+    return 20
+
+
+@pytest.fixture
+def rms_update_threshold() -> float:
+    return 1.0
+
+
+@pytest.fixture
+def finite_difference_solver() -> FiniteDifferenceSolver:
+    return FiniteDifferenceSolver.default()
+
+
+@pytest.fixture
+def least_squares_solver(
+    max_iteration_count: int,
+    rms_update_threshold: float,
+    finite_difference_solver: FiniteDifferenceSolver,
+) -> LeastSquaresSolver:
+    return LeastSquaresSolver(
+        maximum_iteration_count=max_iteration_count,
+        rms_update_threshold=rms_update_threshold,
+        finite_difference_solver=finite_difference_solver,
+    )
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [CoordinateSubset("Position", 1), CoordinateSubset("Velocity", 1)]
+
+
+@pytest.fixture
+def initial_guess_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1],
+        coordinate_subsets[1]: [1e-2],
+    }
+
+
+@pytest.fixture
+def observation_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1],
+        coordinate_subsets[1]: [1e-2],
+    }
+
+
+@pytest.fixture
+def initial_instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def initial_guess(
+    initial_instant: Instant,
+    coordinate_subsets: list[CoordinateSubset],
+    frame: Frame,
+) -> State:
+    return State(initial_instant, [1.0, 0.0], frame, coordinate_subsets)
+
+
+@pytest.fixture
+def observations(
+    initial_instant: Instant,
+    coordinate_subsets: list[CoordinateSubset],
+    frame: Frame,
+    observation_count: int,
+) -> list[State]:
+    return [
+        State(
+            initial_instant + Duration.seconds(float(x)),
+            [np.cos(x), -np.sin(x)],
+            frame,
+            coordinate_subsets,
+        )
+        for x in range(0, observation_count)
+    ]
+
+
+@pytest.fixture
+def state_generator() -> Callable:
+    def state_fn(state, instants) -> list[State]:
+        x0: float = state.get_coordinates()[0]
+        v0: float = state.get_coordinates()[1]
+        omega: float = 1.0
+
+        states: list[State] = []
+
+        for instant in instants:
+            t: float = float((instant - state.get_instant()).in_seconds())
+            x: float = x0 * np.cos(omega * t) + v0 / omega * np.sin(omega * t)
+            v: float = -x0 * omega * np.sin(omega * t) + v0 * np.cos(omega * t)
+
+            states.append(
+                State(instant, [x, v], Frame.GCRF(), state.get_coordinate_subsets())
+            )
+
+        return states
+
+    return state_fn
+
+
+class TestLeastSquaresSolverStep:
+
+    def test_constructor(
+        self,
+        step: LeastSquaresSolver.Step,
+    ):
+        assert isinstance(step, LeastSquaresSolver.Step)
+
+    def test_getters(
+        self,
+        step: LeastSquaresSolver.Step,
+        rms_error: float,
+        x_hat: np.ndarray,
+    ):
+        assert step.rms_error == rms_error
+        assert np.array_equal(step.x_hat, x_hat)
+
+
+class TestLeastSquaresSolverAnalysis:
+
+    def test_constructor(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+    ):
+        assert isinstance(analysis, LeastSquaresSolver.Analysis)
+
+    def test_getters(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+    ):
+        assert isinstance(analysis.rms_error, Real)
+        assert isinstance(analysis.observation_count, int)
+        assert isinstance(analysis.iteration_count, int)
+        assert isinstance(analysis.termination_criteria, String)
+        assert isinstance(analysis.estimated_state, State)
+        assert isinstance(analysis.estimated_covariance, np.ndarray)
+        assert isinstance(analysis.estimated_frisbee_covariance, np.ndarray)
+        assert isinstance(analysis.computed_observations, list)
+        assert isinstance(analysis.steps, list)
+
+    def test_compute_residual_states(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+        observations: list[State],
+    ):
+        residuals: list[State] = analysis.compute_residual_states(
+            observations=observations
+        )
+
+        assert isinstance(residuals, list)
+        assert len(residuals) == len(observations)
+
+
+class TestLeastSquaresSolver:
+    def test_constructor(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+    ):
+        assert isinstance(least_squares_solver, LeastSquaresSolver)
+
+    def test_getters(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        max_iteration_count: int,
+        rms_update_threshold: float,
+    ):
+        assert least_squares_solver.get_max_iteration_count() == max_iteration_count
+        assert least_squares_solver.get_rms_update_threshold() == rms_update_threshold
+        assert least_squares_solver.get_finite_difference_solver() is not None
+
+    def test_solve_defaults(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        initial_guess: State,
+        observations: list[State],
+        state_generator: callable,
+    ):
+        analysis = least_squares_solver.solve(
+            initial_guess=initial_guess,
+            observations=observations,
+            state_generator=state_generator,
+        )
+
+        assert analysis is not None
+
+    def test_solve(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        initial_guess: State,
+        observations: list[State],
+        state_generator: callable,
+        initial_guess_sigmas: dict[CoordinateSubset, list[float]],
+        observation_sigmas: dict[CoordinateSubset, list[float]],
+    ):
+        analysis = least_squares_solver.solve(
+            initial_guess=initial_guess,
+            observations=observations,
+            state_generator=state_generator,
+            initial_guess_sigmas=initial_guess_sigmas,
+            observation_sigmas=observation_sigmas,
+        )
+
+        assert analysis is not None
+
+    def test_calculate_empirical_covariance(
+        self,
+        observations: list[State],
+    ):
+        covariance: np.ndarray = LeastSquaresSolver.calculate_empirical_covariance(
+            observations
+        )
+
+        assert isinstance(covariance, np.ndarray)
+        assert covariance.shape == (2, 2)
+
+    def test_default(self):
+        default_solver: LeastSquaresSolver = LeastSquaresSolver.default()
+
+        assert isinstance(default_solver, LeastSquaresSolver)

ostk/astrodynamics/test/solvers/test_temporal_condition_solver.py

@@ -0,0 +1,161 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.time import Interval
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics import Environment
+
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory.orbit.model import Kepler
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+from ostk.astrodynamics.access import Generator
+from ostk.astrodynamics.solver import TemporalConditionSolver
+from ostk.astrodynamics.access import AccessTarget
+from ostk.astrodynamics.access import VisibilityCriterion
+
+
+@pytest.fixture
+def temporal_condition_solver() -> TemporalConditionSolver:
+    return TemporalConditionSolver(
+        time_step=Duration.seconds(30.0),
+        tolerance=Duration.milliseconds(1.0),
+        maximum_iteration_count=1234,
+    )
+
+
+@pytest.fixture
+def interval() -> Interval:
+    return Interval.closed(
+        Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+        Instant.date_time(DateTime(2018, 1, 1, 2, 0, 0), Scale.UTC),
+    )
+
+
+class TestTemporalConditionSolver:
+    def test_constructor_success(self):
+        temporal_condition_solver = TemporalConditionSolver(
+            time_step=Duration.seconds(30.0),
+            tolerance=Duration.milliseconds(1.0),
+            maximum_iteration_count=1234,
+        )
+
+        assert isinstance(temporal_condition_solver, TemporalConditionSolver)
+
+    def test_getters_success(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+    ):
+        assert temporal_condition_solver.get_time_step() == Duration.seconds(30.0)
+        assert temporal_condition_solver.get_tolerance() == Duration.milliseconds(1.0)
+        assert temporal_condition_solver.get_maximum_iteration_count() == 1234
+
+    def test_solve_success_one_condition_always_true(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        solution: list[Interval] = temporal_condition_solver.solve(
+            condition=lambda _: True,
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == [interval]
+
+    def test_solve_success_one_condition_always_false(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        solution: list[Interval] = temporal_condition_solver.solve(
+            condition=lambda _: False,
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == []
+
+    def test_solve_success_multiple_conditions_always_true(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        solution: list[Interval] = temporal_condition_solver.solve(
+            conditions=[
+                lambda _: True,
+                lambda _: True,
+            ],
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == [interval]
+
+    def test_solve_success_multiple_conditions_one_always_false(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        solution: list[Interval] = temporal_condition_solver.solve(
+            conditions=[
+                lambda _: True,
+                lambda _: False,
+            ],
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == []
+
+    def test_solve_success_using_access_generator(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        environment = Environment.default()
+
+        generator = Generator(
+            environment=environment,
+        )
+
+        earth = environment.access_celestial_object_with_name("Earth")
+
+        trajectory = Orbit(
+            model=Kepler(
+                coe=COE(
+                    semi_major_axis=Length.kilometers(7000.0),
+                    eccentricity=0.0,
+                    inclination=Angle.degrees(45.0),
+                    raan=Angle.degrees(0.0),
+                    aop=Angle.degrees(0.0),
+                    true_anomaly=Angle.degrees(0.0),
+                ),
+                epoch=Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+                celestial_object=earth,
+                perturbation_type=Kepler.PerturbationType.No,
+            ),
+            celestial_object=earth,
+        )
+
+        visibility_criterion: VisibilityCriterion = (
+            VisibilityCriterion.from_line_of_sight(environment)
+        )
+
+        access_target = AccessTarget.from_trajectory(visibility_criterion, trajectory)
+
+        solution: list[Interval] = temporal_condition_solver.solve(
+            condition=generator.get_condition_function(
+                access_target=access_target,
+                to_trajectory=trajectory,
+            ),
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == [interval]