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

ostk/astrodynamics/test/flight/test_maneuver.py

@@ -0,0 +1,231 @@
+# 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.physics.unit import Angle
+
+from ostk.astrodynamics.dynamics import Tabulated as TabulatedDynamics
+from ostk.astrodynamics.flight import Maneuver
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameDirection
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory import State
+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.coordinate_subset import CartesianAcceleration
+
+
+@pytest.fixture
+def instants() -> list[Instant]:
+    return [
+        Instant.J2000(),
+        Instant.J2000() + Duration.seconds(30.0),
+        Instant.J2000() + Duration.seconds(35.0),
+        Instant.J2000() + Duration.seconds(37.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 coordinate_subsets() -> list[CoordinateSubset]:
+    return [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+        CartesianAcceleration.thrust_acceleration(),
+        CoordinateSubset.mass_flow_rate(),
+    ]
+
+
+@pytest.fixture
+def states(
+    instants: list[Instant],
+    acceleration_profile: list[np.ndarray],
+    mass_flow_rate_profile: list[float],
+    frame: Frame,
+    coordinate_subsets: list[CoordinateSubset],
+) -> list[State]:
+    states = []
+    for instant, acceleration, mass_flow_rate in zip(
+        instants, acceleration_profile, mass_flow_rate_profile
+    ):
+        states.append(
+            State(
+                instant,
+                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, *acceleration, mass_flow_rate],
+                frame,
+                coordinate_subsets,
+            )
+        )
+    return states
+
+
+@pytest.fixture
+def maneuver(
+    states: list[State],
+) -> Maneuver:
+    return Maneuver(states)
+
+
+@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,
+        states: list[State],
+    ):
+        assert maneuver.is_defined()
+
+        assert maneuver.get_states() == states
+
+        assert maneuver.get_interval() == Interval.closed(
+            states[0].get_instant(), states[-1].get_instant()
+        )
+
+    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() == [
+            state.get_instant() for state in maneuver.get_states()
+        ]
+
+        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_calculate_mean_thrust_direction_and_maximum_angular_offset(
+        self,
+        maneuver: Maneuver,
+    ):
+        mean_thrust_direction_and_maximum_angular_offset = (
+            maneuver.calculate_mean_thrust_direction_and_maximum_angular_offset(
+                local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+            )
+        )
+        assert isinstance(
+            mean_thrust_direction_and_maximum_angular_offset[0],
+            LocalOrbitalFrameDirection,
+        )
+        assert isinstance(mean_thrust_direction_and_maximum_angular_offset[1], Angle)
+
+    def test_to_constant_local_orbital_frame_direction_maneuver(
+        self,
+        maneuver: Maneuver,
+    ):
+        maneuver: Maneuver = maneuver.to_constant_local_orbital_frame_direction_maneuver(
+            local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+        )
+        assert maneuver.is_defined()
+
+        maneuver_with_maximum_allowed_angular_offset: Maneuver = (
+            maneuver.to_constant_local_orbital_frame_direction_maneuver(
+                local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+                maximum_allowed_angular_offset=Angle.degrees(180.0),
+            )
+        )
+        assert maneuver_with_maximum_allowed_angular_offset.is_defined()
+
+    def test_from_constant_mass_flow_rate(
+        self,
+        states: list[State],
+    ):
+        mass_flow_rate: float = -1.0e-5
+        maneuver: Maneuver = Maneuver.constant_mass_flow_rate_profile(
+            states=states,
+            mass_flow_rate=mass_flow_rate,
+        )
+
+        assert maneuver.is_defined()

ostk/astrodynamics/test/flight/test_profile.py

@@ -0,0 +1,293 @@
+# 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 import Environment
+from ostk.physics.time import DateTime
+from ostk.physics.time import Duration
+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.unit import Angle
+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, 1, 0, 0, 30), Scale.UTC)
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def orbit(instant: Instant, environment: Environment) -> Orbit:
+    return Orbit.sun_synchronous(
+        epoch=instant,
+        altitude=Length.kilometers(500.0),
+        local_time_at_descending_node=Time(14, 0, 0),
+        celestial_object=environment.access_celestial_object_with_name("Earth"),
+    )
+
+
+@pytest.fixture
+def transform_model() -> TransformModel:
+    def dynamic_provider_generator(instant: Instant):
+        return Transform.identity(instant)
+
+    return TransformModel(
+        dynamic_provider=DynamicProvider(dynamic_provider_generator),
+        frame=Frame.GCRF(),
+    )
+
+
+@pytest.fixture
+def tabulated_model() -> TabulatedModel:
+    return 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(),
+            ),
+        ],
+        interpolator_type=Interpolator.Type.Linear,
+    )
+
+
+@pytest.fixture(
+    params=[
+        "transform_model",
+        "tabulated_model",
+    ]
+)
+def profile(request) -> Profile:
+    model: TransformModel | TabulatedModel = request.getfixturevalue(request.param)
+    return Profile(model=model)
+
+
+# TODO: Add test for target_sliding_ground_velocity
+@pytest.fixture(
+    params=[
+        # Axis-based constructors
+        Profile.Target(Profile.TargetType.GeocentricNadir, Profile.Axis.X),
+        Profile.TrajectoryTarget.target_position(
+            Trajectory.position(Position.meters((7000000.0, 0.0, 0.0), Frame.ITRF())),
+            Profile.Axis.X,
+        ),
+        Profile.TrajectoryTarget.target_velocity(
+            Trajectory.position(Position.meters((7000000.0, 0.0, 0.0), Frame.ITRF())),
+            Profile.Axis.X,
+        ),
+        Profile.OrientationProfileTarget(
+            [
+                (Instant.J2000(), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(1.0), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(2.0), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(3.0), [1.0, 0.0, 0.0]),
+            ],
+            Profile.Axis.X,
+            False,
+            Interpolator.Type.Linear,
+        ),
+        Profile.CustomTarget(
+            lambda state: [1.0, 0.0, 0.0],
+            Profile.Axis.X,
+        ),
+        # Vector3d-based constructors
+        Profile.Target(Profile.TargetType.GeocentricNadir, [1.0, 0.0, 0.0]),
+        Profile.TrajectoryTarget.target_position(
+            Trajectory.position(Position.meters((7000000.0, 0.0, 0.0), Frame.ITRF())),
+            [1.0, 0.0, 0.0],
+        ),
+        Profile.TrajectoryTarget.target_velocity(
+            Trajectory.position(Position.meters((7000000.0, 0.0, 0.0), Frame.ITRF())),
+            [1.0, 0.0, 0.0],
+        ),
+        Profile.OrientationProfileTarget(
+            [
+                (Instant.J2000(), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(1.0), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(2.0), [1.0, 0.0, 0.0]),
+                (Instant.J2000() + Duration.minutes(3.0), [1.0, 0.0, 0.0]),
+            ],
+            [1.0, 0.0, 0.0],
+            Interpolator.Type.Linear,
+        ),
+        Profile.CustomTarget(
+            lambda state: [1.0, 0.0, 0.0],
+            [0.0, 0.0, 1.0],
+        ),
+    ]
+)
+def alignment_target(request) -> Profile.Target:
+    return request.param
+
+
+@pytest.fixture
+def clocking_target() -> Profile.Target:
+    return Profile.Target(Profile.TargetType.VelocityECI, Profile.Axis.Y)
+
+
+class TestProfile:
+    def test_constructors(self, profile: Profile):
+        assert profile is not None
+        assert isinstance(profile, Profile)
+
+    def test_profile_target(self, alignment_target: Profile.Target):
+        assert alignment_target is not None
+        assert isinstance(alignment_target, Profile.Target)
+
+    def test_access_model(self, profile: Profile):
+        model = profile.access_model()
+
+        assert model is not None
+
+        if model.is_transform():
+            assert model.as_transform() is not None
+
+        if model.is_tabulated():
+            assert model.as_tabulated() is not None
+
+    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_construct_body_frame(self, profile: Profile):
+        frame_name: str = "test_construct_body_frame"
+
+        if Frame.exists(frame_name):
+            Frame.destruct(frame_name)
+
+        frame: Frame = profile.construct_body_frame(frame_name)
+        assert frame is not None
+
+        frame_2: Frame = profile.construct_body_frame(frame_name, True)
+        assert frame_2 is not None
+
+    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.ITRF())
+        )
+
+        profile: Profile = Profile.inertial_pointing(trajectory, quaternion)
+
+        assert profile is not None
+        assert isinstance(profile, Profile)
+        assert profile.is_defined()
+
+    def test_local_orbital_frame_pointing(
+        self,
+        orbit: Orbit,
+    ):
+        profile: Profile = Profile.local_orbital_frame_pointing(
+            orbit, Orbit.FrameType.VVLH
+        )
+
+        assert profile is not None
+        assert isinstance(profile, Profile)
+        assert profile.is_defined()
+
+    def test_align_and_constrain(
+        self,
+        orbit: Orbit,
+        instant: Instant,
+        alignment_target: Profile.Target,
+        clocking_target: Profile.Target,
+    ):
+        orientation = Profile.align_and_constrain(
+            alignment_target=alignment_target,
+            clocking_target=clocking_target,
+        )
+
+        assert orientation is not None
+        assert orientation(orbit.get_state_at(instant)) is not None
+
+    def test_custom_pointing(
+        self,
+        orbit: Orbit,
+        alignment_target: Profile.Target,
+        clocking_target: Profile.Target,
+    ):
+        profile = Profile.custom_pointing(
+            orbit=orbit,
+            orientation_generator=Profile.align_and_constrain(
+                alignment_target, clocking_target
+            ),
+        )
+
+        assert profile is not None
+        assert profile.is_defined()
+
+        profile = Profile.custom_pointing(
+            orbit=orbit,
+            alignment_target=alignment_target,
+            clocking_target=clocking_target,
+        )
+
+        assert profile is not None
+        assert profile.is_defined()
+
+        profile = Profile.custom_pointing(
+            orbit=orbit,
+            alignment_target=alignment_target,
+            clocking_target=clocking_target,
+            angular_offset=Angle.degrees(90.0),
+        )
+
+        assert profile is not None
+        assert profile.is_defined()

ostk/astrodynamics/test/flight/test_system.py

@@ -0,0 +1,45 @@
+# Apache License 2.0
+
+import pytest
+
+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 import 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