open-space-toolkit-astrodynamics 5.1.5__py38-none-any.whl → 5.2.0__py38-none-any.whl

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

@@ -0,0 +1,55 @@
+# Apache License 2.0
+
+import pytest
+
+import ostk.physics as physics
+
+import ostk.astrodynamics as astrodynamics
+
+Length = physics.units.Length
+Angle = physics.units.Angle
+Scale = physics.time.Scale
+Instant = physics.time.Instant
+Interval = physics.time.Interval
+DateTime = physics.time.DateTime
+Position = physics.coordinate.Position
+Velocity = physics.coordinate.Velocity
+Frame = physics.coordinate.Frame
+Environment = physics.Environment
+
+Trajectory = astrodynamics.Trajectory
+Model = astrodynamics.trajectory.Model
+Orbit = astrodynamics.trajectory.Orbit
+Pass = astrodynamics.trajectory.orbit.Pass
+Kepler = astrodynamics.trajectory.orbit.models.Kepler
+COE = astrodynamics.trajectory.orbit.models.kepler.COE
+SGP4 = astrodynamics.trajectory.orbit.models.SGP4
+TLE = astrodynamics.trajectory.orbit.models.sgp4.TLE
+State = astrodynamics.trajectory.State
+Access = astrodynamics.Access
+
+earth = Environment.default().access_celestial_object_with_name("Earth")
+
+
+def test_trajectory_orbit_pass():
+    pass_type = Pass.Type.Partial
+    pass_revolution_number = 123
+    pass_start_instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    pass_end_instant = Instant.date_time(DateTime(2018, 1, 1, 1, 0, 0), Scale.UTC)
+    pass_interval = Interval.closed(pass_start_instant, pass_end_instant)
+
+    pass_ = Pass(pass_type, pass_revolution_number, pass_interval)
+
+    assert pass_ is not None
+    assert isinstance(pass_, Pass)
+
+    assert pass_.is_defined()
+    assert pass_.is_complete() is not None
+    assert pass_.get_type() is not None
+    assert pass_.get_revolution_number() is not None
+    # Interval conversion to Python type of issue
+    # assert pass_.get_interval() is not None
+
+    assert Pass.string_from_type(Pass.Type.Complete) is not None
+    assert Pass.string_from_phase(Pass.Phase.Ascending) is not None
+    assert Pass.string_from_quarter(Pass.Quarter.First) is not None

ostk/astrodynamics/test/trajectory/state/coordinates_subset/test_angular_velocity.py

@@ -0,0 +1,30 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state.coordinates_subset import (
+    AngularVelocity,
+    AttitudeQuaternion,
+)
+
+
+@pytest.fixture
+def attitude_quaternion() -> AttitudeQuaternion:
+    return AttitudeQuaternion.default()
+
+
+@pytest.fixture
+def name() -> str:
+    return "Angular Velocity"
+
+
+class TestAngularVelocity:
+    def test_constructor(
+        self,
+        attitude_quaternion: AttitudeQuaternion,
+        name: str,
+    ):
+        assert AngularVelocity(attitude_quaternion, name) is not None
+
+    def test_default(self):
+        assert AttitudeQuaternion.default() is not None

ostk/astrodynamics/test/trajectory/state/coordinates_subset/test_attitude_quaternion.py

@@ -0,0 +1,18 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state.coordinates_subset import AttitudeQuaternion
+
+
+@pytest.fixture
+def name() -> str:
+    return "Attitude"
+
+
+class TestAttitudeQuaternion:
+    def test_constructor(self, name: str):
+        assert AttitudeQuaternion(name) is not None
+
+    def test_default(self):
+        assert AttitudeQuaternion.default() is not None

ostk/astrodynamics/test/trajectory/state/coordinates_subset/test_cartesian_position.py

@@ -0,0 +1,107 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinatesBroker, CoordinatesSubset
+from ostk.astrodynamics.trajectory.state.coordinates_subset import CartesianPosition
+
+
+@pytest.fixture
+def name() -> str:
+    return "Position"
+
+
+@pytest.fixture
+def cartesian_position() -> CartesianPosition:
+    return CartesianPosition.default()
+
+
+@pytest.fixture
+def coordinates_subsets(
+    cartesian_position: CartesianPosition,
+) -> list[CoordinatesSubset]:
+    return [cartesian_position]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinates_broker(
+    coordinates_subsets: list[CoordinatesSubset],
+) -> CoordinatesBroker:
+    return CoordinatesBroker(coordinates_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [7000000.0, 0.0, 0.0]
+
+
+@pytest.fixture
+def another_coordinates() -> list[float]:
+    return [0.0, 7000000.0, 0.0]
+
+
+class TestCartesianPosition:
+    def test_constructor(self, name: str):
+        assert CartesianPosition(name) is not None
+
+    def test_add(
+        self,
+        cartesian_position: CartesianPosition,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        assert all(
+            cartesian_position.add(
+                instant, coordinates, another_coordinates, frame, coordinates_broker
+            )
+            == [7000000.0, 7000000.0, 0.0]
+        )
+
+    def test_subtract(
+        self,
+        cartesian_position: CartesianPosition,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        assert all(
+            cartesian_position.subtract(
+                instant, coordinates, another_coordinates, frame, coordinates_broker
+            )
+            == [7000000.0, -7000000.0, 0.0]
+        )
+
+    def test_in_frame(
+        self,
+        cartesian_position: CartesianPosition,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        for value, expected in zip(
+            cartesian_position.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinates_broker
+            ),
+            [1238864.12746338, 6889500.39136482, -176.262107699686],
+        ):
+            assert value == pytest.approx(expected, rel=1e-14)

ostk/astrodynamics/test/trajectory/state/coordinates_subset/test_cartesian_velocity.py

@@ -0,0 +1,115 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinatesBroker, CoordinatesSubset
+from ostk.astrodynamics.trajectory.state.coordinates_subset import (
+    CartesianVelocity,
+    CartesianPosition,
+)
+
+
+@pytest.fixture
+def name() -> str:
+    return "Position"
+
+
+@pytest.fixture
+def cartesian_position() -> CartesianPosition:
+    return CartesianPosition.default()
+
+
+@pytest.fixture
+def cartesian_velocity() -> CartesianVelocity:
+    return CartesianVelocity.default()
+
+
+@pytest.fixture
+def coordinates_subsets(
+    cartesian_position: CartesianPosition, cartesian_velocity: CartesianVelocity
+) -> list[CoordinatesSubset]:
+    return [cartesian_position, cartesian_velocity]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinates_broker(
+    coordinates_subsets: list[CoordinatesSubset],
+) -> CoordinatesBroker:
+    return CoordinatesBroker(coordinates_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [7000000.0, 0.0, 0.0, 0.0, 5335.865450622126, 5335.865450622126]
+
+
+@pytest.fixture
+def another_coordinates() -> list[float]:
+    return [0.0, 7000000.0, 0.0, 5335.865450622126, 0.0, 0.0]
+
+
+class TestCartesianVelocity:
+    def test_constructor(self, name: str):
+        assert CartesianVelocity(CartesianPosition.default(), name) is not None
+
+    def test_add(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        assert all(
+            cartesian_velocity.add(
+                instant, coordinates, another_coordinates, frame, coordinates_broker
+            )
+            == [5335.865450622126, 5335.865450622126, 5335.865450622126]
+        )
+
+    def test_subtract(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        assert all(
+            cartesian_velocity.subtract(
+                instant, coordinates, another_coordinates, frame, coordinates_broker
+            )
+            == [-5335.865450622126, 5335.865450622126, 5335.865450622126]
+        )
+
+    def test_in_frame(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        for value, expected in zip(
+            cartesian_velocity.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinates_broker
+            ),
+            [-4749.36551256577, 854.163395375881, 5335.71857543495],
+        ):
+            assert value == pytest.approx(expected, rel=1e-14)

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

@@ -0,0 +1,84 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state import CoordinatesBroker, CoordinatesSubset
+
+
+@pytest.fixture
+def coordinates_subsets() -> list:
+    return [CoordinatesSubset("Subset1", 2), CoordinatesSubset("Subset2", 3)]
+
+
+@pytest.fixture
+def coordinates_broker(coordinates_subsets) -> CoordinatesBroker:
+    return CoordinatesBroker(coordinates_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [1.0, 2.0, 3.0, 4.0, 5.0]
+
+
+class TestCoordinatesBroker:
+    def test_constructor(self, coordinates_broker: CoordinatesBroker):
+        assert coordinates_broker is not None
+
+    def test_eq(self, coordinates_broker: CoordinatesBroker):
+        assert coordinates_broker == coordinates_broker
+
+    def test_ne(self, coordinates_broker: CoordinatesBroker):
+        assert (coordinates_broker != coordinates_broker) == False
+
+    def test_access_subsets(
+        self, coordinates_broker: CoordinatesBroker, coordinates_subsets: list
+    ):
+        assert coordinates_broker.access_subsets() == coordinates_subsets
+
+    def test_get_number_of_coordinates(self, coordinates_broker: CoordinatesBroker):
+        assert coordinates_broker.get_number_of_coordinates() == 5
+
+    def test_get_number_of_subsets(self, coordinates_broker: CoordinatesBroker):
+        assert coordinates_broker.get_number_of_subsets() == 2
+
+    def test_get_subsets(
+        self, coordinates_broker: CoordinatesBroker, coordinates_subsets: list
+    ):
+        assert coordinates_broker.get_subsets() == coordinates_subsets
+
+    def test_add_subset(self, coordinates_broker: CoordinatesBroker):
+        new_subset = CoordinatesSubset("NewSubset", 4)
+        number_of_coordinates = coordinates_broker.get_number_of_coordinates()
+        assert coordinates_broker.add_subset(new_subset) == number_of_coordinates
+        assert coordinates_broker.has_subset(new_subset)
+
+    def test_has_subset(
+        self, coordinates_broker: CoordinatesBroker, coordinates_subsets: list
+    ):
+        assert coordinates_broker.has_subset(coordinates_subsets[0])
+
+    def test_extract_coordinate(
+        self,
+        coordinates_broker: CoordinatesBroker,
+        coordinates: list[float],
+        coordinates_subsets: list[CoordinatesSubset],
+    ):
+        assert (
+            coordinates_broker.extract_coordinate(coordinates, coordinates_subsets[0])
+            == [1.0, 2.0]
+        ).all()
+        assert (
+            coordinates_broker.extract_coordinate(coordinates, coordinates_subsets[1])
+            == [3.0, 4.0, 5.0]
+        ).all()
+
+    def test_extract_coordinates(
+        self,
+        coordinates_broker: CoordinatesBroker,
+        coordinates: list[float],
+        coordinates_subsets: list[CoordinatesSubset],
+    ):
+        assert (
+            coordinates_broker.extract_coordinates(coordinates, coordinates_subsets)
+            == [1.0, 2.0, 3.0, 4.0, 5.0]
+        ).all()

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

@@ -0,0 +1,43 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state import CoordinatesSubset
+
+
+@pytest.fixture
+def name() -> str:
+    return "MySubset"
+
+
+@pytest.fixture
+def size() -> int:
+    return 3
+
+
+@pytest.fixture
+def coordinates_subset(name: str, size: int) -> CoordinatesSubset:
+    return CoordinatesSubset(name, size)
+
+
+class TestCoordinatesSubset:
+    def test_constructor(self, coordinates_subset: CoordinatesSubset):
+        assert coordinates_subset is not None
+
+    def test_eq(self, coordinates_subset: CoordinatesSubset):
+        assert coordinates_subset == coordinates_subset
+
+    def test_ne(self, coordinates_subset: CoordinatesSubset):
+        assert (coordinates_subset != coordinates_subset) == False
+
+    def test_get_id(self, coordinates_subset: CoordinatesSubset):
+        assert coordinates_subset.get_id() is not None
+
+    def test_get_name(self, coordinates_subset: CoordinatesSubset, name: str):
+        assert coordinates_subset.get_name() == name
+
+    def test_get_size(self, coordinates_subset: CoordinatesSubset, size: int):
+        assert coordinates_subset.get_size() == size
+
+    def test_mass(self):
+        assert CoordinatesSubset.mass() is not None