open-space-toolkit-astrodynamics 5.1.5__py310-none-any.whl → 5.2.0__py310-none-any.whl

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,
+    CoordinatesBroker,
+    CoordinatesSubset,
+)
+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 coordinates_subsets() -> list[CoordinatesSubset]:
+    return [CoordinatesSubset("Subset", 2)]
+
+
+@pytest.fixture
+def coordinates_broker(
+    coordinates_subsets: list[CoordinatesSubset],
+) -> CoordinatesBroker:
+    return CoordinatesBroker(coordinates_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,
+    coordinates_broker: CoordinatesBroker,
+) -> State:
+    return State(start_instant, get_state_vec(0.0), frame, coordinates_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 = 100.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(600.0, 1000.0, 50.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

ostk/astrodynamics/test/trajectory/test_local_orbital_frame_factory.py

@@ -0,0 +1,64 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+
+
+@pytest.fixture
+def local_orbital_frame_factory() -> LocalOrbitalFrameFactory:
+    return LocalOrbitalFrameFactory.VNC(Frame.GCRF())
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def position_vector() -> list:
+    return [7500000.0, 0.0, 0.0]
+
+
+@pytest.fixture
+def velocity_vector() -> list:
+    return [0.0, 5335.865450622126, 5335.865450622126]
+
+
+class TestLocalOrbitalFrameFactory:
+    def test_constructors(self):
+        assert LocalOrbitalFrameFactory.VNC(Frame.GCRF()) is not None
+        assert LocalOrbitalFrameFactory.NED(Frame.GCRF()) is not None
+        assert LocalOrbitalFrameFactory.LVLH(Frame.GCRF()) is not None
+        assert LocalOrbitalFrameFactory.QSW(Frame.GCRF()) is not None
+        assert LocalOrbitalFrameFactory.TNW(Frame.GCRF()) is not None
+        assert LocalOrbitalFrameFactory.VVLH(Frame.GCRF()) is not None
+
+    def test_generate_frame(
+        self,
+        local_orbital_frame_factory: LocalOrbitalFrameFactory,
+        instant: Instant,
+        position_vector: list,
+        velocity_vector: list,
+    ):
+        frame = local_orbital_frame_factory.generate_frame(
+            instant,
+            position_vector,
+            velocity_vector,
+        )
+
+        assert frame is not None
+        assert frame.is_defined()
+
+    def test_is_defined(
+        self,
+        local_orbital_frame_factory: LocalOrbitalFrameFactory,
+    ):
+        assert local_orbital_frame_factory.is_defined()

ostk/astrodynamics/test/trajectory/test_model.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/astrodynamics/test/trajectory/test_orbit.py

@@ -0,0 +1,92 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics import Environment
+from ostk.physics.units import Length, Angle
+from ostk.physics.time import Scale, Instant, DateTime, Time
+
+from ostk.astrodynamics.trajectory import Orbit, State
+from ostk.astrodynamics.trajectory.orbit.models import SGP4
+from ostk.astrodynamics.trajectory.orbit.models.sgp4 import TLE
+
+
+@pytest.fixture
+def earth():
+    return Environment.default().access_celestial_object_with_name("Earth")
+
+
+class TestOrbit:
+    def test_trajectory_orbit_constructors(self, earth):
+        # Construct Two-Line Element set
+        tle = TLE(
+            "1 25544U 98067A   18231.17878740  .00000187  00000-0  10196-4 0  9994",
+            "2 25544  51.6447  64.7824 0005971  73.1467  36.4366 15.53848234128316",
+        )
+
+        # Construct orbit using SGP4 model
+        orbit = Orbit(SGP4(tle), earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+        # Construct get state at current epoch
+        state: State = orbit.get_state_at(Instant.now())
+
+        assert state is not None
+        assert isinstance(state, State)
+
+    def test_trajectory_orbit_circular(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        altitude = Length.kilometers(500.0)
+        inclination = Angle.degrees(45.0)
+
+        orbit: Orbit = Orbit.circular(epoch, altitude, inclination, earth)
+
+    def test_trajectory_orbit_equatorial(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        apoapsis_altitude = Length.kilometers(500.1)
+        periapsis_altitude = Length.kilometers(499.9)
+
+        orbit: Orbit = Orbit.equatorial(
+            epoch, apoapsis_altitude, periapsis_altitude, earth
+        )
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+    def test_trajectory_orbit_circular_equatorial(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        altitude = Length.kilometers(500.0)
+
+        orbit: Orbit = Orbit.circular_equatorial(epoch, altitude, earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+    def test_trajectory_orbit_geo_synchronous(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        inclination = Angle.degrees(45.0)
+        longitude = Angle.degrees(45.0)
+
+        orbit: Orbit = Orbit.geo_synchronous(epoch, inclination, longitude, earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+    def test_trajectory_orbit_sun_synchronous(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        altitude = Length.kilometers(500.0)
+        local_time_at_descending_node = Time.midnight()
+
+        orbit: Orbit = Orbit.sun_synchronous(
+            epoch, altitude, local_time_at_descending_node, earth
+        )
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()