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

ostk/astrodynamics/test/test_converters.py

@@ -0,0 +1,387 @@
+# Apache License 2.0
+
+import pytest
+
+from datetime import datetime, timedelta, timezone
+
+import numpy as np
+
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+
+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 Scale
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.converters import coerce_to_datetime
+from ostk.astrodynamics.converters import coerce_to_instant
+from ostk.astrodynamics.converters import coerce_to_iso
+from ostk.astrodynamics.converters import coerce_to_interval
+from ostk.astrodynamics.converters import coerce_to_duration
+from ostk.astrodynamics.converters import coerce_to_position
+from ostk.astrodynamics.converters import coerce_to_velocity
+from ostk.astrodynamics.converters import coerce_to_quaternion
+
+
+def test_coerce_to_datetime_success_instant():
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC)
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc
+    )
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.TAI)
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 3, 28, 123456, tzinfo=timezone.utc
+    )
+
+
+def test_coerce_to_datetime_success_datetime():
+    value = datetime(2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)
+    assert coerce_to_datetime(value) == value
+
+    value = datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone(timedelta(seconds=3600))
+    )
+    assert coerce_to_datetime(value) == value
+
+
+def test_coerce_to_datetime_success_iso():
+    value = "2020-01-02T03:04:05.123456+00:00"
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc
+    )
+
+    value = "2020-01-02T03:04:05+00:00"
+    assert coerce_to_datetime(value) == datetime(2020, 1, 2, 3, 4, 5, tzinfo=timezone.utc)
+
+    value = "2020-01-02T03:04:05.123456+01:00"
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone(timedelta(seconds=3600))
+    )
+
+    value = "2020-01-02T03:04:05.123456Z"
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc
+    )
+
+    value = "2020-01-02T03:04:05Z"
+    assert coerce_to_datetime(value) == datetime(2020, 1, 2, 3, 4, 5, tzinfo=timezone.utc)
+
+
+def test_coerce_to_datetime_failure():
+    with pytest.raises(TypeError):
+        coerce_to_datetime(False)
+
+    with pytest.raises(Exception):
+        coerce_to_datetime("some_ill_formed_iso")
+
+
+def test_coerce_to_instant_success_datetime():
+    value = datetime(2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC
+    )
+
+    value = datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone(timedelta(seconds=3600))
+    )
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 2, 4, 5, 123, 456), Scale.UTC
+    )
+
+
+def test_coerce_to_instant_success_instant():
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC)
+    assert coerce_to_instant(value) == value
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.TAI)
+    assert coerce_to_instant(value) == value
+
+
+def test_coerce_to_instant_success_iso():
+    value = "2020-01-02T03:04:05.123456+00:00"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC
+    )
+
+    value = "2020-01-02T03:04:05+00:00"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 3, 4, 5), Scale.UTC
+    )
+
+    value = "2020-01-02T03:04:05.123456+01:00"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 2, 4, 5, 123, 456), Scale.UTC
+    )
+
+    value = "2020-01-02T03:04:05.123456Z"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC
+    )
+
+    value = "2020-01-02T03:04:05Z"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(
+            2020,
+            1,
+            2,
+            3,
+            4,
+            5,
+        ),
+        Scale.UTC,
+    )
+
+
+def test_coerce_to_instant_failure():
+    with pytest.raises(TypeError):
+        coerce_to_instant(False)
+
+    with pytest.raises(Exception):
+        coerce_to_instant("some_ill_formed_iso")
+
+
+def test_coerce_to_iso_success_datetime():
+    value = datetime(2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123456+00:00"
+    )
+
+    value = datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone(timedelta(seconds=3600))
+    )
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123456+01:00"
+    )
+
+    value = datetime(2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)
+    assert (
+        coerce_to_iso(value, timespec="milliseconds") == "2020-01-02T03:04:05.123+00:00"
+    )
+
+    value = datetime(2020, 1, 2, 3, 4, 5, 0, tzinfo=timezone.utc)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.000000+00:00"
+    )
+
+
+def test_coerce_to_iso_success_instant():
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123456+00:00"
+    )
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.TAI)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:03:28.123456+00:00"
+    )
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC)
+    assert (
+        coerce_to_iso(value, timespec="milliseconds") == "2020-01-02T03:04:05.123+00:00"
+    )
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123), Scale.UTC)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123000+00:00"
+    )
+
+
+def test_coerce_to_iso_success_iso():
+    value = "2020-01-02T03:04:05.123456+00:00"
+    assert coerce_to_iso(value, timespec="microseconds") == value
+
+    value = "2020-01-02T03:04:05.123456+01:00"
+    assert coerce_to_iso(value, timespec="microseconds") == value
+
+    value = "2020-01-02T03:04:05.123456+00:00"
+    assert (
+        coerce_to_iso(value, timespec="milliseconds") == "2020-01-02T03:04:05.123+00:00"
+    )
+
+    value = "2020-01-02T03:04:05.123+00:00"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123000+00:00"
+    )
+
+    value = "2020-01-02T03:04:05+00:00"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.000000+00:00"
+    )
+
+    value = "2020-01-02T03:04:05.123456Z"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123456+00:00"
+    )
+
+    value = "2020-01-02T03:04:05.123456Z"
+    assert (
+        coerce_to_iso(value, timespec="milliseconds") == "2020-01-02T03:04:05.123+00:00"
+    )
+
+    value = "2020-01-02T03:04:05.123Z"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123000+00:00"
+    )
+
+    value = "2020-01-02T03:04:05Z"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.000000+00:00"
+    )
+
+
+def test_coerce_to_iso_failure():
+    with pytest.raises(TypeError):
+        coerce_to_iso(False)
+
+    with pytest.raises(Exception):
+        coerce_to_iso("some_ill_formed_iso")
+
+
+def test_coerce_to_interval_success_interval():
+    value = Interval.closed(
+        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+    )
+    assert coerce_to_interval(value) == value
+
+
+def test_coerce_to_interval_success_tuple_instant():
+    value = (
+        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+    )
+    assert coerce_to_interval(value) == Interval.closed(
+        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+    )
+
+
+def test_coerce_to_interval_success_list_instant():
+    value = [
+        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+    ]
+    assert coerce_to_interval(value) == Interval.closed(
+        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+    )
+
+
+def test_coerce_to_interval_success_tuple_datetime():
+    value = (
+        datetime(2020, 1, 1, tzinfo=timezone.utc),
+        datetime(2020, 1, 2, tzinfo=timezone.utc),
+    )
+    assert coerce_to_interval(value) == Interval.closed(
+        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+    )
+
+
+def test_coerce_to_interval_success_list_datetime():
+    value = [
+        datetime(2020, 1, 1, tzinfo=timezone.utc),
+        datetime(2020, 1, 2, tzinfo=timezone.utc),
+    ]
+    assert coerce_to_interval(value) == Interval.closed(
+        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+    )
+
+
+def test_coerce_to_duration_success_duration():
+    value = Duration.seconds(1.0)
+    assert coerce_to_duration(value) == value
+
+
+def test_coerce_to_duration_success_timedelta():
+    value = timedelta(seconds=1.0)
+    assert coerce_to_duration(value) == Duration.seconds(1.0)
+
+
+def test_coerce_to_position_success_position():
+    value = Position.meters((1.0, 2.0, 3.0), Frame.GCRF())
+    assert coerce_to_position(value, Frame.GCRF()) == value
+
+
+def test_coerce_to_position_success_tuple_float():
+    value = (1.0, 2.0, 3.0)
+    assert coerce_to_position(value, Frame.GCRF()) == Position.meters(
+        (1.0, 2.0, 3.0), Frame.GCRF()
+    )
+
+
+def test_coerce_to_position_success_list_float():
+    value = [1.0, 2.0, 3.0]
+    assert coerce_to_position(value, Frame.GCRF()) == Position.meters(
+        (1.0, 2.0, 3.0), Frame.GCRF()
+    )
+
+
+def test_coerce_to_position_success_np_array():
+    value = np.array((1.0, 2.0, 3.0))
+    assert coerce_to_position(value, Frame.GCRF()) == Position.meters(
+        (1.0, 2.0, 3.0), Frame.GCRF()
+    )
+
+
+def test_coerce_to_velocity_success_velocity():
+    value = Velocity.meters_per_second((1.0, 2.0, 3.0), Frame.GCRF())
+    assert coerce_to_velocity(value, Frame.GCRF()) == value
+
+
+def test_coerce_to_velocity_success_tuple_float():
+    value = (1.0, 2.0, 3.0)
+    assert coerce_to_velocity(value, Frame.GCRF()) == Velocity.meters_per_second(
+        (1.0, 2.0, 3.0), Frame.GCRF()
+    )
+
+
+def test_coerce_to_velocity_success_list_float():
+    value = [1.0, 2.0, 3.0]
+    assert coerce_to_velocity(value, Frame.GCRF()) == Velocity.meters_per_second(
+        (1.0, 2.0, 3.0), Frame.GCRF()
+    )
+
+
+def test_coerce_to_velocity_success_np_array():
+    value = np.array((1.0, 2.0, 3.0))
+    assert coerce_to_velocity(value, Frame.GCRF()) == Velocity.meters_per_second(
+        (1.0, 2.0, 3.0), Frame.GCRF()
+    )
+
+
+def test_coerce_to_quaternion_success_quaternion():
+    value = Quaternion.xyzs(1.0, 2.0, 3.0, 4.0)
+    assert coerce_to_quaternion(value) == value
+
+
+def test_coerce_to_quaternion_success_list_float():
+    value = [1.0, 2.0, 3.0, 4.0]
+    assert coerce_to_quaternion(value) == Quaternion.xyzs(1.0, 2.0, 3.0, 4.0)
+
+
+def test_coerce_to_quaternion_success_np_array():
+    value = np.array((1.0, 2.0, 3.0, 4.0))
+    assert coerce_to_quaternion(value) == Quaternion.xyzs(1.0, 2.0, 3.0, 4.0)
+
+
+def test_coerce_to_quaternion_success_tuple_float():
+    value = (1.0, 2.0, 3.0, 4.0)
+    assert coerce_to_quaternion(value) == Quaternion.xyzs(1.0, 2.0, 3.0, 4.0)

ostk/astrodynamics/test/test_display.py

@@ -0,0 +1,115 @@
+# Apache License 2.0
+
+from ostk.mathematics.object import RealInterval
+
+from ostk.physics import Environment
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.environment.object import Celestial
+from ostk.physics.time import DateTime
+from ostk.physics.time import Duration
+from ostk.physics.time import Instant
+from ostk.physics.time import Interval
+from ostk.physics.time import Scale
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics import display
+from ostk.astrodynamics.access import Generator as AccessGenerator
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.orbit.model import SGP4
+from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
+
+
+class TestDisplay:
+    def test_accesses_plot(self, state: State):
+        start_instant: Instant = Instant.date_time(
+            DateTime(2023, 1, 3, 0, 0, 0),
+            Scale.UTC,
+        )
+        duration: Duration = Duration.days(7.0)
+        step: Duration = Duration.seconds(10.0)
+        tolerance: Duration = Duration.seconds(1.0)
+
+        ground_station_lla: LLA = LLA(
+            Angle.degrees(70.0),
+            Angle.degrees(160.0),
+            Length.meters(0.0),
+        )
+
+        tle_1 = TLE(
+            "1 55076U 23001BV  23146.17959645  .00004328  00000-0  23719-3 0  9993",
+            "2 55076  97.4793 205.9529 0016244  89.9523 270.3571 15.14609100 21723",
+        )
+
+        tle_2 = TLE(
+            "1 48915U 21059AN  23146.32782040  .00004955  00000-0  24678-3 0  9999",
+            "2 48915  97.5954 279.7041 0010303 354.9434   5.1694 15.18004448105867",
+        )
+
+        environment: Environment = Environment.default()
+        earth: Celestial = environment.access_celestial_object_with_name("Earth")
+
+        ground_station_trajectory: Trajectory = Trajectory.position(
+            Position.meters(
+                ground_station_lla.to_cartesian(
+                    earth.get_equatorial_radius(),
+                    earth.get_flattening(),
+                ),
+                Frame.ITRF(),
+            ),
+        )
+
+        stop_instant: Instant = start_instant + duration
+        search_interval: RealInterval = Interval.closed(start_instant, stop_instant)
+
+        orbit_1: Orbit = Orbit(SGP4(tle_1), earth)
+        orbit_2: Orbit = Orbit(SGP4(tle_2), earth)
+
+        generator = AccessGenerator(
+            environment=environment,
+            step=step,
+            tolerance=tolerance,
+        )
+
+        accesses_1 = generator.compute_accesses(
+            interval=search_interval,
+            from_trajectory=ground_station_trajectory,
+            to_trajectory=orbit_1,
+        )
+
+        assert len(accesses_1) > 0
+
+        accesses_2 = generator.compute_accesses(
+            interval=search_interval,
+            from_trajectory=ground_station_trajectory,
+            to_trajectory=orbit_2,
+        )
+
+        assert len(accesses_2) > 0
+
+        accesses_plot = display.AccessesPlot(
+            earth=earth,
+            interval=search_interval,
+            trajectory_step=Duration.minutes(5.0),
+            access_step=Duration.seconds(10.0),
+            ground_station_lla=ground_station_lla,
+            color="green",
+        )
+
+        accesses_plot.add_satellite(
+            trajectory=orbit_1,
+            accesses=accesses_1,
+            rgb=[180, 0, 0],
+        )
+
+        accesses_plot.add_satellite(
+            trajectory=orbit_2,
+            accesses=accesses_2,
+            rgb=[0, 0, 180],
+        )
+
+        accesses_plot.show()

ostk/astrodynamics/test/test_event_condition.py

@@ -0,0 +1,58 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics import EventCondition
+
+
+@pytest.fixture
+def name() -> str:
+    return "MyEvent"
+
+
+@pytest.fixture
+def evaluator() -> callable:
+    return lambda state: 0.0
+
+
+@pytest.fixture
+def target_value() -> float:
+    return 0.0
+
+
+@pytest.fixture
+def target(target_value: float) -> EventCondition.Target:
+    return EventCondition.Target(target_value, EventCondition.Target.Type.Absolute)
+
+
+@pytest.fixture
+def event_condition(
+    name: str, evaluator: callable, target: EventCondition.Target
+) -> EventCondition:
+    class MyEventCondition(EventCondition):
+        def is_satisfied(
+            self,
+            current_state_vector,
+            current_time,
+            previous_state_vector,
+            previous_time,
+        ):
+            return current_state_vector[0] > 0.0 and previous_state_vector[0] < 0.0
+
+    return MyEventCondition(name, evaluator, target)
+
+
+class TestEventCondition:
+    def test_subclass(self, event_condition: EventCondition):
+        assert event_condition is not None
+
+    def test_get_name(self, event_condition: EventCondition, name: str):
+        assert event_condition.get_name() == name
+
+    def test_get_evaluator(self, event_condition: EventCondition):
+        assert event_condition.get_evaluator() is not None
+
+    def test_get_target(
+        self, event_condition: EventCondition, target: EventCondition.Target
+    ):
+        assert event_condition.get_target() == target

ostk/astrodynamics/test/test_import.py

@@ -0,0 +1,26 @@
+# Apache License 2.0
+
+import pytest
+
+
+class TestImport:
+    def test_import(self):
+        from ostk.astrodynamics import Trajectory
+        from ostk.astrodynamics.trajectory import State
+        from ostk.astrodynamics.trajectory import Orbit
+        from ostk.astrodynamics.trajectory import Model
+        from ostk.astrodynamics.trajectory.orbit import Pass
+        from ostk.astrodynamics.trajectory.orbit.model import Kepler
+        from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+        from ostk.astrodynamics.trajectory.orbit.model import SGP4
+        from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
+        from ostk.astrodynamics.trajectory.orbit.model import Propagated
+        from ostk.astrodynamics.flight import Profile
+        from ostk.astrodynamics.flight import System
+        from ostk.astrodynamics.flight import Maneuver
+        from ostk.astrodynamics.flight.system import SatelliteSystem
+        from ostk.astrodynamics.dynamics import CentralBodyGravity
+        from ostk.astrodynamics.dynamics import AtmosphericDrag
+        from ostk.astrodynamics import Access
+        from ostk.astrodynamics.access import Generator
+        from ostk.astrodynamics.trajectory.state import NumericalSolver

ostk/astrodynamics/test/test_root_solver.py

@@ -0,0 +1,70 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics import RootSolver
+
+
+def quadratic_function(x):
+    return x**2 - 4
+
+
+@pytest.fixture
+def maximum_iteration_count() -> int:
+    return 100
+
+
+@pytest.fixture
+def tolerance() -> float:
+    return 1e-15
+
+
+@pytest.fixture
+def root_solver(maximum_iteration_count: int, tolerance: float) -> RootSolver:
+    return RootSolver(maximum_iteration_count, tolerance)
+
+
+class TestRootSolver:
+    def test_constructor(self, maximum_iteration_count: int, tolerance: float):
+        assert (
+            RootSolver(
+                maximum_iteration_count=maximum_iteration_count, tolerance=tolerance
+            )
+            is not None
+        )
+
+    def test_getters(
+        self,
+        root_solver: RootSolver,
+        maximum_iteration_count: int,
+        tolerance: float,
+    ):
+        assert root_solver.get_tolerance() == tolerance
+        assert root_solver.get_maximum_iteration_count() == maximum_iteration_count
+
+    def test_bracket_and_solve(self, root_solver):
+        solution = root_solver.bracket_and_solve(
+            function=quadratic_function,
+            initial_guess=1.0,
+            is_rising=True,
+        )
+        assert pytest.approx(solution.root, abs=1e-15) == 2.0
+
+    def test_solve(self, root_solver):
+        solution = root_solver.solve(
+            function=quadratic_function,
+            lower_bound=1.0,
+            upper_bound=3.0,
+        )
+        assert pytest.approx(solution.root, abs=1e-15) == 2.0
+
+    def test_bisection(self, root_solver):
+        solution = root_solver.bisection(
+            function=quadratic_function,
+            lower_bound=1.0,
+            upper_bound=3.0,
+        )
+        assert pytest.approx(solution.root, abs=1e-15) == 2.0
+
+    def test_default(self):
+        assert RootSolver.default() is not None

ostk/astrodynamics/test/test_trajectory.py

@@ -0,0 +1,40 @@
+# Apache License 2.0
+
+import ostk.mathematics as mathematics
+
+import ostk.physics as physics
+
+import ostk.astrodynamics as astrodynamics
+
+RealInterval = mathematics.object.RealInterval
+Quaternion = mathematics.geometry.d3.transformation.rotation.Quaternion
+Length = physics.unit.Length
+Angle = physics.unit.Angle
+DateTime = physics.time.DateTime
+Scale = physics.time.Scale
+Duration = physics.time.Duration
+Instant = physics.time.Instant
+Transform = physics.coordinate.Transform
+Frame = physics.coordinate.Frame
+Axes = physics.coordinate.Axes
+DynamicProvider = physics.coordinate.frame.provider.Dynamic
+Environment = physics.Environment
+Earth = physics.environment.object.celestial.Earth
+Trajectory = astrodynamics.Trajectory
+Profile = astrodynamics.flight.Profile
+SatelliteSystem = astrodynamics.flight.system.SatelliteSystem
+Orbit = astrodynamics.trajectory.Orbit
+State = astrodynamics.trajectory.State
+Pass = astrodynamics.trajectory.orbit.Pass
+Kepler = astrodynamics.trajectory.orbit.model.Kepler
+COE = astrodynamics.trajectory.orbit.model.kepler.COE
+SGP4 = astrodynamics.trajectory.orbit.model.sgp4
+Access = astrodynamics.Access
+
+
+def test_trajectory_undefined():
+    trajectory: Trajectory = Trajectory.undefined()
+
+    assert trajectory is not None
+    assert isinstance(trajectory, Trajectory)
+    assert trajectory.is_defined() is False