open-space-toolkit-astrodynamics 12.0.1__py39-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_velocity.py

@@ -0,0 +1,115 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinateBroker, CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import (
+    CartesianVelocity,
+    CartesianPosition,
+)
+
+
+@pytest.fixture
+def name() -> str:
+    return "Position"
+
+
+@pytest.fixture
+def cartesian_position() -> CartesianPosition:
+    return CartesianPosition.default()
+
+
+@pytest.fixture
+def cartesian_velocity() -> CartesianVelocity:
+    return CartesianVelocity.default()
+
+
+@pytest.fixture
+def coordinate_subsets(
+    cartesian_position: CartesianPosition, cartesian_velocity: CartesianVelocity
+) -> list[CoordinateSubset]:
+    return [cartesian_position, cartesian_velocity]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinate_broker(
+    coordinate_subsets: list[CoordinateSubset],
+) -> CoordinateBroker:
+    return CoordinateBroker(coordinate_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [7000000.0, 0.0, 0.0, 0.0, 5335.865450622126, 5335.865450622126]
+
+
+@pytest.fixture
+def another_coordinates() -> list[float]:
+    return [0.0, 7000000.0, 0.0, 5335.865450622126, 0.0, 0.0]
+
+
+class TestCartesianVelocity:
+    def test_constructor(self, name: str):
+        assert CartesianVelocity(CartesianPosition.default(), name) is not None
+
+    def test_add(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_velocity.add(
+                instant, coordinates, another_coordinates, frame, coordinate_broker
+            )
+            == [5335.865450622126, 5335.865450622126, 5335.865450622126]
+        )
+
+    def test_subtract(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_velocity.subtract(
+                instant, coordinates, another_coordinates, frame, coordinate_broker
+            )
+            == [-5335.865450622126, 5335.865450622126, 5335.865450622126]
+        )
+
+    def test_in_frame(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        for value, expected in zip(
+            cartesian_velocity.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinate_broker
+            ),
+            [-4749.36551256577, 854.163395375881, 5335.71857543495],
+        ):
+            assert value == pytest.approx(expected, rel=1e-14)

ostk/astrodynamics/test/trajectory/state/test_coordinate_broker.py

@@ -0,0 +1,84 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state import CoordinateBroker, CoordinateSubset
+
+
+@pytest.fixture
+def coordinate_subsets() -> list:
+    return [CoordinateSubset("Subset1", 2), CoordinateSubset("Subset2", 3)]
+
+
+@pytest.fixture
+def coordinate_broker(coordinate_subsets) -> CoordinateBroker:
+    return CoordinateBroker(coordinate_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [1.0, 2.0, 3.0, 4.0, 5.0]
+
+
+class TestCoordinateBroker:
+    def test_constructor(self, coordinate_broker: CoordinateBroker):
+        assert coordinate_broker is not None
+
+    def test_eq(self, coordinate_broker: CoordinateBroker):
+        assert coordinate_broker == coordinate_broker
+
+    def test_ne(self, coordinate_broker: CoordinateBroker):
+        assert (coordinate_broker != coordinate_broker) == False
+
+    def test_access_subsets(
+        self, coordinate_broker: CoordinateBroker, coordinate_subsets: list
+    ):
+        assert coordinate_broker.access_subsets() == coordinate_subsets
+
+    def test_get_number_of_coordinates(self, coordinate_broker: CoordinateBroker):
+        assert coordinate_broker.get_number_of_coordinates() == 5
+
+    def test_get_number_of_subsets(self, coordinate_broker: CoordinateBroker):
+        assert coordinate_broker.get_number_of_subsets() == 2
+
+    def test_get_subsets(
+        self, coordinate_broker: CoordinateBroker, coordinate_subsets: list
+    ):
+        assert coordinate_broker.get_subsets() == coordinate_subsets
+
+    def test_add_subset(self, coordinate_broker: CoordinateBroker):
+        new_subset = CoordinateSubset("NewSubset", 4)
+        number_of_coordinates = coordinate_broker.get_number_of_coordinates()
+        assert coordinate_broker.add_subset(new_subset) == number_of_coordinates
+        assert coordinate_broker.has_subset(new_subset)
+
+    def test_has_subset(
+        self, coordinate_broker: CoordinateBroker, coordinate_subsets: list
+    ):
+        assert coordinate_broker.has_subset(coordinate_subsets[0])
+
+    def test_extract_coordinate(
+        self,
+        coordinate_broker: CoordinateBroker,
+        coordinates: list[float],
+        coordinate_subsets: list[CoordinateSubset],
+    ):
+        assert (
+            coordinate_broker.extract_coordinate(coordinates, coordinate_subsets[0])
+            == [1.0, 2.0]
+        ).all()
+        assert (
+            coordinate_broker.extract_coordinate(coordinates, coordinate_subsets[1])
+            == [3.0, 4.0, 5.0]
+        ).all()
+
+    def test_extract_coordinates(
+        self,
+        coordinate_broker: CoordinateBroker,
+        coordinates: list[float],
+        coordinate_subsets: list[CoordinateSubset],
+    ):
+        assert (
+            coordinate_broker.extract_coordinates(coordinates, coordinate_subsets)
+            == [1.0, 2.0, 3.0, 4.0, 5.0]
+        ).all()

ostk/astrodynamics/test/trajectory/state/test_coordinate_subset.py

@@ -0,0 +1,46 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+
+
+@pytest.fixture
+def name() -> str:
+    return "MySubset"
+
+
+@pytest.fixture
+def size() -> int:
+    return 3
+
+
+@pytest.fixture
+def coordinate_subset(name: str, size: int) -> CoordinateSubset:
+    return CoordinateSubset(name, size)
+
+
+class TestCoordinateSubset:
+    def test_constructor(self, coordinate_subset: CoordinateSubset):
+        assert coordinate_subset is not None
+
+    def test_eq(self, coordinate_subset: CoordinateSubset):
+        assert coordinate_subset == coordinate_subset
+
+    def test_ne(self, coordinate_subset: CoordinateSubset):
+        assert (coordinate_subset != coordinate_subset) == False
+
+    def test_hash(self, coordinate_subset: CoordinateSubset):
+        assert hash(coordinate_subset) is not None
+
+    def test_get_id(self, coordinate_subset: CoordinateSubset):
+        assert coordinate_subset.get_id() is not None
+
+    def test_get_name(self, coordinate_subset: CoordinateSubset, name: str):
+        assert coordinate_subset.get_name() == name
+
+    def test_get_size(self, coordinate_subset: CoordinateSubset, size: int):
+        assert coordinate_subset.get_size() == size
+
+    def test_mass(self):
+        assert CoordinateSubset.mass() is not None

ostk/astrodynamics/test/trajectory/state/test_numerical_solver.py

@@ -0,0 +1,314 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+import math
+
+from ostk.physics.time import Instant, Duration
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import (
+    NumericalSolver,
+    CoordinateBroker,
+    CoordinateSubset,
+)
+from ostk.astrodynamics.event_condition import RealCondition
+
+
+def oscillator(x, dxdt, _):
+    dxdt[0] = x[1]
+    dxdt[1] = -x[0]
+    return dxdt
+
+
+def get_state_vec(time: float) -> np.ndarray:
+    return np.array([math.sin(time), math.cos(time)])
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [CoordinateSubset("Subset", 2)]
+
+
+@pytest.fixture
+def coordinate_broker(
+    coordinate_subsets: list[CoordinateSubset],
+) -> CoordinateBroker:
+    return CoordinateBroker(coordinate_subsets)
+
+
+@pytest.fixture
+def start_instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def initial_state(
+    start_instant: Instant,
+    frame: Frame,
+    coordinate_broker: CoordinateBroker,
+) -> State:
+    return State(start_instant, get_state_vec(0.0), frame, coordinate_broker)
+
+
+@pytest.fixture
+def custom_condition() -> RealCondition:
+    return RealCondition(
+        "Custom",
+        RealCondition.Criterion.StrictlyPositive,
+        lambda state: (state.get_instant() - Instant.J2000()).in_seconds(),
+        5.0,
+    )
+
+
+@pytest.fixture
+def log_type() -> NumericalSolver.LogType:
+    return NumericalSolver.LogType.NoLog
+
+
+@pytest.fixture
+def variable_size_stepper_type() -> NumericalSolver.StepperType:
+    return NumericalSolver.StepperType.RungeKuttaCashKarp54
+
+
+@pytest.fixture
+def fixed_size_stepper_type() -> NumericalSolver.StepperType:
+    return NumericalSolver.StepperType.RungeKutta4
+
+
+@pytest.fixture
+def initial_time_step() -> float:
+    return 5.0
+
+
+@pytest.fixture
+def relative_tolerance() -> float:
+    return 1.0e-15
+
+
+@pytest.fixture
+def absolute_tolerance() -> float:
+    return 1.0e-15
+
+
+@pytest.fixture
+def state_logger() -> callable:
+    def log_state(state: State) -> None:
+        print(state.get_coordinates())
+
+    return log_state
+
+
+@pytest.fixture
+def numerical_solver(
+    log_type: NumericalSolver.LogType,
+    variable_size_stepper_type: NumericalSolver.StepperType,
+    initial_time_step: float,
+    relative_tolerance: float,
+    absolute_tolerance: float,
+) -> NumericalSolver:
+    return NumericalSolver(
+        log_type=log_type,
+        stepper_type=variable_size_stepper_type,
+        time_step=initial_time_step,
+        relative_tolerance=relative_tolerance,
+        absolute_tolerance=absolute_tolerance,
+    )
+
+
+@pytest.fixture
+def numerical_solver_conditional() -> NumericalSolver:
+    return NumericalSolver.default_conditional()
+
+
+class TestNumericalSolver:
+    def test_constructors(self, numerical_solver: NumericalSolver):
+        assert numerical_solver is not None
+        assert isinstance(numerical_solver, NumericalSolver)
+        assert numerical_solver.is_defined()
+
+    def test_comparators(self, numerical_solver: NumericalSolver):
+        assert numerical_solver == numerical_solver
+        assert (numerical_solver != numerical_solver) is False
+
+    def test_get_types(
+        self,
+        log_type: NumericalSolver.LogType,
+        variable_size_stepper_type: NumericalSolver.StepperType,
+        initial_time_step: float,
+        relative_tolerance: float,
+        absolute_tolerance: float,
+        numerical_solver: NumericalSolver,
+    ):
+        assert numerical_solver.get_log_type() == log_type
+        assert numerical_solver.get_stepper_type() == variable_size_stepper_type
+        assert numerical_solver.get_time_step() == initial_time_step
+        assert numerical_solver.get_relative_tolerance() == relative_tolerance
+        assert numerical_solver.get_absolute_tolerance() == absolute_tolerance
+        assert numerical_solver.get_root_solver() is not None
+        assert numerical_solver.get_observed_states() is not None
+
+    def test_get_string_from_types(self):
+        assert (
+            NumericalSolver.string_from_stepper_type(
+                NumericalSolver.StepperType.RungeKutta4
+            )
+            == "RungeKutta4"
+        )
+        assert (
+            NumericalSolver.string_from_stepper_type(
+                NumericalSolver.StepperType.RungeKuttaCashKarp54
+            )
+            == "RungeKuttaCashKarp54"
+        )
+        assert (
+            NumericalSolver.string_from_stepper_type(
+                NumericalSolver.StepperType.RungeKuttaFehlberg78
+            )
+            == "RungeKuttaFehlberg78"
+        )
+        assert (
+            NumericalSolver.string_from_log_type(NumericalSolver.LogType.NoLog) == "NoLog"
+        )
+        assert (
+            NumericalSolver.string_from_log_type(NumericalSolver.LogType.LogConstant)
+            == "LogConstant"
+        )
+        assert (
+            NumericalSolver.string_from_log_type(NumericalSolver.LogType.LogAdaptive)
+            == "LogAdaptive"
+        )
+
+    def test_integrate_time(
+        self,
+        initial_state: State,
+        numerical_solver: NumericalSolver,
+    ):
+        duration_seconds: float = 10.0
+        end_instant: Instant = initial_state.get_instant() + Duration.seconds(
+            duration_seconds
+        )
+
+        state_vector: np.ndarray = numerical_solver.integrate_time(
+            initial_state, end_instant, oscillator
+        ).get_coordinates()
+
+        assert 5e-9 >= abs(state_vector[0] - math.sin(duration_seconds))
+        assert 5e-9 >= abs(state_vector[1] - math.cos(duration_seconds))
+
+        end_instants: list[Instant] = [
+            initial_state.get_instant() + Duration.seconds(duration)
+            for duration in np.arange(60.0, 100.0, 20.0)
+        ]
+        states: list[State] = numerical_solver.integrate_time(
+            initial_state, end_instants, oscillator
+        )
+
+        for state, end_instant in zip(states, end_instants):
+            state_vector: np.ndarray = state.get_coordinates()
+
+            assert 5e-9 >= abs(
+                state_vector[0]
+                - math.sin((end_instant - initial_state.get_instant()).in_seconds())
+            )
+            assert 5e-9 >= abs(
+                state_vector[1]
+                - math.cos((end_instant - initial_state.get_instant()).in_seconds())
+            )
+
+    def test_integrate_time_with_condition(
+        self,
+        initial_state: State,
+        numerical_solver_conditional: NumericalSolver,
+        custom_condition: RealCondition,
+    ):
+        end_time: float = initial_state.get_instant() + Duration.seconds(100.0)
+
+        condition_solution = numerical_solver_conditional.integrate_time(
+            initial_state, end_time, oscillator, custom_condition
+        )
+
+        assert condition_solution.condition_is_satisfied
+        assert (
+            condition_solution.iteration_count
+            < numerical_solver_conditional.get_root_solver().get_maximum_iteration_count()
+        )
+        assert condition_solution.root_solver_has_converged
+
+        state_vector = condition_solution.state.get_coordinates()
+        time = (
+            condition_solution.state.get_instant() - initial_state.get_instant()
+        ).in_seconds()
+
+        assert abs(float(time - custom_condition.get_target().value)) < 1e-6
+
+        assert 5e-9 >= abs(state_vector[0] - math.sin(time))
+        assert 5e-9 >= abs(state_vector[1] - math.cos(time))
+
+    def test_integrate_conditional_with_logger(
+        self,
+        initial_state: State,
+        state_logger: callable,
+        custom_condition: RealCondition,
+        capsys,
+    ):
+        numerical_solver: NumericalSolver = NumericalSolver.conditional(
+            5.0,
+            1.0e-15,
+            1.0e-15,
+            state_logger,
+        )
+        end_time: float = initial_state.get_instant() + Duration.seconds(10.0)
+
+        numerical_solver.integrate_time(
+            initial_state, end_time, oscillator, custom_condition
+        )
+
+        captured = capsys.readouterr()
+
+        assert captured.out != ""
+
+    def test_default(self):
+        assert NumericalSolver.default() is not None
+
+    def test_undefined(self):
+        assert NumericalSolver.undefined() is not None
+        assert NumericalSolver.undefined().is_defined() is False
+
+    def test_fixed_step_size(
+        self,
+        fixed_size_stepper_type: NumericalSolver.StepperType,
+        variable_size_stepper_type: NumericalSolver.StepperType,
+        initial_time_step: float,
+    ):
+        assert (
+            NumericalSolver.fixed_step_size(fixed_size_stepper_type, initial_time_step)
+            is not None
+        )
+        with pytest.raises(Exception):
+            NumericalSolver.fixed_step_size(variable_size_stepper_type, initial_time_step)
+
+    def test_default_conditional(self, state_logger):
+        assert NumericalSolver.default_conditional() is not None
+        assert NumericalSolver.default_conditional(state_logger) is not None
+
+    def test_conditional(
+        self,
+        initial_time_step: float,
+        relative_tolerance: float,
+        absolute_tolerance: float,
+        state_logger,
+    ):
+        assert (
+            NumericalSolver.conditional(
+                initial_time_step, relative_tolerance, absolute_tolerance, state_logger
+            )
+            is not None
+        )

ostk/astrodynamics/test/trajectory/test_local_orbital_frame_direction.py

@@ -0,0 +1,81 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameDirection
+
+
+@pytest.fixture
+def local_orbital_frame_factory() -> LocalOrbitalFrameFactory:
+    return LocalOrbitalFrameFactory.VNC(Frame.GCRF())
+
+
+@pytest.fixture
+def direction_vector() -> list:
+    return [1.0, 0.0, 0.0]
+
+
+@pytest.fixture
+def local_orbital_frame_direction(
+    direction_vector: list,
+    local_orbital_frame_factory: LocalOrbitalFrameFactory,
+) -> LocalOrbitalFrameDirection:
+    return LocalOrbitalFrameDirection(
+        vector=direction_vector,
+        local_orbital_frame_factory=local_orbital_frame_factory,
+    )
+
+
+class TestLocalOrbitalFrameDirection:
+    def test_constructor(
+        self,
+        direction_vector: list,
+        local_orbital_frame_factory: LocalOrbitalFrameFactory,
+    ):
+        local_orbital_frame_direction: LocalOrbitalFrameDirection = (
+            LocalOrbitalFrameDirection(
+                direction_vector,
+                local_orbital_frame_factory,
+            )
+        )
+
+        assert local_orbital_frame_direction is not None
+        assert isinstance(local_orbital_frame_direction, LocalOrbitalFrameDirection)
+
+    def test_equal_to_operator(
+        self, local_orbital_frame_direction: LocalOrbitalFrameDirection
+    ):
+        assert local_orbital_frame_direction == local_orbital_frame_direction
+        assert local_orbital_frame_direction != LocalOrbitalFrameDirection(
+            [0.0, 1.0, 0.0],
+            local_orbital_frame_direction.get_local_orbital_frame_factory(),
+        )
+
+    def test_is_defined(
+        self,
+        local_orbital_frame_direction: LocalOrbitalFrameDirection,
+    ):
+        assert local_orbital_frame_direction.is_defined()
+
+    def test_getters(
+        self,
+        local_orbital_frame_direction: LocalOrbitalFrameDirection,
+        direction_vector: list,
+        local_orbital_frame_factory: LocalOrbitalFrameFactory,
+    ):
+        assert list(local_orbital_frame_direction.get_value()) == direction_vector
+        assert (
+            local_orbital_frame_direction.get_local_orbital_frame_factory()
+            == local_orbital_frame_factory
+        )
+
+    def test_undefined(
+        self,
+    ):
+        local_orbital_frame_direction: LocalOrbitalFrameDirection = (
+            LocalOrbitalFrameDirection.undefined()
+        )
+        assert local_orbital_frame_direction.is_defined() is False