open-space-toolkit-astrodynamics 9.0.3__py39-none-manylinux2014_aarch64.whl → 13.0.2__py39-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/test_display.py

@@ -19,18 +19,17 @@ 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 import State
 from ostk.astrodynamics.trajectory.orbit.model import SGP4
 from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
 
 
 class TestDisplay:
-    def test_accesses_plot(self, state: State):
+    def test_accesses_plot(self):
         start_instant: Instant = Instant.date_time(
             DateTime(2023, 1, 3, 0, 0, 0),
             Scale.UTC,
         )
-        duration: Duration = Duration.days(7.0)
+        duration: Duration = Duration.hours(12.0)
         step: Duration = Duration.seconds(10.0)
         tolerance: Duration = Duration.seconds(1.0)
 

ostk/astrodynamics/test/test_event_condition.py

@@ -2,6 +2,10 @@
 
 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
 
 
@@ -12,7 +16,7 @@ def name() -> str:
 
 @pytest.fixture
 def evaluator() -> callable:
-    return lambda state: 0.0
+    return lambda state: 5.0
 
 
 @pytest.fixture
@@ -22,7 +26,7 @@ def target_value() -> float:
 
 @pytest.fixture
 def target(target_value: float) -> EventCondition.Target:
-    return EventCondition.Target(target_value, EventCondition.Target.Type.Absolute)
+    return EventCondition.Target(target_value, EventCondition.Target.Type.Relative)
 
 
 @pytest.fixture
@@ -32,12 +36,13 @@ def event_condition(
     class MyEventCondition(EventCondition):
         def is_satisfied(
             self,
-            current_state_vector,
-            current_time,
-            previous_state_vector,
-            previous_time,
+            current_state,
+            previous_state,
         ):
-            return current_state_vector[0] > 0.0 and previous_state_vector[0] < 0.0
+            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)
 
@@ -56,3 +61,18 @@ class TestEventCondition:
         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_trajectory.py

@@ -1,40 +1,118 @@
 # 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
+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

@@ -1,25 +1,15 @@
 # Apache License 2.0
 
-import pytest
+from datetime import datetime
 
-import ostk.physics as physics
-import ostk.astrodynamics as astrodynamics
-from ostk.astrodynamics import utilities
+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
 
-Length = physics.unit.Length
-Angle = physics.unit.Angle
-DateTime = physics.time.DateTime
-Scale = physics.time.Scale
-Instant = physics.time.Instant
-Interval = physics.time.Interval
-Position = physics.coordinate.Position
-Velocity = physics.coordinate.Velocity
-Frame = physics.coordinate.Frame
-LLA = physics.coordinate.spherical.LLA
-AER = physics.coordinate.spherical.AER
-Environment = physics.Environment
-Trajectory = astrodynamics.Trajectory
-State = astrodynamics.trajectory.State
+from ostk.astrodynamics import utilities
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import State
 
 
 class TestUtility:
@@ -27,22 +17,16 @@ class TestUtility:
         self,
         state: State,
     ):
-        lla: tuple[float, float, float] = utilities.lla_from_state(state)
+        lla: LLA = utilities.lla_from_state(state)
 
         assert lla is not None
-        assert len(lla) == 3
-        assert isinstance(lla, tuple)
-        assert isinstance(lla[0], float)
-        assert lla[0] >= -90.0 and lla[0] <= 90.0
-        assert isinstance(lla[1], float)
-        assert lla[0] >= -180.0 and lla[0] <= 180.0
-        assert isinstance(lla[2], float)
+        assert isinstance(lla, LLA)
+        assert lla.is_defined()
 
     def test_lla_from_position(
         self,
         instant: Instant,
         position: Position,
-        state: State,
     ):
         lla: LLA = utilities.lla_from_position(position, instant)
 
@@ -50,12 +34,6 @@ class TestUtility:
         assert isinstance(lla, LLA)
         assert lla.is_defined()
 
-        lla_from_state: tuple[float, float, float] = utilities.lla_from_state(state)
-
-        assert lla.get_latitude().in_degrees() == lla_from_state[0]
-        assert lla.get_longitude().in_degrees() == lla_from_state[1]
-        assert lla.get_altitude().in_meters() == lla_from_state[2]
-
     def test_position_from_lla(
         self,
         lla: LLA,
@@ -72,28 +50,24 @@ class TestUtility:
         position: Position,
         environment: Environment,
     ):
-        aer: tuple[float, float, float] = utilities.compute_aer(
-            instant, position, position, environment
-        )
+        aer: AER = utilities.compute_aer(instant, position, position, environment)
 
         assert aer is not None
-        assert len(aer) == 3
-        assert aer[2] == 0.0
+        assert isinstance(aer, AER)
 
-    def test_compute_time_lla_aer_state(
+    def test_compute_time_lla_aer_coordinates(
         self,
         state: State,
         position: Position,
         environment: Environment,
     ):
-        time_lla_aer: float[Instant, float, float, float, float, float, float] = (
-            utilities.compute_time_lla_aer_state(state, position, 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], Instant)
-        assert time_lla_aer[0] == state.get_instant()
+        assert isinstance(time_lla_aer[0], datetime)
         for i in range(1, 7):
             assert isinstance(time_lla_aer[i], float)
 
@@ -102,12 +76,23 @@ class TestUtility:
         interval: Interval,
         trajectory: Trajectory,
     ):
-        output: list[tuple[float, float, float]] = utilities.compute_trajectory_geometry(
-            trajectory, interval
-        )
+        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[

ostk/astrodynamics/test/trajectory/orbit/models/kepler/test_coe.py

@@ -4,7 +4,9 @@ import pytest
 
 from ostk.physics.unit import Length
 from ostk.physics.unit import Angle
+from ostk.physics.time import Instant
 from ostk.physics.environment.gravitational import Earth
+from ostk.physics.environment.object.celestial import Sun
 
 from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
 
@@ -140,6 +142,17 @@ class TestCOE:
         )
         assert COE.compute_radial_distance(7000.0e3, 0.0, 0.0) is not None
 
+        assert COE.compute_ltan(Angle.degrees(270.0), Instant.J2000()) is not None
+        assert (
+            COE.compute_ltan(Angle.degrees(270.0), Instant.J2000(), Sun.default())
+            is not None
+        )
+        assert COE.compute_mean_ltan(Angle.degrees(270.0), Instant.J2000()) is not None
+        assert (
+            COE.compute_mean_ltan(Angle.degrees(270.0), Instant.J2000(), Sun.default())
+            is not None
+        )
+
     def test_from_SI_vector(
         self,
         coe: COE,

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

@@ -41,6 +41,15 @@ class TestPass:
     def test_get_duration(self, pass_: Pass):
         assert pass_.get_duration() is not None
 
+    def test_get_start_instant(self, pass_: Pass):
+        assert pass_.get_start_instant() is not None
+
+    def test_get_end_instant(self, pass_: Pass):
+        assert pass_.get_end_instant() is not None
+
+    def test_get_interval(self, pass_: Pass):
+        assert pass_.get_interval() is not None
+
     def test_get_instant_at_ascending_node(self, pass_: Pass):
         assert pass_.get_instant_at_ascending_node() is not None
 

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

@@ -30,6 +30,9 @@ class TestCoordinateSubset:
     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
 

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

@@ -191,7 +191,7 @@ class TestNumericalSolver:
         initial_state: State,
         numerical_solver: NumericalSolver,
     ):
-        duration_seconds: float = 100.0
+        duration_seconds: float = 10.0
         end_instant: Instant = initial_state.get_instant() + Duration.seconds(
             duration_seconds
         )
@@ -205,7 +205,7 @@ class TestNumericalSolver:
 
         end_instants: list[Instant] = [
             initial_state.get_instant() + Duration.seconds(duration)
-            for duration in np.arange(600.0, 1000.0, 50.0)
+            for duration in np.arange(60.0, 100.0, 20.0)
         ]
         states: list[State] = numerical_solver.integrate_time(
             initial_state, end_instants, oscillator

ostk/astrodynamics/test/trajectory/test_local_orbital_frame_factory.py

@@ -5,16 +5,31 @@ 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.physics.coordinate import Transform
 
 from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameTransformProvider
 
 
 @pytest.fixture
-def local_orbital_frame_factory() -> LocalOrbitalFrameFactory:
-    return LocalOrbitalFrameFactory.VNC(Frame.GCRF())
+def parent_frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def local_orbital_transform_provider_type() -> LocalOrbitalFrameTransformProvider.Type:
+    return LocalOrbitalFrameTransformProvider.Type.VNC
+
+
+@pytest.fixture
+def transform_generator() -> callable:
+    return lambda instant, position, velocity: Transform.identity(Transform.Type.passive)
+
+
+@pytest.fixture
+def local_orbital_frame_factory(parent_frame: Frame) -> LocalOrbitalFrameFactory:
+    return LocalOrbitalFrameFactory.VNC(parent_frame)
 
 
 @pytest.fixture
@@ -41,6 +56,13 @@ class TestLocalOrbitalFrameFactory:
         assert LocalOrbitalFrameFactory.TNW(Frame.GCRF()) is not None
         assert LocalOrbitalFrameFactory.VVLH(Frame.GCRF()) is not None
 
+    def test_accessors(
+        self,
+        parent_frame: Frame,
+        local_orbital_frame_factory: LocalOrbitalFrameFactory,
+    ):
+        assert parent_frame == local_orbital_frame_factory.access_parent_frame()
+
     def test_generate_frame(
         self,
         local_orbital_frame_factory: LocalOrbitalFrameFactory,
@@ -62,3 +84,25 @@ class TestLocalOrbitalFrameFactory:
         local_orbital_frame_factory: LocalOrbitalFrameFactory,
     ):
         assert local_orbital_frame_factory.is_defined()
+
+    def test_constructor(
+        self,
+        local_orbital_transform_provider_type: LocalOrbitalFrameTransformProvider.Type,
+        parent_frame: Frame,
+    ):
+        assert (
+            LocalOrbitalFrameFactory.construct(
+                local_orbital_transform_provider_type, parent_frame
+            )
+            is not None
+        )
+
+    def test_custom_constructor(
+        self,
+        transform_generator: callable,
+        parent_frame: Frame,
+    ):
+        assert (
+            LocalOrbitalFrameFactory.construct(transform_generator, parent_frame)
+            is not None
+        )

ostk/astrodynamics/test/trajectory/test_orbit.py

@@ -58,6 +58,22 @@ class TestOrbit:
         assert state is not None
         assert isinstance(state, State)
 
+    @pytest.mark.parametrize(
+        "frame_type",
+        [
+            (Orbit.FrameType.NED),
+            (Orbit.FrameType.LVLH),
+            (Orbit.FrameType.VVLH),
+            (Orbit.FrameType.LVLHGD),
+            (Orbit.FrameType.LVLHGDGT),
+            (Orbit.FrameType.QSW),
+            (Orbit.FrameType.TNW),
+            (Orbit.FrameType.VNC),
+        ],
+    )
+    def test_get_orbital_frame(self, orbit: Orbit, frame_type: Orbit.FrameType):
+        assert orbit.get_orbital_frame(frame_type) is not None
+
     def test_get_revolution_number_at(self, orbit: Orbit):
         assert (
             orbit.get_revolution_number_at(
@@ -82,6 +98,20 @@ class TestOrbit:
         assert isinstance(pass_, Pass)
         assert pass_.is_defined()
 
+        assert (
+            orbit.get_pass_with_revolution_number(2, Duration.minutes(10.0)) is not None
+        )
+
+    def test_get_passes_within_interval(self, orbit: Orbit):
+        passes: list[Pass] = orbit.get_passes_within_interval(
+            Interval.closed(
+                Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+                Instant.date_time(DateTime(2018, 1, 1, 0, 10, 0), Scale.UTC),
+            )
+        )
+
+        assert len(passes) > 0
+
     def test_undefined(self):
         assert Orbit.undefined().is_defined() is False
 
@@ -151,6 +181,16 @@ class TestOrbit:
             argument_of_latitude=Angle.degrees(50.0),
         ).is_defined()
 
-    def test_compute_passes(self, orbit: Orbit, states: list[State]):
-        passes: list[tuple[int, Pass]] = orbit.compute_passes(states, 1)
+    def test_compute_passes(self, states: list[State]):
+        passes: list[tuple[int, Pass]] = Orbit.compute_passes(states, 1)
         assert passes is not None
+
+    def test_compute_passes_with_model(self, orbit: Orbit):
+        passes: list[tuple[int, Pass]] = Orbit.compute_passes_with_model(
+            model=orbit.access_kepler_model(),
+            start_instant=Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+            end_instant=Instant.date_time(DateTime(2018, 1, 1, 0, 10, 0), Scale.UTC),
+            initial_revolution_number=1,
+        )
+
+        assert len(passes) > 0