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

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.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.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 CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+from ostk.astrodynamics.trajectory.state import CoordinateBroker
+
+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 coordinate_broker() -> CoordinateBroker:
+    return CoordinateBroker(
+        [
+            CartesianPosition.default(),
+            CartesianVelocity.default(),
+            CoordinateSubset.mass(),
+        ]
+    )
+
+
+@pytest.fixture
+def state(coordinate_broker: CoordinateBroker) -> 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(), coordinate_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_coordinate_subsets() is not None
+        assert dynamics.get_write_coordinate_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,
+        coordinate_broker: CoordinateBroker,
+        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(), coordinate_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.unit 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.unit 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
+        )

ostk/astrodynamics/test/event_condition/test_real_condition.py

@@ -0,0 +1,50 @@
+# 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 RealCondition
+
+
+@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 target() -> float:
+    return 10.0
+
+
+@pytest.fixture
+def event_condition(evaluator, target: float) -> RealCondition:
+    return RealCondition(
+        "My Condition", RealCondition.Criterion.PositiveCrossing, evaluator, target
+    )
+
+
+class TestRealCondition:
+    def test_evaluate(self, state: State, event_condition: RealCondition):
+        assert event_condition.evaluate(state) is not None
+
+    def test_is_satisfied(self, state: State, event_condition: RealCondition):
+        assert (
+            event_condition.is_satisfied(previous_state=state, current_state=state)
+            is not None
+        )

ostk/astrodynamics/test/flight/__init__.py

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

ostk/astrodynamics/test/flight/system/__init__.py

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

ostk/astrodynamics/test/flight/system/test_propulsion_system.py

@@ -0,0 +1,73 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+import ostk.physics as physics
+
+import ostk.astrodynamics as astrodynamics
+
+Mass = physics.unit.Mass
+
+PropulsionSystem = astrodynamics.flight.system.PropulsionSystem
+
+
+@pytest.fixture
+def propulsion_system() -> PropulsionSystem:
+    return PropulsionSystem(
+        1.0,
+        150.0,
+    )
+
+
+@pytest.fixture
+def mass() -> Mass:
+    return Mass(90.0, Mass.Unit.Kilogram)
+
+
+class TestPropulsionSystem:
+    def test_constructors(
+        self,
+        propulsion_system: PropulsionSystem,
+    ):
+        assert propulsion_system is not None
+        assert isinstance(propulsion_system, PropulsionSystem)
+        assert propulsion_system.is_defined()
+
+    def test_comparators(
+        self,
+        propulsion_system: PropulsionSystem,
+    ):
+        assert (propulsion_system == propulsion_system) is True
+        assert (propulsion_system != propulsion_system) is False
+
+    def test_is_defined(
+        self,
+        propulsion_system: PropulsionSystem,
+    ):
+        assert propulsion_system.is_defined()
+
+    def test_getters(
+        self,
+        propulsion_system: PropulsionSystem,
+        mass: Mass,
+    ):
+        assert propulsion_system.get_thrust() == 1.0
+        assert propulsion_system.get_specific_impulse() == 150.0
+        assert propulsion_system.get_mass_flow_rate() is not None
+        assert propulsion_system.get_acceleration(mass) is not None
+
+    def test_static_methods(
+        self,
+        mass: Mass,
+    ):
+        assert PropulsionSystem.undefined().is_defined() is False
+
+        assert PropulsionSystem.default().is_defined() is True
+        assert PropulsionSystem.default().get_thrust() is not None
+        assert PropulsionSystem.default().get_specific_impulse() is not None
+        assert PropulsionSystem.default().get_mass_flow_rate() is not None
+        assert PropulsionSystem.default().get_acceleration(mass) is not None