open-space-toolkit-astrodynamics 16.8.0__py313-none-manylinux2014_aarch64.whl → 16.10.0__py313-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/guidance_law/test_heterogeneous_guidance_law.py

@@ -0,0 +1,164 @@
+# Apache License 2.0
+
+import numpy as np
+
+import pytest
+
+from ostk.physics.coordinate import Frame
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.time import Interval
+from ostk.astrodynamics import GuidanceLaw
+from ostk.astrodynamics.guidance_law import HeterogeneousGuidanceLaw
+
+
+@pytest.fixture
+def interval_1() -> Interval:
+    return Interval.closed(
+        start_instant=Instant.J2000(),
+        end_instant=Instant.J2000() + Duration.seconds(100.0),
+    )
+
+
+@pytest.fixture
+def guidance_law_1() -> GuidanceLaw:
+    class GuidanceLaw1(GuidanceLaw):
+
+        def __init__(
+            self,
+            name: str,
+        ):
+            super().__init__(name)
+
+        def calculate_thrust_acceleration_at(
+            self,
+            instant: Instant,
+            position_coordinates: np.array,
+            velocity_coordinates: np.array,
+            thrust_acceleration: float,
+            output_frame: Frame,
+        ) -> np.array:
+            return np.array([1.0, 2.0, 3.0])
+
+    return GuidanceLaw1("My Guidance Law 1")
+
+
+@pytest.fixture
+def interval_2() -> Interval:
+    return Interval.closed(
+        start_instant=Instant.J2000() + Duration.seconds(200.0),
+        end_instant=Instant.J2000() + Duration.seconds(300.0),
+    )
+
+
+@pytest.fixture
+def guidance_law_2() -> GuidanceLaw:
+    class GuidanceLaw2(GuidanceLaw):
+
+        def __init__(
+            self,
+            name: str,
+        ):
+            super().__init__(name)
+
+        def calculate_thrust_acceleration_at(
+            self,
+            instant: Instant,
+            position_coordinates: np.array,
+            velocity_coordinates: np.array,
+            thrust_acceleration: float,
+            output_frame: Frame,
+        ) -> np.array:
+            return np.array([4.0, 5.0, 6.0])
+
+    return GuidanceLaw2("My Guidance Law 2")
+
+
+@pytest.fixture
+def heterogeneous_guidance_law(
+    interval_1: Interval,
+    guidance_law_1: GuidanceLaw,
+    interval_2: Interval,
+    guidance_law_2: GuidanceLaw,
+) -> HeterogeneousGuidanceLaw:
+    return HeterogeneousGuidanceLaw(
+        guidance_laws_with_intervals=[
+            (guidance_law_1, interval_1),
+            (guidance_law_2, interval_2),
+        ],
+    )
+
+
+class TestHeterogeneousGuidanceLaw:
+    def test_constructor_and_getters(
+        self,
+        interval_1: Interval,
+        guidance_law_1: GuidanceLaw,
+        interval_2: Interval,
+        guidance_law_2: GuidanceLaw,
+    ):
+        heterogeneous_guidance_law = HeterogeneousGuidanceLaw(
+            guidance_laws_with_intervals=[
+                (guidance_law_1, interval_1),
+                (guidance_law_2, interval_2),
+            ],
+        )
+        assert heterogeneous_guidance_law is not None
+        assert isinstance(heterogeneous_guidance_law, HeterogeneousGuidanceLaw)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
+            (guidance_law_1, interval_1),
+            (guidance_law_2, interval_2),
+        ]
+
+    def test_add_guidance_law(
+        self,
+        interval_1: Interval,
+        guidance_law_1: GuidanceLaw,
+        interval_2: Interval,
+        guidance_law_2: GuidanceLaw,
+    ):
+        heterogeneous_guidance_law = HeterogeneousGuidanceLaw()
+
+        assert isinstance(heterogeneous_guidance_law, HeterogeneousGuidanceLaw)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == []
+
+        heterogeneous_guidance_law.add_guidance_law(guidance_law_1, interval_1)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
+            (guidance_law_1, interval_1),
+        ]
+
+        heterogeneous_guidance_law.add_guidance_law(guidance_law_2, interval_2)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
+            (guidance_law_1, interval_1),
+            (guidance_law_2, interval_2),
+        ]
+
+    @pytest.mark.parametrize(
+        (
+            "instant",
+            "expected_thrust_acceleration",
+        ),
+        [
+            (Instant.J2000() - Duration.seconds(50.0), np.array([0.0, 0.0, 0.0])),
+            (Instant.J2000() + Duration.seconds(50.0), np.array([1.0, 2.0, 3.0])),
+            (Instant.J2000() + Duration.seconds(150.0), np.array([0.0, 0.0, 0.0])),
+            (Instant.J2000() + Duration.seconds(250.0), np.array([4.0, 5.0, 6.0])),
+            (Instant.J2000() + Duration.seconds(350.0), np.array([0.0, 0.0, 0.0])),
+        ],
+    )
+    def test_calculate_thrust_acceleration_at(
+        self,
+        heterogeneous_guidance_law: HeterogeneousGuidanceLaw,
+        instant: Instant,
+        expected_thrust_acceleration: np.array,
+    ):
+        assert np.array_equal(
+            heterogeneous_guidance_law.calculate_thrust_acceleration_at(
+                instant=instant,
+                position_coordinates=np.array([0.0, 0.0, 0.0]),
+                velocity_coordinates=np.array([0.0, 0.0, 0.0]),
+                thrust_acceleration=1.0,
+                output_frame=Frame.GCRF(),
+            ),
+            expected_thrust_acceleration,
+        )

ostk/astrodynamics/test/trajectory/test_segment.py

@@ -10,6 +10,7 @@ from ostk.physics.time import Scale
 from ostk.physics.time import Duration
 from ostk.physics.coordinate import Frame
 from ostk.physics.environment.object.celestial import Earth
+from ostk.physics.unit import Angle
 
 from ostk.astrodynamics.flight.system import SatelliteSystem
 from ostk.astrodynamics import Dynamics
@@ -17,6 +18,7 @@ from ostk.astrodynamics.dynamics import CentralBodyGravity
 from ostk.astrodynamics.dynamics import PositionDerivative
 from ostk.astrodynamics.dynamics import Thruster
 from ostk.astrodynamics.guidance_law import ConstantThrust
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
 from ostk.astrodynamics.trajectory import State
 from ostk.astrodynamics.trajectory import Segment
 from ostk.astrodynamics.event_condition import InstantCondition
@@ -75,6 +77,11 @@ def dynamics(
     ]
 
 
+@pytest.fixture
+def local_orbital_frame_factory() -> LocalOrbitalFrameFactory:
+    return LocalOrbitalFrameFactory.VNC(Frame.GCRF())
+
+
 @pytest.fixture
 def numerical_solver() -> NumericalSolver:
     return NumericalSolver.default_conditional()
@@ -122,6 +129,51 @@ def maneuver_segment(
     )
 
 
+@pytest.fixture
+def maximum_allowed_angular_offset() -> Angle:
+    return Angle.degrees(180.0)
+
+
+@pytest.fixture
+def constant_local_orbital_frame_direction_maneuver_segment(
+    name: str,
+    instant_condition: InstantCondition,
+    thruster_dynamics: Thruster,
+    dynamics: list,
+    numerical_solver: NumericalSolver,
+    local_orbital_frame_factory: LocalOrbitalFrameFactory,
+) -> Segment:
+    return Segment.constant_local_orbital_frame_direction_maneuver(
+        name=name,
+        event_condition=instant_condition,
+        thruster_dynamics=thruster_dynamics,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+        local_orbital_frame_factory=local_orbital_frame_factory,
+    )
+
+
+@pytest.fixture
+def constant_local_orbital_frame_direction_maneuver_segment_with_maximum_allowed_angular_offset(
+    name: str,
+    instant_condition: InstantCondition,
+    thruster_dynamics: Thruster,
+    dynamics: list,
+    numerical_solver: NumericalSolver,
+    local_orbital_frame_factory: LocalOrbitalFrameFactory,
+    maximum_allowed_angular_offset: Angle,
+) -> Segment:
+    return Segment.constant_local_orbital_frame_direction_maneuver(
+        name=name,
+        event_condition=instant_condition,
+        thruster_dynamics=thruster_dynamics,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+        local_orbital_frame_factory=local_orbital_frame_factory,
+        maximum_allowed_angular_offset=maximum_allowed_angular_offset,
+    )
+
+
 @pytest.fixture
 def instants(state: State) -> list[Instant]:
     return [state.get_instant(), state.get_instant() + Duration.minutes(1.0)]
@@ -293,6 +345,41 @@ class TestSegment:
             is not None
         )
 
+    def test_constant_local_orbital_frame_direction_maneuver(
+        self,
+        name: str,
+        instant_condition: InstantCondition,
+        thruster_dynamics: ConstantThrust,
+        dynamics: list,
+        numerical_solver: NumericalSolver,
+        local_orbital_frame_factory: LocalOrbitalFrameFactory,
+        maximum_allowed_angular_offset: Angle,
+    ):
+        assert (
+            Segment.constant_local_orbital_frame_direction_maneuver(
+                name=name,
+                event_condition=instant_condition,
+                thruster_dynamics=thruster_dynamics,
+                dynamics=dynamics,
+                numerical_solver=numerical_solver,
+                local_orbital_frame_factory=local_orbital_frame_factory,
+            )
+            is not None
+        )
+
+        assert (
+            Segment.constant_local_orbital_frame_direction_maneuver(
+                name=name,
+                event_condition=instant_condition,
+                thruster_dynamics=thruster_dynamics,
+                dynamics=dynamics,
+                numerical_solver=numerical_solver,
+                local_orbital_frame_factory=local_orbital_frame_factory,
+                maximum_allowed_angular_offset=maximum_allowed_angular_offset,
+            )
+            is not None
+        )
+
     def test_create_solution(
         self,
         dynamics: list,
@@ -310,7 +397,7 @@ class TestSegment:
 
         assert segment_solution is not None
 
-    def test_solve(
+    def test_solve_maneuver_segment(
         self,
         state: State,
         end_instant: Instant,
@@ -318,7 +405,7 @@ class TestSegment:
         instants: list[Instant],
         numerical_solver: NumericalSolver,
     ):
-        solution = maneuver_segment.solve(state)
+        solution: Segment.Solution = maneuver_segment.solve(state)
 
         assert (
             pytest.approx(
@@ -400,3 +487,21 @@ class TestSegment:
             solution.get_dynamics_acceleration_contribution(
                 solution.dynamics[0], state.get_frame()
             )
+
+    def test_solve_constant_local_orbital_frame_direction_maneuver_segment(
+        self,
+        state: State,
+        constant_local_orbital_frame_direction_maneuver_segment: Segment,
+        constant_local_orbital_frame_direction_maneuver_segment_with_maximum_allowed_angular_offset: Segment,
+    ):
+        solution: Segment.Solution = (
+            constant_local_orbital_frame_direction_maneuver_segment.solve(state)
+        )
+        assert solution is not None
+
+        solution_with_maximum_allowed_angular_offset: Segment.Solution = (
+            constant_local_orbital_frame_direction_maneuver_segment_with_maximum_allowed_angular_offset.solve(
+                state
+            )
+        )
+        assert solution_with_maximum_allowed_angular_offset is not None

ostk/astrodynamics/trajectory/__init__.pyi

@@ -1094,6 +1094,30 @@ class Segment:
                             Segment: The coast segment.
         """
     @staticmethod
+    def constant_local_orbital_frame_direction_maneuver(name: ostk.core.type.String, event_condition: typing.Any, thruster_dynamics: typing.Any, dynamics: list[...], numerical_solver: state.NumericalSolver, local_orbital_frame_factory: LocalOrbitalFrameFactory, maximum_allowed_angular_offset: ostk.physics.unit.Angle = ...) -> Segment:
+        """
+                        Create a maneuvering segment that produces maneuvers with a constant direction in the local orbital frame.
+        
+                        The provided thruster dynamics are used to solve the segment at first. The maneuvers produced by this segement solution
+                        are then used to create a new thruster dynamics with a constant direction in the local orbital frame. This new thruster dynamics
+                        is then used to actually solve the segment.
+        
+                        If defined, a runtime error will be thrown if the maximum allowed angular offset between the original thruster dynamics
+                        and the mean thrust direction is violated.
+        
+                        Args:
+                            name (str): The name of the segment.
+                            event_condition (EventCondition): The event condition.
+                            thruster_dynamics (ThrusterDynamics): The thruster dynamics.
+                            dynamics (Dynamics): The dynamics.
+                            numerical_solver (NumericalSolver): The numerical solver.
+                            local_orbital_frame_factory (LocalOrbitalFrameFactory): The local orbital frame factory.
+                            maximum_allowed_angular_offset (Angle, optional): The maximum allowed angular offset to consider (if any). Defaults to Angle.undefined().
+        
+                        Returns:
+                            Segment: The maneuver segment.
+        """
+    @staticmethod
     def maneuver(name: ostk.core.type.String, event_condition: typing.Any, thruster_dynamics: typing.Any, dynamics: list[...], numerical_solver: state.NumericalSolver) -> Segment:
         """
                         Create a maneuver segment.