open-space-toolkit-astrodynamics 13.1.0__py313-none-manylinux2014_aarch64.whl → 15.0.0__py313-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/flight/test_maneuver.py

@@ -12,24 +12,21 @@ from ostk.physics.coordinate import Frame
 from ostk.physics.unit import Mass
 
 from ostk.astrodynamics.flight import Maneuver
+from ostk.astrodynamics.trajectory import State
 from ostk.astrodynamics.dynamics import Tabulated as TabulatedDynamics
 from ostk.astrodynamics.trajectory.state import CoordinateSubset
-
-
-from ..dynamics.test_tabulated import (
-    instants as tabulated_instants,
-    contribution_profile as tabulated_contribution_profile,
-    coordinate_subsets as tabulated_coordinate_subsets,
-)
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianAcceleration
 
 
 @pytest.fixture
 def instants() -> list[Instant]:
     return [
         Instant.J2000(),
-        Instant.J2000() + Duration.seconds(1.0),
-        Instant.J2000() + Duration.seconds(5.0),
-        Instant.J2000() + Duration.seconds(7.0),
+        Instant.J2000() + Duration.seconds(30.0),
+        Instant.J2000() + Duration.seconds(35.0),
+        Instant.J2000() + Duration.seconds(37.0),
     ]
 
 
@@ -54,13 +51,43 @@ def mass_flow_rate_profile() -> list[float]:
 
 
 @pytest.fixture
-def maneuver(
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+        CartesianAcceleration.thrust_acceleration(),
+        CoordinateSubset.mass_flow_rate(),
+    ]
+
+
+@pytest.fixture
+def states(
     instants: list[Instant],
     acceleration_profile: list[np.ndarray],
-    frame: Frame,
     mass_flow_rate_profile: list[float],
+    frame: Frame,
+    coordinate_subsets: list[CoordinateSubset],
+) -> list[State]:
+    states = []
+    for instant, acceleration, mass_flow_rate in zip(
+        instants, acceleration_profile, mass_flow_rate_profile
+    ):
+        states.append(
+            State(
+                instant,
+                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, *acceleration, mass_flow_rate],
+                frame,
+                coordinate_subsets,
+            )
+        )
+    return states
+
+
+@pytest.fixture
+def maneuver(
+    states: list[State],
 ) -> Maneuver:
-    return Maneuver(instants, acceleration_profile, frame, mass_flow_rate_profile)
+    return Maneuver(states)
 
 
 @pytest.fixture
@@ -97,35 +124,15 @@ class TestManeuver:
     def test_getters(
         self,
         maneuver: Maneuver,
-        instants: list[Instant],
-        acceleration_profile: list[np.ndarray],
-        mass_flow_rate_profile: list[float],
+        states: list[State],
     ):
         assert maneuver.is_defined()
 
-        assert maneuver.get_instants() == instants
+        assert maneuver.get_states() == states
 
-        computed_acceleration_profile_default_frame = maneuver.get_acceleration_profile()
-        for i in range(len(instants)):
-            assert np.array_equal(
-                computed_acceleration_profile_default_frame[i], acceleration_profile[i]
-            )
-
-        computed_acceleration_profile_non_default_frame = (
-            maneuver.get_acceleration_profile(frame=Frame.ITRF())
+        assert maneuver.get_interval() == Interval.closed(
+            states[0].get_instant(), states[-1].get_instant()
         )
-        for i in range(len(instants)):
-            assert (
-                np.array_equal(
-                    computed_acceleration_profile_non_default_frame[i],
-                    acceleration_profile[i],
-                )
-                == False
-            )
-
-        assert maneuver.get_mass_flow_rate_profile() == mass_flow_rate_profile
-
-        assert maneuver.get_interval() == Interval.closed(instants[0], instants[-1])
 
     def test_calculators(
         self,
@@ -159,7 +166,9 @@ class TestManeuver:
         )
 
         assert tabulated_dynamics.is_defined()
-        assert tabulated_dynamics.access_instants() == maneuver.get_instants()
+        assert tabulated_dynamics.access_instants() == [
+            state.get_instant() for state in maneuver.get_states()
+        ]
 
         contribution_profile: np.ndarray = (
             tabulated_dynamics.access_contribution_profile()
@@ -175,38 +184,14 @@ class TestManeuver:
 
         assert tabulated_dynamics.access_frame() == frame
 
-    def test_from_tabulated_dynamics(
-        self,
-        tabulated_dynamics: TabulatedDynamics,
-    ):
-        maneuver = Maneuver.tabulated_dynamics(tabulated_dynamics)
-
-        assert maneuver.is_defined()
-        assert maneuver.get_instants() == tabulated_dynamics.access_instants()
-        assert (
-            len(maneuver.get_acceleration_profile())
-            == tabulated_dynamics.access_contribution_profile().shape[0]
-        )
-        assert (
-            len(maneuver.get_mass_flow_rate_profile())
-            == tabulated_dynamics.access_contribution_profile().shape[0]
-        )
-
     def test_from_constant_mass_flow_rate(
         self,
-        instants: list[Instant],
-        acceleration_profile: list[np.ndarray],
-        frame: Frame,
+        states: list[State],
     ):
         mass_flow_rate: float = -1.0e-5
         maneuver = Maneuver.constant_mass_flow_rate_profile(
-            instants=instants,
-            acceleration_profile=acceleration_profile,
-            frame=frame,
+            states=states,
             mass_flow_rate=mass_flow_rate,
         )
 
         assert maneuver.is_defined()
-        assert maneuver.get_mass_flow_rate_profile() == [
-            mass_flow_rate for _ in range(len(instants))
-        ]

ostk/astrodynamics/test/flight/test_profile.py

@@ -192,11 +192,13 @@ class TestProfile:
         assert isinstance(profile, Profile)
         assert profile.is_defined()
 
-    def test_nadir_pointing(
+    def test_local_orbital_frame_pointing(
         self,
         orbit: Orbit,
     ):
-        profile: Profile = Profile.nadir_pointing(orbit, Orbit.FrameType.VVLH)
+        profile: Profile = Profile.local_orbital_frame_pointing(
+            orbit, Orbit.FrameType.VVLH
+        )
 
         assert profile is not None
         assert isinstance(profile, Profile)

ostk/astrodynamics/test/flight/test_system.py

@@ -2,21 +2,11 @@
 
 import pytest
 
-import numpy as np
-
-import ostk.mathematics as mathematics
-
-import ostk.physics as physics
-
-import ostk.astrodynamics as astrodynamics
-
-Cuboid = mathematics.geometry.d3.object.Cuboid
-Composite = mathematics.geometry.d3.object.Composite
-Point = mathematics.geometry.d3.object.Point
-
-Mass = physics.unit.Mass
-
-System = astrodynamics.flight.System
+from ostk.mathematics.geometry.d3.object import Cuboid
+from ostk.mathematics.geometry.d3.object import Composite
+from ostk.mathematics.geometry.d3.object import Point
+from ostk.physics.unit import Mass
+from ostk.astrodynamics.flight import System
 
 
 @pytest.fixture

ostk/astrodynamics/test/solvers/test_finite_difference_solver.py

@@ -1,5 +1,7 @@
 # Apache License 2.0
 
+from typing import Callable
+
 import pytest
 import math
 
@@ -71,7 +73,7 @@ def instants(initial_instant: Instant) -> list[Instant]:
 
 
 @pytest.fixture
-def generate_states_coordinates() -> callable:
+def generate_states_coordinates() -> Callable:
     def state_fn(state, instants) -> np.ndarray:
         x0: float = state.get_coordinates()[0]
         v0: float = state.get_coordinates()[1]
@@ -84,17 +86,17 @@ def generate_states_coordinates() -> callable:
             x: float = x0 * math.cos(omega * t) + v0 / omega * math.sin(omega * t)
             v: float = -x0 * omega * math.sin(omega * t) + v0 * math.cos(omega * t)
 
-            coordinates: list[float] = [x, v]
+            coordinates: list[float] = list(np.array([x, v]).astype(float))
 
             states_coordinates.append(coordinates)
 
-        return np.array(states_coordinates)
+        return np.array(states_coordinates).transpose()
 
     return state_fn
 
 
 @pytest.fixture
-def generate_state_coordinates() -> callable:
+def generate_state_coordinates() -> Callable:
     def state_fn(state, instant) -> np.ndarray:
         x0: float = state.get_coordinates()[0]
         v0: float = state.get_coordinates()[1]
@@ -126,37 +128,37 @@ class TestFiniteDifferenceSolver:
             == "Forward"
         )
 
-    def test_compute_jacobian_array(
+    def test_compute_state_transition_matrix_array(
         self,
         finite_difference_solver: FiniteDifferenceSolver,
         state: State,
         instants: list[Instant],
-        generate_states_coordinates: callable,
+        generate_states_coordinates: Callable,
     ):
-        stm = finite_difference_solver.compute_jacobian(
+        stms: list[np.ndarray] = finite_difference_solver.compute_state_transition_matrix(
             state=state,
             instants=instants,
             generate_states_coordinates=generate_states_coordinates,
-            coordinates_dimension=2,
         )
-        assert isinstance(stm, np.ndarray)
-        assert stm.shape == (
-            len(state.get_coordinates()) * len(instants),
+
+        assert len(stms) == len(instants)
+
+        assert stms[0].shape == (
+            len(state.get_coordinates()),
             len(state.get_coordinates()),
         )
 
-    def test_compute_jacobian_single(
+    def test_compute_state_transition_matrix_single(
         self,
         finite_difference_solver: FiniteDifferenceSolver,
         state: State,
-        generate_state_coordinates: callable,
+        generate_state_coordinates: Callable,
         instant: Instant,
     ):
-        stm = finite_difference_solver.compute_jacobian(
+        stm: np.ndarray = finite_difference_solver.compute_state_transition_matrix(
             state=state,
             instant=instant,
             generate_state_coordinates=generate_state_coordinates,
-            coordinates_dimension=2,
         )
         assert isinstance(stm, np.ndarray)
         assert stm.shape == (
@@ -168,7 +170,7 @@ class TestFiniteDifferenceSolver:
         self,
         finite_difference_solver: FiniteDifferenceSolver,
         state: State,
-        generate_state_coordinates: callable,
+        generate_state_coordinates: Callable,
     ):
         gradient = finite_difference_solver.compute_gradient(
             state=state,
@@ -177,5 +179,18 @@ class TestFiniteDifferenceSolver:
         assert isinstance(gradient, np.ndarray)
         assert all(gradient - np.array([0.0, -1.0]) < 1e-6)
 
+    def test_compute_jacobian(
+        self,
+        finite_difference_solver: FiniteDifferenceSolver,
+        state: State,
+        generate_state_coordinates: Callable,
+    ):
+        gradient = finite_difference_solver.compute_jacobian(
+            state=state,
+            generate_state_coordinates=generate_state_coordinates,
+        )
+        assert isinstance(gradient, np.ndarray)
+        assert np.all(gradient - np.array([[0.0, 1.0], [-1.0, 0.0]]) < 1e-6)
+
     def test_default(self):
         assert isinstance(FiniteDifferenceSolver.default(), FiniteDifferenceSolver)

ostk/astrodynamics/test/solvers/test_temporal_condition_solver.py

@@ -16,6 +16,8 @@ from ostk.astrodynamics.trajectory.orbit.model import Kepler
 from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
 from ostk.astrodynamics.access import Generator
 from ostk.astrodynamics.solver import TemporalConditionSolver
+from ostk.astrodynamics.access import AccessTarget
+from ostk.astrodynamics.access import VisibilityCriterion
 
 
 @pytest.fixture
@@ -141,9 +143,15 @@ class TestTemporalConditionSolver:
             celestial_object=earth,
         )
 
+        visibility_criterion: VisibilityCriterion = (
+            VisibilityCriterion.from_line_of_sight(environment)
+        )
+
+        access_target = AccessTarget.from_trajectory(visibility_criterion, trajectory)
+
         solution: list[Interval] = temporal_condition_solver.solve(
             condition=generator.get_condition_function(
-                from_trajectory=trajectory,
+                access_target=access_target,
                 to_trajectory=trajectory,
             ),
             interval=interval,

ostk/astrodynamics/test/test_display.py

@@ -15,12 +15,13 @@ 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.orbit.model import SGP4
 from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
+from ostk.astrodynamics.access import AccessTarget
+from ostk.astrodynamics.access import VisibilityCriterion
 
 
 class TestDisplay:
@@ -29,7 +30,7 @@ class TestDisplay:
             DateTime(2023, 1, 3, 0, 0, 0),
             Scale.UTC,
         )
-        duration: Duration = Duration.hours(12.0)
+        duration: Duration = Duration.hours(1.0)
         step: Duration = Duration.seconds(10.0)
         tolerance: Duration = Duration.seconds(1.0)
 
@@ -52,7 +53,12 @@ class TestDisplay:
         environment: Environment = Environment.default()
         earth: Celestial = environment.access_celestial_object_with_name("Earth")
 
-        ground_station_trajectory: Trajectory = Trajectory.position(
+        visibility_criterion: VisibilityCriterion = (
+            VisibilityCriterion.from_line_of_sight(environment)
+        )
+
+        access_target: AccessTarget = AccessTarget.from_position(
+            visibility_criterion,
             Position.meters(
                 ground_station_lla.to_cartesian(
                     earth.get_equatorial_radius(),
@@ -76,7 +82,7 @@ class TestDisplay:
 
         accesses_1 = generator.compute_accesses(
             interval=search_interval,
-            from_trajectory=ground_station_trajectory,
+            access_target=access_target,
             to_trajectory=orbit_1,
         )
 
@@ -84,7 +90,7 @@ class TestDisplay:
 
         accesses_2 = generator.compute_accesses(
             interval=search_interval,
-            from_trajectory=ground_station_trajectory,
+            access_target=access_target,
             to_trajectory=orbit_2,
         )
 

ostk/astrodynamics/test/test_event_condition.py

@@ -1,5 +1,7 @@
 # Apache License 2.0
 
+from typing import Callable
+
 import pytest
 
 from ostk.physics.time import Instant
@@ -15,7 +17,7 @@ def name() -> str:
 
 
 @pytest.fixture
-def evaluator() -> callable:
+def evaluator() -> Callable:
     return lambda state: 5.0
 
 
@@ -31,7 +33,7 @@ def target(target_value: float) -> EventCondition.Target:
 
 @pytest.fixture
 def event_condition(
-    name: str, evaluator: callable, target: EventCondition.Target
+    name: str, evaluator: Callable, target: EventCondition.Target
 ) -> EventCondition:
     class MyEventCondition(EventCondition):
         def is_satisfied(

ostk/astrodynamics/test/test_utilities.py

@@ -61,7 +61,7 @@ class TestUtility:
         position: Position,
         environment: Environment,
     ):
-        time_lla_aer: float[datetime, float, float, float, float, float, float] = (
+        time_lla_aer: tuple[datetime, float, float, float, float, float, float] = (
             utilities.compute_time_lla_aer_coordinates(state, position, environment)
         )
 

ostk/astrodynamics/test/test_viewer.py

@@ -38,7 +38,7 @@ def orbit(environment: Environment) -> Orbit:
 
 @pytest.fixture
 def profile(orbit: Orbit) -> Profile:
-    return Profile.nadir_pointing(
+    return Profile.local_orbital_frame_pointing(
         orbit=orbit,
         orbital_frame_type=Orbit.FrameType.VVLH,
     )
@@ -127,3 +127,72 @@ class TestViewer:
             in rendered_html
         )
         assert rendered_html.endswith("</script>")
+
+    def test_add_target_with_label_success(
+        self,
+        viewer: Viewer,
+    ):
+        viewer.add_target(
+            position=Position.meters([1.0, 2.0, 3.0], Frame.ITRF()),
+            size=123,
+            color="red",
+            label="TEST",
+        )
+
+        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 (
+            'widget.entities.add({position: Cesium.Cartesian3.fromDegrees(63.43494882292201, 18.22447811510915, -6376045.535225509), label: {text: "TEST", fillColor: Cesium.Color.RED, scale: 123.0}});'
+            in rendered_html
+        )
+        assert rendered_html.endswith("</script>")
+
+    def test_add_line_success(
+        self,
+        viewer: Viewer,
+    ):
+        viewer.add_line(
+            positions=[
+                Position.meters([1.0, 2.0, 3.0], Frame.ITRF()),
+                Position.meters([4.0, 5.0, 6.0], Frame.ITRF()),
+            ],
+            size=10.0,
+            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({polyline: {positions: Cesium.Cartesian3.fromDegreesArrayHeights([63.43494882292201, 18.22447811510915, 10.0, 51.34019174590991, 10.165199393640696, 10.0]), width: 10.0, material: Cesium.Color.RED}});"
+            in rendered_html
+        )
+        assert rendered_html.endswith("</script>")
+
+    def test_add_label_success(
+        self,
+        viewer: Viewer,
+    ):
+        viewer.add_label(
+            position=Position.meters([6671000.0, 0.0, 0.0], Frame.ITRF()),
+            text="Hello, World!",
+            size=1.0,
+            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(0.0, 0.0, 292863.0000000001), label: {text: "Hello, World!", fillColor: Cesium.Color.RED, scale: 1.0}});'
+            in rendered_html
+        )
+        assert rendered_html.endswith("</script>")

ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_acceleration.py

@@ -0,0 +1,136 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinateBroker, CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianAcceleration
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+
+
+@pytest.fixture
+def name() -> str:
+    return "Cartesian Acceleration"
+
+
+@pytest.fixture
+def cartesian_position() -> CartesianPosition:
+    return CartesianPosition.default()
+
+
+@pytest.fixture
+def cartesian_velocity() -> CartesianVelocity:
+    return CartesianVelocity.default()
+
+
+@pytest.fixture
+def cartesian_acceleration() -> CartesianAcceleration:
+    return CartesianAcceleration.default()
+
+
+@pytest.fixture
+def coordinate_subsets(
+    cartesian_acceleration: CartesianAcceleration,
+) -> list[CoordinateSubset]:
+    return [cartesian_acceleration]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinate_broker(
+    coordinate_subsets: list[CoordinateSubset],
+) -> CoordinateBroker:
+    return CoordinateBroker(coordinate_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [9.81, 0.0, 0.0]
+
+
+@pytest.fixture
+def another_coordinates() -> list[float]:
+    return [0.0, 9.81, 0.0]
+
+
+class TestCartesianAcceleration:
+    def test_constructor(
+        self,
+        cartesian_position: CartesianPosition,
+        cartesian_velocity: CartesianVelocity,
+        name: str,
+    ):
+        assert (
+            CartesianAcceleration(cartesian_position, cartesian_velocity, name)
+            is not None
+        )
+
+    def test_add(
+        self,
+        cartesian_acceleration: CartesianAcceleration,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_acceleration.add(
+                instant, coordinates, another_coordinates, frame, coordinate_broker
+            )
+            == [9.81, 9.81, 0.0]
+        )
+
+    def test_subtract(
+        self,
+        cartesian_acceleration: CartesianAcceleration,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert all(
+            cartesian_acceleration.subtract(
+                instant, coordinates, another_coordinates, frame, coordinate_broker
+            )
+            == [9.81, -9.81, 0.0]
+        )
+
+    def test_in_frame(
+        self,
+        cartesian_acceleration: CartesianAcceleration,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert (
+            cartesian_acceleration.in_frame(
+                instant, coordinates, frame, frame, coordinate_broker
+            )
+            is not None
+        )
+
+        with pytest.raises(RuntimeError):
+            cartesian_acceleration.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinate_broker
+            )
+
+    def test_default(self):
+        assert CartesianAcceleration.default() is not None
+
+    def test_thrust_acceleration(self):
+        assert CartesianAcceleration.thrust_acceleration() is not None

ostk/astrodynamics/test/trajectory/state/test_coordinate_subset.py

@@ -44,3 +44,12 @@ class TestCoordinateSubset:
 
     def test_mass(self):
         assert CoordinateSubset.mass() is not None
+
+    def test_surface_area(self):
+        assert CoordinateSubset.surface_area() is not None
+
+    def test_drag_coefficient(self):
+        assert CoordinateSubset.drag_coefficient() is not None
+
+    def test_mass_flow_rate(self):
+        assert CoordinateSubset.mass_flow_rate() is not None