open-space-toolkit-astrodynamics 5.1.5__py38-none-any.whl → 5.2.0__py38-none-any.whl

ostk/astrodynamics/test/dynamics/test_position_derivative.py

@@ -0,0 +1,51 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.physics.time import Instant
+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.physics.environment.objects.celestial_bodies import Earth
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics import Dynamics
+from ostk.astrodynamics.dynamics import PositionDerivative
+
+
+@pytest.fixture
+def dynamics() -> PositionDerivative:
+    return PositionDerivative()
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters([7500000.0, 0.0, 0.0], frame)
+    velocity: Velocity = Velocity.meters_per_second(
+        [0.0, 5335.865450622126, 5335.865450622126], frame
+    )
+    instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+class TestPositionDerivative:
+    def test_constructors(
+        self,
+        dynamics: PositionDerivative,
+    ):
+        assert dynamics is not None
+        assert isinstance(dynamics, PositionDerivative)
+        assert isinstance(dynamics, Dynamics)
+        assert dynamics.is_defined()
+
+    def test_compute_contribution(self, dynamics: PositionDerivative, state: State):
+        contribution = dynamics.compute_contribution(
+            state.get_instant(), state.get_coordinates(), state.get_frame()
+        )
+        assert len(contribution) == 3
+        assert contribution == pytest.approx(state.get_coordinates()[:3])

ostk/astrodynamics/test/dynamics/test_third_body_gravity.py

@@ -0,0 +1,67 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.physics.time import Instant
+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.physics.environment.objects.celestial_bodies import Moon
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics import Dynamics
+from ostk.astrodynamics.dynamics import ThirdBodyGravity
+
+
+@pytest.fixture
+def moon() -> Moon:
+    return Moon.spherical()
+
+
+@pytest.fixture
+def dynamics(moon: Moon) -> ThirdBodyGravity:
+    return ThirdBodyGravity(moon)
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters([7000000.0, 0.0, 0.0], frame)
+    velocity: Velocity = Velocity.meters_per_second([0.0, 0.0, 0.0], frame)
+    instant = Instant.date_time(DateTime(2021, 3, 20, 12, 0, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+class TestThirdBodyGravity:
+    def test_constructors(
+        self,
+        dynamics: ThirdBodyGravity,
+    ):
+        assert dynamics is not None
+        assert isinstance(dynamics, ThirdBodyGravity)
+        assert isinstance(dynamics, Dynamics)
+        assert dynamics.is_defined()
+
+    def test_getters(
+        self,
+        dynamics: ThirdBodyGravity,
+        moon: Moon,
+    ):
+        assert dynamics.get_celestial() == moon
+
+    def test_compute_contribution(
+        self,
+        dynamics: ThirdBodyGravity,
+        state: State,
+    ):
+        contribution = dynamics.compute_contribution(
+            state.get_instant(), state.get_coordinates(), state.get_frame()
+        )
+        assert len(contribution) == 3
+        assert contribution == pytest.approx(
+            [-4.620543790697659e-07, 2.948717888154649e-07, 1.301648617451192e-07]
+        )

ostk/astrodynamics/test/dynamics/test_thruster.py

@@ -0,0 +1,142 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.geometry.d3.objects import Cuboid
+from ostk.mathematics.geometry.d3.objects import Composite
+from ostk.mathematics.geometry.d3.objects import Point
+
+from ostk.physics.units import Mass
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinatesSubset
+from ostk.astrodynamics.trajectory.state.coordinates_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinates_subset import CartesianVelocity
+from ostk.astrodynamics.trajectory.state import CoordinatesBroker
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.flight.system import PropulsionSystem
+from ostk.astrodynamics.flight.system import SatelliteSystem
+from ostk.astrodynamics import Dynamics
+from ostk.astrodynamics.dynamics import Thruster
+from ostk.astrodynamics.guidance_law import ConstantThrust
+
+
+@pytest.fixture
+def guidance_law() -> ConstantThrust:
+    return ConstantThrust.intrack(True)
+
+
+@pytest.fixture
+def propulsion_system() -> PropulsionSystem:
+    return PropulsionSystem(
+        1.0,
+        150.0,
+    )
+
+
+@pytest.fixture
+def satellite_system(propulsion_system: PropulsionSystem) -> SatelliteSystem:
+    mass = Mass(100.0, Mass.Unit.Kilogram)
+    satellite_geometry = Composite(
+        Cuboid(
+            Point(0.0, 0.0, 0.0),
+            [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
+            [1.0, 0.0, 0.0],
+        )
+    )
+    inertia_tensor = np.ndarray(shape=(3, 3))
+    surface_area = 0.8
+    drag_coefficient = 2.1
+
+    return SatelliteSystem(
+        mass,
+        satellite_geometry,
+        inertia_tensor,
+        surface_area,
+        drag_coefficient,
+        propulsion_system,
+    )
+
+
+@pytest.fixture
+def dynamics(
+    satellite_system: SatelliteSystem,
+    guidance_law: ConstantThrust,
+) -> Thruster:
+    return Thruster(
+        satellite_system=satellite_system,
+        guidance_law=guidance_law,
+        name="Constant Thrust Thruster Dynamics",
+    )
+
+
+@pytest.fixture
+def coordinates_broker() -> CoordinatesBroker:
+    return CoordinatesBroker(
+        [
+            CartesianPosition.default(),
+            CartesianVelocity.default(),
+            CoordinatesSubset.mass(),
+        ]
+    )
+
+
+@pytest.fixture
+def state(coordinates_broker: CoordinatesBroker) -> State:
+    instant: Instant = Instant.date_time(DateTime(2021, 3, 20, 12, 0, 0), Scale.UTC)
+    coordinates: list = [7000000.0, 0.0, 0.0, 0.0, 7546.05329, 0.0, 105.0]
+
+    return State(instant, coordinates, Frame.GCRF(), coordinates_broker)
+
+
+class TestThruster:
+    def test_constructors(self, dynamics: Thruster):
+        assert dynamics is not None
+        assert isinstance(dynamics, Thruster)
+        assert isinstance(dynamics, Dynamics)
+        assert dynamics.is_defined()
+
+    def test_getters(self, dynamics: Thruster):
+        assert dynamics.get_satellite_system() is not None
+        assert dynamics.get_guidance_law() is not None
+        assert dynamics.get_read_coordinates_subsets() is not None
+        assert dynamics.get_write_coordinates_subsets() is not None
+
+    def test_compute_contribution_success(self, dynamics: Thruster, state: State):
+        contribution = dynamics.compute_contribution(
+            state.get_instant(), state.get_coordinates(), state.get_frame()
+        )
+
+        assert len(contribution) == 4
+        assert contribution == pytest.approx(
+            [0.0, 0.009523809523809525, 0.0, -0.0006798108086519521], abs=5e-11
+        )
+
+    def test_compute_contribution_failure_out_of_fuel(
+        self,
+        satellite_system: SatelliteSystem,
+        coordinates_broker: CoordinatesBroker,
+        dynamics: Thruster,
+    ):
+        instant: Instant = Instant.date_time(DateTime(2021, 3, 20, 12, 0, 0), Scale.UTC)
+        coordinates: list = [
+            7000000.0,
+            0.0,
+            0.0,
+            0.0,
+            7546.05329,
+            0.0,
+            satellite_system.get_mass().in_kilograms(),
+        ]
+        state = State(instant, coordinates, Frame.GCRF(), coordinates_broker)
+
+        with pytest.raises(RuntimeError):
+            contribution = dynamics.compute_contribution(
+                state.get_instant(), state.get_coordinates(), state.get_frame()
+            )

ostk/astrodynamics/test/event_condition/test_angular_condition.py

@@ -0,0 +1,113 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant, DateTime, Scale
+from ostk.physics.coordinate import Frame, Position, Velocity
+from ostk.physics.units import Angle
+
+from ostk.astrodynamics.trajectory import State
+
+from ostk.astrodynamics.event_condition import AngularCondition
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters([7500000.0, 0.0, 0.0], frame)
+    velocity: Velocity = Velocity.meters_per_second(
+        [0.0, 5335.865450622126, 5335.865450622126], frame
+    )
+
+    instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def criterion() -> AngularCondition.Criterion:
+    return AngularCondition.Criterion.PositiveCrossing
+
+
+@pytest.fixture
+def evaluator():
+    return lambda state: state.get_coordinates()[0]
+
+
+@pytest.fixture
+def target_angle() -> Angle:
+    return Angle.degrees(0.0)
+
+
+@pytest.fixture
+def target_range() -> tuple[Angle, Angle]:
+    return (Angle.degrees(0.0), Angle.degrees(10.0))
+
+
+@pytest.fixture
+def event_condition(
+    criterion: AngularCondition.Criterion, evaluator, target_angle: Angle
+) -> AngularCondition:
+    return AngularCondition(
+        "My Condition",
+        criterion,
+        evaluator,
+        target_angle,
+    )
+
+
+@pytest.fixture
+def within_range_condition(
+    evaluator, target_range: tuple[Angle, Angle]
+) -> AngularCondition:
+    return AngularCondition.within_range("My Condition", evaluator, target_range)
+
+
+class TestAngularCondition:
+    def test_constructor(
+        self,
+        criterion: AngularCondition.Criterion,
+        evaluator,
+        target_angle: Angle,
+    ):
+        assert (
+            AngularCondition("My Condition", criterion, evaluator, target_angle)
+            is not None
+        )
+
+    def test_get_criterion(
+        self,
+        event_condition: AngularCondition,
+        criterion: AngularCondition.Criterion,
+    ):
+        assert event_condition.get_criterion() == criterion
+
+    def test_get_target_angle(
+        self,
+        event_condition: AngularCondition,
+        within_range_condition: AngularCondition,
+        target_angle: Angle,
+    ):
+        assert event_condition.get_target_angle() == target_angle
+
+        with pytest.raises(RuntimeError):
+            within_range_condition.get_target_angle()
+
+    def test_get_target_range(
+        self,
+        event_condition: AngularCondition,
+        within_range_condition: AngularCondition,
+        target_range: tuple[Angle, Angle],
+    ):
+        with pytest.raises(RuntimeError):
+            event_condition.get_target_range()
+
+        assert within_range_condition.get_target_range() == target_range
+
+    def test_is_satisfied(self, state: State, event_condition: AngularCondition):
+        assert (
+            event_condition.is_satisfied(previous_state=state, current_state=state)
+            is not None
+        )
+
+    def test_string_from_criterion(self, criterion: AngularCondition.Criterion):
+        assert AngularCondition.string_from_criterion(criterion) is not None

ostk/astrodynamics/test/event_condition/test_boolean_condition.py

@@ -0,0 +1,55 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant, DateTime, Scale
+from ostk.physics.coordinate import Frame, Position, Velocity
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.event_condition import BooleanCondition
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters([7500000.0, 0.0, 0.0], frame)
+    velocity: Velocity = Velocity.meters_per_second(
+        [0.0, 5335.865450622126, 5335.865450622126], frame
+    )
+
+    instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def evaluator():
+    return lambda state: state.get_coordinates()[0]
+
+
+@pytest.fixture
+def is_inversed() -> bool:
+    return False
+
+
+@pytest.fixture
+def event_condition(evaluator, is_inversed: bool) -> BooleanCondition:
+    return BooleanCondition(
+        "My Condition",
+        BooleanCondition.Criterion.StrictlyPositive,
+        evaluator,
+        is_inversed,
+    )
+
+
+class TestBooleanCondition:
+    def test_is_inversed(self, event_condition: BooleanCondition, is_inversed: bool):
+        assert event_condition.is_inversed() == is_inversed
+
+    def test_evaluate(self, state: State, event_condition: BooleanCondition):
+        assert event_condition.evaluate(state) is not None
+
+    def test_is_satisfied(self, state: State, event_condition: BooleanCondition):
+        assert (
+            event_condition.is_satisfied(previous_state=state, current_state=state)
+            is not None
+        )

ostk/astrodynamics/test/event_condition/test_coe_condition.py

@@ -0,0 +1,87 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.environment.gravitational import Earth
+from ostk.physics.units import Derived, Length, Angle
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics import EventCondition
+from ostk.astrodynamics.event_condition import (
+    COECondition,
+    AngularCondition,
+    RealCondition,
+)
+
+
+@pytest.fixture
+def criterion() -> AngularCondition.Criterion:
+    return AngularCondition.Criterion.AnyCrossing
+
+
+@pytest.fixture
+def gravitational_parameter() -> Derived:
+    return Earth.spherical.gravitational_parameter
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+class TestCOECondition:
+    @pytest.mark.parametrize(
+        "static_constructor,target,criterion",
+        (
+            (
+                COECondition.semi_major_axis,
+                EventCondition.Target(Length.meters(7e6)),
+                RealCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.eccentricity,
+                EventCondition.Target(0.1),
+                RealCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.inclination,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.aop,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.raan,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.true_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.mean_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.eccentric_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+        ),
+    )
+    def test_static_constructors(
+        self,
+        static_constructor,
+        target,
+        criterion,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
+        condition = static_constructor(criterion, frame, target, gravitational_parameter)
+        assert condition is not None

ostk/astrodynamics/test/event_condition/test_instant_condition.py

@@ -0,0 +1,48 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.coordinate import Frame, Position, Velocity
+from ostk.physics.time import DateTime, Instant, Scale
+
+from ostk.astrodynamics.event_condition import InstantCondition
+from ostk.astrodynamics.trajectory import State
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def criterion() -> InstantCondition.Criterion:
+    return InstantCondition.Criterion.StrictlyPositive
+
+
+@pytest.fixture
+def instant_condition(
+    criterion: InstantCondition.Criterion, instant: Instant
+) -> InstantCondition:
+    return InstantCondition(criterion, instant)
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters(
+        [717094.039086306, -6872433.2241124, 46175.9696673281], frame
+    )
+    velocity: Velocity = Velocity.meters_per_second(
+        [-970.650826004612, -45.4598114773158, 7529.82424886455], frame
+    )
+
+    instant: Instant = Instant.date_time(DateTime(2023, 1, 1, 0, 1, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+class TestInstantCondition:
+    def test_get_instant(self, instant_condition: InstantCondition, instant: Instant):
+        assert instant_condition.get_instant() == instant
+
+    def test_evaluate(self, instant_condition: InstantCondition, state: State):
+        assert instant_condition.evaluate(state) == 60.0

ostk/astrodynamics/test/event_condition/test_logical_condition.py

@@ -0,0 +1,120 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.coordinate import Frame, Position, Velocity
+from ostk.physics.time import DateTime, Instant, Scale
+
+from ostk.astrodynamics.event_condition import RealCondition, LogicalCondition
+from ostk.astrodynamics.trajectory import State
+
+
+@pytest.fixture
+def always_true() -> RealCondition:
+    return RealCondition(
+        "Always True Condition",
+        RealCondition.Criterion.StrictlyPositive,
+        lambda state: 1.0,
+        0.0,
+    )
+
+
+@pytest.fixture
+def always_false() -> RealCondition:
+    return RealCondition(
+        "Always False Condition",
+        RealCondition.Criterion.StrictlyPositive,
+        lambda state: -1.0,
+        0.0,
+    )
+
+
+@pytest.fixture
+def event_conditions(
+    always_true: RealCondition, always_false: RealCondition
+) -> list[RealCondition]:
+    return [always_true, always_false]
+
+
+@pytest.fixture
+def logical_condition_type() -> LogicalCondition.Type:
+    return LogicalCondition.Type.And
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters(
+        [717094.039086306, -6872433.2241124, 46175.9696673281], frame
+    )
+    velocity: Velocity = Velocity.meters_per_second(
+        [-970.650826004612, -45.4598114773158, 7529.82424886455], frame
+    )
+
+    instant: Instant = Instant.date_time(DateTime(2023, 1, 1, 0, 1, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def logical_condition(
+    logical_condition_type: LogicalCondition.Type, event_conditions: list[RealCondition]
+) -> LogicalCondition:
+    return LogicalCondition("Logical", logical_condition_type, event_conditions)
+
+
+class TestLogicalCondition:
+    @pytest.mark.parametrize(
+        "logical_condition_type",
+        (
+            LogicalCondition.Type.And,
+            LogicalCondition.Type.Or,
+        ),
+    )
+    def test_constructor(
+        self,
+        logical_condition_type: LogicalCondition.Type,
+        event_conditions: list[RealCondition],
+    ):
+        assert (
+            LogicalCondition(
+                "Logical Condition", logical_condition_type, event_conditions
+            )
+            is not None
+        )
+
+    def test_get_event_conditions(
+        self,
+        logical_condition: LogicalCondition,
+        event_conditions: list[RealCondition],
+    ):
+        assert logical_condition.get_event_conditions() == event_conditions
+
+    def test_get_type(
+        self,
+        logical_condition: LogicalCondition,
+        logical_condition_type: LogicalCondition.Type,
+    ):
+        assert logical_condition.get_type() == logical_condition_type
+
+    @pytest.mark.parametrize(
+        "logical_condition_type,expected_result",
+        (
+            (LogicalCondition.Type.And, False),
+            (LogicalCondition.Type.Or, True),
+        ),
+    )
+    def test_is_satisfied(
+        self,
+        logical_condition_type: LogicalCondition.Type,
+        expected_result: bool,
+        event_conditions: list[RealCondition],
+        state: State,
+    ):
+        logical_condition: LogicalCondition = LogicalCondition(
+            "Logical Condition", logical_condition_type, event_conditions
+        )
+
+        assert (
+            logical_condition.is_satisfied(previous_state=state, current_state=state)
+            == expected_result
+        )