open-space-toolkit-astrodynamics 13.1.0__py313-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/trajectory/orbit/message/spacex/data/opm_1.yaml

@@ -0,0 +1,44 @@
+# Dummy SpaceX OPM output
+
+# Notes:
+# - ECEF velocity is Earth relative
+# - Apogee/Perigee altitude assumes a spherical Earth, 6378.137 km radius
+# - Orbital elements are computed in an inertial frame realized by inertially
+#   freezing the WGS84 ECEF frame at time of current state
+# - State is post-deployment, so includes separation delta-velocity
+
+
+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
+
+- name: satellite_b
+  sequence_number: 2
+  mission_time_s: 7200.0
+  date: 2020-01-02T14:34:56.789Z
+  r_ecef_m: [699863.059, 6875647.517, -123777.595]
+  v_ecef_m_per_s: [1504.658, 6.705, 7538.669]
+  mean_perigee_altitude_km: 536.779
+  mean_apogee_altitude_km: 529.851
+  mean_inclination_deg: 97.124
+  mean_argument_of_perigee_deg: 136.875
+  mean_longitude_ascending_node_deg: 85.032
+  mean_mean_anomaly_deg: -127.164
+  ballistic_coef_kg_per_m2: 44.26

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,201 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import Instant
+from ostk.physics.environment.gravitational import Earth
+from ostk.physics.environment.object.celestial import Sun
+from ostk.physics import Environment
+
+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
+
+        coe: COE = COE.frozen_orbit(
+            a,
+            Earth.EGM2008.equatorial_radius,
+            Earth.EGM2008.J2,
+            Earth.EGM2008.J3,
+            inclination=i,
+        )
+
+        assert coe is not None
+        assert isinstance(coe, COE)
+        assert coe.is_defined()
+
+        coe: COE = COE.frozen_orbit(
+            a, Environment.default().access_celestial_object_with_name("Earth")
+        )
+
+        assert coe is not None
+        assert isinstance(coe, COE)
+        assert coe.is_defined()
+
+    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
+
+        assert COE.compute_ltan(Angle.degrees(270.0), Instant.J2000()) is not None
+        assert (
+            COE.compute_ltan(Angle.degrees(270.0), Instant.J2000(), Sun.default())
+            is not None
+        )
+        assert COE.compute_mean_ltan(Angle.degrees(270.0), Instant.J2000()) is not None
+        assert (
+            COE.compute_mean_ltan(Angle.degrees(270.0), Instant.J2000(), Sun.default())
+            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