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

ostk/physics/test/environment/gravitational/test_moon.py

@@ -0,0 +1,55 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.core.filesystem import Directory
+
+from ostk.physics.time import Instant
+from ostk.physics.environment.gravitational import Model as GravitationalModel
+from ostk.physics.environment.gravitational import Moon as MoonGravitationalModel
+
+
+@pytest.fixture
+def moon_gravitational_model() -> MoonGravitationalModel:
+    return MoonGravitationalModel(MoonGravitationalModel.Type.Spherical)
+
+
+class TestMoon:
+    def test_constructor_success_with_type(self):
+        assert isinstance(
+            MoonGravitationalModel(MoonGravitationalModel.Type.Spherical),
+            MoonGravitationalModel,
+        )
+        assert isinstance(
+            MoonGravitationalModel(MoonGravitationalModel.Type.Spherical),
+            GravitationalModel,
+        )
+
+    def test_constructor_success_with_directory(self):
+        moon_gravitational_model = MoonGravitationalModel(
+            MoonGravitationalModel.Type.Spherical, Directory.undefined()
+        )
+
+        assert isinstance(moon_gravitational_model, MoonGravitationalModel)
+        assert isinstance(moon_gravitational_model, GravitationalModel)
+
+    def test_get_type_success(self, moon_gravitational_model: MoonGravitationalModel):
+        assert (
+            moon_gravitational_model.get_type() == MoonGravitationalModel.Type.Spherical
+        )
+
+    def test_get_field_value_at_success(
+        self, moon_gravitational_model: MoonGravitationalModel
+    ):
+        grav_acceleration = moon_gravitational_model.get_field_value_at(
+            np.array([160000e3, 0.0, 0.0]), Instant.J2000()
+        )
+        grav_acceleration_ref = np.array([-0.000191515625, 0, 0])
+        assert all(
+            [
+                round(grav_acceleration[i], -7) == round(grav_acceleration_ref[i], -7)
+                for i in range(0, len(grav_acceleration_ref))
+            ]
+        )

ostk/physics/test/environment/gravitational/test_spherical.py

@@ -0,0 +1,36 @@
+# Apache License 2.0
+
+import numpy as np
+
+from ostk.physics.time import Instant
+from ostk.physics.environment.gravitational import (
+    Spherical as SphericalGravitationalModel,
+    Earth as EarthGravitationalModel,
+    Model as GravitationalModel,
+)
+
+
+class TestSpherical:
+    def test_constructor_success(self):
+        spherical_gravitational_model = SphericalGravitationalModel(
+            EarthGravitationalModel.spherical
+        )
+
+        assert isinstance(spherical_gravitational_model, SphericalGravitationalModel)
+        assert isinstance(spherical_gravitational_model, GravitationalModel)
+
+    def test_get_field_value_at_success(self):
+        spherical_gravitational_model = SphericalGravitationalModel(
+            EarthGravitationalModel.spherical
+        )
+
+        grav_acceleration = spherical_gravitational_model.get_field_value_at(
+            np.array([6400e3, 0.0, 0.0]), Instant.J2000()
+        )
+        grav_acceleration_ref = np.array([-9.73145609, 0, 0])
+        assert all(
+            [
+                round(grav_acceleration[i], -7) == round(grav_acceleration_ref[i], -7)
+                for i in range(0, 2)
+            ]
+        )

ostk/physics/test/environment/gravitational/test_sun.py

@@ -0,0 +1,53 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.core.filesystem import Directory
+
+from ostk.physics.time import Instant
+from ostk.physics.environment.gravitational import Model as GravitationalModel
+from ostk.physics.environment.gravitational import Sun as SunGravitationalModel
+
+
+@pytest.fixture
+def sun_gravitational_model() -> SunGravitationalModel:
+    return SunGravitationalModel(SunGravitationalModel.Type.Spherical)
+
+
+class TestSun:
+    def test_constructor_success_with_type(self):
+        assert isinstance(
+            SunGravitationalModel(SunGravitationalModel.Type.Spherical),
+            SunGravitationalModel,
+        )
+        assert isinstance(
+            SunGravitationalModel(SunGravitationalModel.Type.Spherical),
+            GravitationalModel,
+        )
+
+    def test_constructor_success_with_directory(self):
+        sun_gravitational_model = SunGravitationalModel(
+            SunGravitationalModel.Type.Spherical, Directory.undefined()
+        )
+
+        assert isinstance(sun_gravitational_model, SunGravitationalModel)
+        assert isinstance(sun_gravitational_model, GravitationalModel)
+
+    def test_get_type_success(self, sun_gravitational_model: SunGravitationalModel):
+        assert sun_gravitational_model.get_type() == SunGravitationalModel.Type.Spherical
+
+    def test_get_field_value_at_success(
+        self, sun_gravitational_model: SunGravitationalModel
+    ):
+        grav_acceleration = sun_gravitational_model.get_field_value_at(
+            np.array([150000e9, 0.0, 0.0]), Instant.J2000()
+        )
+        grav_acceleration_ref = np.array([-0.00589833066746667, 0, 0])
+        assert all(
+            [
+                round(grav_acceleration[i], -7) == round(grav_acceleration_ref[i], -7)
+                for i in range(0, len(grav_acceleration_ref))
+            ]
+        )

ostk/physics/test/environment/magnetic/__init__.py

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

ostk/physics/test/environment/magnetic/earth/test_manager.py

@@ -0,0 +1,64 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.core.filesystem import Path, Directory, PermissionSet
+
+from ostk.physics.environment.magnetic import Earth as EarthMagneticModel
+from ostk.physics.environment.magnetic.earth import (
+    Manager as EarthMagneticModelManager,
+)
+
+
+@pytest.fixture
+def manager() -> EarthMagneticModelManager:
+    manager = EarthMagneticModelManager.get()
+
+    yield manager
+
+    # This reset is important so that other test modules are not affected
+    manager.reset()
+
+
+class TestManager:
+    def test_get_mode_success(self, manager: EarthMagneticModelManager):
+        assert manager.get_mode() == EarthMagneticModelManager.Mode.Automatic
+
+    def test_has_data_files_for_type_success(self, manager: EarthMagneticModelManager):
+        assert manager.has_data_files_for_type(EarthMagneticModel.Type.EMM2010) == True
+
+    def test_get_local_repository_success(self, manager: EarthMagneticModelManager):
+        assert isinstance(manager.get_local_repository(), Directory)
+        assert len(str(manager.get_local_repository().to_string())) > 0
+
+    def test_fetch_data_files_for_type_success(self, manager: EarthMagneticModelManager):
+        test_directory = Directory.path(
+            manager.get_local_repository().get_path() + Path.parse("/test")
+        )
+        if test_directory.exists():
+            test_directory.remove()
+
+        test_directory.create(PermissionSet.rw(), PermissionSet.r(), PermissionSet.r())
+        manager.set_local_repository(test_directory)
+
+        manager.fetch_data_files_for_type(EarthMagneticModel.Type.EMM2010)
+
+    def test_set_mode_success(self, manager: EarthMagneticModelManager):
+        assert manager.get_mode() == EarthMagneticModelManager.Mode.Automatic
+
+        manager.set_mode(EarthMagneticModelManager.Mode.Manual)
+
+        assert manager.get_mode() == EarthMagneticModelManager.Mode.Manual
+
+    def test_set_local_repository_success(self, manager: EarthMagneticModelManager):
+        manager.set_local_repository(
+            Directory.path(
+                Path.parse("./.open-space-toolkit/physics/environment/magnetic/earth2")
+            )
+        )
+
+        assert isinstance(manager.get_local_repository(), Directory)
+        assert (
+            manager.get_local_repository().to_string()
+            == "./.open-space-toolkit/physics/environment/magnetic/earth2"
+        )

ostk/physics/test/environment/magnetic/test_earth.py

@@ -0,0 +1,38 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.core.filesystem import Directory
+
+from ostk.physics.environment.magnetic import Earth as EarthMagneticModel
+from ostk.physics.environment.object.celestial import Earth
+
+
+@pytest.fixture
+def earth_magnetic_model() -> EarthMagneticModel:
+    return EarthMagneticModel(EarthMagneticModel.Type.EMM2010)
+
+
+class TestEarth:
+    def test_constructor_success_with_type(self):
+        earth_magnetic_model = EarthMagneticModel(
+            EarthMagneticModel.Type.EMM2010,
+        )
+
+        assert isinstance(earth_magnetic_model, EarthMagneticModel)
+
+    def test_constructor_success_with_directory(self):
+        earth_magnetic_model = EarthMagneticModel(
+            EarthMagneticModel.Type.EMM2010,
+            Directory.undefined(),
+        )
+
+        assert isinstance(earth_magnetic_model, EarthMagneticModel)
+
+    def test_get_type_success(self, earth_magnetic_model: EarthMagneticModel):
+        assert earth_magnetic_model.get_type() == EarthMagneticModel.Type.EMM2010
+
+    def test_is_defined_success(self, earth_magnetic_model: EarthMagneticModel):
+        assert earth_magnetic_model.is_defined() == True

ostk/physics/test/environment/object/__init__.py

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

ostk/physics/test/environment/object/celestial/__init__ .py

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

ostk/physics/test/environment/object/celestial/test_earth.py

@@ -0,0 +1,174 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.core.filesystem import Directory
+
+from ostk.physics.environment.object.celestial import Earth
+
+from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
+from ostk.physics.environment.atmospheric import Earth as EarthAtmosphericModel
+from ostk.physics.environment.magnetic import Earth as EarthMagneticModel
+
+
+@pytest.fixture
+def earth():
+    return Earth.default()
+
+
+class TestEarth:
+    def test_properties(self, earth):
+        assert earth.get_gravitational_parameter() is not None
+        assert earth.get_equatorial_radius() is not None
+        assert earth.get_flattening() is not None
+        assert earth.get_j2() is not None
+        assert earth.get_j4() is not None
+
+    def test_default_success(self, earth):
+        assert earth is not None
+        assert isinstance(earth, Earth)
+
+    def test_EGM2008_success(self):
+        earth = Earth.EGM2008()
+
+        assert earth is not None
+        assert isinstance(earth, Earth)
+
+        earth_custom: Earth = Earth.EGM2008(2190, 2160)
+
+        assert earth_custom is not None
+        assert isinstance(earth_custom, Earth)
+
+    def test_WGS84_EGM96_success(self):
+        earth = Earth.WGS84_EGM96()
+
+        assert earth is not None
+        assert isinstance(earth, Earth)
+
+        earth_custom: Earth = Earth.WGS84_EGM96(180, 180)
+
+        assert earth_custom is not None
+        assert isinstance(earth_custom, Earth)
+
+    def test_EGM96_success(self):
+        earth = Earth.EGM96()
+
+        assert earth is not None
+        assert isinstance(earth, Earth)
+
+        earth_custom: Earth = Earth.EGM96(360, 360)
+
+        assert earth_custom is not None
+        assert isinstance(earth_custom, Earth)
+
+    def test_EGM84_success(self):
+        earth = Earth.EGM84()
+
+        assert earth is not None
+        assert isinstance(earth, Earth)
+
+        earth_custom: Earth = Earth.EGM84(180, 180)
+
+        assert earth_custom is not None
+        assert isinstance(earth_custom, Earth)
+
+    def test_WGS84_success(self):
+        earth = Earth.WGS84()
+
+        assert earth is not None
+        assert isinstance(earth, Earth)
+
+        earth_custom: Earth = Earth.WGS84(20, 0)
+
+        assert earth is not None
+        assert isinstance(earth_custom, Earth)
+
+    def test_spherical_success(self):
+        earth = Earth.spherical()
+
+        assert earth is not None
+        assert isinstance(earth, Earth)
+
+    @pytest.mark.parametrize(
+        "grav_model_parameters,atmos_model_parameters,mag_model_parameters",
+        (
+            (
+                (
+                    EarthGravitationalModel.Type.EGM2008,
+                    Directory.undefined(),
+                    20,
+                    20,
+                ),
+                (EarthAtmosphericModel.Type.Exponential,),
+                (EarthMagneticModel.Type.Dipole,),
+            ),
+            (
+                (
+                    EarthGravitationalModel.Type.EGM96,
+                    Directory.undefined(),
+                    20,
+                    20,
+                ),
+                (EarthAtmosphericModel.Type.Exponential,),
+                (EarthMagneticModel.Type.Dipole,),
+            ),
+            (
+                (
+                    EarthGravitationalModel.Type.EGM84,
+                    Directory.undefined(),
+                    20,
+                    20,
+                ),
+                (EarthAtmosphericModel.Type.Exponential,),
+                (EarthMagneticModel.Type.Dipole,),
+            ),
+            (
+                (
+                    EarthGravitationalModel.Type.WGS84_EGM96,
+                    Directory.undefined(),
+                    20,
+                    20,
+                ),
+                (EarthAtmosphericModel.Type.Exponential,),
+                (EarthMagneticModel.Type.Dipole,),
+            ),
+            (
+                (
+                    EarthGravitationalModel.Type.WGS84,
+                    Directory.undefined(),
+                ),
+                (EarthAtmosphericModel.Type.Exponential,),
+                (EarthMagneticModel.Type.Dipole,),
+            ),
+            (
+                (EarthGravitationalModel.Type.Spherical, Directory.undefined()),
+                (EarthAtmosphericModel.Type.Exponential,),
+                (EarthMagneticModel.Type.Dipole,),
+            ),
+        ),
+    )
+    def test_from_models(
+        self,
+        grav_model_parameters: tuple,
+        atmos_model_parameters: tuple,
+        mag_model_parameters: tuple,
+    ):
+        earth = Earth.from_models(
+            EarthGravitationalModel(*grav_model_parameters),
+            EarthMagneticModel(*mag_model_parameters),
+            EarthAtmosphericModel(*atmos_model_parameters),
+        )
+        assert earth.is_defined()
+
+    def test_singular_model_static_constructors(self):
+        assert Earth.gravitational_only(
+            EarthGravitationalModel(EarthGravitationalModel.Type.EGM2008)
+        ).is_defined()
+        assert Earth.atmospheric_only(
+            EarthAtmosphericModel(
+                EarthAtmosphericModel.Type.Exponential,
+            )
+        ).is_defined()
+        assert Earth.magnetic_only(
+            EarthMagneticModel(EarthMagneticModel.Type.WMM2010)
+        ).is_defined()

ostk/physics/test/environment/object/celestial/test_moon.py

@@ -0,0 +1,17 @@
+# Apache License 2.0
+
+from ostk.physics.environment.object.celestial import Moon
+
+
+class TestMoon:
+    def test_default_success(self):
+        moon = Moon.default()
+
+        assert moon is not None
+        assert isinstance(moon, Moon)
+
+    def test_spherical_success(self):
+        moon = Moon.spherical()
+
+        assert moon is not None
+        assert isinstance(moon, Moon)

ostk/physics/test/environment/object/celestial/test_sun.py

@@ -0,0 +1,17 @@
+# Apache License 2.0
+
+from ostk.physics.environment.object.celestial import Sun
+
+
+class TestSun:
+    def test_default_success(self):
+        sun = Sun.default()
+
+        assert sun is not None
+        assert isinstance(sun, Sun)
+
+    def test_spherical_success(self):
+        sun = Sun.spherical()
+
+        assert sun is not None
+        assert isinstance(sun, Sun)

ostk/physics/test/environment/object/test_celestial.py

@@ -0,0 +1,12 @@
+# Apache License 2.0
+
+from ostk.physics.environment.object.celestial import Earth
+
+
+class TestCelestial:
+    def test_model_is_defined_success(self):
+        earth = Earth.spherical()
+
+        assert earth.gravitational_model_is_defined() is True
+        assert earth.magnetic_model_is_defined() is False
+        assert earth.atmospheric_model_is_defined() is False

ostk/physics/test/test_environment.py

@@ -0,0 +1,97 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant, DateTime, Scale
+from ostk.physics.coordinate import Frame, Position
+from ostk.physics import Environment
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+class TestEnvironment:
+
+    def test_constructors(self):
+        instant = Instant.date_time(DateTime(2019, 1, 1, 0, 0, 0), Scale.UTC)
+        objects = []
+
+        env: Environment = Environment(instant, objects)
+
+        assert env is not None
+        assert isinstance(env, Environment)
+
+        env = Environment(instant, objects, set_global_instance=True)
+
+        assert env is not None
+        assert isinstance(env, Environment)
+
+    def test_undefined(self):
+        assert Environment.undefined() is not None
+        assert Environment.undefined().is_defined() is False
+
+    def test_default(self):
+        assert Environment.default() is not None
+        assert Environment.default(set_global_instance=True) is not None
+
+    def test_is_defined(self, environment: Environment):
+        assert environment.is_defined() is not None
+
+    def test_has_object_with_name(self, environment: Environment):
+        assert environment.has_object_with_name("Earth") is not None
+
+    @pytest.mark.skip
+    def test_intersects(self, environment: Environment):
+        assert environment.intersects() is not None
+
+    def test_access_objects(self, environment: Environment):
+        assert environment.access_objects() is not None
+
+    def test_access_object_with_name(self, environment: Environment):
+        assert environment.access_object_with_name("Earth") is not None
+
+    def test_access_celestial_object_with_name(self, environment: Environment):
+        assert environment.access_celestial_object_with_name("Earth") is not None
+
+    def test_get_instant(self, environment: Environment):
+        assert environment.get_instant() is not None
+
+    def test_get_object_names(self, environment: Environment):
+        assert environment.get_object_names() is not None
+
+    def test_set_instant(self, environment: Environment):
+        environment.set_instant(
+            Instant.date_time(DateTime(2019, 1, 1, 0, 0, 0), Scale.UTC)
+        )
+
+    def test_is_position_in_eclipse(self, environment: Environment):
+        environment.set_instant(
+            Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        )
+
+        assert environment.is_position_in_eclipse(
+            Position.meters(
+                [7000e3, 0.0, 0.0],
+                Frame.ITRF(),
+            )
+        )
+
+    def test_access_global_instance(self):
+        with pytest.raises(RuntimeError):
+            Environment.access_global_instance()
+
+        Environment.default(set_global_instance=True)
+
+        assert Environment.access_global_instance() is not None
+
+    def test_has_global_instance(self):
+        assert Environment.has_global_instance() is False
+
+        Environment.default(set_global_instance=True)
+
+        assert Environment.has_global_instance() is True
+
+    def teardown_method(self, method):
+        Environment.reset_global_instance()

ostk/physics/test/test_import.py

@@ -0,0 +1,25 @@
+# Apache License 2.0
+
+import pytest
+
+import ostk.mathematics as mathematics
+import ostk.physics as physics
+
+
+def test_import():
+    Point = mathematics.geometry.d3.object.Point
+    Segment = mathematics.geometry.d3.object.Segment
+
+    Scale = physics.time.Scale
+    Instant = physics.time.Instant
+    Duration = physics.time.Duration
+    Interval = physics.time.Interval
+    Date = physics.time.Date
+    Time = physics.time.Time
+    DateTime = physics.time.DateTime
+    Frame = physics.coordinate.Frame
+    Environment = physics.Environment
+    Object = physics.environment.Object
+    Geometry = physics.environment.object.Geometry
+    Celestial = physics.environment.object.Celestial
+    Earth = physics.environment.object.celestial.Earth

ostk/physics/test/time/__init__.py

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