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

ostk/astrodynamics/test/trajectory/model/test_nadir_trajectory.py

@@ -0,0 +1,87 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.environment.object.celestial import Earth
+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.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.model import Nadir
+from ostk.astrodynamics.trajectory.orbit.model import Kepler
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+
+
+@pytest.fixture
+def orbit() -> Orbit:
+    earth = Earth.WGS84()
+    coe = COE(
+        semi_major_axis=Length.kilometers(7000.0),
+        eccentricity=0.0,
+        inclination=Angle.degrees(98.0),
+        raan=Angle.degrees(0.0),
+        aop=Angle.degrees(0.0),
+        true_anomaly=Angle.degrees(0.0),
+    )
+    keplerian_model = Kepler(
+        coe=coe,
+        epoch=Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+        gravitational_parameter=earth.get_gravitational_parameter(),
+        equatorial_radius=earth.get_equatorial_radius(),
+        j2=earth.get_j2(),
+        j4=earth.get_j4(),
+        perturbation_type=Kepler.PerturbationType.No,
+    )
+    return Orbit(keplerian_model, earth)
+
+
+@pytest.fixture
+def nadir(orbit: Orbit) -> Nadir:
+    return Nadir(orbit)
+
+
+class TestNadir:
+    def test_constructor(
+        self,
+        nadir: Nadir,
+    ):
+        assert nadir.is_defined()
+
+    def test_calculate_state_at(
+        self,
+        nadir: Nadir,
+    ):
+        instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+        state: State = nadir.calculate_state_at(instant)
+
+        assert state is not None
+
+    def test_equality_operator(
+        self,
+        nadir: Nadir,
+    ):
+        assert nadir == nadir
+
+    def test_inequality_operator(
+        self,
+        nadir: Nadir,
+    ):
+        nadir2 = Nadir(Orbit.undefined())
+        assert nadir != nadir2
+
+    def test_get_orbit(
+        self,
+        nadir: Nadir,
+    ):
+        assert nadir.get_orbit() is not None
+
+    def test_get_step_size(
+        self,
+        nadir: Nadir,
+    ):
+        assert nadir.get_step_size() is not None

ostk/astrodynamics/test/trajectory/model/test_tabulated_trajectory.py

@@ -0,0 +1,303 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.curve_fitting import Interpolator
+
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.model import Tabulated
+
+
+@pytest.fixture
+def reference_states() -> list[State]:
+    data = [
+        [
+            "2023-04-18T08:28:32.744064",
+            -3310024.847608758,
+            -6052528.239971979,
+            7626.534641683145,
+            -855.2088930507367,
+            495.9541573743367,
+            7536.520188134902,
+        ],
+        [
+            "2023-04-18T08:28:33.744064",
+            -3310878.047628086,
+            -6052028.610429457,
+            15163.0493833017,
+            -851.1838953959017,
+            503.31279367207185,
+            7536.506322816037,
+        ],
+        [
+            "2023-04-18T08:28:34.744064",
+            -3311727.222133691,
+            -6051521.622540367,
+            22699.545682944226,
+            -847.1578341126227,
+            510.67087060642456,
+            7536.483268627912,
+        ],
+        [
+            "2023-04-18T08:28:35.744064",
+            -3312572.370064364,
+            -6051007.276868478,
+            30236.014351773065,
+            -843.1307141262514,
+            518.0283791399937,
+            7536.451025467619,
+        ],
+        [
+            "2023-04-18T08:28:36.744064",
+            -3313413.490363804,
+            -6050485.573986613,
+            37772.44620082258,
+            -839.1025403636198,
+            525.3853102358,
+            7536.40959324377,
+        ],
+        [
+            "2023-04-18T08:28:37.744064",
+            -3314250.5819806806,
+            -6049956.514476612,
+            45308.83204108345,
+            -835.0733177529921,
+            532.7416548573802,
+            7536.358971876497,
+        ],
+        [
+            "2023-04-18T08:28:38.744064",
+            -3315083.6438685474,
+            -6049420.098929363,
+            52845.16268340493,
+            -831.0430512241197,
+            540.0974039686765,
+            7536.299161297429,
+        ],
+        [
+            "2023-04-18T08:28:39.744064",
+            -3315912.6749859042,
+            -6048876.327944793,
+            60381.42893867038,
+            -827.0117457081434,
+            547.4525485342174,
+            7536.23016144972,
+        ],
+        [
+            "2023-04-18T08:28:40.744064",
+            -3316737.6742961914,
+            -6048325.2021318525,
+            67917.62161760827,
+            -822.9794061376964,
+            554.8070795189376,
+            7536.1519722880375,
+        ],
+        [
+            "2023-04-18T08:28:41.744064",
+            -3317558.640767768,
+            -6047766.722108539,
+            75453.73153099201,
+            -818.9460374467976,
+            562.1609878883643,
+            7536.064593778564,
+        ],
+        [
+            "2023-04-18T08:28:42.744064",
+            -3318375.5733739412,
+            -6047200.888501875,
+            82989.7494894997,
+            -814.9116445709234,
+            569.5142646084902,
+            7535.968025898996,
+        ],
+        [
+            "2023-04-18T08:28:43.744064",
+            -3319188.471092942,
+            -6046627.7019479135,
+            90525.66630384693,
+            -810.8762324469382,
+            576.866900645898,
+            7535.862268638544,
+        ],
+        [
+            "2023-04-18T08:28:44.744064",
+            -3319997.332907958,
+            -6046047.163091751,
+            98061.47278470133,
+            -806.8398060131411,
+            584.2188869676824,
+            7535.747321997941,
+        ],
+        [
+            "2023-04-18T08:28:45.744064",
+            -3320802.157807084,
+            -6045459.272587514,
+            105597.15974279115,
+            -802.8023702092072,
+            591.5702145415504,
+            7535.62318598943,
+        ],
+        [
+            "2023-04-18T08:28:46.744064",
+            -3321602.9447833803,
+            -6044864.0310983565,
+            113132.71798877101,
+            -798.7639299762548,
+            598.9208743356983,
+            7535.48986063679,
+        ],
+        [
+            "2023-04-18T08:28:47.744064",
+            -3322399.692834845,
+            -6044261.439296465,
+            120668.13833342775,
+            -794.7244902567405,
+            606.2708573190106,
+            7535.347345975296,
+        ],
+        [
+            "2023-04-18T08:28:48.744064",
+            -3323192.400964402,
+            -6043651.497863061,
+            128203.41158748553,
+            -790.6840559945587,
+            613.6201544608678,
+            7535.195642051765,
+        ],
+        [
+            "2023-04-18T08:28:49.744064",
+            -3323981.068179951,
+            -6043034.207488383,
+            135738.52856182377,
+            -786.6426321349277,
+            620.9687567313651,
+            7535.034748924513,
+        ],
+        [
+            "2023-04-18T08:28:50.744064",
+            -3324765.6934943097,
+            -6042409.568871722,
+            143273.48006733102,
+            -782.6002236244674,
+            628.3166551011666,
+            7534.864666663388,
+        ],
+        [
+            "2023-04-18T08:28:51.744064",
+            -3325546.2759252544,
+            -6041777.582721372,
+            150808.25691495842,
+            -778.5568354111685,
+            635.6638405415614,
+            7534.68539534976,
+        ],
+    ]
+    return [
+        State(
+            instant=Instant.date_time(DateTime.parse(row[0]), Scale.UTC),
+            position=Position.meters(
+                [float(row[1]), float(row[2]), float(row[3])], Frame.GCRF()
+            ),
+            velocity=Velocity.meters_per_second(
+                [float(row[4]), float(row[5]), float(row[6])], Frame.GCRF()
+            ),
+        )
+        for row in data
+    ]
+
+
+@pytest.fixture
+def test_states(reference_states: list[State]) -> list[State]:
+    return reference_states[::4]
+
+
+@pytest.fixture
+def interpolation_type() -> Interpolator.Type:
+    return Interpolator.Type.CubicSpline
+
+
+@pytest.fixture
+def tabulated(
+    test_states: list[State],
+    interpolation_type: Interpolator.Type,
+) -> Tabulated:
+    return Tabulated(
+        states=test_states,
+        interpolation_type=interpolation_type,
+    )
+
+
+class TestTabulatedTrajectory:
+    @pytest.mark.parametrize(
+        "interpolation_type",
+        (
+            (Interpolator.Type.Linear),
+            (Interpolator.Type.CubicSpline),
+            (Interpolator.Type.BarycentricRational),
+        ),
+    )
+    def test_constructor(
+        self,
+        test_states: list[State],
+        interpolation_type: Interpolator.Type,
+    ):
+        assert (
+            Tabulated(
+                states=test_states,
+                interpolation_type=interpolation_type,
+            )
+            is not None
+        )
+
+    def test_get_interpolation_type(
+        self,
+        test_states: list[State],
+        tabulated: Tabulated,
+        interpolation_type: Interpolator.Type,
+    ):
+        assert tabulated.get_interpolation_type() == Interpolator.Type.CubicSpline
+
+    @pytest.mark.parametrize(
+        "interpolation_type,error_tolerance",
+        (
+            (Interpolator.Type.Linear, 420.0),
+            (Interpolator.Type.CubicSpline, 5e-3),
+            (Interpolator.Type.BarycentricRational, 5e-2),
+        ),
+    )
+    def test_calculate_state_at(
+        self,
+        test_states: list[State],
+        reference_states: list[State],
+        interpolation_type: Interpolator.Type,
+        error_tolerance: float,
+    ):
+        tabulated: Tabulated = Tabulated(
+            states=test_states,
+            interpolation_type=interpolation_type,
+        )
+
+        for reference_state in reference_states:
+            if not tabulated.get_interval().contains_instant(
+                reference_state.get_instant()
+            ):
+                continue
+
+            calculated_state: State = tabulated.calculate_state_at(
+                reference_state.get_instant()
+            )
+            assert np.all(
+                np.abs(
+                    calculated_state.get_coordinates() - reference_state.get_coordinates()
+                )
+                < error_tolerance
+            )

ostk/astrodynamics/test/trajectory/model/test_target_scan_trajectory.py

@@ -0,0 +1,126 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.environment.object.celestial import Earth
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.time import Duration
+from ostk.physics.unit import Derived
+from ostk.astrodynamics.trajectory.model import TargetScan
+from ostk.astrodynamics.trajectory import State
+
+
+@pytest.fixture
+def earth() -> Earth:
+    return Earth.WGS84()
+
+
+@pytest.fixture
+def start_lla() -> LLA:
+    return LLA.vector([0.0, 0.0, 0.0])
+
+
+@pytest.fixture
+def end_lla() -> LLA:
+    return LLA.vector([0.0, 1.0, 0.0])
+
+
+@pytest.fixture
+def start_instant() -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def end_instant() -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 1, 0, 10, 0), Scale.UTC)
+
+
+@pytest.fixture
+def target_scan(
+    earth: Earth,
+    start_lla: LLA,
+    end_lla: LLA,
+    start_instant: Instant,
+    end_instant: Instant,
+) -> TargetScan:
+    return TargetScan(
+        start_lla=start_lla,
+        end_lla=end_lla,
+        start_instant=start_instant,
+        end_instant=end_instant,
+        celestial=earth,
+    )
+
+
+class TestTargetScan:
+    def test_constructor(
+        self,
+        target_scan: TargetScan,
+    ):
+        assert target_scan.is_defined()
+
+    def test_calculate_state_at(
+        self,
+        target_scan: TargetScan,
+    ):
+        instant: Instant = Instant.date_time(DateTime(2023, 1, 1, 0, 5, 0), Scale.UTC)
+        state: State = target_scan.calculate_state_at(instant)
+        assert state is not None
+
+    def test_equality_operator(
+        self,
+        target_scan: TargetScan,
+    ):
+        assert target_scan == target_scan
+
+    def test_inequality_operator(
+        self,
+        target_scan: TargetScan,
+        start_lla: LLA,
+        end_lla: LLA,
+        start_instant: Instant,
+        earth: Earth,
+    ):
+        target_scan2 = TargetScan(
+            start_lla=start_lla,
+            end_lla=end_lla,
+            start_instant=start_instant,
+            end_instant=Instant.undefined(),
+            celestial=earth,
+        )
+        assert target_scan != target_scan2
+
+    def test_getters(
+        self,
+        target_scan: TargetScan,
+    ):
+        assert target_scan.get_start_lla() is not None
+        assert target_scan.get_end_lla() is not None
+        assert target_scan.get_start_instant() is not None
+        assert target_scan.get_end_instant() is not None
+        assert target_scan.get_celestial() is not None
+        assert target_scan.get_step_size() is not None
+
+    def test_from_ground_speed(
+        self,
+        start_lla: LLA,
+        end_lla: LLA,
+        start_instant: Instant,
+        earth: Earth,
+    ):
+        ground_speed: Derived = Derived(100.0, Derived.Unit.meter_per_second())
+        step_size: Duration = Duration.seconds(1.0)
+
+        target_scan = TargetScan.from_ground_speed(
+            start_lla=start_lla,
+            end_lla=end_lla,
+            ground_speed=ground_speed,
+            start_instant=start_instant,
+            celestial=earth,
+            step_size=step_size,
+        )
+
+        assert target_scan.is_defined()

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