open-space-toolkit-astrodynamics 12.0.1__py39-none-manylinux2014_x86_64.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,58 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics import EventCondition
+
+
+@pytest.fixture
+def name() -> str:
+    return "MyEvent"
+
+
+@pytest.fixture
+def evaluator() -> callable:
+    return lambda state: 0.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.Absolute)
+
+
+@pytest.fixture
+def event_condition(
+    name: str, evaluator: callable, target: EventCondition.Target
+) -> EventCondition:
+    class MyEventCondition(EventCondition):
+        def is_satisfied(
+            self,
+            current_state_vector,
+            current_time,
+            previous_state_vector,
+            previous_time,
+        ):
+            return current_state_vector[0] > 0.0 and previous_state_vector[0] < 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

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,40 @@
+# Apache License 2.0
+
+import ostk.mathematics as mathematics
+
+import ostk.physics as physics
+
+import ostk.astrodynamics as astrodynamics
+
+RealInterval = mathematics.object.RealInterval
+Quaternion = mathematics.geometry.d3.transformation.rotation.Quaternion
+Length = physics.unit.Length
+Angle = physics.unit.Angle
+DateTime = physics.time.DateTime
+Scale = physics.time.Scale
+Duration = physics.time.Duration
+Instant = physics.time.Instant
+Transform = physics.coordinate.Transform
+Frame = physics.coordinate.Frame
+Axes = physics.coordinate.Axes
+DynamicProvider = physics.coordinate.frame.provider.Dynamic
+Environment = physics.Environment
+Earth = physics.environment.object.celestial.Earth
+Trajectory = astrodynamics.Trajectory
+Profile = astrodynamics.flight.Profile
+SatelliteSystem = astrodynamics.flight.system.SatelliteSystem
+Orbit = astrodynamics.trajectory.Orbit
+State = astrodynamics.trajectory.State
+Pass = astrodynamics.trajectory.orbit.Pass
+Kepler = astrodynamics.trajectory.orbit.model.Kepler
+COE = astrodynamics.trajectory.orbit.model.kepler.COE
+SGP4 = astrodynamics.trajectory.orbit.model.sgp4
+Access = astrodynamics.Access
+
+
+def test_trajectory_undefined():
+    trajectory: Trajectory = Trajectory.undefined()
+
+    assert trajectory is not None
+    assert isinstance(trajectory, Trajectory)
+    assert trajectory.is_defined() is False

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"))

ostk/astrodynamics/test/trajectory/orbit/message/spacex/data/opm_1.yaml

@@ -0,0 +1,44 @@
+# Dummy SpaceX OPM output
+
+# Notes:
+# - ECEF velocity is Earth relative
+# - Apogee/Perigee altitude assumes a spherical Earth, 6378.137 km radius
+# - Orbital elements are computed in an inertial frame realized by inertially
+#   freezing the WGS84 ECEF frame at time of current state
+# - State is post-deployment, so includes separation delta-velocity
+
+
+header:
+  generation_date: 2020-01-01T12:34:56.789Z
+  launch_date: 2020-01-02T12:34:56.789Z
+
+
+deployments:
+
+- name: satellite_a
+  sequence_number: 1
+  mission_time_s: 3600.0
+  date: 2020-01-02T13:34:56.789Z
+  r_ecef_m: [693289.644, 6876578.628, -133035.288]
+  v_ecef_m_per_s: [1305.783, 39.783, 7525.920]
+  mean_perigee_altitude_km: 526.768
+  mean_apogee_altitude_km: 568.430
+  mean_inclination_deg: 97.123
+  mean_argument_of_perigee_deg: -179.513
+  mean_longitude_ascending_node_deg: 85.057
+  mean_mean_anomaly_deg: 179.263
+  ballistic_coef_kg_per_m2: 47.55
+
+- name: satellite_b
+  sequence_number: 2
+  mission_time_s: 7200.0
+  date: 2020-01-02T14:34:56.789Z
+  r_ecef_m: [699863.059, 6875647.517, -123777.595]
+  v_ecef_m_per_s: [1504.658, 6.705, 7538.669]
+  mean_perigee_altitude_km: 536.779
+  mean_apogee_altitude_km: 529.851
+  mean_inclination_deg: 97.124
+  mean_argument_of_perigee_deg: 136.875
+  mean_longitude_ascending_node_deg: 85.032
+  mean_mean_anomaly_deg: -127.164
+  ballistic_coef_kg_per_m2: 44.26