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

ostk/physics/test/coordinate/frame/provider/iers/test_finals_2000a.py

@@ -0,0 +1,93 @@
+# Apache License 2.0
+
+from datetime import datetime
+
+from ostk.core.filesystem import File
+
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+
+import ostk.physics as physics
+
+Finals2000A = physics.coordinate.frame.provider.iers.Finals2000A
+
+
+class TestFinals2000A:
+    def test_str_success(self, finals_2000a: Finals2000A):
+        assert str(finals_2000a).startswith("-- Finals 2000A --")
+
+    def test_repr_success(self, finals_2000a: Finals2000A):
+        assert repr(finals_2000a).startswith("-- Finals 2000A --")
+
+    def test_is_defined_success(self, finals_2000a: Finals2000A):
+        assert finals_2000a.is_defined() is True
+
+    def test_get_interval_success(self, finals_2000a: Finals2000A):
+        assert (
+            finals_2000a.get_interval().to_string()
+            == "[1992-01-01 00:00:00 - 2021-12-26 00:00:00] [UTC]"
+        )
+
+    def test_get_polar_motion_at_success(self, finals_2000a: Finals2000A):
+        assert list(
+            finals_2000a.get_polar_motion_at(
+                Instant.date_time(datetime(2020, 10, 31, 0, 0, 0), Scale.UTC)
+            )
+        ) == [0.160621, 0.297128]
+
+    def test_get_ut1_minus_utc_at_success(self, finals_2000a: Finals2000A):
+        assert (
+            finals_2000a.get_ut1_minus_utc_at(
+                Instant.date_time(datetime(2020, 10, 31, 0, 0, 0), Scale.UTC)
+            )
+            == -0.17524010000000001
+        )
+
+    def test_get_lod_at_success(self, finals_2000a: Finals2000A):
+        assert (
+            finals_2000a.get_lod_at(
+                Instant.date_time(datetime(2015, 10, 31, 0, 0, 0), Scale.UTC)
+            )
+            == 1.5646
+        )
+        assert not finals_2000a.get_lod_at(
+            Instant.date_time(datetime(2020, 10, 31, 0, 0, 0), Scale.UTC)
+        ).is_defined()
+
+    def test_get_data_at_success(self, finals_2000a: Finals2000A):
+        data: Finals2000A.Data = finals_2000a.get_data_at(
+            Instant.date_time(datetime(2020, 10, 31, 0, 0, 0), Scale.UTC)
+        )
+
+        assert isinstance(data, Finals2000A.Data)
+
+        assert data.year == 20
+        assert data.month == 10
+        assert data.day == 30
+        assert data.mjd == 59153.0
+        assert data.polar_motionflag == "P"
+        assert data.x_a == 0.16062100000000001
+        assert data.x_error_a == 0.000892
+        assert data.y_a == 0.297128
+        assert data.y_error_a == 0.00066399999999999999
+        assert data.ut1_minus_utc_flag == "P"
+        assert data.ut1_minus_utc_a == -0.17524010000000001
+        assert data.ut1_minus_utc_error_a == 0.0002041
+        assert not data.lod_a.is_defined()
+        assert not data.lod_error_a.is_defined()
+        assert data.nutation_flag == "P"
+        assert data.dx_a == 0.021999999999999999
+        assert data.dx_error_a == 0.128
+        assert data.dy_a == 0.17899999999999999
+        assert data.dy_error_a == 0.16
+        assert not data.x_b.is_defined()
+        assert not data.y_b.is_defined()
+        assert not data.ut1_minus_utc_b.is_defined()
+        assert not data.dx_b.is_defined()
+        assert not data.dy_b.is_defined()
+
+    def test_undefined_success(self):
+        assert Finals2000A.undefined() is not None
+
+    def test_load_success(self, finals_2000a_file: File):
+        assert Finals2000A.load(finals_2000a_file) is not None

ostk/physics/test/coordinate/frame/provider/iers/test_manager.py

@@ -0,0 +1,205 @@
+# Apache License 2.0
+
+import pytest
+
+from datetime import datetime
+import pathlib
+
+from ostk.core.filesystem import Path
+from ostk.core.filesystem import File
+from ostk.core.filesystem import Directory
+
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+
+from ostk.physics.coordinate.frame.provider.iers import Manager
+from ostk.physics.coordinate.frame.provider.iers import BulletinA
+from ostk.physics.coordinate.frame.provider.iers import Finals2000A
+
+
+@pytest.fixture
+def manager(bulletin_a) -> Manager:
+    manager = Manager.get()
+
+    manager.set_mode(Manager.Mode.Automatic)
+
+    manager.load_bulletin_a(bulletin_a)
+
+    yield manager
+
+    manager.reset()
+    manager.clear_local_repository()
+
+
+class TestManager:
+    def test_get_mode_success(self, manager: Manager):
+        assert manager.get_mode() == Manager.Mode.Automatic
+
+    def test_get_local_repository_success(self, manager: Manager):
+        assert isinstance(manager.get_local_repository(), Directory)
+        assert len(str(manager.get_local_repository().to_string())) > 0
+
+    def test_get_bulletin_a_directory_success(self, manager: Manager):
+        assert isinstance(manager.get_bulletin_a_directory(), Directory)
+        assert len(str(manager.get_bulletin_a_directory().to_string())) > 0
+
+    def test_get_finals_2000a_directory_success(self, manager: Manager):
+        assert isinstance(manager.get_finals_2000a_directory(), Directory)
+        assert len(str(manager.get_finals_2000a_directory().to_string())) > 0
+
+    def test_get_bulletin_a_success(self, manager: Manager):
+        bulletin_a: BulletinA = manager.get_bulletin_a()
+
+        assert isinstance(bulletin_a, BulletinA)
+
+    def test_get_finals_2000a_success(self, manager: Manager):
+        finals_2000a: Finals2000A = manager.get_finals_2000a()
+
+        assert isinstance(finals_2000a, Finals2000A)
+
+    def test_get_polar_motion_at_success(self, manager: Manager):
+        assert list(
+            manager.get_polar_motion_at(
+                Instant.date_time(datetime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+        ) == [0.076577, 0.282336]
+
+    @pytest.mark.skip(reason="Flaky external dependency.")
+    def test_get_polar_motion_at_success_2(self, manager: Manager):
+        assert len(manager.get_bulletin_a_array()) == 0
+        assert len(manager.get_finals_2000a_array()) == 0
+
+        assert manager.get_polar_motion_at(Instant.now() - Duration.days(7.0)) is not None
+
+        assert len(manager.get_bulletin_a_array()) == 1
+        assert len(manager.get_finals_2000a_array()) == 0
+
+        assert (
+            manager.get_polar_motion_at(
+                Instant.date_time(datetime(2000, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+            is not None
+        )
+        assert (
+            manager.get_polar_motion_at(
+                Instant.date_time(datetime(2010, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+            is not None
+        )
+        assert (
+            manager.get_polar_motion_at(
+                Instant.date_time(datetime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+            is not None
+        )
+        assert (
+            manager.get_polar_motion_at(
+                Instant.date_time(datetime(2023, 7, 16, 0, 0, 0), Scale.UTC)
+            )
+            is not None
+        )
+
+        assert len(manager.get_bulletin_a_array()) == 1
+        assert len(manager.get_finals_2000a_array()) == 1
+
+    def test_get_ut1_minus_utc_at_success(self, manager: Manager):
+        assert (
+            manager.get_ut1_minus_utc_at(
+                Instant.date_time(datetime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+            == -0.17715539999999999
+        )
+
+    def test_get_lod_at_success(self, manager: Manager):
+        assert (
+            manager.get_lod_at(
+                Instant.date_time(datetime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+            == 0.43790000000000001
+        )
+
+    def test_set_mode_success(self, manager: Manager):
+        assert manager.get_mode() == Manager.Mode.Automatic
+
+        manager.set_mode(Manager.Mode.Manual)
+
+        assert manager.get_mode() == Manager.Mode.Manual
+
+    def test_set_local_repository_success(self, manager: Manager):
+        assert isinstance(manager.get_local_repository(), Directory)
+        assert len(str(manager.get_local_repository().to_string())) > 0
+
+        manager.set_local_repository(
+            Directory.path(
+                Path.parse(
+                    "./.open-space-toolkit/physics/coordinate/frame/provider/iers2"
+                )
+            )
+        )
+
+        assert isinstance(manager.get_local_repository(), Directory)
+        assert (
+            manager.get_local_repository().to_string()
+            == "./.open-space-toolkit/physics/coordinate/frame/provider/iers2"
+        )
+
+    def test_load_bulletin_a_success(self, manager: Manager, bulletin_a: BulletinA):
+        manager.load_bulletin_a(bulletin_a)
+
+        assert manager.get_bulletin_a().is_defined()
+
+    def test_load_finals_2000a_success(self, manager: Manager, finals_2000a: Finals2000A):
+        manager.load_finals_2000a(finals_2000a)
+
+        assert manager.get_finals_2000a().is_defined()
+
+    def test_fetch_latest_bulletin_a_success(self, manager: Manager):
+        file: File = manager.fetch_latest_bulletin_a()
+
+        assert isinstance(file, File)
+        assert file.exists()
+
+        file.remove()
+
+    def test_fetch_latest_finals_2000a_success(self, manager: Manager):
+        file: File = manager.fetch_latest_finals_2000a()
+
+        assert isinstance(file, File)
+        assert file.exists()
+
+        file.remove()
+
+    def test_reset_success(self, manager: Manager, bulletin_a: BulletinA):
+        assert manager.get_bulletin_a().is_defined()
+
+        manager.reset()
+
+        # The get methods automatically load things if they are not loaded, so we set to manual
+        manager.set_mode(manager.Mode.Manual)
+
+        with pytest.raises(Exception):
+            manager.get_bulletin_a()
+
+        manager.set_mode(manager.Mode.Automatic)
+
+    def test_clear_local_repository_success(self, manager: Manager):
+        assert manager.get_local_repository().exists()
+        assert manager.get_bulletin_a_directory().exists()
+        assert manager.get_finals_2000a_directory().exists()
+        pathlib.Path(
+            str(manager.get_bulletin_a_directory().get_path().to_string()) + "/toto"
+        ).touch()
+        pathlib.Path(
+            str(manager.get_finals_2000a_directory().get_path().to_string()) + "/toto"
+        ).touch()
+        assert not manager.get_local_repository().is_empty()
+
+        manager.clear_local_repository()
+
+        assert manager.get_local_repository().exists()
+        assert manager.get_bulletin_a_directory().is_empty()
+        assert manager.get_finals_2000a_directory().is_empty()
+
+    def test_get_success(self):
+        assert isinstance(Manager.get(), Manager)

ostk/physics/test/coordinate/spherical/__init__.py

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

ostk/physics/test/coordinate/spherical/test_aer.py

@@ -0,0 +1,143 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+from ostk.core.type import String
+
+import ostk.physics as physics
+
+Angle = physics.unit.Angle
+Length = physics.unit.Length
+AER = physics.coordinate.spherical.AER
+
+
+def test_coordinate_spherical_aer_constructors():
+    # Main Constructor
+    azimuth: Angle = Angle(30.0, Angle.Unit.Degree)
+    elevation: Angle = Angle(30.0, Angle.Unit.Degree)
+    aer_range: Length = Length(1000.0, Length.Unit.Meter)
+
+    # Construction with undefined static method
+
+    aer: AER = AER(azimuth, elevation, aer_range)
+
+    assert aer is not None
+    assert isinstance(aer, AER)
+
+    # Construction with vector static method
+
+    # ... with python list
+    aer: AER = AER.vector([1.0, 1.0, 1.0])
+
+    assert aer is not None
+    assert isinstance(aer, AER)
+
+    # ... with python tuple
+    aer: AER = AER.vector((1.0, 1.0, 1.0))
+
+    assert aer is not None
+    assert isinstance(aer, AER)
+
+    # ... with python numpy array
+    aer: AER = AER.vector(np.array((1.0, 1.0, 1.0)))
+
+    assert aer is not None
+    assert isinstance(aer, AER)
+
+    # Invalid azimuth
+
+    with pytest.raises(RuntimeError):
+        aer: AER = AER.vector((400.0, 1.0, 1.0))
+
+    # Invalid elevation
+
+    with pytest.raises(RuntimeError):
+        aer: AER = AER.vector((1.0, 181.0, 1.0))
+
+    # Negative Range
+
+    with pytest.raises(RuntimeError):
+        aer: AER = AER.vector((1.0, 2.0, -1.0))
+
+
+def test_coordinate_spherical_aer_comparators():
+    # Main Constructor
+    azimuth: Angle = Angle(30.0, Angle.Unit.Degree)
+    elevation: Angle = Angle(30.0, Angle.Unit.Degree)
+    aer_range: Length = Length(1000.0, Length.Unit.Meter)
+
+    # Construction
+    aer_1: AER = AER(azimuth, elevation, aer_range)
+    aer_2: AER = AER(azimuth, elevation, Length(10.0, Length.Unit.Meter))
+
+    assert aer_1 == aer_1
+    assert aer_2 == aer_2
+    assert aer_1 != aer_2
+
+
+def test_coordinate_spherical_aer_is_defined():
+    # Main Constructor
+    azimuth: Angle = Angle(30.0, Angle.Unit.Degree)
+    elevation: Angle = Angle(30.0, Angle.Unit.Degree)
+    aer_range: Length = Length(1000.0, Length.Unit.Meter)
+
+    # Construction
+    aer: AER = AER(azimuth, elevation, aer_range)
+
+    assert aer.is_defined()
+    assert AER.undefined().is_defined() is False
+
+
+def test_coordinate_spherical_aer_getters():
+    # Main Constructor
+    azimuth: Angle = Angle(30.0, Angle.Unit.Degree)
+    elevation: Angle = Angle(30.0, Angle.Unit.Degree)
+    aer_range: Length = Length(1000.0, Length.Unit.Meter)
+
+    # Construction
+    aer: AER = AER(azimuth, elevation, aer_range)
+
+    # get_azimuth
+    lat = aer.get_azimuth()
+
+    assert lat is not None
+    assert isinstance(lat, Angle)
+
+    # get_elevation
+    lon = aer.get_elevation()
+
+    assert lon is not None
+    assert isinstance(lon, Angle)
+
+    # get_range
+    alt = aer.get_range()
+
+    assert alt is not None
+    assert isinstance(alt, Length)
+
+
+def test_coordinate_spherical_aer_conversions():
+    # Main Constructor
+    azimuth: Angle = Angle(30.0, Angle.Unit.Degree)
+    elevation: Angle = Angle(30.0, Angle.Unit.Degree)
+    aer_range: Length = Length(1000.0, Length.Unit.Meter)
+
+    # Construction
+    aer: AER = AER(azimuth, elevation, aer_range)
+
+    # to_vector
+    vector = AER.to_vector(aer)
+
+    assert vector is not None
+    assert isinstance(vector, np.ndarray)
+
+    # to_string
+    string = aer.to_string()
+
+    assert string is not None
+    assert isinstance(string, String)
+    assert string == "[30.0 [deg], 30.0 [deg], 1000.0 [m]]"
+
+
+# def test_coordinate_spherical_aer_from_position_to_position ():