open-space-toolkit-astrodynamics 13.1.0__py313-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/trajectory/test_local_orbital_frame_factory.py

@@ -0,0 +1,108 @@
+# Apache License 2.0
+
+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 Frame
+from ostk.physics.coordinate import Transform
+
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameTransformProvider
+
+
+@pytest.fixture
+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
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def position_vector() -> list:
+    return [7500000.0, 0.0, 0.0]
+
+
+@pytest.fixture
+def velocity_vector() -> list:
+    return [0.0, 5335.865450622126, 5335.865450622126]
+
+
+class TestLocalOrbitalFrameFactory:
+    def test_constructors(self):
+        assert LocalOrbitalFrameFactory.VNC(Frame.GCRF()) is not None
+        assert LocalOrbitalFrameFactory.NED(Frame.GCRF()) is not None
+        assert LocalOrbitalFrameFactory.LVLH(Frame.GCRF()) is not None
+        assert LocalOrbitalFrameFactory.QSW(Frame.GCRF()) is not None
+        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,
+        instant: Instant,
+        position_vector: list,
+        velocity_vector: list,
+    ):
+        frame = local_orbital_frame_factory.generate_frame(
+            instant,
+            position_vector,
+            velocity_vector,
+        )
+
+        assert frame is not None
+        assert frame.is_defined()
+
+    def test_is_defined(
+        self,
+        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_model.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/astrodynamics/test/trajectory/test_orbit.py

@@ -0,0 +1,205 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.environment.object.celestial import Earth
+from ostk.physics.unit import Length, Angle
+from ostk.physics.time import Scale, Instant, DateTime, Time, Duration, Interval
+
+from ostk.astrodynamics.trajectory import Orbit, State
+from ostk.astrodynamics.trajectory.orbit import Pass
+from ostk.astrodynamics.trajectory.orbit import Pass
+from ostk.astrodynamics.trajectory.orbit.model import SGP4
+from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
+
+
+@pytest.fixture
+def earth() -> Earth:
+    return Earth.default()
+
+
+@pytest.fixture
+def epoch() -> Instant:
+    return Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def orbit(earth: Earth, epoch: Instant):
+    return Orbit.sun_synchronous(epoch, Length.kilometers(500.0), Time.midnight(), earth)
+
+
+@pytest.fixture
+def states(orbit: Orbit, epoch: Instant) -> list[State]:
+    instants: list[Instant] = Interval.closed(
+        epoch, epoch + Duration.days(1.0)
+    ).generate_grid(Duration.seconds(20.0))
+
+    return orbit.get_states_at(instants)
+
+
+class TestOrbit:
+    def test_constructors(self, earth):
+        # Construct Two-Line Element set
+        tle = TLE(
+            "1 25544U 98067A   18231.17878740  .00000187  00000-0  10196-4 0  9994",
+            "2 25544  51.6447  64.7824 0005971  73.1467  36.4366 15.53848234128316",
+        )
+
+        # Construct orbit using SGP4 model
+        orbit = Orbit(SGP4(tle), earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+        # Construct get state at current epoch
+        state: State = orbit.get_state_at(Instant.now())
+
+        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(
+                Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+            == 1
+        )
+
+    def test_get_pass_at(self, orbit: Orbit):
+        pass_ = orbit.get_pass_at(
+            Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        )
+
+        assert pass_ is not None
+        assert isinstance(pass_, Pass)
+        assert pass_.is_defined()
+
+    def test_get_pass_with_revolution_number(self, orbit: Orbit):
+        pass_ = orbit.get_pass_with_revolution_number(1)
+
+        assert pass_ is not None
+        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
+
+    def test_circular(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        altitude = Length.kilometers(500.0)
+        inclination = Angle.degrees(45.0)
+
+        orbit: Orbit = Orbit.circular(epoch, altitude, inclination, earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+    def test_equatorial(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        apoapsis_altitude = Length.kilometers(500.1)
+        periapsis_altitude = Length.kilometers(499.9)
+
+        orbit: Orbit = Orbit.equatorial(
+            epoch, apoapsis_altitude, periapsis_altitude, earth
+        )
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+    def test_circular_equatorial(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        altitude = Length.kilometers(500.0)
+
+        orbit: Orbit = Orbit.circular_equatorial(epoch, altitude, earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+    def test_geo_synchronous(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        inclination = Angle.degrees(45.0)
+        longitude = Angle.degrees(45.0)
+
+        orbit: Orbit = Orbit.geo_synchronous(epoch, inclination, longitude, earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+    def test_sun_synchronous(self, earth):
+        epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        altitude = Length.kilometers(500.0)
+        local_time_at_descending_node = Time.midnight()
+
+        orbit: Orbit = Orbit.sun_synchronous(
+            epoch, altitude, local_time_at_descending_node, earth
+        )
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+        assert Orbit.sun_synchronous(
+            epoch=epoch,
+            altitude=altitude,
+            local_time_at_descending_node=local_time_at_descending_node,
+            celestial_object=earth,
+            argument_of_latitude=Angle.degrees(50.0),
+        ).is_defined()
+
+    def test_frozen(self, earth, epoch):
+        altitude = Length.kilometers(500.0)
+
+        orbit: Orbit = Orbit.frozen(epoch, altitude, earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+    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