open-space-toolkit-astrodynamics 9.4.1__py38-none-manylinux2014_x86_64.whl

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.object.Cuboid
+Composite = mathematics.geometry.d3.object.Composite
+Point = mathematics.geometry.d3.object.Point
+
+Mass = physics.unit.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.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

ostk/astrodynamics/test/flight/test_maneuver.py

@@ -0,0 +1,212 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+
+from ostk.physics.time import Instant
+from ostk.physics.time import Interval
+from ostk.physics.time import Duration
+from ostk.physics.coordinate import Frame
+from ostk.physics.unit import Mass
+
+from ostk.astrodynamics.flight import Maneuver
+from ostk.astrodynamics.dynamics import Tabulated as TabulatedDynamics
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+
+
+from ..dynamics.test_tabulated import (
+    instants as tabulated_instants,
+    contribution_profile as tabulated_contribution_profile,
+    coordinate_subsets as tabulated_coordinate_subsets,
+)
+
+
+@pytest.fixture
+def instants() -> list[Instant]:
+    return [
+        Instant.J2000(),
+        Instant.J2000() + Duration.seconds(1.0),
+        Instant.J2000() + Duration.seconds(5.0),
+        Instant.J2000() + Duration.seconds(7.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 frame() -> Frame:
+    return Frame.GCRF()
+
+
+@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 maneuver(
+    instants: list[Instant],
+    acceleration_profile: list[np.ndarray],
+    frame: Frame,
+    mass_flow_rate_profile: list[float],
+) -> Maneuver:
+    return Maneuver(instants, acceleration_profile, frame, mass_flow_rate_profile)
+
+
+@pytest.fixture
+def tabulated_dynamics(
+    tabulated_instants: list[Instant],
+    tabulated_contribution_profile: np.ndarray,
+    tabulated_coordinate_subsets: list[CoordinateSubset],
+    frame: Frame,
+) -> TabulatedDynamics:
+    return TabulatedDynamics(
+        tabulated_instants,
+        tabulated_contribution_profile,
+        tabulated_coordinate_subsets,
+        frame,
+    )
+
+
+class TestManeuver:
+    def test_constructor(
+        self,
+        maneuver: Maneuver,
+    ):
+        assert maneuver is not None
+        assert isinstance(maneuver, Maneuver)
+        assert maneuver.is_defined()
+
+    def test_comparators(
+        self,
+        maneuver: Maneuver,
+    ):
+        assert (maneuver == maneuver) is True
+        assert (maneuver != maneuver) is False
+
+    def test_getters(
+        self,
+        maneuver: Maneuver,
+        instants: list[Instant],
+        acceleration_profile: list[np.ndarray],
+        mass_flow_rate_profile: list[float],
+    ):
+        assert maneuver.is_defined()
+
+        assert maneuver.get_instants() == instants
+
+        computed_acceleration_profile_default_frame = maneuver.get_acceleration_profile()
+        for i in range(len(instants)):
+            assert np.array_equal(
+                computed_acceleration_profile_default_frame[i], acceleration_profile[i]
+            )
+
+        computed_acceleration_profile_non_default_frame = (
+            maneuver.get_acceleration_profile(frame=Frame.ITRF())
+        )
+        for i in range(len(instants)):
+            assert (
+                np.array_equal(
+                    computed_acceleration_profile_non_default_frame[i],
+                    acceleration_profile[i],
+                )
+                == False
+            )
+
+        assert maneuver.get_mass_flow_rate_profile() == mass_flow_rate_profile
+
+        assert maneuver.get_interval() == Interval.closed(instants[0], instants[-1])
+
+    def test_calculators(
+        self,
+        maneuver: Maneuver,
+    ):
+        assert maneuver.calculate_delta_v() is not None
+        assert maneuver.calculate_delta_mass().in_kilograms() is not None
+        assert (
+            maneuver.calculate_average_thrust(
+                initial_spacecraft_mass=Mass(100.0, Mass.Unit.Kilogram)
+            )
+            is not None
+        )
+        assert (
+            maneuver.calculate_average_specific_impulse(
+                initial_spacecraft_mass=Mass(100.0, Mass.Unit.Kilogram)
+            )
+            is not None
+        )
+
+    def test_to_tabulated_dynamics(
+        self,
+        maneuver: Maneuver,
+        instants: list[Instant],
+        acceleration_profile: list[np.ndarray],
+        frame: Frame,
+        mass_flow_rate_profile: list[float],
+    ):
+        tabulated_dynamics: TabulatedDynamics = maneuver.to_tabulated_dynamics(
+            frame=frame
+        )
+
+        assert tabulated_dynamics.is_defined()
+        assert tabulated_dynamics.access_instants() == maneuver.get_instants()
+
+        contribution_profile: np.ndarray = (
+            tabulated_dynamics.access_contribution_profile()
+        )
+
+        for i in range(len(instants)):
+            assert contribution_profile[i][0:3] == pytest.approx(
+                acceleration_profile[i], rel=1e-15
+            )
+            assert contribution_profile[i][3] == pytest.approx(
+                mass_flow_rate_profile[i], rel=1e-15
+            )
+
+        assert tabulated_dynamics.access_frame() == frame
+
+    def test_from_tabulated_dynamics(
+        self,
+        tabulated_dynamics: TabulatedDynamics,
+    ):
+        maneuver = Maneuver.tabulated_dynamics(tabulated_dynamics)
+
+        assert maneuver.is_defined()
+        assert maneuver.get_instants() == tabulated_dynamics.access_instants()
+        assert (
+            len(maneuver.get_acceleration_profile())
+            == tabulated_dynamics.access_contribution_profile().shape[0]
+        )
+        assert (
+            len(maneuver.get_mass_flow_rate_profile())
+            == tabulated_dynamics.access_contribution_profile().shape[0]
+        )
+
+    def test_from_constant_mass_flow_rate(
+        self,
+        instants: list[Instant],
+        acceleration_profile: list[np.ndarray],
+        frame: Frame,
+    ):
+        mass_flow_rate: float = -1.0e-5
+        maneuver = Maneuver.constant_mass_flow_rate_profile(
+            instants=instants,
+            acceleration_profile=acceleration_profile,
+            frame=frame,
+            mass_flow_rate=mass_flow_rate,
+        )
+
+        assert maneuver.is_defined()
+        assert maneuver.get_mass_flow_rate_profile() == [
+            mass_flow_rate for _ in range(len(instants))
+        ]

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.unit 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.provider import Dynamic as DynamicProvider
+
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.flight import Profile
+from ostk.astrodynamics.flight.profile.model import Transform as TransformModel
+from ostk.astrodynamics.flight.profile.model 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),
+                        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(),
+                    ),
+                ],
+            ),
+        )
+
+        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.object.Cuboid
+Composite = mathematics.geometry.d3.object.Composite
+Point = mathematics.geometry.d3.object.Point
+
+Mass = physics.unit.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

ostk/astrodynamics/test/guidance_law/test_constant_thrust.py

@@ -0,0 +1,91 @@
+# Apache License 2.0
+
+import pytest
+
+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 import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameDirection
+
+from ostk.astrodynamics import GuidanceLaw
+from ostk.astrodynamics.guidance_law import ConstantThrust
+
+
+@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()
+
+
+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)