open-space-toolkit-astrodynamics 13.1.0__py313-none-manylinux2014_x86_64.whl → 14.0.0__py313-none-manylinux2014_x86_64.whl

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/solvers/test_finite_difference_solver.py

@@ -84,11 +84,11 @@ 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] = np.array([x, v])
 
             states_coordinates.append(coordinates)
 
-        return np.array(states_coordinates)
+        return np.array(states_coordinates).transpose()
 
     return state_fn
 
@@ -126,37 +126,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,
     ):
-        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,
         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 == (
@@ -177,5 +177,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_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

ostk/astrodynamics/test/trajectory/test_local_orbital_frame_factory.py

@@ -7,7 +7,10 @@ from ostk.physics.time import DateTime
 from ostk.physics.time import Scale
 from ostk.physics.coordinate import Frame
 from ostk.physics.coordinate import Transform
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
 
+from ostk.astrodynamics.trajectory import State
 from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
 from ostk.astrodynamics.trajectory import LocalOrbitalFrameTransformProvider
 
@@ -24,7 +27,7 @@ def local_orbital_transform_provider_type() -> LocalOrbitalFrameTransformProvide
 
 @pytest.fixture
 def transform_generator() -> callable:
-    return lambda instant, position, velocity: Transform.identity(Transform.Type.passive)
+    return lambda state: Transform.identity(Transform.Type.passive)
 
 
 @pytest.fixture
@@ -38,13 +41,24 @@ def instant() -> Instant:
 
 
 @pytest.fixture
-def position_vector() -> list:
-    return [7500000.0, 0.0, 0.0]
+def position() -> Position:
+    return Position.meters([7500000.0, 0.0, 0.0], Frame.GCRF())
 
 
 @pytest.fixture
-def velocity_vector() -> list:
-    return [0.0, 5335.865450622126, 5335.865450622126]
+def velocity() -> Velocity:
+    return Velocity.meters_per_second(
+        [0.0, 5335.865450622126, 5335.865450622126], Frame.GCRF()
+    )
+
+
+@pytest.fixture
+def state(
+    instant: Instant,
+    position: Position,
+    velocity: Velocity,
+) -> State:
+    return State(instant, position, velocity)
 
 
 class TestLocalOrbitalFrameFactory:
@@ -66,15 +80,9 @@ class TestLocalOrbitalFrameFactory:
     def test_generate_frame(
         self,
         local_orbital_frame_factory: LocalOrbitalFrameFactory,
-        instant: Instant,
-        position_vector: list,
-        velocity_vector: list,
+        state: State,
     ):
-        frame = local_orbital_frame_factory.generate_frame(
-            instant,
-            position_vector,
-            velocity_vector,
-        )
+        frame = local_orbital_frame_factory.generate_frame(state=state)
 
         assert frame is not None
         assert frame.is_defined()

ostk/astrodynamics/test/trajectory/test_propagator.py

@@ -15,8 +15,6 @@ 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.environment.object.celestial import Earth, Sun
 from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
@@ -25,13 +23,12 @@ from ostk.physics.environment.atmospheric import Earth as EarthAtmosphericModel
 
 from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
 from ostk.astrodynamics.trajectory import LocalOrbitalFrameDirection
-
 from ostk.astrodynamics.trajectory.state import CoordinateSubset
 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
 from ostk.astrodynamics.trajectory.state import CoordinateBroker
 from ostk.astrodynamics.trajectory.state import NumericalSolver
-
 from ostk.astrodynamics import Dynamics
 from ostk.astrodynamics.dynamics import Thruster
 from ostk.astrodynamics.dynamics import CentralBodyGravity
@@ -43,22 +40,9 @@ from ostk.astrodynamics.flight import Maneuver
 from ostk.astrodynamics.flight.system import PropulsionSystem
 from ostk.astrodynamics.flight.system import SatelliteSystem
 from ostk.astrodynamics.trajectory import State
-from ostk.astrodynamics.trajectory.state import CoordinateSubset, CoordinateBroker
-from ostk.astrodynamics.trajectory.state.coordinate_subset import (
-    CartesianPosition,
-    CartesianVelocity,
-)
 from ostk.astrodynamics.trajectory import Propagator
 
 
-from ..flight.test_maneuver import (
-    instants as maneuver_instants,
-    acceleration_profile as maneuver_acceleration_profile,
-    frame as maneuver_frame,
-    mass_flow_rate_profile as maneuver_mass_flow_rate_profile,
-)
-
-
 @pytest.fixture
 def propulsion_system() -> PropulsionSystem:
     return PropulsionSystem(
@@ -249,19 +233,29 @@ def event_condition(state: State) -> InstantCondition:
     )
 
 
+@pytest.fixture
+def maneuver_states(frame: Frame) -> list[State]:
+    return [
+        State(
+            Instant.J2000() + Duration.seconds(float(i)),
+            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -1e-3],
+            frame,
+            [
+                CartesianPosition.default(),
+                CartesianVelocity.default(),
+                CartesianAcceleration.thrust_acceleration(),
+                CoordinateSubset.mass_flow_rate(),
+            ],
+        )
+        for i in range(0, 100, 10)
+    ]
+
+
 @pytest.fixture
 def maneuver(
-    maneuver_instants: list[Instant],
-    maneuver_acceleration_profile: list[np.ndarray],
-    maneuver_frame: Frame,
-    maneuver_mass_flow_rate_profile: list[float],
+    maneuver_states: list[State],
 ) -> Maneuver:
-    return Maneuver(
-        maneuver_instants,
-        maneuver_acceleration_profile,
-        maneuver_frame,
-        maneuver_mass_flow_rate_profile,
-    )
+    return Maneuver(states=maneuver_states)
 
 
 @pytest.fixture

ostk/astrodynamics/test/trajectory/test_segment.py

@@ -183,7 +183,6 @@ class TestSegmentSolution:
     ):
         assert segment_solution.compute_delta_mass() is not None
 
-    @pytest.mark.skip(reason="Not implemented yet")
     def test_extract_maneuvers(
         self,
         segment_solution: Segment.Solution,