open-space-toolkit-astrodynamics 13.1.0__py310-none-manylinux2014_x86_64.whl → 14.0.0__py310-none-manylinux2014_x86_64.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/flight/test_maneuver.py

@@ -12,24 +12,21 @@ from ostk.physics.coordinate import Frame
 from ostk.physics.unit import Mass
 
 from ostk.astrodynamics.flight import Maneuver
+from ostk.astrodynamics.trajectory import State
 from ostk.astrodynamics.dynamics import Tabulated as TabulatedDynamics
 from ostk.astrodynamics.trajectory.state import CoordinateSubset
-
-
-from ..dynamics.test_tabulated import (
-    instants as tabulated_instants,
-    contribution_profile as tabulated_contribution_profile,
-    coordinate_subsets as tabulated_coordinate_subsets,
-)
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianAcceleration
 
 
 @pytest.fixture
 def instants() -> list[Instant]:
     return [
         Instant.J2000(),
-        Instant.J2000() + Duration.seconds(1.0),
-        Instant.J2000() + Duration.seconds(5.0),
-        Instant.J2000() + Duration.seconds(7.0),
+        Instant.J2000() + Duration.seconds(30.0),
+        Instant.J2000() + Duration.seconds(35.0),
+        Instant.J2000() + Duration.seconds(37.0),
     ]
 
 
@@ -54,13 +51,43 @@ def mass_flow_rate_profile() -> list[float]:
 
 
 @pytest.fixture
-def maneuver(
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+        CartesianAcceleration.thrust_acceleration(),
+        CoordinateSubset.mass_flow_rate(),
+    ]
+
+
+@pytest.fixture
+def states(
     instants: list[Instant],
     acceleration_profile: list[np.ndarray],
-    frame: Frame,
     mass_flow_rate_profile: list[float],
+    frame: Frame,
+    coordinate_subsets: list[CoordinateSubset],
+) -> list[State]:
+    states = []
+    for instant, acceleration, mass_flow_rate in zip(
+        instants, acceleration_profile, mass_flow_rate_profile
+    ):
+        states.append(
+            State(
+                instant,
+                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, *acceleration, mass_flow_rate],
+                frame,
+                coordinate_subsets,
+            )
+        )
+    return states
+
+
+@pytest.fixture
+def maneuver(
+    states: list[State],
 ) -> Maneuver:
-    return Maneuver(instants, acceleration_profile, frame, mass_flow_rate_profile)
+    return Maneuver(states)
 
 
 @pytest.fixture
@@ -97,35 +124,15 @@ class TestManeuver:
     def test_getters(
         self,
         maneuver: Maneuver,
-        instants: list[Instant],
-        acceleration_profile: list[np.ndarray],
-        mass_flow_rate_profile: list[float],
+        states: list[State],
     ):
         assert maneuver.is_defined()
 
-        assert maneuver.get_instants() == instants
+        assert maneuver.get_states() == states
 
-        computed_acceleration_profile_default_frame = maneuver.get_acceleration_profile()
-        for i in range(len(instants)):
-            assert np.array_equal(
-                computed_acceleration_profile_default_frame[i], acceleration_profile[i]
-            )
-
-        computed_acceleration_profile_non_default_frame = (
-            maneuver.get_acceleration_profile(frame=Frame.ITRF())
+        assert maneuver.get_interval() == Interval.closed(
+            states[0].get_instant(), states[-1].get_instant()
         )
-        for i in range(len(instants)):
-            assert (
-                np.array_equal(
-                    computed_acceleration_profile_non_default_frame[i],
-                    acceleration_profile[i],
-                )
-                == False
-            )
-
-        assert maneuver.get_mass_flow_rate_profile() == mass_flow_rate_profile
-
-        assert maneuver.get_interval() == Interval.closed(instants[0], instants[-1])
 
     def test_calculators(
         self,
@@ -159,7 +166,9 @@ class TestManeuver:
         )
 
         assert tabulated_dynamics.is_defined()
-        assert tabulated_dynamics.access_instants() == maneuver.get_instants()
+        assert tabulated_dynamics.access_instants() == [
+            state.get_instant() for state in maneuver.get_states()
+        ]
 
         contribution_profile: np.ndarray = (
             tabulated_dynamics.access_contribution_profile()
@@ -175,38 +184,14 @@ class TestManeuver:
 
         assert tabulated_dynamics.access_frame() == frame
 
-    def test_from_tabulated_dynamics(
-        self,
-        tabulated_dynamics: TabulatedDynamics,
-    ):
-        maneuver = Maneuver.tabulated_dynamics(tabulated_dynamics)
-
-        assert maneuver.is_defined()
-        assert maneuver.get_instants() == tabulated_dynamics.access_instants()
-        assert (
-            len(maneuver.get_acceleration_profile())
-            == tabulated_dynamics.access_contribution_profile().shape[0]
-        )
-        assert (
-            len(maneuver.get_mass_flow_rate_profile())
-            == tabulated_dynamics.access_contribution_profile().shape[0]
-        )
-
     def test_from_constant_mass_flow_rate(
         self,
-        instants: list[Instant],
-        acceleration_profile: list[np.ndarray],
-        frame: Frame,
+        states: list[State],
     ):
         mass_flow_rate: float = -1.0e-5
         maneuver = Maneuver.constant_mass_flow_rate_profile(
-            instants=instants,
-            acceleration_profile=acceleration_profile,
-            frame=frame,
+            states=states,
             mass_flow_rate=mass_flow_rate,
         )
 
         assert maneuver.is_defined()
-        assert maneuver.get_mass_flow_rate_profile() == [
-            mass_flow_rate for _ in range(len(instants))
-        ]