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

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/profile/model/test_tabulated_profile.py

@@ -0,0 +1,115 @@
+# Apache License 2.0
+
+from datetime import datetime
+
+import pytest
+
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+from ostk.mathematics.curve_fitting import Interpolator
+
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.flight.profile.model import Tabulated as TabulatedModel
+
+
+@pytest.fixture
+def states() -> list[State]:
+    return [
+        State(
+            instant=Instant.date_time(datetime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+            position=Position.meters((0.0, 0.0, 0.0), Frame.GCRF()),
+            velocity=Velocity.meters_per_second((0.0, 0.0, 0.0), Frame.GCRF()),
+            attitude=Quaternion.unit(),
+            angular_velocity=(0.0, 0.0, 0.0),
+            attitude_frame=Frame.GCRF(),
+        ),
+        State(
+            instant=Instant.date_time(datetime(2020, 1, 1, 0, 1, 0), Scale.UTC),
+            position=Position.meters((0.0, 0.0, 0.0), Frame.GCRF()),
+            velocity=Velocity.meters_per_second((0.0, 0.0, 0.0), Frame.GCRF()),
+            attitude=Quaternion.unit(),
+            angular_velocity=(0.0, 0.0, 0.0),
+            attitude_frame=Frame.GCRF(),
+        ),
+    ]
+
+
+@pytest.fixture
+def interpolator_type() -> Interpolator.Type:
+    return Interpolator.Type.Linear
+
+
+@pytest.fixture
+def tabulated_model(
+    states: list[State],
+    interpolator_type: Interpolator.Type,
+) -> TabulatedModel:
+    return TabulatedModel(
+        states=states,
+        interpolator_type=interpolator_type,
+    )
+
+
+class TestTabulatedProfile:
+    def test_constructors(
+        self,
+        tabulated_model: TabulatedModel,
+    ):
+        assert tabulated_model is not None
+        assert isinstance(tabulated_model, TabulatedModel)
+
+    def test_is_defined(
+        self,
+        tabulated_model: TabulatedModel,
+    ):
+        assert tabulated_model.is_defined() is True
+
+    def test_get_interval(
+        self,
+        tabulated_model: TabulatedModel,
+    ):
+        interval = tabulated_model.get_interval()
+
+        assert interval is not None
+
+    def test_get_interpolator_type(
+        self,
+        tabulated_model: TabulatedModel,
+    ):
+        interpolator_type = tabulated_model.get_interpolator_type()
+
+        assert interpolator_type is not None
+
+    def test_calculate_state_at(
+        self,
+        tabulated_model: TabulatedModel,
+        states: list[State],
+    ):
+        state: State = tabulated_model.calculate_state_at(states[0].get_instant())
+
+        assert state is not None
+
+    def test_get_axes_at(
+        self,
+        tabulated_model: TabulatedModel,
+        states: list[State],
+    ):
+        axes = tabulated_model.get_axes_at(states[0].get_instant())
+
+        assert axes is not None
+
+    def test_construct_body_frame(
+        self,
+        tabulated_model: TabulatedModel,
+    ):
+        if Frame.exists("test"):
+            Frame.destruct("test")
+
+        body_frame = tabulated_model.construct_body_frame("test")
+
+        assert body_frame is not None

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,64 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Mass
+from ostk.astrodynamics.flight.system import 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

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

@@ -0,0 +1,83 @@
+# 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.astrodynamics.flight.system import SatelliteSystem
+from ostk.astrodynamics.flight.system import PropulsionSystem
+
+
+@pytest.fixture
+def satellite_system_default_inputs():
+    mass = Mass(90.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.2
+    propulsion_system = PropulsionSystem(
+        1.0,
+        150.0,
+    )
+
+    return (
+        mass,
+        satellite_geometry,
+        inertia_tensor,
+        surface_area,
+        drag_coefficient,
+        propulsion_system,
+    )
+
+
+@pytest.fixture
+def satellite_system(satellite_system_default_inputs) -> SatelliteSystem:
+    return SatelliteSystem(*satellite_system_default_inputs)
+
+
+class TestSatelliteSystem:
+    def test_constructors(
+        self,
+        satellite_system: SatelliteSystem,
+    ):
+        assert satellite_system is not None
+        assert isinstance(satellite_system, SatelliteSystem)
+        assert satellite_system.is_defined()
+
+    def test_comparators(
+        self,
+        satellite_system: SatelliteSystem,
+    ):
+        assert (satellite_system == satellite_system) is True
+        assert (satellite_system != satellite_system) is False
+
+    def test_getters(
+        self,
+        satellite_system_default_inputs,
+        satellite_system: SatelliteSystem,
+    ):
+        (
+            mass,
+            satellite_geometry,
+            inertia_tensor,
+            surface_area,
+            drag_coefficient,
+            propulsion_system,
+        ) = satellite_system_default_inputs
+
+        assert satellite_system.get_mass() == mass
+        assert satellite_system.get_geometry() == satellite_geometry
+        assert np.array_equal(satellite_system.get_inertia_tensor(), inertia_tensor)
+        assert satellite_system.get_cross_sectional_surface_area() == surface_area
+        assert satellite_system.get_drag_coefficient() == drag_coefficient
+        assert satellite_system.get_propulsion_system() == propulsion_system

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

@@ -0,0 +1,71 @@
+# 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
+
+Cuboid = mathematics.geometry.d3.object.Cuboid
+Composite = mathematics.geometry.d3.object.Composite
+Point = mathematics.geometry.d3.object.Point
+
+Mass = physics.unit.Mass
+
+SatelliteSystem = astrodynamics.flight.system.SatelliteSystem
+SatelliteSystemBuilder = astrodynamics.flight.system.SatelliteSystemBuilder
+PropulsionSystem = astrodynamics.flight.system.PropulsionSystem
+
+
+class TestSatelliteSystemBuilder:
+    def test_constructors(self):
+        builder: SatelliteSystemBuilder = SatelliteSystemBuilder()
+        assert builder is not None
+        assert isinstance(builder, SatelliteSystemBuilder)
+
+        default_builder: SatelliteSystemBuilder = SatelliteSystemBuilder.default()
+        assert default_builder is not None
+        assert isinstance(default_builder, SatelliteSystemBuilder)
+
+    def test_build(self):
+        dry_mass = Mass(90.0, Mass.Unit.Kilogram)
+        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))
+        cross_sectional_surface_area = 0.8
+        drag_coefficient = 2.2
+        propulsion_system = PropulsionSystem(
+            1.0,
+            150.0,
+        )
+
+        builder: SatelliteSystemBuilder = (
+            SatelliteSystemBuilder()
+            .with_dry_mass(dry_mass)
+            .with_geometry(geometry)
+            .with_inertia_tensor(inertia_tensor)
+            .with_cross_sectional_surface_area(cross_sectional_surface_area)
+            .with_drag_coefficient(drag_coefficient)
+            .with_propulsion_system(propulsion_system)
+        )
+
+        satellite_system: SatelliteSystem = builder.build()
+
+        assert satellite_system.get_mass() == dry_mass
+        assert satellite_system.get_geometry() == geometry
+        assert np.array_equal(satellite_system.get_inertia_tensor(), inertia_tensor)
+        assert (
+            satellite_system.get_cross_sectional_surface_area()
+            == cross_sectional_surface_area
+        )
+        assert satellite_system.get_drag_coefficient() == drag_coefficient
+        assert satellite_system.get_propulsion_system() == propulsion_system