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

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

@@ -0,0 +1,30 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state.coordinate_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/coordinate_subset/test_attitude_quaternion.py

@@ -0,0 +1,18 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state.coordinate_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/coordinate_subset/test_cartesian_acceleration.py

@@ -0,0 +1,136 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinateBroker, CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianAcceleration
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+
+
+@pytest.fixture
+def name() -> str:
+    return "Cartesian Acceleration"
+
+
+@pytest.fixture
+def cartesian_position() -> CartesianPosition:
+    return CartesianPosition.default()
+
+
+@pytest.fixture
+def cartesian_velocity() -> CartesianVelocity:
+    return CartesianVelocity.default()
+
+
+@pytest.fixture
+def cartesian_acceleration() -> CartesianAcceleration:
+    return CartesianAcceleration.default()
+
+
+@pytest.fixture
+def coordinate_subsets(
+    cartesian_acceleration: CartesianAcceleration,
+) -> list[CoordinateSubset]:
+    return [cartesian_acceleration]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinate_broker(
+    coordinate_subsets: list[CoordinateSubset],
+) -> CoordinateBroker:
+    return CoordinateBroker(coordinate_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [9.81, 0.0, 0.0]
+
+
+@pytest.fixture
+def another_coordinates() -> list[float]:
+    return [0.0, 9.81, 0.0]
+
+
+class TestCartesianAcceleration:
+    def test_constructor(
+        self,
+        cartesian_position: CartesianPosition,
+        cartesian_velocity: CartesianVelocity,
+        name: str,
+    ):
+        assert (
+            CartesianAcceleration(cartesian_position, cartesian_velocity, name)
+            is not None
+        )
+
+    def test_add(
+        self,
+        cartesian_acceleration: CartesianAcceleration,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_acceleration.add(
+                instant, coordinates, another_coordinates, frame, coordinate_broker
+            )
+            == [9.81, 9.81, 0.0]
+        )
+
+    def test_subtract(
+        self,
+        cartesian_acceleration: CartesianAcceleration,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_acceleration.subtract(
+                instant, coordinates, another_coordinates, frame, coordinate_broker
+            )
+            == [9.81, -9.81, 0.0]
+        )
+
+    def test_in_frame(
+        self,
+        cartesian_acceleration: CartesianAcceleration,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert (
+            cartesian_acceleration.in_frame(
+                instant, coordinates, frame, frame, coordinate_broker
+            )
+            is not None
+        )
+
+        with pytest.raises(RuntimeError):
+            cartesian_acceleration.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinate_broker
+            )
+
+    def test_default(self):
+        assert CartesianAcceleration.default() is not None
+
+    def test_thrust_acceleration(self):
+        assert CartesianAcceleration.thrust_acceleration() is not None

ostk/astrodynamics/test/trajectory/state/coordinate_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 CoordinateBroker, CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+
+
+@pytest.fixture
+def name() -> str:
+    return "Position"
+
+
+@pytest.fixture
+def cartesian_position() -> CartesianPosition:
+    return CartesianPosition.default()
+
+
+@pytest.fixture
+def coordinate_subsets(
+    cartesian_position: CartesianPosition,
+) -> list[CoordinateSubset]:
+    return [cartesian_position]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinate_broker(
+    coordinate_subsets: list[CoordinateSubset],
+) -> CoordinateBroker:
+    return CoordinateBroker(coordinate_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],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_position.add(
+                instant, coordinates, another_coordinates, frame, coordinate_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],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_position.subtract(
+                instant, coordinates, another_coordinates, frame, coordinate_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],
+        coordinate_broker: CoordinateBroker,
+    ):
+        for value, expected in zip(
+            cartesian_position.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinate_broker
+            ),
+            [1238864.12746338, 6889500.39136482, -176.262107699686],
+        ):
+            assert value == pytest.approx(expected, rel=1e-14)

ostk/astrodynamics/test/trajectory/state/coordinate_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 CoordinateBroker, CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_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 coordinate_subsets(
+    cartesian_position: CartesianPosition, cartesian_velocity: CartesianVelocity
+) -> list[CoordinateSubset]:
+    return [cartesian_position, cartesian_velocity]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinate_broker(
+    coordinate_subsets: list[CoordinateSubset],
+) -> CoordinateBroker:
+    return CoordinateBroker(coordinate_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],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_velocity.add(
+                instant, coordinates, another_coordinates, frame, coordinate_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],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_velocity.subtract(
+                instant, coordinates, another_coordinates, frame, coordinate_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],
+        coordinate_broker: CoordinateBroker,
+    ):
+        for value, expected in zip(
+            cartesian_velocity.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinate_broker
+            ),
+            [-4749.36551256577, 854.163395375881, 5335.71857543495],
+        ):
+            assert value == pytest.approx(expected, rel=1e-14)

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

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

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

@@ -0,0 +1,58 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+
+
+@pytest.fixture
+def name() -> str:
+    return "MySubset"
+
+
+@pytest.fixture
+def size() -> int:
+    return 3
+
+
+@pytest.fixture
+def coordinate_subset(name: str, size: int) -> CoordinateSubset:
+    return CoordinateSubset(name, size)
+
+
+class TestCoordinateSubset:
+    def test_constructor(self, coordinate_subset: CoordinateSubset):
+        assert coordinate_subset is not None
+
+    def test_eq(self, coordinate_subset: CoordinateSubset):
+        assert coordinate_subset == coordinate_subset
+
+    def test_ne(self, coordinate_subset: CoordinateSubset):
+        assert (coordinate_subset != coordinate_subset) == False
+
+    def test_hash(self, coordinate_subset: CoordinateSubset):
+        assert hash(coordinate_subset) is not None
+
+    def test_get_id(self, coordinate_subset: CoordinateSubset):
+        assert coordinate_subset.get_id() is not None
+
+    def test_get_name(self, coordinate_subset: CoordinateSubset, name: str):
+        assert coordinate_subset.get_name() == name
+
+    def test_get_size(self, coordinate_subset: CoordinateSubset, size: int):
+        assert coordinate_subset.get_size() == size
+
+    def test_mass(self):
+        assert CoordinateSubset.mass() is not None
+
+    def test_surface_area(self):
+        assert CoordinateSubset.surface_area() is not None
+
+    def test_drag_coefficient(self):
+        assert CoordinateSubset.drag_coefficient() is not None
+
+    def test_mass_flow_rate(self):
+        assert CoordinateSubset.mass_flow_rate() is not None
+
+    def test_ballistic_coefficient(self):
+        assert CoordinateSubset.ballistic_coefficient() is not None