open-space-toolkit-astrodynamics 5.1.5__py38-none-any.whl → 5.2.0__py38-none-any.whl

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.units.Length
+Angle = physics.units.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.models.Kepler
+COE = astrodynamics.trajectory.orbit.models.kepler.COE
+SGP4 = astrodynamics.trajectory.orbit.models.SGP4
+TLE = astrodynamics.trajectory.orbit.models.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_propagated.py

@@ -0,0 +1,195 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+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.physics.environment.objects.celestial_bodies import Earth
+
+from ostk.astrodynamics.trajectory.state import NumericalSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory import Propagator
+from ostk.astrodynamics import Dynamics
+from ostk.astrodynamics.dynamics import CentralBodyGravity
+from ostk.astrodynamics.dynamics import PositionDerivative
+from ostk.astrodynamics.trajectory.orbit.models import Propagated
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters([7500000.0, 0.0, 0.0], frame)
+    velocity: Velocity = Velocity.meters_per_second(
+        [0.0, 5335.865450622126, 5335.865450622126], frame
+    )
+
+    instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def central_body_dynamics() -> CentralBodyGravity:
+    return CentralBodyGravity(Earth.WGS84(20, 0))
+
+
+@pytest.fixture
+def position_derivative() -> PositionDerivative:
+    return PositionDerivative()
+
+
+@pytest.fixture
+def dynamics(
+    position_derivative: PositionDerivative, central_body_dynamics: CentralBodyGravity
+) -> list:
+    return [position_derivative, central_body_dynamics]
+
+
+@pytest.fixture
+def numerical_solver() -> NumericalSolver:
+    return NumericalSolver(
+        NumericalSolver.LogType.NoLog,
+        NumericalSolver.StepperType.RungeKuttaFehlberg78,
+        5.0,
+        1.0e-15,
+        1.0e-15,
+    )
+
+
+@pytest.fixture
+def propagator(numerical_solver: NumericalSolver, dynamics: list[Dynamics]) -> Propagator:
+    return Propagator(numerical_solver, dynamics)
+
+
+@pytest.fixture
+def propagated(propagator: Propagator, state: State) -> Propagated:
+    return Propagated(propagator, state)
+
+
+@pytest.fixture
+def earth() -> Earth:
+    return Earth.spherical()
+
+
+@pytest.fixture
+def orbit(propagated: Propagated, earth: Earth) -> Orbit:
+    return Orbit(propagated, earth)
+
+
+class TestPropagated:
+    def test_constructors(
+        self,
+        propagated: Propagated,
+        earth: Earth,
+        dynamics: list,
+        numerical_solver: NumericalSolver,
+        state: State,
+    ):
+        assert propagated is not None
+        assert isinstance(propagated, Propagated)
+        assert propagated.is_defined()
+
+        orbit = Orbit(propagated, earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+        assert orbit.is_defined()
+
+        state_array = [state, state]
+        propagated_with_state_array = Propagated(
+            Propagator(numerical_solver, dynamics), state_array
+        )
+
+        assert propagated_with_state_array is not None
+        assert isinstance(propagated_with_state_array, Propagated)
+        assert propagated_with_state_array.is_defined()
+
+    def test_comparators(self, propagated: Propagated):
+        assert (propagated == propagated) is True
+        assert (propagated != propagated) is False
+
+    def test_getters(self, propagated: Propagated, state: State):
+        assert propagated.get_epoch() == state.get_instant()
+
+        assert propagated.get_revolution_number_at_epoch() == 1
+
+        assert propagated.access_cached_state_array() == [state]
+
+    def test_calculate_state_at(self, propagated: Propagated, orbit: Orbit):
+        instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 10, 0), Scale.UTC)
+
+        propagated_state = propagated.calculate_state_at(instant)
+        propagated_state_orbit = orbit.get_state_at(instant)
+
+        assert propagated_state == propagated_state_orbit
+
+        propagated_state_position_ref = np.array(
+            [6265892.25765909, 3024770.94961259, 3024359.72137468]
+        )
+        propagated_state_velocity_ref = np.array(
+            [-3974.49168221, 4468.16996776, 4466.19232746]
+        )
+
+        propagated_state_position = propagated_state.get_position().get_coordinates()
+        propagated_state_velocity = propagated_state.get_velocity().get_coordinates()
+
+        assert all(
+            [
+                round(propagated_state_position[i], 8)
+                == round(propagated_state_position_ref[i], 8)
+                for i in range(0, len(propagated_state_position_ref))
+            ]
+        )
+        assert all(
+            [
+                round(propagated_state_velocity[i], 8)
+                == round(propagated_state_velocity_ref[i], 8)
+                for i in range(0, len(propagated_state_velocity_ref))
+            ]
+        )
+        assert propagated_state.get_instant() == instant
+
+    def test_calculate_states_at(self, propagated: Propagated, orbit: Orbit):
+        instant_array = [
+            Instant.date_time(DateTime(2018, 1, 1, 0, 10, 0), Scale.UTC),
+            Instant.date_time(DateTime(2018, 1, 1, 0, 20, 0), Scale.UTC),
+        ]
+
+        propagated_state_array = propagated.calculate_states_at(instant_array)
+        propagated_state_array_orbit = orbit.get_states_at(instant_array)
+
+        assert propagated_state_array_orbit == propagated_state_array
+
+        assert propagated_state_array_orbit[0].get_instant() == instant_array[0]
+        assert propagated_state_array_orbit[1].get_instant() == instant_array[1]
+
+    def test_calculate_rev_number_at(self, propagated: Propagated, orbit: Orbit):
+        instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 40, 0), Scale.UTC)
+
+        assert propagated.calculate_revolution_number_at(instant) == 1
+        assert orbit.get_revolution_number_at(instant) == 1
+
+    def test_access_cached_state_array(self, propagated: Propagated, state: State):
+        assert len(propagated.access_cached_state_array()) == 1
+        assert propagated.access_cached_state_array()[0] == state
+
+    def test_access_propagator(self, propagated: Propagated):
+        assert propagated.access_propagator() is not None
+        assert isinstance(propagated.access_propagator(), Propagator)
+
+    def test_set_cached_state_array(self, propagated: Propagated, state: State):
+        assert len(propagated.access_cached_state_array()) == 1
+
+        propagated.set_cached_state_array([state, state, state])
+
+        assert len(propagated.access_cached_state_array()) == 1
+        assert propagated.access_cached_state_array()[0] == state
+
+        with pytest.raises(Exception) as e:
+            propagated.set_cached_state_array([])

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

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

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

@@ -0,0 +1,380 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+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.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+from ostk.physics import Environment
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory.orbit.models import Tabulated
+
+
+@pytest.fixture
+def earth():
+    return Environment.default().access_celestial_object_with_name("Earth")
+
+
+@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]
+
+
+class TestTabulated:
+    @pytest.mark.parametrize(
+        "interpolation_type",
+        (
+            (Tabulated.InterpolationType.Linear),
+            (Tabulated.InterpolationType.CubicSpline),
+            (Tabulated.InterpolationType.BarycentricRational),
+        ),
+    )
+    def test_constructor(
+        self, test_states: list[State], interpolation_type: Tabulated.InterpolationType
+    ):
+        assert (
+            Tabulated(
+                states=test_states,
+                initial_revolution_number=1,
+                interpolation_type=interpolation_type,
+            )
+            is not None
+        )
+
+    def test_constructor_orbit_tabulated_sucess(
+        self,
+        test_states: list[State],
+        earth,
+    ):
+        tabulated = Tabulated(
+            states=test_states,
+            initial_revolution_number=1,
+            interpolation_type=Tabulated.InterpolationType.CubicSpline,
+        )
+
+        orbit: Orbit = Orbit(tabulated, earth)
+
+        assert orbit is not None
+        assert isinstance(orbit, Orbit)
+
+    def test_get_interpolation_type(self, test_states: list[State]):
+        tabulated = Tabulated(
+            states=test_states,
+            initial_revolution_number=1,
+            interpolation_type=Tabulated.InterpolationType.CubicSpline,
+        )
+
+        assert (
+            tabulated.get_interpolation_type() == Tabulated.InterpolationType.CubicSpline
+        )
+
+    @pytest.mark.parametrize(
+        "interpolation_type,error_tolerance",
+        (
+            (Tabulated.InterpolationType.Linear, 420.0),
+            (Tabulated.InterpolationType.CubicSpline, 5e-3),
+            (Tabulated.InterpolationType.BarycentricRational, 5e-2),
+        ),
+    )
+    def test_calculate_state_at_success(
+        self,
+        test_states: list[State],
+        reference_states: list[State],
+        interpolation_type: Tabulated.InterpolationType,
+        error_tolerance: float,
+    ):
+        tabulated = Tabulated(
+            states=test_states,
+            initial_revolution_number=1,
+            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
+            )
+
+    @pytest.mark.parametrize(
+        "interpolation_type,error_tolerance",
+        (
+            (Tabulated.InterpolationType.Linear, 420.0),
+            (Tabulated.InterpolationType.CubicSpline, 5e-3),
+            (Tabulated.InterpolationType.BarycentricRational, 5e-2),
+        ),
+    )
+    def test_calculate_states_at_success(
+        self,
+        test_states: list[State],
+        reference_states: list[State],
+        interpolation_type: Tabulated.InterpolationType,
+        error_tolerance: float,
+    ):
+        tabulated = Tabulated(
+            states=test_states,
+            initial_revolution_number=1,
+            interpolation_type=interpolation_type,
+        )
+
+        states_within_interval: list[State] = [
+            state
+            for state in reference_states
+            if tabulated.get_interval().contains_instant(state.get_instant())
+        ]
+
+        calculated_states: list[State] = tabulated.calculate_states_at(
+            [state.get_instant() for state in states_within_interval]
+        )
+
+        for calculated_state, reference_state in zip(
+            calculated_states, states_within_interval
+        ):
+            assert np.all(
+                np.abs(
+                    calculated_state.get_coordinates() - reference_state.get_coordinates()
+                )
+                < error_tolerance
+            )
+
+    @pytest.mark.parametrize(
+        "interpolation_type",
+        (
+            (Tabulated.InterpolationType.Linear),
+            (Tabulated.InterpolationType.CubicSpline),
+            (Tabulated.InterpolationType.BarycentricRational),
+        ),
+    )
+    def test_calculate_state_at_failure(
+        self, test_states: list[State], interpolation_type: Tabulated.InterpolationType
+    ):
+        tabulated = Tabulated(
+            states=test_states,
+            initial_revolution_number=1,
+            interpolation_type=interpolation_type,
+        )
+
+        with pytest.raises(Exception):
+            tabulated.calculate_state_at(
+                test_states[0].get_instant() - Duration.seconds(1)
+            )
+
+        with pytest.raises(Exception):
+            tabulated.calculate_state_at(
+                test_states[-1].get_instant() + Duration.seconds(1)
+            )

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

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