open-space-toolkit-astrodynamics 13.1.0__py313-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,253 @@
+# 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 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.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(),
+            ),
+        ],
+    )
+
+
+@pytest.fixture(
+    params=[
+        "transform_model",
+        "tabulated_model",
+    ]
+)
+def profile(request) -> Profile:
+    model: TransformModel | TabulatedModel = request.getfixturevalue(request.param)
+    return Profile(model=model)
+
+
+@pytest.fixture(
+    params=[
+        Profile.Target(Profile.TargetType.GeocentricNadir, Profile.Axis.X),
+        Profile.TrajectoryTarget(
+            Trajectory.position(Position.meters((0.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,
+        ),
+        Profile.CustomTarget(
+            lambda state: [1.0, 0.0, 0.0],
+            Profile.Axis.X,
+        ),
+    ]
+)
+def alignment_target() -> Profile.Target:
+    return Profile.Target(Profile.TargetType.GeocentricNadir, Profile.Axis.X)
+
+
+@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_get_body_frame(self, profile: Profile):
+        if Frame.exists("Name"):
+            Frame.destruct("Name")
+
+        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.ITRF())
+        )
+
+        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,
+        orbit: Orbit,
+    ):
+        profile: Profile = Profile.nadir_pointing(orbit, Orbit.FrameType.VVLH)
+
+        assert profile is not None
+        assert isinstance(profile, Profile)
+        assert profile.is_defined()
+
+    def test_custom_pointing(
+        self,
+        orbit: Orbit,
+        alignment_target: Profile.Target,
+        clocking_target: Profile.Target,
+    ):
+        profile = Profile.custom_pointing(
+            orbit, Profile.align_and_constrain(alignment_target, clocking_target)
+        )
+
+        assert profile is not None
+        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, Profile.align_and_constrain(alignment_target, clocking_target)
+        )
+
+        assert profile is not None
+        assert profile.is_defined()
+
+        profile = Profile.custom_pointing(
+            orbit,
+            alignment_target,
+            clocking_target,
+        )
+
+        assert profile is not None
+        assert profile.is_defined()

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