open-space-toolkit-astrodynamics 17.2.0__py312-none-manylinux2014_x86_64.whl

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,305 @@
+# 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.time import Time
+from ostk.physics.environment.gravitational import Earth
+from ostk.physics.environment.object.celestial import Sun
+from ostk.physics.environment.object import Celestial
+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)
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def earth(environment: Environment) -> Celestial:
+    return environment.access_celestial_object_with_name("Earth")
+
+
+class TestCOE:
+    def test_constructors(
+        self,
+        semi_major_axis: Length,
+        eccentricity: float,
+        inclination: Angle,
+        raan: Angle,
+        aop: Angle,
+        true_anomaly: Angle,
+    ):
+        coe: COE = COE(
+            semi_major_axis,
+            eccentricity,
+            inclination,
+            raan,
+            aop,
+            true_anomaly,
+        )
+
+        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_argument_of_latitude() == aop + 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, earth: Celestial):
+        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
+        )
+        assert COE.compute_ltdn(Angle.degrees(270.0), Instant.J2000()) is not None
+        assert (
+            COE.compute_ltdn(Angle.degrees(270.0), Instant.J2000(), Sun.default())
+            is not None
+        )
+        assert COE.compute_mean_ltdn(Angle.degrees(270.0), Instant.J2000()) is not None
+        assert (
+            COE.compute_mean_ltdn(Angle.degrees(270.0), Instant.J2000(), Sun.default())
+            is not None
+        )
+        assert (
+            COE.compute_sun_synchronous_inclination(Length.meters(7130982.0), 0.0, earth)
+            is not None
+        )
+        assert (
+            COE.compute_raan_from_ltan(Time.parse("12:00:00"), Instant.J2000(), earth)
+            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"
+
+    def test_sun_synchronous(self, earth: Celestial):
+        semi_major_axis: Length = Length.meters(7130982.0)
+        local_time_at_ascending_node: Time = Time.parse("12:00:00")
+        epoch: Instant = Instant.J2000()
+        eccentricity: float = 0.0
+        argument_of_latitude: Angle = Angle.degrees(30.0)
+
+        assert (
+            COE.sun_synchronous(
+                semi_major_axis,
+                local_time_at_ascending_node,
+                epoch,
+                earth,
+                eccentricity,
+                argument_of_latitude,
+            )
+            is not None
+        )
+        assert (
+            COE.sun_synchronous(
+                semi_major_axis, local_time_at_ascending_node, epoch, earth, eccentricity
+            )
+            is not None
+        )
+        assert (
+            COE.sun_synchronous(
+                semi_major_axis, local_time_at_ascending_node, epoch, earth
+            )
+            is not None
+        )
+
+    def test_geo_synchronous(self, earth: Celestial):
+        epoch: Instant = Instant.J2000()
+        inclination: Angle = Angle.degrees(0.01)
+        longitude: Angle = Angle.degrees(0.0)
+
+        assert COE.geo_synchronous(epoch, inclination, longitude, earth) is not None
+
+    def test_circular(self):
+        semi_major_axis: Length = Length.kilometers(7000.0)
+        inclination: Angle = Angle.degrees(45.0)
+        argument_of_latitude: Angle = Angle.degrees(30.0)
+
+        assert (
+            COE.circular(semi_major_axis, inclination, argument_of_latitude) is not None
+        )
+        assert COE.circular(semi_major_axis, inclination) is not None
+        assert COE.circular(semi_major_axis) is not None
+
+    def test_equatorial(self):
+        semi_major_axis: Length = Length.kilometers(7000.0)
+        eccentricity: float = 0.1
+        true_anomaly: Angle = Angle.degrees(45.0)
+
+        assert COE.equatorial(semi_major_axis, eccentricity, true_anomaly) is not None
+        assert COE.equatorial(semi_major_axis, eccentricity) is not None
+        assert COE.equatorial(semi_major_axis) is not None
+
+    def test_undefined(self):
+        coe: COE = COE.undefined()
+
+        assert coe is not None
+        assert isinstance(coe, COE)
+        assert coe.is_defined() is False
+
+    def test_frozen_orbit(
+        self,
+        semi_major_axis: Length,
+        inclination: Angle,
+    ):
+        coe: COE = COE.frozen_orbit(
+            semi_major_axis,
+            Earth.EGM2008.equatorial_radius,
+            Earth.EGM2008.J2,
+            Earth.EGM2008.J3,
+            inclination=inclination,
+        )
+
+        assert coe is not None
+        assert isinstance(coe, COE)
+        assert coe.is_defined()
+
+        coe: COE = COE.frozen_orbit(
+            semi_major_axis,
+            Environment.default().access_celestial_object_with_name("Earth"),
+        )
+
+        assert coe is not None
+        assert isinstance(coe, COE)
+        assert coe.is_defined()

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

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