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

ostk/astrodynamics/test/test_display.py

@@ -0,0 +1,184 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics import Environment
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.environment.object import Celestial
+from ostk.physics.time import DateTime
+from ostk.physics.time import Duration
+from ostk.physics.time import Instant
+from ostk.physics.time import Interval
+from ostk.physics.time import Scale
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+
+from ostk.astrodynamics import display
+from ostk.astrodynamics.access import Generator as AccessGenerator
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory.orbit.model import SGP4
+from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
+from ostk.astrodynamics import Access
+from ostk.astrodynamics.access import AccessTarget
+from ostk.astrodynamics.access import VisibilityCriterion
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def earth(environment: Environment) -> Celestial:
+    return environment.access_celestial_object_with_name("Earth")
+
+
+@pytest.fixture
+def search_interval() -> Interval:
+    start_instant: Instant = Instant.date_time(
+        DateTime(2023, 1, 3, 0, 0, 0),
+        Scale.UTC,
+    )
+    duration: Duration = Duration.hours(1.0)
+    stop_instant: Instant = start_instant + duration
+    return Interval.closed(start_instant, stop_instant)
+
+
+@pytest.fixture
+def access_plot() -> display.AccessesPlot:
+    return display.AccessesPlot(
+        earth=earth,
+        interval=search_interval,
+        trajectory_step=Duration.minutes(5.0),
+        access_step=Duration.seconds(10.0),
+    )
+
+
+@pytest.fixture
+def satellite_1_trajectory(earth: Celestial) -> Orbit:
+    tle_1 = TLE(
+        "1 55076U 23001BV  23146.17959645  .00004328  00000-0  23719-3 0  9993",
+        "2 55076  97.4793 205.9529 0016244  89.9523 270.3571 15.14609100 21723",
+    )
+    return Orbit(SGP4(tle_1), earth)
+
+
+@pytest.fixture
+def satellite_2_trajectory(earth: Celestial) -> Orbit:
+    tle_2 = TLE(
+        "1 48915U 21059AN  23146.32782040  .00004955  00000-0  24678-3 0  9999",
+        "2 48915  97.5954 279.7041 0010303 354.9434   5.1694 15.18004448105867",
+    )
+    return Orbit(SGP4(tle_2), earth)
+
+
+@pytest.fixture
+def ground_station_lla() -> LLA:
+    return LLA(
+        Angle.degrees(70.0),
+        Angle.degrees(160.0),
+        Length.meters(0.0),
+    )
+
+
+@pytest.fixture
+def access_target(
+    environment: Environment,
+    ground_station_lla: LLA,
+) -> AccessTarget:
+    return AccessTarget.from_position(
+        VisibilityCriterion.from_line_of_sight(environment),
+        Position.from_lla(
+            ground_station_lla,
+            environment.access_celestial_object_with_name("Earth"),
+        ),
+    )
+
+
+@pytest.fixture
+def access_generator(environment: Environment) -> AccessGenerator:
+    return AccessGenerator(
+        environment=environment,
+        step=Duration.seconds(10.0),
+        tolerance=Duration.seconds(1.0),
+    )
+
+
+@pytest.fixture
+def satellite_1_accesses(
+    satellite_1_trajectory: Orbit,
+    environment: Environment,
+    search_interval: Interval,
+    access_target: AccessTarget,
+    access_generator: AccessGenerator,
+) -> list[Access]:
+    return access_generator.compute_accesses(
+        interval=search_interval,
+        access_target=access_target,
+        to_trajectory=satellite_1_trajectory,
+    )
+
+
+@pytest.fixture
+def satellite_2_accesses(
+    satellite_2_trajectory: Orbit,
+    environment: Environment,
+    search_interval: Interval,
+    access_target: AccessTarget,
+    access_generator: AccessGenerator,
+) -> list[Access]:
+    return access_generator.compute_accesses(
+        interval=search_interval,
+        access_target=access_target,
+        to_trajectory=satellite_2_trajectory,
+    )
+
+
+class TestDisplay:
+    def test_accesses_plot(
+        self,
+        environment: Environment,
+        earth: Celestial,
+        search_interval: Interval,
+        access_target: AccessTarget,
+        ground_station_lla: LLA,
+        satellite_1_trajectory: Orbit,
+        satellite_2_trajectory: Orbit,
+        satellite_1_accesses: list[Access],
+        satellite_2_accesses: list[Access],
+    ):
+
+        accesses_plot = display.AccessesPlot(
+            earth=earth,
+            interval=search_interval,
+            trajectory_step=Duration.minutes(5.0),
+            access_step=Duration.seconds(10.0),
+        )
+
+        accesses_plot.add_satellite(
+            trajectory=satellite_1_trajectory,
+            rgb=[180, 0, 0],
+        )
+
+        accesses_plot.add_satellite(
+            trajectory=satellite_2_trajectory,
+            rgb=[0, 0, 180],
+        )
+
+        accesses_plot.add_accesses(
+            trajectory=satellite_1_trajectory,
+            accesses=satellite_1_accesses,
+            rgb=[180, 0, 0],
+        )
+
+        accesses_plot.add_accesses(
+            trajectory=satellite_2_trajectory,
+            accesses=satellite_2_accesses,
+            rgb=[0, 0, 180],
+        )
+
+        accesses_plot.add_ground_station(
+            ground_station_lla,
+            color="green",
+        )

ostk/astrodynamics/test/test_event_condition.py

@@ -0,0 +1,80 @@
+# Apache License 2.0
+
+from typing import Callable
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Position, Velocity, Frame
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics import EventCondition
+
+
+@pytest.fixture
+def name() -> str:
+    return "MyEvent"
+
+
+@pytest.fixture
+def evaluator() -> Callable:
+    return lambda state: 5.0
+
+
+@pytest.fixture
+def target_value() -> float:
+    return 0.0
+
+
+@pytest.fixture
+def target(target_value: float) -> EventCondition.Target:
+    return EventCondition.Target(target_value, EventCondition.Target.Type.Relative)
+
+
+@pytest.fixture
+def event_condition(
+    name: str, evaluator: Callable, target: EventCondition.Target
+) -> EventCondition:
+    class MyEventCondition(EventCondition):
+        def is_satisfied(
+            self,
+            current_state,
+            previous_state,
+        ):
+            return (
+                current_state.get_position().get_coordinates()[2] > 0.0
+                and previous_state.get_position().get_coordinates()[2] < 0.0
+            )
+
+    return MyEventCondition(name, evaluator, target)
+
+
+class TestEventCondition:
+    def test_subclass(self, event_condition: EventCondition):
+        assert event_condition is not None
+
+    def test_get_name(self, event_condition: EventCondition, name: str):
+        assert event_condition.get_name() == name
+
+    def test_get_evaluator(self, event_condition: EventCondition):
+        assert event_condition.get_evaluator() is not None
+
+    def test_get_target(
+        self, event_condition: EventCondition, target: EventCondition.Target
+    ):
+        assert event_condition.get_target() == target
+
+    def test_update_target(
+        self,
+        event_condition: EventCondition,
+    ):
+        current_target_value_offset: float = event_condition.get_target().value_offset
+        event_condition.update_target(
+            State(
+                Instant.J2000(),
+                Position.meters([0.0, 0.0, 0.0], Frame.GCRF()),
+                Velocity.meters_per_second([0.0, 0.0, 0.0], Frame.GCRF()),
+            )
+        )
+
+        assert event_condition.get_target().value_offset != current_target_value_offset

ostk/astrodynamics/test/test_import.py

@@ -0,0 +1,26 @@
+# Apache License 2.0
+
+import pytest
+
+
+class TestImport:
+    def test_import(self):
+        from ostk.astrodynamics import Trajectory
+        from ostk.astrodynamics.trajectory import State
+        from ostk.astrodynamics.trajectory import Orbit
+        from ostk.astrodynamics.trajectory import Model
+        from ostk.astrodynamics.trajectory.orbit import Pass
+        from ostk.astrodynamics.trajectory.orbit.model import Kepler
+        from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+        from ostk.astrodynamics.trajectory.orbit.model import SGP4
+        from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
+        from ostk.astrodynamics.trajectory.orbit.model import Propagated
+        from ostk.astrodynamics.flight import Profile
+        from ostk.astrodynamics.flight import System
+        from ostk.astrodynamics.flight import Maneuver
+        from ostk.astrodynamics.flight.system import SatelliteSystem
+        from ostk.astrodynamics.dynamics import CentralBodyGravity
+        from ostk.astrodynamics.dynamics import AtmosphericDrag
+        from ostk.astrodynamics import Access
+        from ostk.astrodynamics.access import Generator
+        from ostk.astrodynamics.trajectory.state import NumericalSolver

ostk/astrodynamics/test/test_root_solver.py

@@ -0,0 +1,70 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics import RootSolver
+
+
+def quadratic_function(x):
+    return x**2 - 4
+
+
+@pytest.fixture
+def maximum_iteration_count() -> int:
+    return 100
+
+
+@pytest.fixture
+def tolerance() -> float:
+    return 1e-15
+
+
+@pytest.fixture
+def root_solver(maximum_iteration_count: int, tolerance: float) -> RootSolver:
+    return RootSolver(maximum_iteration_count, tolerance)
+
+
+class TestRootSolver:
+    def test_constructor(self, maximum_iteration_count: int, tolerance: float):
+        assert (
+            RootSolver(
+                maximum_iteration_count=maximum_iteration_count, tolerance=tolerance
+            )
+            is not None
+        )
+
+    def test_getters(
+        self,
+        root_solver: RootSolver,
+        maximum_iteration_count: int,
+        tolerance: float,
+    ):
+        assert root_solver.get_tolerance() == tolerance
+        assert root_solver.get_maximum_iteration_count() == maximum_iteration_count
+
+    def test_bracket_and_solve(self, root_solver):
+        solution = root_solver.bracket_and_solve(
+            function=quadratic_function,
+            initial_guess=1.0,
+            is_rising=True,
+        )
+        assert pytest.approx(solution.root, abs=1e-15) == 2.0
+
+    def test_solve(self, root_solver):
+        solution = root_solver.solve(
+            function=quadratic_function,
+            lower_bound=1.0,
+            upper_bound=3.0,
+        )
+        assert pytest.approx(solution.root, abs=1e-15) == 2.0
+
+    def test_bisection(self, root_solver):
+        solution = root_solver.bisection(
+            function=quadratic_function,
+            lower_bound=1.0,
+            upper_bound=3.0,
+        )
+        assert pytest.approx(solution.root, abs=1e-15) == 2.0
+
+    def test_default(self):
+        assert RootSolver.default() is not None

ostk/astrodynamics/test/test_trajectory.py

@@ -0,0 +1,126 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.environment.object.celestial import Earth
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.unit import Derived
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import Orbit
+
+
+@pytest.fixture
+def start_lla() -> LLA:
+    return LLA.vector([0.0, 0.0, 0.0])
+
+
+@pytest.fixture
+def end_lla() -> LLA:
+    return LLA.vector([1.0, 0.0, 0.0])
+
+
+@pytest.fixture
+def start_instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def ground_speed() -> Derived:
+    return Derived(7000.0, Derived.Unit.meter_per_second())
+
+
+@pytest.fixture
+def earth() -> Earth:
+    return Earth.WGS84()
+
+
+@pytest.fixture
+def instants() -> list[Instant]:
+    return [Instant.J2000(), Instant.J2000() + Duration.seconds(10.0)]
+
+
+@pytest.fixture
+def position() -> Position:
+    return Position.meters([0.0, 0.0, 0.0], Frame.ITRF())
+
+
+@pytest.fixture
+def trajectory(position: Position) -> Trajectory:
+    return Trajectory.position(position)
+
+
+@pytest.fixture
+def states(trajectory: Trajectory) -> list[State]:
+    return trajectory.get_states_at(
+        [Instant.J2000(), Instant.J2000() + Duration.seconds(10.0)]
+    )
+
+
+@pytest.fixture
+def orbit() -> Orbit:
+    return Orbit.circular(
+        epoch=Instant.J2000(),
+        altitude=Length.meters(545000.0),
+        inclination=Angle.degrees(0.0),
+        celestial_object=Earth.WGS84(),
+    )
+
+
+class TestTrajectory:
+    def test_trajectory(
+        self,
+        states: list[State],
+    ):
+        assert Trajectory(states) is not None
+
+    def test_is_defined(
+        self,
+        trajectory: Trajectory,
+    ):
+        assert trajectory.is_defined()
+
+    def test_access_model(
+        self,
+        trajectory: Trajectory,
+    ):
+        assert trajectory.access_model() is not None
+
+    def test_get_state_at(
+        self,
+        trajectory: Trajectory,
+    ):
+        assert trajectory.get_state_at(Instant.J2000()) is not None
+
+    def test_get_states_at(
+        self,
+        trajectory: Trajectory,
+    ):
+        assert (
+            trajectory.get_states_at(
+                [Instant.J2000(), Instant.J2000() + Duration.seconds(10.0)]
+            )
+            is not None
+        )
+
+    def test_trajectory_undefined(self):
+        trajectory: Trajectory = Trajectory.undefined()
+
+        assert trajectory is not None
+        assert isinstance(trajectory, Trajectory)
+        assert trajectory.is_defined() is False
+
+    def test_trajectory_position(
+        self,
+        position: Position,
+    ):
+        trajectory: Trajectory = Trajectory.position(position)
+
+        assert trajectory is not None