open-space-toolkit-physics 11.3.0__py310-none-manylinux2014_aarch64.whl

ostk/physics/test/environment/atmospheric/earth/test_cssi_space_weather.py

@@ -0,0 +1,126 @@
+# Apache License 2.0
+
+import pytest
+
+from datetime import datetime
+
+from ostk.core.filesystem import File
+
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+
+from ostk.physics.environment.atmospheric.earth import CSSISpaceWeather
+
+
+class TestCSSISpaceWeather:
+    def test_str_success(self, cssi_space_weather: CSSISpaceWeather):
+        assert str(cssi_space_weather).startswith("-- CSSI Space Weather --")
+
+    def test_repr_success(self, cssi_space_weather: CSSISpaceWeather):
+        assert repr(cssi_space_weather).startswith("-- CSSI Space Weather --")
+
+    def test_is_defined_success(self, cssi_space_weather: CSSISpaceWeather):
+        assert cssi_space_weather.is_defined() is True
+
+    def test_access_last_observation_date_success(
+        self, cssi_space_weather: CSSISpaceWeather
+    ):
+        assert (
+            cssi_space_weather.access_last_observation_date().to_string() == "2023-06-19"
+        )
+
+    def test_access_observation_interval_success(
+        self, cssi_space_weather: CSSISpaceWeather
+    ):
+        assert (
+            cssi_space_weather.access_observation_interval().to_string()
+            == "[2018-01-01 00:00:00 - 2023-06-20 00:00:00[ [UTC]"
+        )
+
+    def test_access_observation_at_success(self, cssi_space_weather: CSSISpaceWeather):
+        observation: Observation = cssi_space_weather.access_observation_at(
+            Instant.date_time(datetime(2023, 6, 19, 0, 0, 0), Scale.UTC)
+        )
+
+        assert observation.date.to_string() == "2023-06-19"
+        assert observation.kp_sum == 177
+        assert observation.f107_obs == pytest.approx(168.8)
+        assert observation.f107_obs_center_81 == pytest.approx(160.1)
+
+    def test_access_daily_prediction_interval_success(
+        self, cssi_space_weather: CSSISpaceWeather
+    ):
+        assert (
+            cssi_space_weather.access_daily_prediction_interval().to_string()
+            == "[2023-06-20 00:00:00 - 2023-08-04 00:00:00[ [UTC]"
+        )
+
+    def test_access_daily_prediction_at_success(
+        self, cssi_space_weather: CSSISpaceWeather
+    ):
+        prediction: Reading = cssi_space_weather.access_daily_prediction_at(
+            Instant.date_time(datetime(2023, 8, 3, 0, 0, 0), Scale.UTC)
+        )
+
+        assert prediction.date.to_string() == "2023-08-03"
+        assert prediction.kp_sum == 104
+        assert prediction.f107_obs == pytest.approx(165.1)
+        assert prediction.f107_obs_center_81 == pytest.approx(157.4)
+
+    def test_access_monthly_prediction_interval_success(
+        self, cssi_space_weather: CSSISpaceWeather
+    ):
+        assert (
+            cssi_space_weather.access_monthly_prediction_interval().to_string()
+            == "[2023-08-01 00:00:00 - 2029-01-01 00:00:00] [UTC]"
+        )
+
+    def test_access_monthly_prediction_at_success(
+        self, cssi_space_weather: CSSISpaceWeather
+    ):
+        prediction: Reading = cssi_space_weather.access_monthly_prediction_at(
+            Instant.date_time(datetime(2029, 1, 1, 0, 0, 0), Scale.UTC)
+        )
+
+        assert prediction.date.to_string() == "2029-01-01"
+        assert prediction.f107_obs == pytest.approx(83.5)
+        assert prediction.f107_obs_center_81 == pytest.approx(83.6)
+
+    def test_access_reading_at_success(self, cssi_space_weather: CSSISpaceWeather):
+        reading: Reading = cssi_space_weather.access_reading_at(
+            Instant.date_time(datetime(2029, 1, 1, 0, 0, 0), Scale.UTC)
+        )
+
+        assert reading.date.to_string() == "2029-01-01"
+        assert reading.f107_obs == pytest.approx(83.5)
+        assert reading.f107_obs_center_81 == pytest.approx(83.6)
+        assert reading.f107_data_type == "PRM"
+
+    def test_access_last_reading_where_success(
+        self, cssi_space_weather: CSSISpaceWeather
+    ):
+        reading: Reading = cssi_space_weather.access_last_reading_where(
+            lambda reading: reading.f107_data_type == "PRD",
+            Instant.date_time(datetime(2023, 12, 1, 0, 0, 0), Scale.UTC),
+        )
+
+        assert reading.date.to_string() == "2023-08-03"
+        assert reading.f107_data_type == "PRD"
+
+    def test_access_last_reading_where_failure(
+        self, cssi_space_weather: CSSISpaceWeather
+    ):
+        with pytest.raises(RuntimeError):
+            cssi_space_weather.access_last_reading_where(
+                lambda reading: reading.f107_data_type == "FAKE",
+                Instant.date_time(datetime(2029, 1, 1, 0, 0, 0), Scale.UTC),
+            )
+
+    def test_undefined_success(self):
+        assert CSSISpaceWeather.undefined() is not None
+
+    def test_load_success(self, cssi_space_weather_file: File):
+        assert CSSISpaceWeather.load(cssi_space_weather_file) is not None
+
+    def test_load_legacy_success(self, cssi_space_weather_legacy_file: File):
+        assert CSSISpaceWeather.load_legacy(cssi_space_weather_legacy_file) is not None

ostk/physics/test/environment/atmospheric/earth/test_exponential.py

@@ -0,0 +1,34 @@
+# 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.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.spherical import LLA
+
+from ostk.physics.environment.atmospheric import Earth as EarthAtmosphericModel
+from ostk.physics.environment.atmospheric.earth import Exponential
+
+
+class TestExponential:
+    def test_constructor_success(self, exponential_model):
+        assert isinstance(exponential_model, Exponential)
+
+    def test_is_defined_success(self, exponential_model):
+        assert exponential_model.is_defined() is True
+
+    def test_get_density_at_lla_success(self, exponential_model):
+        lla = LLA(Angle.degrees(0.0), Angle.degrees(0.0), Length.meters(500e3))
+
+        density = exponential_model.get_density_at(
+            lla, Instant.date_time(DateTime.parse("2021-01-01 00:00:00"), Scale.UTC)
+        )
+
+        # assert sensible number for density
+        assert 1.0e-15 < density < 1.0e-12

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

@@ -0,0 +1,173 @@
+# 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.environment.atmospheric.earth import Manager
+from ostk.physics.environment.atmospheric.earth import CSSISpaceWeather
+
+
+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_cssi_space_weather_directory_success(self, manager: Manager):
+        assert isinstance(manager.get_cssi_space_weather_directory(), Directory)
+        assert len(str(manager.get_cssi_space_weather_directory().to_string())) > 0
+
+    def test_get_loaded_cssi_space_weather_success(self, manager: Manager):
+        assert isinstance(manager.get_loaded_cssi_space_weather(), CSSISpaceWeather)
+        assert not manager.get_loaded_cssi_space_weather().is_defined()
+
+    def test_get_cssi_space_weather_at_success(self, manager: Manager):
+        try:
+            cssi_space_weather: CSSISpaceWeather = manager.get_cssi_space_weather_at(
+                Instant.now() - Duration.days(8.0)
+            )
+        except RuntimeError:
+            manager.reset()
+            manager.clear_local_repository()
+            cssi_space_weather: CSSISpaceWeather = manager.get_cssi_space_weather_at(
+                Instant.now() - Duration.days(5.0)
+            )
+
+        assert isinstance(cssi_space_weather, CSSISpaceWeather)
+
+    def test_get_kp_3_hour_solar_indices_at_success(
+        self, manager: Manager, cssi_space_weather: CSSISpaceWeather
+    ):
+        # load test file data for comparison
+        manager.load_cssi_space_weather(cssi_space_weather)
+
+        kp_indices = manager.get_kp_3_hour_solar_indices_at(
+            Instant.date_time(datetime(2023, 6, 18, 12, 34, 56), Scale.UTC)
+        )
+
+        assert kp_indices == [27, 20, 13, 20, 17, 17, 27, 20]
+
+    def test_get_ap_3_hour_solar_indices_at_success(
+        self, manager: Manager, cssi_space_weather: CSSISpaceWeather
+    ):
+        # load test file data for comparison
+        manager.load_cssi_space_weather(cssi_space_weather)
+
+        ap_indices = manager.get_ap_3_hour_solar_indices_at(
+            Instant.date_time(datetime(2023, 6, 18, 12, 34, 56), Scale.UTC)
+        )
+
+        assert ap_indices == [12, 7, 5, 7, 6, 6, 12, 7]
+
+    def test_get_ap_daily_index_at_success(
+        self, manager: Manager, cssi_space_weather: CSSISpaceWeather
+    ):
+        # load test file data for comparison
+        manager.load_cssi_space_weather(cssi_space_weather)
+
+        ap_index = manager.get_ap_daily_index_at(
+            Instant.date_time(datetime(2023, 6, 18, 12, 34, 56), Scale.UTC)
+        )
+
+        assert ap_index == 8
+
+    def test_get_f107_solar_flux_at_success(
+        self, manager: Manager, cssi_space_weather: CSSISpaceWeather
+    ):
+        # load test file data for comparison
+        manager.load_cssi_space_weather(cssi_space_weather)
+
+        flux = manager.get_f107_solar_flux_at(
+            Instant.date_time(datetime(2023, 6, 18, 12, 34, 56), Scale.UTC)
+        )
+
+        assert flux == pytest.approx(164.1)
+
+    def test_get_f107_solar_flux_81_day_avg_at_success(
+        self, manager: Manager, cssi_space_weather: CSSISpaceWeather
+    ):
+        # load test file data for comparison
+        manager.load_cssi_space_weather(cssi_space_weather)
+
+        flux_avg = manager.get_f107_solar_flux_81_day_avg_at(
+            Instant.date_time(datetime(2018, 1, 1, 12, 34, 56), Scale.UTC)
+        )
+
+        assert flux_avg == pytest.approx(71.4)
+
+    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)
+
+        manager.set_local_repository(
+            Directory.path(
+                Path.parse("./.open-space-toolkit/physics/environment/atmospheric/earth")
+            )
+        )
+
+        assert isinstance(manager.get_local_repository(), Directory)
+        assert (
+            manager.get_local_repository().to_string()
+            == "./.open-space-toolkit/physics/environment/atmospheric/earth"
+        )
+
+    def test_load_cssi_space_weather_success(
+        self, manager: Manager, cssi_space_weather: CSSISpaceWeather
+    ):
+        assert not manager.get_loaded_cssi_space_weather().is_defined()
+
+        manager.load_cssi_space_weather(cssi_space_weather)
+
+        assert manager.get_loaded_cssi_space_weather().is_defined()
+
+    def test_fetch_latest_cssi_space_weather_success(self, manager: Manager):
+        file: File = manager.fetch_latest_cssi_space_weather()
+
+        assert isinstance(file, File)
+        assert file.exists()
+
+        file.remove()
+
+    def test_reset_success(self, manager: Manager, cssi_space_weather: CSSISpaceWeather):
+        manager.load_cssi_space_weather(cssi_space_weather)
+
+        assert manager.get_loaded_cssi_space_weather().is_defined()
+
+        manager.reset()
+
+        assert not manager.get_loaded_cssi_space_weather().is_defined()
+
+    def test_clear_local_repository_success(self, manager: Manager):
+        assert manager.get_local_repository().exists()
+        assert manager.get_cssi_space_weather_directory().exists()
+        pathlib.Path(
+            str(manager.get_cssi_space_weather_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_cssi_space_weather_directory().is_empty()
+
+    def test_get_success(self):
+        assert isinstance(Manager.get(), Manager)

ostk/physics/test/environment/atmospheric/earth/test_nrlmsise00.py

@@ -0,0 +1,34 @@
+# 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.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.spherical import LLA
+
+from ostk.physics.environment.atmospheric import Earth as EarthAtmosphericModel
+from ostk.physics.environment.atmospheric.earth import NRLMSISE00
+
+
+class TestNRLMSISE00:
+    def test_constructor_success(self, nrlmsise00_model):
+        assert isinstance(nrlmsise00_model, NRLMSISE00)
+
+    def test_is_defined_success(self, nrlmsise00_model):
+        assert nrlmsise00_model.is_defined() is True
+
+    def test_get_density_at_lla_no_sun_success(self, nrlmsise00_model):
+        lla = LLA(Angle.degrees(0.0), Angle.degrees(0.0), Length.meters(500e3))
+
+        density = nrlmsise00_model.get_density_at(
+            lla, Instant.date_time(DateTime.parse("2021-01-01 00:00:00"), Scale.UTC)
+        )
+
+        # assert sensible number for density
+        assert 1.0e-15 < density < 1.0e-12

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

@@ -0,0 +1,141 @@
+# 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.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.environment.atmospheric import Earth as EarthAtmosphericModel
+from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
+from ostk.physics.environment.object.celestial import Sun
+
+
+@pytest.fixture
+def earth_atmospheric_model_exponential() -> EarthAtmosphericModel:
+    return EarthAtmosphericModel(EarthAtmosphericModel.Type.Exponential)
+
+
+@pytest.fixture
+def earth_atmospheric_model_nrlmsise() -> EarthAtmosphericModel:
+    return EarthAtmosphericModel(EarthAtmosphericModel.Type.NRLMSISE00)
+
+
+class TestEarth:
+    def test_constructor_success_with_type(self):
+        earth_atmospheric_model = EarthAtmosphericModel(
+            type=EarthAtmosphericModel.Type.Exponential,
+            input_data_type=EarthAtmosphericModel.InputDataType.Undefined,
+        )
+
+        assert isinstance(earth_atmospheric_model, EarthAtmosphericModel)
+
+    def test_constructor_success_exponential_with_params(self):
+        earth_atmospheric_model = EarthAtmosphericModel(
+            type=EarthAtmosphericModel.Type.Exponential,
+            input_data_type=EarthAtmosphericModel.InputDataType.Undefined,
+            f107_constant_value=160.0,
+            f107_average_constant_value=160.0,
+            kp_constant_value=4.0,
+            earth_frame=Frame.ITRF(),
+            earth_radius=EarthGravitationalModel.WGS84.equatorial_radius,
+            earth_flattening=EarthGravitationalModel.WGS84.flattening,
+            sun_celestial=Sun.default(),
+        )
+
+        assert isinstance(earth_atmospheric_model, EarthAtmosphericModel)
+
+    def test_constructor_success_nrlmsise_file_with_params(self):
+        earth_atmospheric_model = EarthAtmosphericModel(
+            type=EarthAtmosphericModel.Type.NRLMSISE00,
+            input_data_type=EarthAtmosphericModel.InputDataType.CSSISpaceWeatherFile,
+            earth_frame=Frame.ITRF(),
+            earth_radius=EarthGravitationalModel.WGS84.equatorial_radius,
+            earth_flattening=EarthGravitationalModel.WGS84.flattening,
+        )
+
+        assert isinstance(earth_atmospheric_model, EarthAtmosphericModel)
+
+    def test_constructor_success_nrlmsise_constant_with_params(self):
+        earth_atmospheric_model = EarthAtmosphericModel(
+            type=EarthAtmosphericModel.Type.NRLMSISE00,
+            input_data_type=EarthAtmosphericModel.InputDataType.ConstantFluxAndGeoMag,
+            f107_constant_value=160.0,
+            f107_average_constant_value=160.0,
+            kp_constant_value=4.0,
+            earth_frame=Frame.ITRF(),
+            earth_radius=EarthGravitationalModel.WGS84.equatorial_radius,
+            earth_flattening=EarthGravitationalModel.WGS84.flattening,
+            sun_celestial=Sun.default(),
+        )
+
+        assert isinstance(earth_atmospheric_model, EarthAtmosphericModel)
+
+    def test_get_type_success(
+        self, earth_atmospheric_model_exponential: EarthAtmosphericModel
+    ):
+        assert (
+            earth_atmospheric_model_exponential.get_type()
+            == EarthAtmosphericModel.Type.Exponential
+        )
+
+    def test_get_input_data_type_success(
+        self, earth_atmospheric_model_exponential: EarthAtmosphericModel
+    ):
+        assert (
+            earth_atmospheric_model_exponential.get_input_data_type()
+            == EarthAtmosphericModel.InputDataType.Undefined
+        )
+
+    def test_is_defined_success(
+        self, earth_atmospheric_model_exponential: EarthAtmosphericModel
+    ):
+        assert earth_atmospheric_model_exponential.is_defined() == True
+
+    def test_get_density_at_exponential_success(
+        self, earth_atmospheric_model_exponential: EarthAtmosphericModel
+    ):
+        latitude = Angle.degrees(30.0)
+        longitude = Angle.degrees(40.0)
+        altitude = Length.kilometers(500.0)
+
+        density = earth_atmospheric_model_exponential.get_density_at(
+            position=Position.meters(
+                coordinates=LLA(latitude, longitude, altitude).to_cartesian(
+                    ellipsoid_equatorial_radius=EarthGravitationalModel.EGM2008.equatorial_radius,
+                    ellipsoid_flattening=EarthGravitationalModel.EGM2008.flattening,
+                ),
+                frame=Frame.ITRF(),
+            ),
+            instant=Instant.J2000(),
+        )
+
+        assert density is not None
+
+    def test_get_density_at_nrlmsise_success(
+        self, earth_atmospheric_model_nrlmsise: EarthAtmosphericModel
+    ):
+        latitude = Angle.degrees(30.0)
+        longitude = Angle.degrees(40.0)
+        altitude = Length.kilometers(500.0)
+
+        density = earth_atmospheric_model_nrlmsise.get_density_at(
+            position=Position.meters(
+                coordinates=LLA(latitude, longitude, altitude).to_cartesian(
+                    ellipsoid_equatorial_radius=EarthGravitationalModel.EGM2008.equatorial_radius,
+                    ellipsoid_flattening=EarthGravitationalModel.EGM2008.flattening,
+                ),
+                frame=Frame.ITRF(),
+            ),
+            instant=Instant.date_time(DateTime.parse("2021-01-01 00:00:00"), Scale.UTC),
+        )
+
+        assert density is not None

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

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

ostk/physics/test/environment/gravitational/earth/__init__.py

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

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

@@ -0,0 +1,76 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.core.filesystem import Path, Directory, PermissionSet
+
+from ostk.physics.time import Duration
+from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
+from ostk.physics.environment.gravitational.earth import (
+    Manager as EarthGravitationalModelManager,
+)
+
+
+@pytest.fixture
+def manager() -> EarthGravitationalModelManager:
+    manager = EarthGravitationalModelManager.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: EarthGravitationalModelManager):
+        assert manager.get_mode() == EarthGravitationalModelManager.Mode.Automatic
+
+    def test_has_data_files_for_type_success(
+        self, manager: EarthGravitationalModelManager
+    ):
+        assert manager.has_data_files_for_type(EarthGravitationalModel.Type.WGS84) == True
+        assert manager.has_data_files_for_type(EarthGravitationalModel.Type.EGM84) == True
+        assert manager.has_data_files_for_type(EarthGravitationalModel.Type.EGM96) == True
+        assert (
+            manager.has_data_files_for_type(EarthGravitationalModel.Type.EGM2008) == True
+        )
+
+    def test_get_local_repository_success(self, manager: EarthGravitationalModelManager):
+        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: EarthGravitationalModelManager
+    ):
+        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(EarthGravitationalModel.Type.WGS84)
+
+    def test_set_mode_success(self, manager: EarthGravitationalModelManager):
+        assert manager.get_mode() == EarthGravitationalModelManager.Mode.Automatic
+
+        manager.set_mode(EarthGravitationalModelManager.Mode.Manual)
+
+        assert manager.get_mode() == EarthGravitationalModelManager.Mode.Manual
+
+    def test_set_local_repository_success(self, manager: EarthGravitationalModelManager):
+        manager.set_local_repository(
+            Directory.path(
+                Path.parse(
+                    "./.open-space-toolkit/physics/environment/gravitational/earth2"
+                )
+            )
+        )
+
+        assert isinstance(manager.get_local_repository(), Directory)
+        assert (
+            manager.get_local_repository().to_string()
+            == "./.open-space-toolkit/physics/environment/gravitational/earth2"
+        )

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

@@ -0,0 +1,103 @@
+# 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 Earth as EarthGravitationalModel
+
+
+@pytest.fixture
+def earth_gravitational_model() -> EarthGravitationalModel:
+    return EarthGravitationalModel(EarthGravitationalModel.Type.EGM2008)
+
+
+class TestEarth:
+    def test_constructor_success_with_type(self):
+        assert isinstance(
+            EarthGravitationalModel(EarthGravitationalModel.Type.Spherical),
+            EarthGravitationalModel,
+        )
+        assert isinstance(
+            EarthGravitationalModel(EarthGravitationalModel.Type.WGS84),
+            EarthGravitationalModel,
+        )
+        assert isinstance(
+            EarthGravitationalModel(EarthGravitationalModel.Type.EGM96),
+            EarthGravitationalModel,
+        )
+        assert isinstance(
+            EarthGravitationalModel(EarthGravitationalModel.Type.EGM84),
+            EarthGravitationalModel,
+        )
+        assert isinstance(
+            EarthGravitationalModel(EarthGravitationalModel.Type.EGM2008),
+            EarthGravitationalModel,
+        )
+
+    def test_constructor_success_with_directory(self):
+        earth_gravitational_model = EarthGravitationalModel(
+            EarthGravitationalModel.Type.EGM2008, Directory.undefined()
+        )
+
+        assert isinstance(earth_gravitational_model, EarthGravitationalModel)
+        assert isinstance(earth_gravitational_model, GravitationalModel)
+
+    def test_constructor_success_with_degree_and_order(self):
+        earth_gravitational_model = EarthGravitationalModel(
+            EarthGravitationalModel.Type.EGM2008, Directory.undefined(), 2, 2
+        )
+
+        assert isinstance(earth_gravitational_model, EarthGravitationalModel)
+        assert isinstance(earth_gravitational_model, GravitationalModel)
+
+    def test_constructor_success_without_directory_with_degree_and_order(self):
+        earth_gravitational_model = EarthGravitationalModel(
+            EarthGravitationalModel.Type.EGM2008, 2, 2
+        )
+
+        assert isinstance(earth_gravitational_model, EarthGravitationalModel)
+        assert isinstance(earth_gravitational_model, GravitationalModel)
+
+    def test_get_type_success(self, earth_gravitational_model: EarthGravitationalModel):
+        assert (
+            earth_gravitational_model.get_type() == EarthGravitationalModel.Type.EGM2008
+        )
+
+    def test_get_degree_order_success(self):
+        egm_earth_gravitational_model = EarthGravitationalModel(
+            EarthGravitationalModel.Type.EGM2008, Directory.undefined(), 51, 50
+        )
+
+        assert egm_earth_gravitational_model.get_degree() == 51
+        assert egm_earth_gravitational_model.get_order() == 50
+
+        spherical_earth_gravitational_model = EarthGravitationalModel(
+            EarthGravitationalModel.Type.Spherical
+        )
+
+        assert spherical_earth_gravitational_model.get_degree().is_defined() is False
+        assert spherical_earth_gravitational_model.get_order().is_defined() is False
+
+    def test_get_field_value_at_success(
+        self, earth_gravitational_model: EarthGravitationalModel
+    ):
+        grav_acceleration = earth_gravitational_model.get_field_value_at(
+            np.array([6400e3, 0.0, 0.0]), Instant.J2000()
+        )
+        grav_acceleration_ref = np.array(
+            [-9.74722832e00, -1.29220148e-05, -1.34173896e-05]
+        )
+        assert all(
+            [
+                round(grav_acceleration[i], -7) == round(grav_acceleration_ref[i], -7)
+                for i in range(0, len(grav_acceleration_ref))
+            ]
+        )
+
+    def test_gravity_constant(self):
+        assert EarthGravitationalModel.gravity_constant is not None