open-space-toolkit-astrodynamics 17.2.0__py312-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/guidance_law/test_constant_thrust.py

@@ -0,0 +1,177 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.physics.time import DateTime
+from ostk.physics.time import Duration
+from ostk.physics.time import Instant
+from ostk.physics.time import Scale
+from ostk.physics.unit import Angle
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameDirection
+
+from ostk.astrodynamics import GuidanceLaw
+from ostk.astrodynamics.flight import Maneuver
+from ostk.astrodynamics.guidance_law import ConstantThrust
+from ostk.astrodynamics.trajectory import State
+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
+
+
+@pytest.fixture
+def local_orbital_frame_direction() -> LocalOrbitalFrameDirection:
+    return LocalOrbitalFrameDirection(
+        vector=[1.0, 0.0, 0.0],
+        local_orbital_frame_factory=LocalOrbitalFrameFactory.VNC(Frame.GCRF()),
+    )
+
+
+@pytest.fixture
+def guidance_law(
+    local_orbital_frame_direction: LocalOrbitalFrameDirection,
+) -> ConstantThrust:
+    return ConstantThrust(thrust_direction=local_orbital_frame_direction)
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2021, 3, 20, 12, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def position_coordinates() -> list[float]:
+    return [7000000.0, 0.0, 0.0]
+
+
+@pytest.fixture
+def velocity_coordinates() -> list[float]:
+    return [0.0, 7546.05329, 0.0]
+
+
+@pytest.fixture
+def thrust_acceleration() -> float:
+    return 1.0 / 105.0
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def instants() -> list[Instant]:
+    return [
+        Instant.J2000(),
+        Instant.J2000() + Duration.seconds(30.0),
+        Instant.J2000() + Duration.seconds(35.0),
+        Instant.J2000() + Duration.seconds(37.0),
+    ]
+
+
+@pytest.fixture
+def acceleration_profile() -> list[np.ndarray]:
+    return [
+        np.array([1.0e-3, 0.0e-3, 0.0e-3]),
+        np.array([0.0e-3, 1.0e-3, 0.0e-3]),
+        np.array([0.0e-3, 0.0e-3, 1.0e-3]),
+        np.array([1.0e-3, 1.0e-3, 1.0e-3]),
+    ]
+
+
+@pytest.fixture
+def mass_flow_rate_profile() -> list[float]:
+    return [-1.0e-5, -1.1e-5, -0.9e-5, -1.0e-5]
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+        CartesianAcceleration.thrust_acceleration(),
+        CoordinateSubset.mass_flow_rate(),
+    ]
+
+
+@pytest.fixture
+def maneuver(
+    instants: list[Instant],
+    acceleration_profile: list[np.ndarray],
+    mass_flow_rate_profile: list[float],
+    frame: Frame,
+    coordinate_subsets: list[CoordinateSubset],
+) -> Maneuver:
+    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 Maneuver(states)
+
+
+class TestConstantThrust:
+    def test_constructors(self, guidance_law: ConstantThrust):
+        assert guidance_law is not None
+        assert isinstance(guidance_law, ConstantThrust)
+        assert isinstance(guidance_law, GuidanceLaw)
+
+    def test_getters(self, guidance_law: ConstantThrust):
+        assert guidance_law.get_local_thrust_direction() is not None
+
+    def test_static_constructors(self):
+        assert ConstantThrust.intrack() is not None
+
+        assert ConstantThrust.intrack(velocity_direction=False) is not None
+
+        assert ConstantThrust.intrack(velocity_direction=True) is not None
+
+    def test_compute_acceleration_success(
+        self,
+        guidance_law: ConstantThrust,
+        instant: Instant,
+        position_coordinates: list[float],
+        velocity_coordinates: list[float],
+        thrust_acceleration: float,
+        frame: Frame,
+    ):
+        contribution = guidance_law.calculate_thrust_acceleration_at(
+            instant=instant,
+            position_coordinates=position_coordinates,
+            velocity_coordinates=velocity_coordinates,
+            thrust_acceleration=thrust_acceleration,
+            output_frame=frame,
+        )
+
+        assert len(contribution) == 3
+        assert contribution == pytest.approx([0.0, 0.009523809523809525, 0.0], abs=5e-11)
+
+    def test_from_maneuver(self, maneuver: Maneuver):
+        constant_thrust = ConstantThrust.from_maneuver(
+            maneuver=maneuver,
+            local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+        )
+        assert isinstance(constant_thrust, ConstantThrust)
+
+        constant_thrust_with_maximum_allowed_angular_offset = (
+            ConstantThrust.from_maneuver(
+                maneuver=maneuver,
+                local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+                maximum_allowed_angular_offset=Angle.degrees(180.0),
+            )
+        )
+        assert isinstance(
+            constant_thrust_with_maximum_allowed_angular_offset, ConstantThrust
+        )

ostk/astrodynamics/test/guidance_law/test_guidance_law.py

@@ -0,0 +1,60 @@
+# Apache License 2.0
+
+import numpy as np
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+from ostk.astrodynamics import GuidanceLaw
+
+
+@pytest.fixture
+def guidance_law() -> GuidanceLaw:
+    class MyGuidanceLaw(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([0.0, 0.0, 0.0])
+
+    return MyGuidanceLaw("My Guidance Law")
+
+
+class TestGuidanceLaw:
+    def test_subclass(
+        self,
+        guidance_law: GuidanceLaw,
+    ):
+        assert isinstance(guidance_law, GuidanceLaw)
+
+    def test_get_name(
+        self,
+        guidance_law: GuidanceLaw,
+    ):
+        assert guidance_law.get_name() == "My Guidance Law"
+
+    def test_calculate_thrust_acceleration_at(
+        self,
+        guidance_law: GuidanceLaw,
+    ):
+        thrust_acceleration: np.array = guidance_law.calculate_thrust_acceleration_at(
+            instant=Instant.J2000(),
+            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(),
+        )
+
+        assert np.array_equal(thrust_acceleration, np.array([0.0, 0.0, 0.0]))

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/guidance_law/test_qlaw.py

@@ -0,0 +1,209 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.unit import Derived
+from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
+from ostk.physics.time import Instant
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+
+
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+from ostk.astrodynamics import GuidanceLaw
+from ostk.astrodynamics.guidance_law import QLaw
+from ostk.astrodynamics.trajectory import State
+
+
+@pytest.fixture
+def target_COE() -> COE:
+    return COE(
+        Length.meters(42000.0e3),
+        0.01,
+        Angle.degrees(0.05),
+        Angle.degrees(0.0),
+        Angle.degrees(0.0),
+        Angle.degrees(0.0),
+    )
+
+
+@pytest.fixture
+def gravitational_parameter() -> Derived:
+    return Derived(
+        3.986004418e14,
+        EarthGravitationalModel.EGM2008.gravitational_parameter.get_unit(),
+    )
+
+
+@pytest.fixture
+def parameters() -> QLaw.Parameters:
+    return QLaw.Parameters(
+        element_weights={
+            COE.Element.SemiMajorAxis: (1.0, 100.0),
+            COE.Element.Eccentricity: (1.0, 1e-3),
+        },
+        m=5,
+        n=6,
+        r=7,
+        b=0.08,
+        k=9,
+        periapsis_weight=0.1,
+        minimum_periapsis_radius=Length.kilometers(7000.0),
+        absolute_effectivity_threshold=0.2,
+        relative_effectivity_threshold=0.3,
+    )
+
+
+@pytest.fixture
+def gradient_strategy() -> QLaw.GradientStrategy:
+    return QLaw.GradientStrategy.FiniteDifference
+
+
+@pytest.fixture
+def q_law(
+    target_COE: COE,
+    gravitational_parameter: Derived,
+    parameters: QLaw.Parameters,
+    gradient_strategy: QLaw.GradientStrategy,
+) -> QLaw:
+    return QLaw(
+        target_coe=target_COE,
+        gravitational_parameter=gravitational_parameter,
+        parameters=parameters,
+        coe_domain=QLaw.COEDomain.Osculating,
+        gradient_strategy=gradient_strategy,
+    )
+
+
+@pytest.fixture
+def thrust_acceleration() -> float:
+    return 1.0 / 300.0
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def position_coordinates() -> list[float]:
+    return [6930000.0, 0.0, 0.0]
+
+
+@pytest.fixture
+def velocity_coordinates() -> list[float]:
+    return [0.0, 7621.89248591193, 6.65135764404186]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def position(frame: Frame, position_coordinates: list[float]) -> Position:
+    return Position.meters(position_coordinates, frame)
+
+
+@pytest.fixture
+def velocity(frame: Frame, velocity_coordinates: list[float]) -> Velocity:
+    return Velocity.meters_per_second(velocity_coordinates, frame)
+
+
+@pytest.fixture
+def state(instant: Instant, position: Position, velocity: Velocity) -> State:
+    return State(instant=instant, position=position, velocity=velocity)
+
+
+class TestQLawParameters:
+    def test_constructors(self, parameters: QLaw.Parameters):
+        assert parameters is not None
+        assert isinstance(parameters, QLaw.Parameters)
+
+    def test_getters(self, parameters: QLaw.Parameters):
+        assert parameters.get_control_weights() is not None
+        assert parameters.get_convergence_thresholds() is not None
+        assert parameters.m == 5
+        assert parameters.n == 6
+        assert parameters.r == 7
+        assert parameters.b == 0.08
+        assert parameters.k == 9
+        assert parameters.periapsis_weight == 0.1
+        assert parameters.get_minimum_periapsis_radius() == Length.kilometers(7000.0)
+        assert parameters.absolute_effectivity_threshold == 0.2
+        assert parameters.relative_effectivity_threshold == 0.3
+
+
+class TestQLaw:
+    def test_constructors(
+        self,
+        target_COE: COE,
+        gravitational_parameter: Derived,
+        parameters: QLaw.Parameters,
+        gradient_strategy: QLaw.GradientStrategy,
+    ):
+        qlaw: QLaw = QLaw(
+            target_coe=target_COE,
+            gravitational_parameter=gravitational_parameter,
+            parameters=parameters,
+            coe_domain=QLaw.COEDomain.BrouwerLyddaneMeanLong,
+            gradient_strategy=gradient_strategy,
+        )
+
+        assert qlaw is not None
+        assert isinstance(qlaw, QLaw)
+        assert isinstance(qlaw, GuidanceLaw)
+
+    def test_getters(self, q_law: QLaw):
+        assert q_law.get_parameters() is not None
+        assert q_law.get_target_coe() is not None
+        assert q_law.get_gradient_strategy() is not None
+        assert q_law.get_coe_domain() is not None
+
+    def test_calculate_thrust_acceleration_at(
+        self,
+        q_law: QLaw,
+        position_coordinates: list[float],
+        velocity_coordinates: list[float],
+        thrust_acceleration: float,
+        instant: Instant,
+        frame: Frame,
+    ):
+        assert pytest.approx(
+            q_law.calculate_thrust_acceleration_at(
+                instant=instant,
+                position_coordinates=position_coordinates,
+                velocity_coordinates=velocity_coordinates,
+                thrust_acceleration=thrust_acceleration,
+                output_frame=frame,
+            )
+        ) == np.array([0.0, 0.0033333320640941645, 2.9088817174504986e-06])
+
+    def test_compute_effectivity(
+        self,
+        q_law: QLaw,
+        state: State,
+        thrust_acceleration: float,
+    ):
+        assert (
+            q_law.compute_effectivity(
+                state=state,
+                thrust_acceleration=thrust_acceleration,
+            )
+            is not None
+        )
+
+        assert (
+            q_law.compute_effectivity(
+                state=state,
+                thrust_acceleration=thrust_acceleration,
+                discretization_step_count=15,
+            )
+            is not None
+        )

ostk/astrodynamics/test/solvers/__init__.py

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