open-space-toolkit-astrodynamics 13.1.0__py313-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/test_display.py

@@ -0,0 +1,114 @@
+# Apache License 2.0
+
+from ostk.mathematics.object import RealInterval
+
+from ostk.physics import Environment
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+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 Trajectory
+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
+
+
+class TestDisplay:
+    def test_accesses_plot(self):
+        start_instant: Instant = Instant.date_time(
+            DateTime(2023, 1, 3, 0, 0, 0),
+            Scale.UTC,
+        )
+        duration: Duration = Duration.hours(12.0)
+        step: Duration = Duration.seconds(10.0)
+        tolerance: Duration = Duration.seconds(1.0)
+
+        ground_station_lla: LLA = LLA(
+            Angle.degrees(70.0),
+            Angle.degrees(160.0),
+            Length.meters(0.0),
+        )
+
+        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",
+        )
+
+        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",
+        )
+
+        environment: Environment = Environment.default()
+        earth: Celestial = environment.access_celestial_object_with_name("Earth")
+
+        ground_station_trajectory: Trajectory = Trajectory.position(
+            Position.meters(
+                ground_station_lla.to_cartesian(
+                    earth.get_equatorial_radius(),
+                    earth.get_flattening(),
+                ),
+                Frame.ITRF(),
+            ),
+        )
+
+        stop_instant: Instant = start_instant + duration
+        search_interval: RealInterval = Interval.closed(start_instant, stop_instant)
+
+        orbit_1: Orbit = Orbit(SGP4(tle_1), earth)
+        orbit_2: Orbit = Orbit(SGP4(tle_2), earth)
+
+        generator = AccessGenerator(
+            environment=environment,
+            step=step,
+            tolerance=tolerance,
+        )
+
+        accesses_1 = generator.compute_accesses(
+            interval=search_interval,
+            from_trajectory=ground_station_trajectory,
+            to_trajectory=orbit_1,
+        )
+
+        assert len(accesses_1) > 0
+
+        accesses_2 = generator.compute_accesses(
+            interval=search_interval,
+            from_trajectory=ground_station_trajectory,
+            to_trajectory=orbit_2,
+        )
+
+        assert len(accesses_2) > 0
+
+        accesses_plot = display.AccessesPlot(
+            earth=earth,
+            interval=search_interval,
+            trajectory_step=Duration.minutes(5.0),
+            access_step=Duration.seconds(10.0),
+            ground_station_lla=ground_station_lla,
+            color="green",
+        )
+
+        accesses_plot.add_satellite(
+            trajectory=orbit_1,
+            accesses=accesses_1,
+            rgb=[180, 0, 0],
+        )
+
+        accesses_plot.add_satellite(
+            trajectory=orbit_2,
+            accesses=accesses_2,
+            rgb=[0, 0, 180],
+        )
+
+        accesses_plot.show()

ostk/astrodynamics/test/test_event_condition.py

@@ -0,0 +1,78 @@
+# Apache License 2.0
+
+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,118 @@
+# 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.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import State
+
+
+@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)]
+    )
+
+
+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
+
+    def test_ground_strip(
+        self,
+        start_lla: LLA,
+        end_lla: LLA,
+        ground_speed: Derived,
+        start_instant: Instant,
+        earth: Earth,
+        instants: list[Instant],
+    ):
+        assert (
+            Trajectory.ground_strip(
+                start_lla, end_lla, ground_speed, start_instant, earth
+            )
+            is not None
+        )
+        assert (
+            Trajectory.ground_strip(start_lla, end_lla, ground_speed, start_instant)
+            is not None
+        )
+
+        assert Trajectory.ground_strip(start_lla, end_lla, instants, earth) is not None
+        assert Trajectory.ground_strip(start_lla, end_lla, instants) is not None

ostk/astrodynamics/test/test_utilities.py

@@ -0,0 +1,106 @@
+# Apache License 2.0
+
+from datetime import datetime
+
+from ostk.physics import Environment
+from ostk.physics.time import Instant, Interval
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate.spherical import LLA, AER
+
+from ostk.astrodynamics import utilities
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import State
+
+
+class TestUtility:
+    def test_lla_from_state(
+        self,
+        state: State,
+    ):
+        lla: LLA = utilities.lla_from_state(state)
+
+        assert lla is not None
+        assert isinstance(lla, LLA)
+        assert lla.is_defined()
+
+    def test_lla_from_position(
+        self,
+        instant: Instant,
+        position: Position,
+    ):
+        lla: LLA = utilities.lla_from_position(position, instant)
+
+        assert lla is not None
+        assert isinstance(lla, LLA)
+        assert lla.is_defined()
+
+    def test_position_from_lla(
+        self,
+        lla: LLA,
+    ):
+        position: Position = utilities.position_from_lla(lla)
+
+        assert position is not None
+        assert isinstance(position, Position)
+        assert position.is_defined()
+
+    def test_compute_aer(
+        self,
+        instant: Instant,
+        position: Position,
+        environment: Environment,
+    ):
+        aer: AER = utilities.compute_aer(instant, position, position, environment)
+
+        assert aer is not None
+        assert isinstance(aer, AER)
+
+    def test_compute_time_lla_aer_coordinates(
+        self,
+        state: State,
+        position: Position,
+        environment: Environment,
+    ):
+        time_lla_aer: float[datetime, float, float, float, float, float, float] = (
+            utilities.compute_time_lla_aer_coordinates(state, position, environment)
+        )
+
+        assert time_lla_aer is not None
+        assert len(time_lla_aer) == 7
+        assert isinstance(time_lla_aer[0], datetime)
+        for i in range(1, 7):
+            assert isinstance(time_lla_aer[i], float)
+
+    def test_compute_trajectory_geometry(
+        self,
+        interval: Interval,
+        trajectory: Trajectory,
+    ):
+        output: list[LLA] = utilities.compute_trajectory_geometry(trajectory, interval)
+
+        assert output is not None
+        assert len(output) == 2
+        assert isinstance(output[0], LLA)
+
+    def test_compute_ground_track(
+        self,
+        interval: Interval,
+        trajectory: Trajectory,
+    ):
+        output: list[LLA] = utilities.compute_ground_track(trajectory, interval)
+
+        assert output is not None
+        assert len(output) == 2
+        assert isinstance(output[0], LLA)
+        assert output[0].get_altitude().in_meters() <= 15.0
+
+    def test_convert_state(self, state: State):
+        output: tuple[
+            str, float, float, float, float, float, float, float, float, float
+        ] = utilities.convert_state(state)
+
+        assert output is not None
+        assert len(output) == 11
+        assert isinstance(output[0], str)
+        for i in range(1, 11):
+            assert isinstance(output[i], float)

ostk/astrodynamics/test/test_viewer.py

@@ -0,0 +1,129 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics import Environment
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import Instant
+from ostk.physics.time import Interval
+from ostk.physics.time import Duration
+from ostk.physics.time import DateTime
+from ostk.physics.time import Time
+from ostk.physics.time import Scale
+from ostk.physics.unit import Length
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.flight import Profile
+from ostk.astrodynamics.viewer import Viewer
+from ostk.astrodynamics.viewer import ConicSensor
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def orbit(environment: Environment) -> Orbit:
+    return Orbit.sun_synchronous(
+        epoch=Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+        altitude=Length.kilometers(500.0),
+        local_time_at_descending_node=Time(14, 0, 0),
+        celestial_object=environment.access_celestial_object_with_name("Earth"),
+    )
+
+
+@pytest.fixture
+def profile(orbit: Orbit) -> Profile:
+    return Profile.nadir_pointing(
+        orbit=orbit,
+        orbital_frame_type=Orbit.FrameType.VVLH,
+    )
+
+
+@pytest.fixture
+def interval() -> Interval:
+    return Interval.closed(
+        start_instant=Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+        end_instant=Instant.date_time(DateTime(2020, 1, 1, 0, 10, 0), Scale.UTC),
+    )
+
+
+@pytest.fixture
+def viewer(interval: Interval) -> Viewer:
+    return Viewer(
+        interval=interval,
+    )
+
+
+class TestViewer:
+    def test_constructor_success(self, interval: Interval):
+        viewer = Viewer(
+            interval=interval,
+        )
+
+        assert viewer is not None
+        assert viewer.interval == interval
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert rendered_html.endswith("</script>")
+
+    def test_add_profile_success(
+        self,
+        viewer: Viewer,
+        profile: Profile,
+    ):
+        viewer.add_profile(
+            profile=profile,
+            step=Duration.seconds(30.0),
+            show_orbital_track=True,
+            cesium_asset_id=123,
+            sensors=[
+                ConicSensor(
+                    name="star_tracker",
+                    direction=(1.0, 0.0, 0.0),
+                    half_angle=Angle.degrees(8.0),
+                    length=Length.meters(0.1),
+                    color="red",
+                ),
+            ],
+            show_xyz_axes=True,
+        )
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert " widget.entities.add({position: widget" in rendered_html
+        assert "Cesium.IonResource.fromAssetId(123)" in rendered_html
+        assert "widget.entities.add({polyline:" in rendered_html
+        assert (
+            "widget.entities.add({position: widget.star_tracker_position" in rendered_html
+        )
+        assert rendered_html.endswith("</script>")
+
+    def test_add_target_success(
+        self,
+        viewer: Viewer,
+    ):
+        viewer.add_target(
+            position=Position.meters([1.0, 2.0, 3.0], Frame.ITRF()),
+            size=123,
+            color="red",
+        )
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert (
+            "widget.entities.add({position: Cesium.Cartesian3.fromDegrees(63.43494882292201, 18.22447811510915, -6376045.535225509), point: {pixelSize: 123.0, color: Cesium.Color.RED}});"
+            in rendered_html
+        )
+        assert rendered_html.endswith("</script>")

ostk/astrodynamics/test/trajectory/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/message/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/message/spacex/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/message/spacex/conftest.py

@@ -0,0 +1,18 @@
+# Apache License 2.0
+
+import pytest
+
+import pathlib
+
+from ostk.core.filesystem import Path
+from ostk.core.filesystem import File
+
+
+@pytest.fixture
+def data_directory_path() -> str:
+    return f"{pathlib.Path(__file__).parent.absolute()}/data"
+
+
+@pytest.fixture
+def opm_file(data_directory_path: str) -> File:
+    return File.path(Path.parse(f"{data_directory_path}/opm_1.yaml"))