open-space-toolkit-physics 11.2.1__py313-none-manylinux2014_aarch64.whl

ostk/physics/test/coordinate/test_position.py

@@ -0,0 +1,206 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+from ostk.core.type import String
+import ostk.physics as physics
+
+Scale = physics.time.Scale
+DateTime = physics.time.DateTime
+Instant = physics.time.Instant
+Frame = physics.coordinate.Frame
+Position = physics.coordinate.Position
+Unit = physics.unit.Length.Unit
+
+
+def test_coordinate_position_constructors():
+    # Construct arbitrary frame
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+
+    # 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_coordinate_position_comparators():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    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_coordinate_position_is_defined():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    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_coordinate_position_is_near():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+
+    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, Unit.Meter)
+    assert position_2.is_near(position_1, Unit.Meter)
+
+
+def test_coordinate_position_access_frame():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    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_coordinate_position_get_coordinates():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    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_coordinate_position_get_unit():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    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, Unit)
+    assert ans_unit == unit
+
+
+def test_coordinate_position_in_unit():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    vector = [1000.0, 0.0, 0.0]
+
+    position: Position = Position(vector, unit, frame)
+
+    new_position: Position = position.in_unit(Unit.Meter)
+
+    assert new_position is not None
+    assert isinstance(new_position, Position)
+    assert new_position == position
+
+    new_position: Position = position.in_unit(Unit.TerrestrialMile)
+
+    assert new_position is not None
+    assert isinstance(new_position, Position)
+    # assert new_position == position
+
+
+def test_coordinate_position_in_meters():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    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_coordinate_position_in_frame():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    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_coordinate_position_to_string():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.Meter
+    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"

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 ():

ostk/physics/test/coordinate/test_velocity.py

@@ -0,0 +1,180 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+from ostk.core.type import String
+import ostk.physics as physics
+
+Scale = physics.time.Scale
+DateTime = physics.time.DateTime
+Instant = physics.time.Instant
+Frame = physics.coordinate.Frame
+Velocity = physics.coordinate.Velocity
+Unit = Velocity.Unit
+
+
+def test_coordinate_position_constructors():
+    # Construct arbitrary frame
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+
+    # Construction with python lists
+    vector = [1000.0, 0.0, 0.0]
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    assert velocity is not None
+    assert isinstance(velocity, Velocity)
+    assert velocity.is_defined()
+
+    # Construction with python tuples
+    vector = (1000.0, 0.0, 0.0)
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    assert velocity is not None
+    assert isinstance(velocity, Velocity)
+    assert velocity.is_defined()
+
+    # Construction with python numpy arrays
+    vector = np.array((1000.0, 0.0, 0.0))
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    assert velocity is not None
+    assert isinstance(velocity, Velocity)
+    assert velocity.is_defined()
+
+    # Construction with meters static constructor
+    velocity: Velocity = Velocity.meters_per_second(vector, frame)
+
+    assert velocity is not None
+    assert isinstance(velocity, Velocity)
+    assert velocity.is_defined()
+
+    # Construction with undefined static constructor
+    velocity: Velocity = Velocity.undefined()
+
+    assert velocity is not None
+    assert isinstance(velocity, Velocity)
+    assert velocity.is_defined() is False
+
+
+def test_coordinate_velocity_comparators():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+    vector_1 = [1000.0, 0.0, 0.0]
+    vector_2 = [-450.3, 234.9, -23.0]
+
+    velocity_1: Velocity = Velocity(vector_1, unit, frame)
+    velocity_2: Velocity = Velocity(vector_2, unit, frame)
+
+    assert velocity_1 == velocity_1
+    assert velocity_2 == velocity_2
+    assert velocity_1 != velocity_2
+
+
+def test_coordinate_velocity_is_defined():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+    vector = [1000.0, 0.0, 0.0]
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    assert velocity.is_defined()
+    assert Velocity.undefined().is_defined() is False
+
+
+def test_coordinate_velocity_access_frame():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+    vector = [1000.0, 0.0, 0.0]
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    ans_frame = velocity.access_frame()
+
+    assert ans_frame is not None
+    assert isinstance(ans_frame, Frame)
+    assert ans_frame == frame
+
+
+def test_coordinate_velocity_get_coordinates():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+    vector = [1000.0, 0.0, 0.0]
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    coordinates = velocity.get_coordinates()
+
+    assert coordinates is not None
+    assert isinstance(coordinates, np.ndarray)
+    assert np.array_equal(coordinates, vector)
+
+
+def test_coordinate_velocity_get_unit():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+    vector = [1000.0, 0.0, 0.0]
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    ans_unit = velocity.get_unit()
+
+    assert ans_unit is not None
+    assert isinstance(ans_unit, Unit)
+    assert ans_unit == unit
+
+
+def test_coordinate_velocity_in_unit():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+    vector = [1000.0, 0.0, 0.0]
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    new_velocity: Velocity = velocity.in_unit(Unit.MeterPerSecond)
+
+    assert new_velocity is not None
+    assert isinstance(new_velocity, Velocity)
+    assert new_velocity == velocity
+
+
+@pytest.mark.skip
+def test_coordinate_velocity_in_frame():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+    vector = [1000.0, 0.0, 0.0]
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+    new_velocity: Velocity = velocity.in_frame(frame, instant)
+
+    assert new_velocity is not None
+    assert isinstance(new_velocity, Velocity)
+    assert new_velocity == velocity
+
+
+def test_coordinate_velocity_to_string():
+    frame: Frame = Frame.GCRF()
+    unit: Unit = Unit.MeterPerSecond
+    vector = [1000.0, 0.0, 0.0]
+
+    velocity: Velocity = Velocity(vector, unit, frame)
+
+    string: String = velocity.to_string()
+
+    assert string is not None
+    assert isinstance(string, String)
+    assert string == "[1000.0, 0.0, 0.0] [m/s] @ GCRF"
+
+
+def test_coordinate_velocity_string_from_unit():
+    string: String = Velocity.string_from_unit(Unit.MeterPerSecond)
+
+    assert string is not None
+    assert isinstance(string, String)
+    assert string == "m/s"

ostk/physics/test/data/conftest.py

@@ -0,0 +1,34 @@
+# Apache License 2.0
+
+import pytest
+
+import pathlib
+
+from ostk.core.filesystem import Path
+from ostk.core.filesystem import File
+
+from ostk.physics.data import Manager, Manifest
+
+
+@pytest.fixture
+def data_directory_path() -> str:
+    return f"{pathlib.Path(__file__).parent.absolute()}/data"
+
+
+@pytest.fixture
+def manifest_file(data_directory_path: str) -> File:
+    return File.path(Path.parse(f"{data_directory_path}/manifest.json"))
+
+
+@pytest.fixture
+def manifest(manifest_file: File) -> Manifest:
+    return Manifest.load(manifest_file)
+
+
+@pytest.fixture
+def manager() -> Manager:
+    manager = Manager.get()
+
+    yield manager
+
+    manager.reset()