open-space-toolkit-astrodynamics 17.2.0__py312-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/access/test_generator.py

@@ -0,0 +1,319 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.object import RealInterval
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+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
+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
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def earth(environment: Environment) -> Celestial:
+    return environment.access_celestial_object_with_name("Earth")
+
+
+@pytest.fixture
+def generator(environment: Environment) -> Generator:
+    return Generator(
+        environment=environment,
+        access_filter=lambda access: True,
+        state_filter=None,
+    )
+
+
+@pytest.fixture
+def from_trajectory(earth: Celestial) -> Trajectory:
+    return Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(7000.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(45.0),
+                raan=Angle.degrees(0.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(0.0),
+            ),
+            epoch=Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+
+
+@pytest.fixture
+def to_trajectory(earth: Celestial) -> Trajectory:
+    return Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(7000.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(45.0),
+                raan=Angle.degrees(180.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(180.0),
+            ),
+            epoch=Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+
+
+@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 access_target is not None
+        assert isinstance(access_target, AccessTarget)
+
+    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,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+
+    def test_constructor_success_environment_access_filter(
+        self,
+        environment: Environment,
+    ):
+        generator = Generator(
+            environment=environment,
+            access_filter=lambda access: True,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+
+    def test_constructor_success_environment_state_filter(
+        self,
+        environment: Environment,
+    ):
+        generator = Generator(
+            environment=environment,
+            state_filter=lambda state_1, state_2: True,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+
+    def test_constructor_success_environment_step_tolerance(
+        self,
+        environment: Environment,
+    ):
+        generator = Generator(
+            environment=environment,
+            step=Duration.seconds(1.0),
+            tolerance=Duration.minutes(1.0),
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.get_step() == Duration.seconds(1.0)
+        assert generator.get_tolerance() == Duration.minutes(1.0)
+
+    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_access_filter() is not None
+        assert generator.get_state_filter() is None
+
+    def test_get_condition_function_success(
+        self,
+        generator: Generator,
+        trajectory_target: AccessTarget,
+        to_trajectory: Trajectory,
+    ):
+        condition_function = generator.get_condition_function(
+            access_target=trajectory_target,
+            to_trajectory=to_trajectory,
+        )
+
+        assert condition_function is not None
+        assert (
+            condition_function(
+                Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+            is True
+        )
+
+    def test_compute_accesses_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_target=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], 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_access_filter_success(self, generator: Generator):
+        generator.set_access_filter(access_filter=lambda access: True)
+
+    def test_set_state_filter_success(self, generator: Generator):
+        generator.set_state_filter(state_filter=lambda state_1, state_2: True)
+
+    def test_undefined_success(self):
+        generator = Generator.undefined()
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.is_defined() is False

ostk/astrodynamics/test/access/test_visibility_criterion.py

@@ -0,0 +1,201 @@
+# 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.physics.unit import Angle
+
+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
+        assert elevation_criterion.is_satisfied(Angle.radians(elevation_valid)) is True
+
+        elevation_invalid = np.pi / 2  # 90 degrees
+        assert elevation_criterion.is_satisfied(elevation_invalid) is False
+        assert elevation_criterion.is_satisfied(Angle.radians(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/conftest.py

@@ -0,0 +1,119 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics import Environment
+from ostk.physics.unit import Angle
+from ostk.physics.unit import Length
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.time import Interval
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.coordinate.spherical import AER
+
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import State
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def scale() -> Scale:
+    return Scale.UTC
+
+
+@pytest.fixture
+def instant_1(scale: Scale) -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 8, 13, 45, 34), scale)
+
+
+@pytest.fixture
+def instant_2(scale: Scale) -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 8, 13, 46, 34), scale)
+
+
+@pytest.fixture
+def instant_3(scale: Scale) -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 8, 13, 47, 34), scale)
+
+
+@pytest.fixture
+def instant(instant_1: Instant) -> Instant:
+    return instant_1
+
+
+@pytest.fixture
+def interval(instant_1: Instant, instant_2: Instant) -> Interval:
+    return Interval(instant_1, instant_2, Interval.Type.Closed)
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def position(frame: Frame) -> Position:
+    return Position.meters([7000000.0, 0.0, 0.0], frame)
+
+
+@pytest.fixture
+def velocity(frame: Frame) -> Velocity:
+    return Velocity.meters_per_second([7600.0, 0.0, 0.0], frame)
+
+
+@pytest.fixture
+def state(instant: Instant, position: Position, velocity: Velocity) -> State:
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def latitude() -> Angle:
+    return Angle(30.0, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def longitude() -> Angle:
+    return Angle(-111.0, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def altitude() -> Length:
+    return Length(10000.0, Length.Unit.Meter)
+
+
+@pytest.fixture
+def lla(latitude: Angle, longitude: Angle, altitude: Length) -> LLA:
+    return LLA(latitude, longitude, altitude)
+
+
+@pytest.fixture
+def azimuth() -> Angle:
+    return Angle(270.0, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def elevation() -> Angle:
+    return Angle(10.45, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def range() -> Length:
+    return Length(100000.0, Length.Unit.Meter)
+
+
+@pytest.fixture
+def aer(azimuth: Angle, elevation: Angle, range: Length) -> LLA:
+    return AER(azimuth, elevation, range)
+
+
+@pytest.fixture
+def trajectory(position: Position, instant_1: Instant) -> Trajectory:
+    return Trajectory.position(position.in_frame(Frame.ITRF(), instant_1))