open-space-toolkit-astrodynamics 12.0.1__py39-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/trajectory/orbit/message/spacex/test_opm.py

@@ -0,0 +1,108 @@
+# Apache License 2.0
+
+import pytest
+
+from datetime import datetime
+
+from ostk.core.container import Dictionary
+from ostk.core.filesystem import Path
+from ostk.core.filesystem import File
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import Instant
+from ostk.physics.time import Scale
+from ostk.physics.time import Duration
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.orbit.message.spacex import OPM
+
+
+@pytest.fixture
+def opm() -> OPM:
+    return OPM(
+        header=OPM.Header(
+            generation_date=Instant.date_time(datetime(2020, 1, 2, 3, 4, 5), Scale.UTC),
+            launch_date=Instant.date_time(datetime(2020, 1, 3, 3, 4, 5), Scale.UTC),
+        ),
+        deployments=[
+            OPM.Deployment(
+                name="A",
+                sequence_number=1,
+                mission_time=Duration.hours(3600.0),
+                date=Instant.date_time(datetime(2020, 1, 4, 3, 4, 5), Scale.UTC),
+                position=Position.meters((1.0, 2.0, 3.0), Frame.ITRF()),
+                velocity=Velocity.meters_per_second((4.0, 5.0, 6.0), Frame.ITRF()),
+                mean_perigee_altitude=Length.kilometers(500.0),
+                mean_apogee_altitude=Length.kilometers(500.0),
+                mean_inclination=Angle.degrees(1.0),
+                mean_argument_of_perigee=Angle.degrees(2.0),
+                mean_longitude_ascending_node=Angle.degrees(3.0),
+                mean_mean_anomaly=Angle.degrees(4.0),
+                ballistic_coefficient=123.456,
+            ),
+        ],
+    )
+
+
+class TestOPM:
+    def test_constructor(self, opm: OPM):
+        assert opm is not None
+
+    def test_get_header(self, opm: OPM):
+        assert opm.get_header() is not None
+
+    def test_get_deployments(self, opm: OPM):
+        assert len(opm.get_deployments()) == 1
+
+    def test_get_deployment_at(self, opm: OPM):
+        assert opm.get_deployment_at(index=0).name == "A"
+
+    def test_get_deployment_with_name(self, opm: OPM):
+        assert opm.get_deployment_with_name(name="A").name == "A"
+
+    def test_undefined(self):
+        assert OPM.undefined().is_defined() is False
+
+    def test_dictionary(self):
+        dictionary = Dictionary(
+            {
+                "header": {
+                    "generation_date": "2020-01-01T12:34:56.789Z",
+                    "launch_date": "2020-01-02T12:34:56.789Z",
+                },
+                "deployments": [
+                    {
+                        "name": "satellite_a",
+                        "sequence_number": 1,
+                        "mission_time_s": 3600.0,
+                        "date": "2020-01-02T13:34:56.789Z",
+                        "r_ecef_m": [693289.644, 6876578.628, -133035.288],
+                        "v_ecef_m_per_s": [1305.783, 39.783, 7525.920],
+                        "mean_perigee_altitude_km": 526.768,
+                        "mean_apogee_altitude_km": 568.430,
+                        "mean_inclination_deg": 97.123,
+                        "mean_argument_of_perigee_deg": -179.513,
+                        "mean_longitude_ascending_node_deg": 85.057,
+                        "mean_mean_anomaly_deg": 179.263,
+                        "ballistic_coef_kg_per_m2": 47.55,
+                    }
+                ],
+            }
+        )
+
+        assert OPM.dictionary(dictionary) is not None
+
+    def test_parse(self, opm_file: File):
+        with open(str(opm_file.get_path().to_string()), "r") as stream:
+            assert OPM.parse(string=stream.read()) is not None
+
+    def test_load(self, opm_file: File):
+        assert OPM.load(file=opm_file) is not None
+
+
+class TestOPMDeployment:
+    def test_to_state(self, opm: OPM):
+        assert opm.get_deployment_with_name(name="A").to_state() is not None

ostk/astrodynamics/test/trajectory/orbit/models/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/models/kepler/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/models/kepler/test_brouwer_lyddane_mean.py

@@ -0,0 +1,65 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+
+from ostk.astrodynamics.trajectory.orbit.model import BrouwerLyddaneMean
+
+
+@pytest.fixture
+def semi_major_axis() -> Length:
+    return Length.kilometers(7000.0)
+
+
+@pytest.fixture
+def eccentricity() -> float:
+    return 1e-3
+
+
+@pytest.fixture
+def inclination() -> Angle:
+    return Angle.degrees(35.0)
+
+
+@pytest.fixture
+def raan() -> Angle:
+    return Angle.degrees(40.0)
+
+
+@pytest.fixture
+def aop() -> Angle:
+    return Angle.degrees(50.0)
+
+
+@pytest.fixture
+def mean_anomaly() -> Angle:
+    return Angle.degrees(60.0)
+
+
+@pytest.fixture
+def brouwer_lyddane_mean(
+    semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly
+):
+    class BrouwerLyddaneMeanMock(BrouwerLyddaneMean):
+        def __init__(
+            self, semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly
+        ):
+            super().__init__(
+                semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly
+            )
+
+        def to_coe():
+            return 0.0
+
+    return BrouwerLyddaneMeanMock(
+        semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly
+    )
+
+
+class TestBrouwerLyddaneMean:
+    def test_getters(self, brouwer_lyddane_mean: BrouwerLyddaneMean):
+        assert isinstance(brouwer_lyddane_mean.get_mean_anomaly(), Angle)
+        assert isinstance(brouwer_lyddane_mean.get_true_anomaly(), Angle)
+        assert isinstance(brouwer_lyddane_mean.get_eccentric_anomaly(), Angle)

ostk/astrodynamics/test/trajectory/orbit/models/kepler/test_brouwer_lyddane_mean_long.py

@@ -0,0 +1,102 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.environment.gravitational import Earth
+
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+from ostk.astrodynamics.trajectory.orbit.model.brouwerLyddaneMean import (
+    BrouwerLyddaneMeanLong,
+)
+
+
+@pytest.fixture
+def semi_major_axis() -> Length:
+    return Length.kilometers(7000.0)
+
+
+@pytest.fixture
+def eccentricity() -> float:
+    return 1e-3
+
+
+@pytest.fixture
+def inclination() -> Angle:
+    return Angle.degrees(35.0)
+
+
+@pytest.fixture
+def raan() -> Angle:
+    return Angle.degrees(40.0)
+
+
+@pytest.fixture
+def aop() -> Angle:
+    return Angle.degrees(50.0)
+
+
+@pytest.fixture
+def mean_anomaly() -> Angle:
+    return Angle.degrees(60.0)
+
+
+@pytest.fixture
+def coe(
+    semi_major_axis: Length,
+    eccentricity: float,
+    inclination: Angle,
+    raan: Angle,
+    aop: Angle,
+    mean_anomaly: Angle,
+) -> COE:
+    return COE(semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly)
+
+
+@pytest.fixture
+def cartesian_state() -> tuple[Position, Velocity]:
+    return (
+        Position.meters(
+            [6596407.223662058, 2281266.582975321, -10540.61521486086], Frame.GCRF()
+        ),
+        Velocity.meters_per_second(
+            [337.7269674273224, -969.7192552349448, 7488.702816619139], Frame.GCRF()
+        ),
+    )
+
+
+@pytest.fixture
+def gravitational_parameter():
+    return Earth.EGM2008.gravitational_parameter
+
+
+@pytest.fixture
+def brouwer_lyddane_mean_long(
+    semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly
+):
+    return BrouwerLyddaneMeanLong(
+        semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly
+    )
+
+
+class TestBrouwerLyddaneMeanLong:
+    def test_to_coe(self, brouwer_lyddane_mean_long: BrouwerLyddaneMeanLong):
+        assert brouwer_lyddane_mean_long.to_coe().is_defined()
+
+    def test_coe(self, coe: COE):
+        assert BrouwerLyddaneMeanLong.COE(coe).is_defined()
+
+    def test_cartesian(
+        self, cartesian_state: tuple[Position, Velocity], gravitational_parameter
+    ):
+        assert BrouwerLyddaneMeanLong.cartesian(
+            cartesian_state, gravitational_parameter
+        ).is_defined()
+
+    def test_undefined(self):
+        assert BrouwerLyddaneMeanLong.undefined().is_defined() is False

ostk/astrodynamics/test/trajectory/orbit/models/kepler/test_brouwer_lyddane_mean_short.py

@@ -0,0 +1,102 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.environment.gravitational import Earth
+
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+from ostk.astrodynamics.trajectory.orbit.model.brouwerLyddaneMean import (
+    BrouwerLyddaneMeanShort,
+)
+
+
+@pytest.fixture
+def semi_major_axis() -> Length:
+    return Length.kilometers(7000.0)
+
+
+@pytest.fixture
+def eccentricity() -> float:
+    return 1e-3
+
+
+@pytest.fixture
+def inclination() -> Angle:
+    return Angle.degrees(35.0)
+
+
+@pytest.fixture
+def raan() -> Angle:
+    return Angle.degrees(40.0)
+
+
+@pytest.fixture
+def aop() -> Angle:
+    return Angle.degrees(50.0)
+
+
+@pytest.fixture
+def mean_anomaly() -> Angle:
+    return Angle.degrees(60.0)
+
+
+@pytest.fixture
+def coe(
+    semi_major_axis: Length,
+    eccentricity: float,
+    inclination: Angle,
+    raan: Angle,
+    aop: Angle,
+    mean_anomaly: Angle,
+) -> COE:
+    return COE(semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly)
+
+
+@pytest.fixture
+def cartesian_state() -> tuple[Position, Velocity]:
+    return (
+        Position.meters(
+            [6596407.223662058, 2281266.582975321, -10540.61521486086], Frame.GCRF()
+        ),
+        Velocity.meters_per_second(
+            [337.7269674273224, -969.7192552349448, 7488.702816619139], Frame.GCRF()
+        ),
+    )
+
+
+@pytest.fixture
+def gravitational_parameter():
+    return Earth.EGM2008.gravitational_parameter
+
+
+@pytest.fixture
+def brouwer_lyddane_mean_short(
+    semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly
+):
+    return BrouwerLyddaneMeanShort(
+        semi_major_axis, eccentricity, inclination, raan, aop, mean_anomaly
+    )
+
+
+class TestBrouwerLyddaneMeanShort:
+    def test_to_coe(self, brouwer_lyddane_mean_short: BrouwerLyddaneMeanShort):
+        assert brouwer_lyddane_mean_short.to_coe().is_defined()
+
+    def test_coe(self, coe: COE) -> COE:
+        assert BrouwerLyddaneMeanShort.COE(coe).is_defined()
+
+    def test_cartesian(
+        self, cartesian_state: tuple[Position, Velocity], gravitational_parameter
+    ):
+        assert BrouwerLyddaneMeanShort.cartesian(
+            cartesian_state, gravitational_parameter
+        ).is_defined()
+
+    def test_undefined(self):
+        assert BrouwerLyddaneMeanShort.undefined().is_defined() is False

ostk/astrodynamics/test/trajectory/orbit/models/kepler/test_coe.py

@@ -0,0 +1,167 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.environment.gravitational import Earth
+
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+
+
+@pytest.fixture
+def semi_major_axis() -> Length:
+    return Length.kilometers(7000.0)
+
+
+@pytest.fixture
+def eccentricity() -> float:
+    return 0.1
+
+
+@pytest.fixture
+def inclination() -> Angle:
+    return Angle.degrees(35.0)
+
+
+@pytest.fixture
+def raan() -> Angle:
+    return Angle.degrees(40.0)
+
+
+@pytest.fixture
+def aop() -> Angle:
+    return Angle.degrees(50.0)
+
+
+@pytest.fixture
+def true_anomaly() -> Angle:
+    return Angle.degrees(60.0)
+
+
+@pytest.fixture
+def coe(
+    semi_major_axis: Length,
+    eccentricity: float,
+    inclination: Angle,
+    raan: Angle,
+    aop: Angle,
+    true_anomaly: Angle,
+) -> COE:
+    return COE(semi_major_axis, eccentricity, inclination, raan, aop, true_anomaly)
+
+
+class TestCOE:
+    def test_constructors(self):
+        a = Length.kilometers(7000.0)
+        e = 0.1
+        i = Angle.degrees(35.0)
+        raan = Angle.degrees(40.0)
+        aop = Angle.degrees(50.0)
+        nu = Angle.degrees(60.0)
+
+        coe: COE = COE(a, e, i, raan, aop, nu)
+
+        assert coe is not None
+        assert isinstance(coe, COE)
+        assert coe.is_defined()
+
+        coe: COE = COE.undefined()
+
+        assert coe is not None
+        assert isinstance(coe, COE)
+        assert coe.is_defined() is False
+
+    def test_comparators(
+        self,
+        coe: COE,
+    ):
+        assert coe == coe
+        assert (coe != coe) is False
+
+    def test_getters(
+        self,
+        coe: COE,
+        semi_major_axis: Length,
+        eccentricity: float,
+        inclination: Angle,
+        raan: Angle,
+        aop: Angle,
+        true_anomaly: Angle,
+    ):
+        assert coe.get_semi_major_axis() == semi_major_axis
+        assert coe.get_eccentricity() == eccentricity
+        assert coe.get_inclination() == inclination
+        assert coe.get_raan() == raan
+        assert coe.get_aop() == aop
+        assert coe.get_true_anomaly() == true_anomaly
+        assert coe.get_mean_anomaly() is not None
+        assert coe.get_eccentric_anomaly() is not None
+        assert coe.get_mean_motion(Earth.EGM2008.gravitational_parameter) is not None
+        assert coe.get_orbital_period(Earth.EGM2008.gravitational_parameter) is not None
+        assert coe.get_periapsis_radius() is not None
+        assert coe.get_apoapsis_radius() is not None
+        assert coe.get_semi_latus_rectum() is not None
+        assert coe.get_radial_distance() is not None
+        assert coe.get_angular_momentum(Earth.EGM2008.gravitational_parameter) is not None
+        assert coe.get_SI_vector(COE.AnomalyType.TrueAnomaly) is not None
+        assert coe.get_SI_vector(COE.AnomalyType.MeanAnomaly) is not None
+        assert coe.get_SI_vector(COE.AnomalyType.EccentricAnomaly) is not None
+
+    def test_anomaly_conversions(self):
+        assert (
+            COE.eccentric_anomaly_from_true_anomaly(Angle.degrees(0.0), 0.0) is not None
+        )
+        assert (
+            COE.true_anomaly_from_eccentric_anomaly(Angle.degrees(0.0), 0.0) is not None
+        )
+        assert (
+            COE.mean_anomaly_from_eccentric_anomaly(Angle.degrees(0.0), 0.0) is not None
+        )
+        assert (
+            COE.eccentric_anomaly_from_mean_anomaly(Angle.degrees(0.0), 0.0, 0.0)
+            is not None
+        )
+
+    def test_compute_methods(self):
+        semi_latus_rectum: float = COE.compute_semi_latus_rectum(7000.0e3, 0.0)
+        assert semi_latus_rectum is not None
+        assert (
+            COE.compute_angular_momentum(
+                7000.0e3, 0.0, Earth.EGM2008.gravitational_parameter
+            )
+            is not None
+        )
+        assert (
+            COE.compute_angular_momentum(
+                semi_latus_rectum, Earth.EGM2008.gravitational_parameter
+            )
+            is not None
+        )
+        assert COE.compute_radial_distance(7000.0e3, 0.0, 0.0) is not None
+
+    def test_from_SI_vector(
+        self,
+        coe: COE,
+        semi_major_axis: Length,
+        eccentricity: float,
+        inclination: Angle,
+        raan: Angle,
+        aop: Angle,
+        true_anomaly: Angle,
+    ):
+        assert coe == COE.from_SI_vector(
+            [
+                semi_major_axis.in_meters(),
+                eccentricity,
+                inclination.in_radians(),
+                raan.in_radians(),
+                aop.in_radians(),
+                true_anomaly.in_radians(),
+            ],
+            COE.AnomalyType.TrueAnomaly,
+        )
+
+    def test_string_from_element(self):
+        element_str = COE.string_from_element(COE.Element.SemiMajorAxis)
+        assert element_str == "SemiMajorAxis"

ostk/astrodynamics/test/trajectory/orbit/models/sgp4/__init__.py

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