open-space-toolkit-physics 11.3.0__py312-none-manylinux2014_x86_64.whl

ostk/physics/test/coordinate/test_frame.py

@@ -0,0 +1,107 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+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.frame.provider import iau
+from ostk.physics.coordinate.frame.provider import Dynamic
+
+
+@pytest.fixture
+def epoch() -> Instant:
+    return Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.ITRF()
+
+
+class TestFrame:
+    def test_is_defined(self, frame: Frame):
+        assert frame.is_defined() is True
+
+    def test_is_quasi_inertial(self, frame: Frame):
+        assert frame.is_quasi_inertial() is False
+
+    def test_has_parent(self, frame: Frame):
+        assert frame.has_parent() is True
+
+    def test_access_parent(self, frame: Frame):
+        assert frame.access_parent() is not None
+
+    def test_access_ancestor(self, frame: Frame):
+        assert frame.access_ancestor(ancestor_degree=1) is not None
+
+    def test_access_provider(self, frame: Frame):
+        assert frame.access_provider()
+
+    def test_get_name(self, frame: Frame):
+        assert frame.get_name() == "ITRF"
+
+    def test_get_origin_in(self, epoch: Instant, frame: Frame):
+        assert frame.get_origin_in(frame=frame, instant=epoch) is not None
+
+    def test_get_velocity_in(self, epoch: Instant, frame: Frame):
+        assert frame.get_velocity_in(frame=frame, instant=epoch) is not None
+
+    def test_get_axes_in(self, epoch: Instant, frame: Frame):
+        assert frame.get_axes_in(frame=frame, instant=epoch) is not None
+
+    def test_get_transform_to(self, epoch: Instant, frame: Frame):
+        assert frame.get_transform_to(frame=frame, instant=epoch) is not None
+
+    def test_undefined(self):
+        assert Frame.undefined() is not None
+
+    def test_GCRF(self):
+        assert Frame.GCRF() is not None
+
+    def test_J2000(self):
+        assert Frame.J2000(theory=iau.Theory.IAU_2006) is not None
+
+    def test_MOD(self, epoch: Instant):
+        assert Frame.MOD(epoch=epoch) is not None
+
+    def test_TOD(self, epoch: Instant):
+        assert Frame.TOD(epoch=epoch, theory=iau.Theory.IAU_2006) is not None
+
+    def test_TEME(self):
+        assert Frame.TEME() is not None
+
+    def test_TEME_of_epoch(self, epoch: Instant):
+        assert Frame.TEME_of_epoch(epoch=epoch) is not None
+
+    def test_CIRF(self):
+        assert Frame.CIRF() is not None
+
+    def test_TIRF(self):
+        assert Frame.TIRF() is not None
+
+    def test_ITRF(self):
+        assert Frame.ITRF() is not None
+
+    def test_with_name(self, frame: Frame):
+        assert Frame.with_name(name=frame.get_name()) is not None
+
+    def test_exists(self, frame: Frame):
+        assert Frame.exists(name=frame.get_name()) is True
+
+    def test_construct_destruct(self, frame: Frame):
+        custom_frame = Frame.construct(
+            name="Custom Frame",
+            is_quasi_inertial=True,
+            parent_frame=frame,
+            provider=Dynamic(lambda _: None),
+        )
+
+        assert custom_frame is not None
+
+        Frame.destruct(custom_frame.get_name())
+
+        assert Frame.exists(name="Custom Frame") is False

ostk/physics/test/coordinate/test_position.py

@@ -0,0 +1,201 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+from ostk.core.type import String
+
+from ostk.physics import Environment
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.time import Instant
+from ostk.physics.time import Scale
+from ostk.physics.time import DateTime
+from ostk.physics.unit import Length
+
+
+@pytest.fixture
+def unit() -> Length.Unit:
+    return Length.Unit.Meter
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def earth():
+    return Environment.default().access_celestial_object_with_name("Earth")
+
+
+@pytest.fixture
+def lla() -> LLA:
+    return LLA.vector([0.0, 0.0, 0.0])
+
+
+class TestPosition:
+
+    def test_constructors(self, unit: Length.Unit, frame: Frame):
+        # Construction with python lists
+        vector = [1000.0, 0.0, 0.0]
+
+        position: Position = Position(vector, unit, frame)
+
+        assert position is not None
+        assert isinstance(position, Position)
+        assert position.is_defined()
+
+        # Construction with python tuples
+        vector = (1000.0, 0.0, 0.0)
+
+        position: Position = Position(vector, unit, frame)
+
+        assert position is not None
+        assert isinstance(position, Position)
+        assert position.is_defined()
+
+        # Construction with python numpy arrays
+        vector = np.array((1000.0, 0.0, 0.0))
+
+        position: Position = Position(vector, unit, frame)
+
+        assert position is not None
+        assert isinstance(position, Position)
+        assert position.is_defined()
+
+        # Construction with meters static constructor
+        position: Position = Position.meters(vector, frame)
+
+        assert position is not None
+        assert isinstance(position, Position)
+        assert position.is_defined()
+
+        # Construction with undefined static constructor
+        position: Position = Position.undefined()
+
+        assert position is not None
+        assert isinstance(position, Position)
+        assert position.is_defined() is False
+
+    def test_comparators(self, unit: Length.Unit, frame: Frame):
+        vector_1 = [1000.0, 0.0, 0.0]
+        vector_2 = [-450.3, 234.9, -23.0]
+
+        position_1: Position = Position(vector_1, unit, frame)
+        position_2: Position = Position(vector_2, unit, frame)
+
+        assert position_1 == position_1
+        assert position_2 == position_2
+        assert position_1 != position_2
+
+    def test_is_defined(self, unit: Length.Unit, frame: Frame):
+        vector = [1000.0, 0.0, 0.0]
+        position: Position = Position(vector, unit, frame)
+
+        assert position.is_defined()
+        assert Position.undefined().is_defined() is False
+
+    @pytest.mark.skip
+    def test_is_near(self, unit: Length.Unit, frame: Frame):
+
+        vector_1 = [1000.0, 0.0, 0.0]
+        vector_2 = [1000.00001, 0.0001, 0.0]
+
+        position_1: Position = Position(vector_1, unit, frame)
+        position_2: Position = Position(vector_2, unit, frame)
+
+        assert position_1.is_near(position_2, Length.Unit.Meter)
+        assert position_2.is_near(position_1, Length.Unit.Meter)
+
+    def test_access_frame(self, unit: Length.Unit, frame: Frame):
+        vector = [1000.0, 0.0, 0.0]
+
+        position: Position = Position(vector, unit, frame)
+
+        ans_frame = position.access_frame()
+
+        assert ans_frame is not None
+        assert isinstance(ans_frame, Frame)
+        assert ans_frame == frame
+
+    def test_get_coordinates(self, unit: Length.Unit, frame: Frame):
+        vector = [1000.0, 0.0, 0.0]
+
+        position: Position = Position(vector, unit, frame)
+
+        coordinates = position.get_coordinates()
+
+        assert coordinates is not None
+        assert isinstance(coordinates, np.ndarray)
+        assert np.array_equal(coordinates, vector)
+
+    def test_get_unit(self, unit: Length.Unit, frame: Frame):
+        vector = [1000.0, 0.0, 0.0]
+
+        position: Position = Position(vector, unit, frame)
+
+        ans_unit = position.get_unit()
+
+        assert ans_unit is not None
+        assert isinstance(ans_unit, Length.Unit)
+        assert ans_unit == unit
+
+    def test_in_unit(self, unit: Length.Unit, frame: Frame):
+        vector = [1000.0, 0.0, 0.0]
+
+        position: Position = Position(vector, unit, frame)
+
+        new_position: Position = position.in_unit(Length.Unit.Meter)
+
+        assert new_position is not None
+        assert isinstance(new_position, Position)
+        assert new_position == position
+
+        new_position: Position = position.in_unit(Length.Unit.TerrestrialMile)
+
+        assert new_position is not None
+        assert isinstance(new_position, Position)
+        # assert new_position == position
+
+    def test_in_meters(self, unit: Length.Unit, frame: Frame):
+        vector = [1000.0, 0.0, 0.0]
+
+        position: Position = Position(vector, unit, frame)
+
+        new_position: Position = position.in_meters()
+
+        assert new_position is not None
+        assert isinstance(new_position, Position)
+        assert new_position == position
+
+    def test_in_frame(self, unit: Length.Unit, frame: Frame):
+        vector = [1000.0, 0.0, 0.0]
+
+        instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+        position: Position = Position(vector, unit, frame)
+
+        new_position: Position = position.in_frame(frame, instant)
+
+        assert new_position is not None
+        assert isinstance(new_position, Position)
+        assert new_position == position
+
+    def test_to_string(self, unit: Length.Unit, frame: Frame):
+        vector = [1000.0, 0.0, 0.0]
+
+        position: Position = Position(vector, unit, frame)
+
+        string: String = position.to_string()
+
+        assert string is not None
+        assert isinstance(string, String)
+        assert string == "[1000.0, 0.0, 0.0] [m] @ GCRF"
+
+    def test_from_lla(self, lla: LLA, earth):
+        assert Position.from_lla(lla, earth) is not None
+
+        Environment.default(True)
+        assert Position.from_lla(lla) is not None

ostk/physics/test/coordinate/test_transform.py

@@ -0,0 +1,294 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+from ostk.core.type import String
+import ostk.physics as physics
+
+import ostk.mathematics as mathematics
+
+Scale = physics.time.Scale
+DateTime = physics.time.DateTime
+Instant = physics.time.Instant
+Quaternion = mathematics.geometry.d3.transformation.rotation.Quaternion
+Transform = physics.coordinate.Transform
+Type = Transform.Type
+
+
+def test_coordinate_transform_type():
+    enum_members = Type.__members__
+
+    list_keys = ["Undefined", "Active", "Passive"]
+    list_values = [Type.Undefined, Type.Active, Type.Passive]
+
+    assert list(enum_members.keys()) == list_keys
+    assert list(enum_members.values()) == list_values
+
+
+def test_coordinate_transform_constructors():
+    # Construct arbitrary Instant
+    instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+    # Construct arbitrary Orientation
+    quaternion: Quaternion = Quaternion([0.0, 0.0, 0.0], 1.0)
+
+    # Construct Transform Type
+    transform_type: Type = Type.Passive
+
+    # Construction using python lists
+    translation = [1.0, 0.0, 0.0]
+    velocity = [0.01, 0.0, 0.0]
+    angular_velocity = [0.01, 0.01, 0.01]
+
+    transform: Transform = Transform(
+        instant, translation, velocity, quaternion, angular_velocity, transform_type
+    )
+
+    assert transform is not None
+    assert isinstance(transform, Transform)
+
+    # Construction using python tuples
+    translation = (1.0, 0.0, 0.0)
+    velocity = (0.01, 0.0, 0.0)
+    angular_velocity = (0.01, 0.01, 0.01)
+
+    transform: Transform = Transform(
+        instant, translation, velocity, quaternion, angular_velocity, transform_type
+    )
+
+    assert transform is not None
+    assert isinstance(transform, Transform)
+
+    # Construction using python numpy arrays
+    translation = np.array(translation)
+    velocity = np.array(velocity)
+    angular_velocity = np.array(angular_velocity)
+
+    transform: Transform = Transform(
+        instant, translation, velocity, quaternion, angular_velocity, transform_type
+    )
+
+    assert transform is not None
+    assert isinstance(transform, Transform)
+
+    # Construct using identity static constructor
+
+    transform: Transform = Transform.identity(instant)
+
+    assert transform is not None
+    assert isinstance(transform, Transform)
+
+    # Construct using active static constructor
+
+    transform: Transform = Transform.active(
+        instant, translation, velocity, quaternion, angular_velocity
+    )
+
+    assert transform is not None
+    assert isinstance(transform, Transform)
+
+    # Construct using passive static constructor
+
+    transform: Transform = Transform.passive(
+        instant, translation, velocity, quaternion, angular_velocity
+    )
+
+    assert transform is not None
+    assert isinstance(transform, Transform)
+
+
+def test_coordinate_transform_comparators():
+    # Construct arbitrary Instant
+    instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+    # Construct arbitrary Orientation
+    quaternion: Quaternion = Quaternion([0.0, 0.0, 0.0], 1.0)
+
+    # Construct Transform Type
+    transform_type: Type = Type.Passive
+
+    # Construction using python lists
+    translation_1 = [1.0, 0.0, 0.0]
+    translation_2 = [0.0, 0.0, 0.0]
+    velocity = [0.01, 0.0, 0.0]
+    angular_velocity = [0.01, 0.01, 0.01]
+
+    transform_1: Transform = Transform(
+        instant, translation_1, velocity, quaternion, angular_velocity, transform_type
+    )
+    transform_2: Transform = Transform(
+        instant, translation_2, velocity, quaternion, angular_velocity, transform_type
+    )
+
+    assert transform_1 == transform_1
+    assert transform_2 == transform_2
+    assert transform_1 != transform_2
+
+
+def test_coordinate_transform_operators():
+    # Construct arbitrary Instant
+    instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+    # Construct arbitrary Orientation
+    quaternion: Quaternion = Quaternion([0.0, 0.0, 0.0], 1.0)
+
+    # Construct Transform Type
+    transform_type: Type = Type.Passive
+
+    # Construction using python lists
+    translation = [1.0, 0.0, 0.0]
+    velocity = [0.01, 0.0, 0.0]
+    angular_velocity = [0.01, 0.01, 0.01]
+
+    transform: Transform = Transform(
+        instant, translation, velocity, quaternion, angular_velocity, transform_type
+    )
+
+    mul_transform = transform * transform
+
+    assert mul_transform is not None
+    assert isinstance(mul_transform, Transform)
+    assert mul_transform.is_defined()
+
+    transform *= transform
+
+    assert transform is not None
+    assert isinstance(transform, Transform)
+    assert transform.is_defined()
+
+
+def test_coordinate_transform_is_defined():
+    # Construct arbitrary Instant
+    instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+    # Construct arbitrary Orientation
+    quaternion: Quaternion = Quaternion([0.0, 0.0, 0.0], 1.0)
+
+    # Construct Transform Type
+    transform_type: Type = Type.Passive
+
+    # Construction using python lists
+    translation = [1.0, 0.0, 0.0]
+    velocity = [0.01, 0.0, 0.0]
+    angular_velocity = [0.01, 0.01, 0.01]
+
+    transform: Transform = Transform(
+        instant, translation, velocity, quaternion, angular_velocity, transform_type
+    )
+
+    assert transform.is_defined()
+    assert transform.undefined().is_defined() is False
+
+
+def test_coordinate_transform_is_identity():
+    # Construct arbitrary Instant
+    instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+    # Construct arbitrary Orientation
+    quaternion: Quaternion = Quaternion([0.0, 0.0, 0.0], 1.0)
+
+    # Construct Transform Type
+    transform_type: Type = Type.Passive
+
+    # Construction using python lists
+    translation = [0.0, 0.0, 0.0]
+    velocity = [0.00, 0.0, 0.0]
+    angular_velocity = [0.00, 0.00, 0.00]
+
+    transform: Transform = Transform(
+        instant, translation, velocity, quaternion, angular_velocity, transform_type
+    )
+
+    assert transform.is_defined()
+    assert transform.is_identity()
+    assert transform.identity(instant).is_identity()
+
+
+# def test_coordinate_transform_accesses ():
+
+# access_instant
+
+
+# access_translation
+
+
+# access_velocity
+
+
+# access_orientation
+
+
+# access_angular_velocity
+
+
+def test_coordinate_transform_getters():
+    # Construct arbitrary Instant
+    instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+    # Construct arbitrary Orientation
+    quaternion: Quaternion = Quaternion([0.0, 0.0, 0.0], 1.0)
+
+    # Construct Transform Type
+    transform_type: Type = Type.Passive
+
+    # Construction using python lists
+    translation = [1.0, 0.0, 0.0]
+    velocity = [0.01, 0.0, 0.0]
+    angular_velocity = [0.01, 0.01, 0.01]
+
+    transform: Transform = Transform(
+        instant, translation, velocity, quaternion, angular_velocity, transform_type
+    )
+
+    # get_instant
+    ans_instant: Instant = transform.get_instant()
+
+    assert ans_instant is not None
+    assert isinstance(ans_instant, Instant)
+    assert ans_instant == instant
+
+    # get_translation
+    ans_translation = transform.get_translation()
+
+    assert ans_translation is not None
+    assert isinstance(ans_translation, np.ndarray)
+    assert np.array_equal(ans_translation, translation)
+
+    # get_velocity
+    ans_velocity = transform.get_velocity()
+
+    assert ans_velocity is not None
+    assert isinstance(ans_velocity, np.ndarray)
+    assert np.array_equal(ans_velocity, velocity)
+
+    # get_orientation
+    ans_quaternion = transform.get_orientation()
+
+    assert ans_quaternion is not None
+    assert isinstance(ans_quaternion, Quaternion)
+    assert ans_quaternion == quaternion
+
+    # get_angular_velocity
+    ans_angular_velocity = transform.get_angular_velocity()
+
+    assert ans_angular_velocity is not None
+    assert isinstance(ans_angular_velocity, np.ndarray)
+    assert np.array_equal(ans_angular_velocity, angular_velocity)
+
+    # get_inverse
+    inverse: Transform = transform.get_inverse()
+
+    assert inverse is not None
+    assert isinstance(inverse, Transform)
+
+
+# def test_coordinate_transform_apply_to_position ():
+
+# ################################################################################################################################################################
+
+# def test_coordinate_transform_apply_to_velocity ():
+
+# ################################################################################################################################################################
+
+# def test_coordinate_transform_apply_to_vector ():