open-space-toolkit-astrodynamics 13.1.0__py312-none-manylinux2014_aarch64.whl → 15.0.0__py312-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/access/test_generator.py

@@ -2,6 +2,8 @@
 
 import pytest
 
+import numpy as np
+
 from ostk.mathematics.object import RealInterval
 
 from ostk.physics.unit import Length
@@ -12,7 +14,11 @@ from ostk.physics.time import Duration
 from ostk.physics.time import Instant
 from ostk.physics.time import Interval
 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.environment.object.celestial import Earth
 
 from ostk.astrodynamics import Trajectory
 from ostk.astrodynamics.trajectory import Orbit
@@ -20,6 +26,8 @@ from ostk.astrodynamics.trajectory.orbit.model import Kepler
 from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
 from ostk.astrodynamics import Access
 from ostk.astrodynamics.access import Generator
+from ostk.astrodynamics.access import AccessTarget
+from ostk.astrodynamics.access import VisibilityCriterion
 
 
 @pytest.fixture
@@ -36,9 +44,8 @@ def earth(environment: Environment) -> Celestial:
 def generator(environment: Environment) -> Generator:
     return Generator(
         environment=environment,
-        aer_filter=lambda aer: True,
         access_filter=lambda access: True,
-        state_filter=lambda state_1, state_2: True,
+        state_filter=None,
     )
 
 
@@ -82,19 +89,106 @@ def to_trajectory(earth: Celestial) -> Trajectory:
     )
 
 
-class TestGenerator:
-    def test_constructor_success_environment(self, environment: Environment):
-        generator = Generator(
-            environment=environment,
+@pytest.fixture
+def visibility_criterion(environment: Environment) -> VisibilityCriterion:
+    return VisibilityCriterion.from_line_of_sight(environment=environment)
+
+
+@pytest.fixture
+def lla() -> LLA:
+    return LLA.vector([0.0, 0.0, 500.0])
+
+
+@pytest.fixture
+def access_target(
+    visibility_criterion: VisibilityCriterion,
+    lla: LLA,
+    earth: Earth,
+) -> AccessTarget:
+    return AccessTarget.from_lla(visibility_criterion, lla, earth)
+
+
+@pytest.fixture
+def trajectory_target(
+    visibility_criterion: VisibilityCriterion,
+    from_trajectory: Trajectory,
+) -> AccessTarget:
+    return AccessTarget.from_trajectory(visibility_criterion, from_trajectory)
+
+
+class TestAccessTarget:
+    def test_constructor_success(self, access_target: AccessTarget):
+        assert isinstance(access_target, AccessTarget)
+
+    def test_get_type_success(self, access_target: AccessTarget):
+        assert access_target.get_type() == AccessTarget.Type.Fixed
+
+    def test_get_visibility_criterion_success(self, access_target: AccessTarget):
+        assert access_target.get_visibility_criterion() is not None
+        assert isinstance(access_target.get_visibility_criterion(), VisibilityCriterion)
+
+    def test_get_trajectory_success(self, access_target: AccessTarget):
+        assert access_target.get_trajectory() is not None
+        assert isinstance(access_target.get_trajectory(), Trajectory)
+
+    def test_get_position_success(self, access_target: AccessTarget):
+        assert access_target.get_position() is not None
+        assert isinstance(access_target.get_position(), Position)
+
+    def test_get_lla_success(
+        self,
+        access_target: AccessTarget,
+        earth: Earth,
+    ):
+        assert access_target.get_lla(earth) is not None
+        assert isinstance(access_target.get_lla(earth), LLA)
+
+    def test_compute_r_sez_ecef_success(
+        self,
+        access_target: AccessTarget,
+        earth: Earth,
+    ):
+        assert access_target.compute_r_sez_ecef(earth) is not None
+        assert isinstance(access_target.compute_r_sez_ecef(earth), np.ndarray)
+
+    def test_from_lla_success(
+        self,
+        visibility_criterion: VisibilityCriterion,
+        lla: LLA,
+        earth: Earth,
+    ):
+        access_target = AccessTarget.from_lla(visibility_criterion, lla, earth)
+
+        assert access_target is not None
+        assert isinstance(access_target, AccessTarget)
+
+    def test_from_position_success(
+        self,
+        visibility_criterion: VisibilityCriterion,
+        position: Position,
+    ):
+        access_target = AccessTarget.from_position(
+            visibility_criterion, position.in_frame(Frame.ITRF(), Instant.J2000())
         )
 
-        assert generator is not None
-        assert isinstance(generator, Generator)
+        assert access_target is not None
+        assert isinstance(access_target, AccessTarget)
 
-    def test_constructor_success_environment_aer_filter(self, environment: Environment):
+    def test_from_trajectory_success(
+        self,
+        visibility_criterion: VisibilityCriterion,
+        trajectory: Trajectory,
+    ):
+        access_target = AccessTarget.from_trajectory(visibility_criterion, trajectory)
+
+        assert access_target is not None
+        assert isinstance(access_target, AccessTarget)
+
+
+class TestGenerator:
+    def test_constructor_success_environment(self, environment: Environment):
         generator = Generator(
             environment=environment,
-            aer_filter=lambda aer: True,
         )
 
         assert generator is not None
@@ -142,18 +236,17 @@ class TestGenerator:
     def test_getters_success(self, generator: Generator):
         assert generator.get_step() == Duration.minutes(1.0)
         assert generator.get_tolerance() == Duration.microseconds(1.0)
-        assert generator.get_aer_filter() is not None
         assert generator.get_access_filter() is not None
-        assert generator.get_state_filter() is not None
+        assert generator.get_state_filter() is None
 
     def test_get_condition_function_success(
         self,
         generator: Generator,
-        from_trajectory: Trajectory,
+        trajectory_target: AccessTarget,
         to_trajectory: Trajectory,
     ):
         condition_function = generator.get_condition_function(
-            from_trajectory=from_trajectory,
+            access_target=trajectory_target,
             to_trajectory=to_trajectory,
         )
 
@@ -168,7 +261,7 @@ class TestGenerator:
     def test_compute_accesses_success(
         self,
         generator: Generator,
-        from_trajectory: Trajectory,
+        trajectory_target: AccessTarget,
         to_trajectory: Trajectory,
     ):
         accesses = generator.compute_accesses(
@@ -176,7 +269,7 @@ class TestGenerator:
                 Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
                 Instant.date_time(DateTime(2018, 1, 1, 2, 0, 0), Scale.UTC),
             ),
-            from_trajectory=from_trajectory,
+            access_target=trajectory_target,
             to_trajectory=to_trajectory,
         )
 
@@ -185,15 +278,33 @@ class TestGenerator:
         assert accesses[0] is not None
         assert isinstance(accesses[0], Access)
 
+    def test_compute_accesses_multiple_targets_success(
+        self,
+        generator: Generator,
+        trajectory_target: AccessTarget,
+        to_trajectory: Trajectory,
+    ):
+        accesses = generator.compute_accesses(
+            interval=Interval.closed(
+                Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+                Instant.date_time(DateTime(2018, 1, 1, 2, 0, 0), Scale.UTC),
+            ),
+            access_targets=[trajectory_target],
+            to_trajectory=to_trajectory,
+        )
+
+        assert accesses is not None
+        assert isinstance(accesses, list)
+        assert accesses[0] is not None
+        assert isinstance(accesses[0], list)
+        assert isinstance(accesses[0][0], Access)
+
     def test_set_step_success(self, generator: Generator):
         generator.set_step(Duration.seconds(1.0))
 
     def test_set_tolerance_success(self, generator: Generator):
         generator.set_tolerance(Duration.seconds(1.0))
 
-    def test_set_aer_filter_success(self, generator: Generator):
-        generator.set_aer_filter(aer_filter=lambda aer: True)
-
     def test_set_access_filter_success(self, generator: Generator):
         generator.set_access_filter(access_filter=lambda access: True)
 
@@ -206,43 +317,3 @@ class TestGenerator:
         assert generator is not None
         assert isinstance(generator, Generator)
         assert generator.is_defined() is False
-
-    def test_aer_ranges_success(self, environment: Environment):
-        # Construct arbitrary AER ranges
-        azimuth_interval = RealInterval.closed(0.0, 360.0)
-        elevation_interval = RealInterval.closed(0.0, 90.0)
-        range_interval = RealInterval.closed(0.0, 7000e3)
-
-        generator = Generator.aer_ranges(
-            azimuth_range=azimuth_interval,
-            elevation_range=elevation_interval,
-            range_range=range_interval,
-            environment=environment,
-        )
-
-        assert generator is not None
-        assert isinstance(generator, Generator)
-        assert generator.is_defined()
-
-    def test_aer_mask_success(self, environment: Environment):
-        # Construct arbitrary anAzimuthElevationMask using python dict
-        an_azimuth_elevation_mask = {
-            0.0: 30.0,
-            90.0: 60.0,
-            180.0: 60.0,
-            270.0: 30.0,
-            359.0: 30.0,
-        }
-
-        # Construct arbitrary aRangerange
-        a_range_range = RealInterval(0.0, 10e4, RealInterval.Type.Closed)
-
-        generator = Generator.aer_mask(
-            azimuth_elevation_mask=an_azimuth_elevation_mask,
-            range_range=a_range_range,
-            environment=environment,
-        )
-
-        assert generator is not None
-        assert isinstance(generator, Generator)
-        assert generator.is_defined()

ostk/astrodynamics/test/access/test_visibility_criterion.py

@@ -0,0 +1,198 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+from ostk.mathematics.object import RealInterval
+
+from ostk.physics import Environment
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+
+from ostk.astrodynamics.access import VisibilityCriterion
+
+
+@pytest.fixture()
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def azimuth_interval() -> RealInterval:
+    return RealInterval.closed(0.0, 90.0)
+
+
+@pytest.fixture
+def elevation_interval() -> RealInterval:
+    return RealInterval.closed(0.0, 45.0)
+
+
+@pytest.fixture
+def range_interval() -> RealInterval:
+    return RealInterval.closed(0.0, 1e7)
+
+
+@pytest.fixture
+def aer_mask() -> dict[float, float]:
+    return {
+        0.0: 0.0,
+        90.0: 45.0,
+    }
+
+
+class TestVisibilityCriterion:
+    def test_aer_interval_constructor(
+        self,
+        azimuth_interval: RealInterval,
+        elevation_interval: RealInterval,
+        range_interval: RealInterval,
+    ):
+        aer_interval = VisibilityCriterion.AERInterval(
+            azimuth_interval,
+            elevation_interval,
+            range_interval,
+        )
+        assert aer_interval is not None
+        assert isinstance(aer_interval, VisibilityCriterion.AERInterval)
+
+    def test_aer_mask_constructor(
+        self,
+        aer_mask: dict[float, float],
+        range_interval: RealInterval,
+    ):
+        aer_mask_criterion = VisibilityCriterion.AERMask(aer_mask, range_interval)
+        assert aer_mask_criterion is not None
+        assert isinstance(aer_mask_criterion, VisibilityCriterion.AERMask)
+
+    def test_line_of_sight_constructor(
+        self,
+        environment: Environment,
+    ):
+        line_of_sight = VisibilityCriterion.LineOfSight(environment)
+        assert line_of_sight is not None
+        assert isinstance(line_of_sight, VisibilityCriterion.LineOfSight)
+
+    def test_elevation_interval_constructor(
+        self,
+        elevation_interval: RealInterval,
+    ):
+        elevation_criterion = VisibilityCriterion.ElevationInterval(elevation_interval)
+        assert elevation_criterion is not None
+        assert isinstance(elevation_criterion, VisibilityCriterion.ElevationInterval)
+
+    def test_visibility_criterion_from_aer_interval(
+        self,
+        azimuth_interval: RealInterval,
+        elevation_interval: RealInterval,
+        range_interval: RealInterval,
+    ):
+        criterion = VisibilityCriterion.from_aer_interval(
+            azimuth_interval, elevation_interval, range_interval
+        )
+        assert criterion is not None
+        assert isinstance(criterion, VisibilityCriterion)
+        assert criterion.is_aer_interval()
+
+    def test_visibility_criterion_from_aer_mask(
+        self,
+        aer_mask: dict[float, float],
+        range_interval: RealInterval,
+    ):
+        criterion = VisibilityCriterion.from_aer_mask(aer_mask, range_interval)
+        assert criterion is not None
+        assert isinstance(criterion, VisibilityCriterion)
+        assert criterion.is_aer_mask()
+
+    def test_visibility_criterion_from_line_of_sight(
+        self,
+        environment: Environment,
+    ):
+        criterion = VisibilityCriterion.from_line_of_sight(environment)
+        assert criterion is not None
+        assert isinstance(criterion, VisibilityCriterion)
+        assert criterion.is_line_of_sight()
+
+    def test_visibility_criterion_from_elevation_interval(
+        self, elevation_interval: RealInterval
+    ):
+        criterion = VisibilityCriterion.from_elevation_interval(elevation_interval)
+        assert criterion is not None
+        assert isinstance(criterion, VisibilityCriterion)
+        assert criterion.is_elevation_interval()
+
+    def test_aer_interval_is_satisfied(
+        self,
+        azimuth_interval: RealInterval,
+        elevation_interval: RealInterval,
+        range_interval: RealInterval,
+    ):
+        aer_interval = VisibilityCriterion.AERInterval(
+            azimuth_interval, elevation_interval, range_interval
+        )
+        assert (
+            aer_interval.is_satisfied(azimuth=np.pi / 4, elevation=np.pi / 8, range=5e6)
+            is True
+        )
+
+        assert (
+            aer_interval.is_satisfied(azimuth=np.pi, elevation=np.pi / 2, range=1e8)
+            is False
+        )
+
+    def test_elevation_interval_is_satisfied(
+        self,
+        elevation_interval: RealInterval,
+    ):
+        elevation_criterion = VisibilityCriterion.ElevationInterval(elevation_interval)
+        elevation_valid = np.pi / 8  # 22.5 degrees
+        assert elevation_criterion.is_satisfied(elevation_valid) is True
+
+        elevation_invalid = np.pi / 2  # 90 degrees
+        assert elevation_criterion.is_satisfied(elevation_invalid) is False
+
+    def test_line_of_sight_is_satisfied(
+        self,
+        environment: Environment,
+    ):
+        line_of_sight = VisibilityCriterion.LineOfSight(environment)
+        instant = Instant.now()
+
+        from_position = np.array([7000e3, 0.0, 0.0])
+        to_position = np.array([7005e3, 0.0, 0.0])
+
+        assert line_of_sight.is_satisfied(instant, from_position, to_position) is True
+
+    def test_visibility_criterion_type_checks(
+        self,
+        elevation_interval: RealInterval,
+        environment: Environment,
+    ):
+        criterion = VisibilityCriterion.from_elevation_interval(elevation_interval)
+        assert criterion.is_elevation_interval() is True
+        assert criterion.is_aer_interval() is False
+        assert criterion.is_line_of_sight() is False
+
+        criterion = VisibilityCriterion.from_line_of_sight(environment)
+        assert criterion.is_line_of_sight() is True
+
+    def test_visibility_criterion_cast(
+        self,
+        azimuth_interval: RealInterval,
+        elevation_interval: RealInterval,
+        range_interval: RealInterval,
+    ):
+        criterion = VisibilityCriterion.from_aer_interval(
+            azimuth_interval, elevation_interval, range_interval
+        )
+        aer_interval = criterion.as_aer_interval()
+        assert aer_interval is not None
+        assert isinstance(aer_interval, VisibilityCriterion.AERInterval)
+
+        with pytest.raises(ValueError):
+            criterion.as_line_of_sight()

ostk/astrodynamics/test/data/provider/test_off_nadir.py

@@ -0,0 +1,58 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import DateTime
+from ostk.physics.time import Instant
+from ostk.physics.time import Scale
+from ostk.physics.unit import Angle
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.data.provider import compute_off_nadir_angles
+
+
+@pytest.fixture
+def target_position() -> Position:
+    return Position.meters([0.0, 0.0, 0.0], Frame.GCRF())
+
+
+@pytest.fixture
+def state() -> State:
+    instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+    position = Position.meters([0.0, 0.0, 0.0], Frame.GCRF())
+    velocity = Velocity.meters_per_second([0.0, 0.0, 0.0], Frame.GCRF())
+
+    return State(instant=instant, position=position, velocity=velocity)
+
+
+class TestOffNadirAngles:
+
+    def test_compute_off_nadir_angles(
+        self,
+        state: State,
+        target_position: Position,
+    ):
+        along_track: Angle
+        cross_track: Angle
+        off_nadir: Angle
+        along_track, cross_track, off_nadir = compute_off_nadir_angles(
+            state, target_position
+        )
+
+        assert along_track is not None
+        assert cross_track is not None
+        assert off_nadir is not None
+
+    def test_compute_off_nadir_angles_undefined(
+        self,
+        state: State,
+        target_position: Position,
+    ):
+        with pytest.raises(RuntimeError):
+            compute_off_nadir_angles(State.undefined(), target_position)
+
+        with pytest.raises(RuntimeError):
+            compute_off_nadir_angles(state, Position.undefined())

ostk/astrodynamics/test/dynamics/test_dynamics.py

@@ -21,7 +21,7 @@ def environment() -> Environment:
 @pytest.fixture
 def dynamics(name: str) -> Dynamics:
     class MyDynamics(Dynamics):
-        def is_defined():
+        def is_defined(self):
             return True
 
         def get_read_coordinate_subsets(self):

ostk/astrodynamics/test/flight/system/test_propulsion_system.py

@@ -2,17 +2,8 @@
 
 import pytest
 
-import numpy as np
-
-import ostk.mathematics as mathematics
-
-import ostk.physics as physics
-
-import ostk.astrodynamics as astrodynamics
-
-Mass = physics.unit.Mass
-
-PropulsionSystem = astrodynamics.flight.system.PropulsionSystem
+from ostk.physics.unit import Mass
+from ostk.astrodynamics.flight.system import PropulsionSystem
 
 
 @pytest.fixture

ostk/astrodynamics/test/flight/system/test_satellite_system.py

@@ -4,20 +4,12 @@ import pytest
 
 import numpy as np
 
-import ostk.mathematics as mathematics
-
-import ostk.physics as physics
-
-import ostk.astrodynamics as astrodynamics
-
-Cuboid = mathematics.geometry.d3.object.Cuboid
-Composite = mathematics.geometry.d3.object.Composite
-Point = mathematics.geometry.d3.object.Point
-
-Mass = physics.unit.Mass
-
-SatelliteSystem = astrodynamics.flight.system.SatelliteSystem
-PropulsionSystem = astrodynamics.flight.system.PropulsionSystem
+from ostk.mathematics.geometry.d3.object import Cuboid
+from ostk.mathematics.geometry.d3.object import Composite
+from ostk.mathematics.geometry.d3.object import Point
+from ostk.physics.unit import Mass
+from ostk.astrodynamics.flight.system import SatelliteSystem
+from ostk.astrodynamics.flight.system import PropulsionSystem
 
 
 @pytest.fixture