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

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/__init__.py

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

ostk/astrodynamics/test/flight/profile/test_state.py

@@ -0,0 +1,144 @@
+# 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
+
+Quaternion = mathematics.geometry.d3.transformation.rotation.Quaternion
+DateTime = physics.time.DateTime
+Instant = physics.time.Instant
+Scale = physics.time.Scale
+Position = physics.coordinate.Position
+Velocity = physics.coordinate.Velocity
+Frame = physics.coordinate.Frame
+State = astrodynamics.flight.profile.State
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2020, 1, 3, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def position(frame: Frame) -> Position:
+    return Position.meters([0.0, 3.2, 3000.0], frame)
+
+
+@pytest.fixture
+def velocity(frame: Frame) -> Velocity:
+    return Velocity.meters_per_second([1.0, 3.0, 0.0], frame)
+
+
+@pytest.fixture
+def quaternion() -> Quaternion:
+    return Quaternion([0.0, 0.0, 0.0, 1.0], Quaternion.Format.XYZS)
+
+
+@pytest.fixture
+def angular_velocity() -> np.array:
+    return np.array((0.01, 0.01, 0.0))
+
+
+@pytest.fixture
+def state(
+    instant: Instant,
+    position: Position,
+    velocity: Velocity,
+    quaternion: Quaternion,
+    angular_velocity: np.array,
+    frame: Frame,
+) -> State:
+    return State(
+        instant,
+        position,
+        velocity,
+        quaternion,
+        angular_velocity,
+        frame,
+    )
+
+
+class TestState:
+    def test_constructors_list(
+        self, instant: Instant, quaternion: Quaternion, frame: Frame
+    ):
+        position = Position.meters([0.0, 3.2, 3000.0], frame)
+        velocity = Velocity.meters_per_second([1.0, 3.0, 0.0], frame)
+        angular_velocity = [0.01, 0.01, 0.0]
+
+        assert isinstance(
+            State(instant, position, velocity, quaternion, angular_velocity, frame),
+            State,
+        )
+
+    def test_constructors_tuples(
+        self, instant: Instant, quaternion: Quaternion, frame: Frame
+    ):
+        position = Position.meters((0.0, 3.2, 3000.0), frame)
+        velocity = Velocity.meters_per_second((1.0, 3.0, 0.0), frame)
+        angular_velocity = (0.01, 0.01, 0.0)
+
+        assert isinstance(
+            State(instant, position, velocity, quaternion, angular_velocity, frame),
+            State,
+        )
+
+    def test_constructors_array(
+        self, instant: Instant, quaternion: Quaternion, frame: Frame
+    ):
+        position = Position.meters(np.array((0.0, 3.2, 3000.0)), Frame.GCRF())
+        velocity = Velocity.meters_per_second(np.array((1.0, 3.0, 0.0)), Frame.GCRF())
+        angular_velocity = np.array((0.01, 0.01, 0.0))
+
+        assert isinstance(
+            State(instant, position, velocity, quaternion, angular_velocity, frame),
+            State,
+        )
+
+    def test_comparators(self, state: State):
+        assert (state == state) is True
+        assert (state != state) is False
+
+    def test_get_instant(self, instant: Instant, state: State):
+        assert isinstance(state.get_instant(), Instant)
+        assert state.get_instant() == instant
+
+    def test_get_position(self, position: Position, state: State):
+        assert isinstance(state.get_position(), Position)
+        assert state.get_position() == position
+
+    def test_get_velocity(self, velocity: Velocity, state: State):
+        assert isinstance(state.get_velocity(), Velocity)
+        assert state.get_velocity() == velocity
+
+    def test_get_attitude(self, quaternion: Quaternion, state: State):
+        assert isinstance(state.get_attitude(), Quaternion)
+        assert state.get_attitude() == quaternion
+
+    def test_get_angular_velocity(self, angular_velocity: np.array, state: State):
+        assert isinstance(state.get_angular_velocity(), np.ndarray)
+        assert np.array_equal(state.get_angular_velocity(), angular_velocity)
+
+    def test_get_frame(self, frame: Frame, state: State):
+        assert isinstance(state.get_frame(), Frame)
+        assert state.get_frame() == frame
+
+    def test_in_frame(self, frame: Frame, state: State):
+        assert isinstance(state.in_frame(frame), State)
+
+    def test_undefined(self):
+        state: State = State.undefined()
+
+        assert isinstance(state, State)
+        assert state.is_defined() is False

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,46 @@
+# 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.units.Mass
+
+PropulsionSystem = astrodynamics.flight.system.PropulsionSystem
+
+
+@pytest.fixture
+def propulsion_system() -> PropulsionSystem:
+    return PropulsionSystem(
+        1.0,
+        150.0,
+    )
+
+
+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()

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

@@ -0,0 +1,91 @@
+# 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.objects.Cuboid
+Composite = mathematics.geometry.d3.objects.Composite
+Point = mathematics.geometry.d3.objects.Point
+
+Mass = physics.units.Mass
+
+SatelliteSystem = astrodynamics.flight.system.SatelliteSystem
+PropulsionSystem = astrodynamics.flight.system.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.objects.Cuboid
+Composite = mathematics.geometry.d3.objects.Composite
+Point = mathematics.geometry.d3.objects.Point
+
+Mass = physics.units.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

ostk/astrodynamics/test/flight/test_profile.py

@@ -0,0 +1,153 @@
+# Apache License 2.0
+
+from datetime import datetime
+
+import pytest
+
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+
+from ostk.physics import Environment
+from ostk.physics.time import DateTime
+from ostk.physics.time import Time
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+from ostk.physics.units import Length
+from ostk.physics.coordinate import Transform
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate import Axes
+from ostk.physics.coordinate.frame.providers import Dynamic as DynamicProvider
+
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.flight import Profile
+from ostk.astrodynamics.flight.profile import State
+from ostk.astrodynamics.flight.profile.models import Transform as TransformModel
+from ostk.astrodynamics.flight.profile.models import Tabulated as TabulatedModel
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2020, 1, 3), Scale.UTC)
+
+
+@pytest.fixture
+def profile() -> Profile:
+    def dynamic_provider_generator(instant: Instant):
+        return Transform.identity(instant)
+
+    return Profile(
+        model=TransformModel(
+            dynamic_provider=DynamicProvider(dynamic_provider_generator),
+            frame=Frame.GCRF(),
+        ),
+    )
+
+
+class TestProfile:
+    def test_constructors(self, profile: Profile):
+        assert profile is not None
+        assert isinstance(profile, Profile)
+
+    def test_get_state_at(self, profile: Profile, instant: Instant):
+        state: State = profile.get_state_at(instant)
+
+        assert state is not None
+        assert isinstance(state, State)
+        state.is_defined()
+
+    def test_get_states_at(self, profile: Profile, instant: Instant):
+        states = profile.get_states_at([instant, instant])
+
+        assert states is not None
+
+    def test_get_axes_at(self, profile: Profile, instant: Instant):
+        axes = profile.get_axes_at(instant)
+
+        assert axes is not None
+        assert isinstance(axes, Axes)
+
+    def test_get_body_frame(self, profile: Profile, instant: Instant):
+        frame = profile.get_body_frame("Name")
+
+        assert frame is not None
+        assert isinstance(frame, Frame)
+
+    def test_undefined(self):
+        profile: Profile = Profile.undefined()
+
+        assert profile is not None
+        assert isinstance(profile, Profile)
+        assert profile.is_defined() is False
+
+    def test_inertial_pointing(self):
+        quaternion: Quaternion = Quaternion([0.0, 0.0, 0.0, 1.0], Quaternion.Format.XYZS)
+
+        trajectory: Trajectory = Trajectory.position(
+            Position.meters((0.0, 0.0, 0.0), Frame.GCRF())
+        )
+
+        profile: Profile = Profile.inertial_pointing(trajectory, quaternion)
+
+        assert profile is not None
+        assert isinstance(profile, Profile)
+        assert profile.is_defined()
+
+    def test_nadir_pointing(self):
+        environment = Environment.default()
+
+        orbit = Orbit.sun_synchronous(
+            epoch=Instant.date_time(datetime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+            altitude=Length.kilometers(500.0),
+            local_time_at_descending_node=Time(14, 0, 0),
+            celestial_object=environment.access_celestial_object_with_name("Earth"),
+        )
+
+        profile: Profile = Profile.nadir_pointing(orbit, Orbit.FrameType.VVLH)
+
+        assert profile is not None
+        assert isinstance(profile, Profile)
+        assert profile.is_defined()
+
+    def test_tabulated(self):
+        profile = Profile(
+            model=TabulatedModel(
+                states=[
+                    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),
+                        reference_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),
+                        reference_frame=Frame.GCRF(),
+                    ),
+                ],
+            ),
+        )
+
+        assert isinstance(profile, Profile)
+        assert profile.is_defined()
+
+        assert (
+            profile.get_state_at(
+                Instant.date_time(datetime(2020, 1, 1, 0, 0, 30), Scale.UTC)
+            )
+            is not None
+        )

ostk/astrodynamics/test/flight/test_system.py

@@ -0,0 +1,55 @@
+# 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.objects.Cuboid
+Composite = mathematics.geometry.d3.objects.Composite
+Point = mathematics.geometry.d3.objects.Point
+
+Mass = physics.units.Mass
+
+System = astrodynamics.flight.System
+
+
+@pytest.fixture
+def system_default_inputs():
+    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],
+        )
+    )
+
+    return (mass, geometry)
+
+
+@pytest.fixture
+def system(system_default_inputs) -> System:
+    return System(*system_default_inputs)
+
+
+class TestSatelliteSystem:
+    def test_constructors(self, system: System):
+        assert system is not None
+        assert isinstance(system, System)
+        assert system.is_defined()
+
+    def test_comparators(self, system: System):
+        assert (system == system) is True
+        assert (system != system) is False
+
+    def test_getters(self, system_default_inputs, system: System):
+        (mass, geometry) = system_default_inputs
+
+        assert system.get_mass() == mass
+        assert system.get_geometry() == geometry