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

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

@@ -0,0 +1,337 @@
+# Apache License 2.0
+
+import pytest
+
+import tempfile
+
+from ostk.core.filesystem import Path
+from ostk.core.filesystem import File
+
+from ostk.physics.unit import Time
+from ostk.physics.unit import Angle
+from ostk.physics.unit import Derived
+from ostk.physics.time import Instant
+from ostk.physics.time import Scale
+from ostk.physics.time import DateTime
+from ostk.physics.time import Duration
+
+from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
+
+# Only 8 decimal places of numerical precision for fractional portion of day (=864 us)
+TLE_EPOCH_NUMERICAL_PRECISION: Duration = Duration.days(1.0) * 1e-8
+
+
+@pytest.fixture
+def tle() -> TLE:
+    return TLE(
+        satellite_name="Satellite",
+        first_line="1 25544U 98067A   18231.17878740  .00000187  00000-0  10196-4 0  9994",
+        second_line="2 25544  51.6447  64.7824 0005971  73.1467  36.4366 15.53848234128316",
+    )
+
+
+class TestTLE:
+    def test_constructor(self):
+        tle = TLE(
+            first_line="1 25544U 98067A   18231.17878740  .00000187  00000-0  10196-4 0  9994",
+            second_line="2 25544  51.6447  64.7824 0005971  73.1467  36.4366 15.53848234128316",
+        )
+
+        assert isinstance(tle, TLE)
+
+    def test_constructor_with_satellite_name(self):
+        tle = TLE(
+            satellite_name="Satellite",
+            first_line="1 25544U 98067A   18231.17878740  .00000187  00000-0  10196-4 0  9994",
+            second_line="2 25544  51.6447  64.7824 0005971  73.1467  36.4366 15.53848234128316",
+        )
+
+        assert isinstance(tle, TLE)
+
+    def test_comparators(self, tle: TLE):
+        assert (tle == tle) is True
+        assert (tle != tle) is False
+
+    def test_is_defined(self, tle: TLE):
+        assert tle.is_defined()
+
+    def test_get_satellite_name(self, tle: TLE):
+        assert tle.get_satellite_name() == "Satellite"
+
+    def test_get_first_line(self, tle: TLE):
+        assert (
+            tle.get_first_line()
+            == "1 25544U 98067A   18231.17878740  .00000187  00000-0  10196-4 0  9994"
+        )
+
+    def test_get_second_line(self, tle: TLE):
+        assert (
+            tle.get_second_line()
+            == "2 25544  51.6447  64.7824 0005971  73.1467  36.4366 15.53848234128316"
+        )
+
+    def test_get_satellite_number(self, tle: TLE):
+        assert tle.get_satellite_number() == 25544
+
+    def test_get_classification(self, tle: TLE):
+        assert tle.get_classification() == "U"
+
+    def test_get_international_designator(self, tle: TLE):
+        assert tle.get_international_designator() == "98067A"
+
+    def test_get_epoch(self, tle: TLE):
+        assert tle.get_epoch() == Instant.date_time(
+            DateTime(2018, 8, 19, 4, 17, 27, 231, 360, 0), Scale.UTC
+        )
+
+    def test_get_mean_motion_first_time_derivative_divided_by_two(self, tle: TLE):
+        assert (
+            tle.get_mean_motion_first_time_derivative_divided_by_two()
+            == 1.8700000000000001e-06
+        )
+
+    def test_get_mean_motion_second_time_derivative_divided_by_six(self, tle: TLE):
+        assert tle.get_mean_motion_second_time_derivative_divided_by_six() == 0.0
+
+    def test_get_b_star_drag_term(self, tle: TLE):
+        assert tle.get_b_star_drag_term() == 1.0196e-05
+
+    def test_get_ephemeris_type(self, tle: TLE):
+        assert tle.get_ephemeris_type() == 0
+
+    def test_get_element_set_number(self, tle: TLE):
+        assert tle.get_element_set_number() == 999
+
+    def test_get_first_line_checksum(self, tle: TLE):
+        assert tle.get_first_line_checksum() == 4
+
+    def test_get_inclination(self, tle: TLE):
+        assert tle.get_inclination().in_degrees() == 51.6447
+
+    def test_get_raan(self, tle: TLE):
+        assert tle.get_raan().in_degrees() == 64.782399999999996
+
+    def test_get_eccentricity(self, tle: TLE):
+        assert tle.get_eccentricity() == 0.00059710000000000004
+
+    def test_get_aop(self, tle: TLE):
+        assert tle.get_aop().in_degrees() == 73.146699999999996
+
+    def test_get_mean_anomaly(self, tle: TLE):
+        assert tle.get_mean_anomaly().in_degrees() == 36.436599999999999
+
+    def test_get_mean_motion(self, tle: TLE):
+        assert (
+            tle.get_mean_motion().in_unit(
+                Derived.Unit.angular_velocity(Angle.Unit.Revolution, Time.Unit.Day)
+            )
+            == 15.53848234
+        )
+
+    def test_get_revolution_number_at_epoch(self, tle: TLE):
+        assert tle.get_revolution_number_at_epoch() == 12831
+
+    def test_get_second_line_checksum(self, tle: TLE):
+        assert tle.get_second_line_checksum() == 6
+
+    def test_set_satellite_number(self, tle: TLE):
+        tle.set_satellite_number(99959)
+
+        assert tle.get_satellite_number() == 99959
+
+        tle.set_satellite_number(25544)
+
+        assert tle.get_satellite_number() == 25544
+
+    def test_set_epoch(self, tle: TLE):
+        tle.set_epoch(
+            Instant.date_time(DateTime(2019, 9, 20, 5, 18, 28, 232, 361, 0), Scale.UTC)
+        )
+
+        assert tle.get_epoch().is_near(
+            Instant.date_time(DateTime(2019, 9, 20, 5, 18, 28, 232, 361, 0), Scale.UTC),
+            TLE_EPOCH_NUMERICAL_PRECISION,
+        )
+
+        tle.set_epoch(
+            Instant.date_time(DateTime(2018, 8, 19, 4, 17, 27, 231, 360, 0), Scale.UTC)
+        )
+
+        assert tle.get_epoch().is_near(
+            Instant.date_time(DateTime(2018, 8, 19, 4, 17, 27, 231, 360, 0), Scale.UTC),
+            TLE_EPOCH_NUMERICAL_PRECISION,
+        )
+
+    def test_set_revolution_number_at_epoch(self, tle: TLE):
+        tle.set_revolution_number_at_epoch(2345)
+
+        assert tle.get_revolution_number_at_epoch() == 2345
+        assert (
+            tle.get_first_line()
+            == "1 25544U 98067A   18231.17878740  .00000187  00000-0  10196-4 0  9994"
+        )
+        assert (
+            tle.get_second_line()
+            == "2 25544  51.6447  64.7824 0005971  73.1467  36.4366 15.53848234 23455"
+        )
+
+        tle.set_revolution_number_at_epoch(6)
+
+        assert tle.get_revolution_number_at_epoch() == 6
+        assert (
+            tle.get_first_line()
+            == "1 25544U 98067A   18231.17878740  .00000187  00000-0  10196-4 0  9994"
+        )
+        assert (
+            tle.get_second_line()
+            == "2 25544  51.6447  64.7824 0005971  73.1467  36.4366 15.53848234    67"
+        )
+
+        other_tle = TLE(
+            "1 99993U 21990ZZZ 21182.62513889  .00000763  00000-0  42347-4 0 99995",
+            "2 99993 097.5132 311.4037 0016005 231.4378 006.3908 15.13696975009992",
+        )
+
+        assert other_tle.get_revolution_number_at_epoch() == 999
+
+        other_tle.set_revolution_number_at_epoch(999)
+
+        assert other_tle.get_revolution_number_at_epoch() == 999
+        assert (
+            other_tle.get_first_line()
+            == "1 99993U 21990ZZZ 21182.62513889  .00000763  00000-0  42347-4 0 99995"
+        )
+        assert (
+            other_tle.get_second_line()
+            == "2 99993 097.5132 311.4037 0016005 231.4378 006.3908 15.13696975  9992"
+        )
+
+        other_tle.set_revolution_number_at_epoch(9909)
+
+        assert other_tle.get_revolution_number_at_epoch() == 9909
+        assert (
+            other_tle.get_first_line()
+            == "1 99993U 21990ZZZ 21182.62513889  .00000763  00000-0  42347-4 0 99995"
+        )
+        assert (
+            other_tle.get_second_line()
+            == "2 99993 097.5132 311.4037 0016005 231.4378 006.3908 15.13696975 99092"
+        )
+
+        other_tle.set_revolution_number_at_epoch(99)
+
+        assert other_tle.get_revolution_number_at_epoch() == 99
+        assert (
+            other_tle.get_first_line()
+            == "1 99993U 21990ZZZ 21182.62513889  .00000763  00000-0  42347-4 0 99995"
+        )
+        assert (
+            other_tle.get_second_line()
+            == "2 99993 097.5132 311.4037 0016005 231.4378 006.3908 15.13696975   993"
+        )
+
+    def test_can_parse(self, tle: TLE):
+        assert TLE.can_parse(tle.get_first_line(), tle.get_second_line())
+
+    def test_parse(self, tle: TLE):
+        tle_lines: str = "\n".join(
+            [
+                str(tle.get_satellite_name()),
+                str(tle.get_first_line()),
+                str(tle.get_second_line()),
+            ]
+        )
+
+        assert TLE.parse(tle_lines) == tle
+
+    def test_load(self, tle: TLE):
+        tle_lines: str = "\n".join(
+            [
+                str(tle.get_satellite_name()),
+                str(tle.get_first_line()),
+                str(tle.get_second_line()),
+            ]
+        )
+
+        tle_file = tempfile.NamedTemporaryFile(suffix=".tle", delete=False)
+        tle_file.write(tle_lines.encode())
+        tle_file.close()
+
+        try:
+            assert TLE.load(File.path(Path.parse(tle_file.name))) == tle
+
+        finally:
+            File.path(Path.parse(tle_file.name)).remove()
+
+    def test_construct_with_satellite_name(self, tle: TLE):
+        constructed_tle = TLE.construct(
+            satellite_name="Satellite",
+            satellite_number=25544,
+            classification="U",
+            international_designator="98067A",
+            epoch=Instant.date_time(
+                DateTime(2018, 8, 19, 4, 17, 27, 231, 360, 0), Scale.UTC
+            ),
+            mean_motion_first_time_derivative_divided_by_two=1.8700000000000001e-06,
+            mean_motion_second_time_derivative_divided_by_six=0.0,
+            b_star_drag_term=1.0196e-05,
+            ephemeris_type=0,
+            element_set_number=999,
+            inclination=Angle.degrees(51.6447),
+            raan=Angle.degrees(64.782399999999996),
+            eccentricity=0.00059710000000000004,
+            aop=Angle.degrees(73.146699999999996),
+            mean_anomaly=Angle.degrees(36.436599999999999),
+            mean_motion=Derived(
+                15.53848234,
+                Derived.Unit.angular_velocity(Angle.Unit.Revolution, Time.Unit.Day),
+            ),
+            revolution_number_at_epoch=12831,
+        )
+
+        assert constructed_tle == tle
+
+    def test_construct_without_satellite_name(self, tle: TLE):
+        constructed_tle = TLE.construct(
+            satellite_number=25544,
+            classification="U",
+            international_designator="98067A",
+            epoch=Instant.date_time(
+                DateTime(2018, 8, 19, 4, 17, 27, 231, 360, 0), Scale.UTC
+            ),
+            mean_motion_first_time_derivative_divided_by_two=1.8700000000000001e-06,
+            mean_motion_second_time_derivative_divided_by_six=0.0,
+            b_star_drag_term=1.0196e-05,
+            ephemeris_type=0,
+            element_set_number=999,
+            inclination=Angle.degrees(51.6447),
+            raan=Angle.degrees(64.782399999999996),
+            eccentricity=0.00059710000000000004,
+            aop=Angle.degrees(73.146699999999996),
+            mean_anomaly=Angle.degrees(36.436599999999999),
+            mean_motion=Derived(
+                15.53848234,
+                Derived.Unit.angular_velocity(Angle.Unit.Revolution, Time.Unit.Day),
+            ),
+            revolution_number_at_epoch=12831,
+        )
+
+        assert constructed_tle.get_first_line() == tle.get_first_line()
+        assert constructed_tle.get_second_line() == tle.get_second_line()
+
+    def test_generate_checksum(self, tle: TLE):
+        assert (
+            TLE.generate_checksum(tle.get_first_line()) == tle.get_first_line_checksum()
+        )
+        assert (
+            TLE.generate_checksum(tle.get_second_line()) == tle.get_second_line_checksum()
+        )
+
+        assert (
+            TLE.generate_checksum(f"{str(tle.get_first_line())[:-1]}0")
+            == tle.get_first_line_checksum()
+        )
+        assert (
+            TLE.generate_checksum(f"{str(tle.get_second_line())[:-1]}9")
+            == tle.get_second_line_checksum()
+        )

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

@@ -0,0 +1,130 @@
+# Apache License 2.0
+
+import ostk.physics as physics
+
+import ostk.astrodynamics as astrodynamics
+
+Length = physics.unit.Length
+Angle = physics.unit.Angle
+Scale = physics.time.Scale
+Instant = physics.time.Instant
+Interval = physics.time.Interval
+DateTime = physics.time.DateTime
+Position = physics.coordinate.Position
+Velocity = physics.coordinate.Velocity
+Frame = physics.coordinate.Frame
+Environment = physics.Environment
+
+Trajectory = astrodynamics.Trajectory
+Model = astrodynamics.trajectory.Model
+Orbit = astrodynamics.trajectory.Orbit
+Pass = astrodynamics.trajectory.orbit.Pass
+Kepler = astrodynamics.trajectory.orbit.model.Kepler
+COE = astrodynamics.trajectory.orbit.model.kepler.COE
+SGP4 = astrodynamics.trajectory.orbit.model.SGP4
+TLE = astrodynamics.trajectory.orbit.model.sgp4.TLE
+State = astrodynamics.trajectory.State
+Access = astrodynamics.Access
+
+earth = Environment.default().access_celestial_object_with_name("Earth")
+
+
+def construct_kepler():
+    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(a, e, i, raan, aop, nu)
+
+    assert coe is not None
+    assert isinstance(coe, COE)
+
+    epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+    kepler = Kepler(coe, epoch, earth, Kepler.PerturbationType.No)
+
+    return kepler
+
+
+def test_trajectory_orbit_models_kepler_constructors():
+    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(a, e, i, raan, aop, nu)
+
+    assert coe is not None
+    assert isinstance(coe, COE)
+
+    epoch = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+    kepler = Kepler(coe, epoch, earth, Kepler.PerturbationType.No)
+
+    assert kepler is not None
+    assert isinstance(kepler, Kepler)
+    assert kepler.is_defined()
+
+
+def test_trajectory_orbit_models_kepler_comparators():
+    kepler: Kepler = construct_kepler()
+
+    assert kepler == kepler
+    assert (kepler != kepler) is False
+
+
+def test_trajectory_orbit_models_kepler_getters():
+    kepler: Kepler = construct_kepler()
+
+    # get_classical_orbital_elements
+
+    assert kepler.get_classical_orbital_elements() is not None
+
+    # get_epoch
+
+    assert kepler.get_epoch() is not None
+
+    # get_revolution_number_at_epoch()
+
+    assert kepler.get_revolution_number_at_epoch() is not None
+
+    # get_gravitational_parameter()
+
+    assert kepler.get_gravitational_parameter() is not None
+
+    # get_equatorial_radius()
+
+    assert kepler.get_equatorial_radius() is not None
+
+    # get_j2()
+
+    assert kepler.get_j2() is not None
+
+    # get_j4()
+
+    assert kepler.get_j4() is not None
+
+    # get_perturbation_type()
+
+    assert kepler.get_perturbation_type() is not None
+
+
+def test_trajectory_orbit_models_kepler_calculate_state_at_epoch():
+    kepler: Kepler = construct_kepler()
+
+    epoch: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+    assert kepler.calculate_state_at(epoch) is not None
+
+
+def test_trajectory_orbit_models_kepler_calculate_rev_number_at_epoch():
+    kepler: Kepler = construct_kepler()
+
+    epoch: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+    assert kepler.calculate_revolution_number_at(epoch) is not None

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

@@ -0,0 +1,142 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length, Angle, Derived
+from ostk.physics.coordinate import Position, Velocity, Frame
+from ostk.physics.environment.object.celestial import Earth
+
+from ostk.astrodynamics.trajectory.orbit.model import ModifiedEquinoctial
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+
+
+@pytest.fixture
+def earth_gravitational_parameter() -> Derived:
+    return Earth.default().get_gravitational_parameter()
+
+
+@pytest.fixture
+def gcrf() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def meoe_default_values():
+    return {
+        "p": Length.kilometers(7500.0),
+        "f": 0.01,
+        "g": 0.02,
+        "h": 0.03,
+        "k": 0.04,
+        "L": Angle.degrees(45.0),
+    }
+
+
+@pytest.fixture
+def reference_coe() -> COE:
+    sma_ref = Length.kilometers(7000.0)
+    ecc_ref = 0.0  # Circular
+    inc_ref = Angle.degrees(28.5)
+    raan_ref = Angle.degrees(10.0)
+    aop_ref = Angle.degrees(0.0)  # Typically undefined for circular, set to 0 for COE
+    ta_ref = Angle.degrees(45.0)  # Argument of latitude
+
+    return COE(sma_ref, ecc_ref, inc_ref, raan_ref, aop_ref, ta_ref)
+
+
+@pytest.fixture
+def reference_cartesian_state(
+    reference_coe: COE,
+    earth_gravitational_parameter: Derived,
+    gcrf: Frame,
+) -> tuple[Position, Velocity]:
+    return reference_coe.get_cartesian_state(
+        earth_gravitational_parameter,
+        gcrf,
+    )
+
+
+@pytest.fixture
+def modified_equinoctial(meoe_default_values: dict) -> ModifiedEquinoctial:
+    return ModifiedEquinoctial(
+        meoe_default_values["p"],
+        meoe_default_values["f"],
+        meoe_default_values["g"],
+        meoe_default_values["h"],
+        meoe_default_values["k"],
+        meoe_default_values["L"],
+    )
+
+
+class TestModifiedEquinoctial:
+
+    def test_constructor_and_getters(
+        self,
+        modified_equinoctial: ModifiedEquinoctial,
+        meoe_default_values: dict,
+    ):
+        assert modified_equinoctial.is_defined()
+        assert modified_equinoctial.get_semi_latus_rectum() == meoe_default_values["p"]
+        assert modified_equinoctial.get_eccentricity_x() == meoe_default_values["f"]
+        assert modified_equinoctial.get_eccentricity_y() == meoe_default_values["g"]
+        assert modified_equinoctial.get_node_x() == meoe_default_values["h"]
+        assert modified_equinoctial.get_node_y() == meoe_default_values["k"]
+        assert modified_equinoctial.get_true_longitude() == meoe_default_values["L"]
+
+    def test_undefined_state(self):
+        meoe_undefined = ModifiedEquinoctial.undefined()
+        assert not meoe_undefined.is_defined()
+
+    def test_get_si_vector(
+        self,
+        modified_equinoctial: ModifiedEquinoctial,
+    ):
+        si_vector = modified_equinoctial.get_si_vector()
+        assert len(si_vector) == 6
+
+    def test_cartesian(
+        self,
+        reference_cartesian_state: tuple[Position, Velocity],
+        earth_gravitational_parameter: Derived,
+    ):
+        assert (
+            ModifiedEquinoctial.cartesian(
+                reference_cartesian_state,
+                earth_gravitational_parameter,
+            )
+            is not None
+        )
+
+    def test_get_cartesian_state(
+        self,
+        modified_equinoctial: ModifiedEquinoctial,
+        gcrf: Frame,
+        earth_gravitational_parameter: Derived,
+    ):
+        assert (
+            modified_equinoctial.get_cartesian_state(
+                earth_gravitational_parameter,
+                gcrf,
+            )
+            is not None
+        )
+
+    def test_coe_method_general_elliptical(self):
+        sma = Length.kilometers(24396.137)
+        ecc = 0.7308
+        inc = Angle.degrees(7.0)
+        raan = Angle.degrees(0.0)
+        aop = Angle.degrees(90.0)
+        ta = Angle.degrees(0.0)
+
+        coe = COE(sma, ecc, inc, raan, aop, ta)
+
+        assert ModifiedEquinoctial.coe(coe) is not None
+
+    def test_to_coe(
+        self,
+        modified_equinoctial: ModifiedEquinoctial,
+        earth_gravitational_parameter: Derived,
+    ):
+        coe = modified_equinoctial.to_coe(earth_gravitational_parameter)
+        assert coe.is_defined()