open-space-toolkit-astrodynamics 9.4.1__py38-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/test_utilities.py

@@ -0,0 +1,121 @@
+# Apache License 2.0
+
+import pytest
+
+import ostk.physics as physics
+import ostk.astrodynamics as astrodynamics
+from ostk.astrodynamics import utilities
+
+Length = physics.unit.Length
+Angle = physics.unit.Angle
+DateTime = physics.time.DateTime
+Scale = physics.time.Scale
+Instant = physics.time.Instant
+Interval = physics.time.Interval
+Position = physics.coordinate.Position
+Velocity = physics.coordinate.Velocity
+Frame = physics.coordinate.Frame
+LLA = physics.coordinate.spherical.LLA
+AER = physics.coordinate.spherical.AER
+Environment = physics.Environment
+Trajectory = astrodynamics.Trajectory
+State = astrodynamics.trajectory.State
+
+
+class TestUtility:
+    def test_lla_from_state(
+        self,
+        state: State,
+    ):
+        lla: tuple[float, float, float] = utilities.lla_from_state(state)
+
+        assert lla is not None
+        assert len(lla) == 3
+        assert isinstance(lla, tuple)
+        assert isinstance(lla[0], float)
+        assert lla[0] >= -90.0 and lla[0] <= 90.0
+        assert isinstance(lla[1], float)
+        assert lla[0] >= -180.0 and lla[0] <= 180.0
+        assert isinstance(lla[2], float)
+
+    def test_lla_from_position(
+        self,
+        instant: Instant,
+        position: Position,
+        state: State,
+    ):
+        lla: LLA = utilities.lla_from_position(position, instant)
+
+        assert lla is not None
+        assert isinstance(lla, LLA)
+        assert lla.is_defined()
+
+        lla_from_state: tuple[float, float, float] = utilities.lla_from_state(state)
+
+        assert lla.get_latitude().in_degrees() == lla_from_state[0]
+        assert lla.get_longitude().in_degrees() == lla_from_state[1]
+        assert lla.get_altitude().in_meters() == lla_from_state[2]
+
+    def test_position_from_lla(
+        self,
+        lla: LLA,
+    ):
+        position: Position = utilities.position_from_lla(lla)
+
+        assert position is not None
+        assert isinstance(position, Position)
+        assert position.is_defined()
+
+    def test_compute_aer(
+        self,
+        instant: Instant,
+        position: Position,
+        environment: Environment,
+    ):
+        aer: tuple[float, float, float] = utilities.compute_aer(
+            instant, position, position, environment
+        )
+
+        assert aer is not None
+        assert len(aer) == 3
+        assert aer[2] == 0.0
+
+    def test_compute_time_lla_aer_state(
+        self,
+        state: State,
+        position: Position,
+        environment: Environment,
+    ):
+        time_lla_aer: float[Instant, float, float, float, float, float, float] = (
+            utilities.compute_time_lla_aer_state(state, position, environment)
+        )
+
+        assert time_lla_aer is not None
+        assert len(time_lla_aer) == 7
+        assert isinstance(time_lla_aer[0], Instant)
+        assert time_lla_aer[0] == state.get_instant()
+        for i in range(1, 7):
+            assert isinstance(time_lla_aer[i], float)
+
+    def test_compute_trajectory_geometry(
+        self,
+        interval: Interval,
+        trajectory: Trajectory,
+    ):
+        output: list[tuple[float, float, float]] = utilities.compute_trajectory_geometry(
+            trajectory, interval
+        )
+
+        assert output is not None
+        assert len(output) == 2
+
+    def test_convert_state(self, state: State):
+        output: tuple[
+            str, float, float, float, float, float, float, float, float, float
+        ] = utilities.convert_state(state)
+
+        assert output is not None
+        assert len(output) == 11
+        assert isinstance(output[0], str)
+        for i in range(1, 11):
+            assert isinstance(output[i], float)

ostk/astrodynamics/test/test_viewer.py

@@ -0,0 +1,129 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics import Environment
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import Instant
+from ostk.physics.time import Interval
+from ostk.physics.time import Duration
+from ostk.physics.time import DateTime
+from ostk.physics.time import Time
+from ostk.physics.time import Scale
+from ostk.physics.unit import Length
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.flight import Profile
+from ostk.astrodynamics.viewer import Viewer
+from ostk.astrodynamics.viewer import ConicSensor
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def orbit(environment: Environment) -> Orbit:
+    return Orbit.sun_synchronous(
+        epoch=Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+        altitude=Length.kilometers(500.0),
+        local_time_at_descending_node=Time(14, 0, 0),
+        celestial_object=environment.access_celestial_object_with_name("Earth"),
+    )
+
+
+@pytest.fixture
+def profile(orbit: Orbit) -> Profile:
+    return Profile.nadir_pointing(
+        orbit=orbit,
+        orbital_frame_type=Orbit.FrameType.VVLH,
+    )
+
+
+@pytest.fixture
+def interval() -> Interval:
+    return Interval.closed(
+        start_instant=Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+        end_instant=Instant.date_time(DateTime(2020, 1, 1, 0, 10, 0), Scale.UTC),
+    )
+
+
+@pytest.fixture
+def viewer(interval: Interval) -> Viewer:
+    return Viewer(
+        interval=interval,
+    )
+
+
+class TestViewer:
+    def test_constructor_success(self, interval: Interval):
+        viewer = Viewer(
+            interval=interval,
+        )
+
+        assert viewer is not None
+        assert viewer.interval == interval
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert rendered_html.endswith("</script>")
+
+    def test_add_profile_success(
+        self,
+        viewer: Viewer,
+        profile: Profile,
+    ):
+        viewer.add_profile(
+            profile=profile,
+            step=Duration.seconds(30.0),
+            show_orbital_track=True,
+            cesium_asset_id=123,
+            sensors=[
+                ConicSensor(
+                    name="star_tracker",
+                    direction=(1.0, 0.0, 0.0),
+                    half_angle=Angle.degrees(8.0),
+                    length=Length.meters(0.1),
+                    color="red",
+                ),
+            ],
+            show_xyz_axes=True,
+        )
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert " widget.entities.add({position: widget" in rendered_html
+        assert "Cesium.IonResource.fromAssetId(123)" in rendered_html
+        assert "widget.entities.add({polyline:" in rendered_html
+        assert (
+            "widget.entities.add({position: widget.star_tracker_position" in rendered_html
+        )
+        assert rendered_html.endswith("</script>")
+
+    def test_add_target_success(
+        self,
+        viewer: Viewer,
+    ):
+        viewer.add_target(
+            position=Position.meters([1.0, 2.0, 3.0], Frame.ITRF()),
+            size=123,
+            color="red",
+        )
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert (
+            "widget.entities.add({position: Cesium.Cartesian3.fromDegrees(63.43494882292201, 18.22447811510915, -6376045.535225509), point: {pixelSize: 123.0, color: Cesium.Color.RED}});"
+            in rendered_html
+        )
+        assert rendered_html.endswith("</script>")

ostk/astrodynamics/test/trajectory/__init__.py

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

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+# Apache License 2.0
+
+import pytest
+
+import pathlib
+
+from ostk.core.filesystem import Path
+from ostk.core.filesystem import File
+
+
+@pytest.fixture
+def data_directory_path() -> str:
+    return f"{pathlib.Path(__file__).parent.absolute()}/data"
+
+
+@pytest.fixture
+def opm_file(data_directory_path: str) -> File:
+    return File.path(Path.parse(f"{data_directory_path}/opm_1.yaml"))

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