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

ostk/astrodynamics/test/trajectory/test_sequence.py

@@ -0,0 +1,477 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.geometry.d3.object import Composite
+from ostk.mathematics.geometry.d3.object import Cuboid
+from ostk.mathematics.geometry.d3.object import Point
+
+from ostk.physics import Environment
+from ostk.physics.coordinate import Frame
+from ostk.physics.environment.atmospheric import Earth as EarthAtmosphericModel
+from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
+from ostk.physics.environment.magnetic import Earth as EarthMagneticModel
+from ostk.physics.environment.object.celestial import Earth
+from ostk.physics.time import DateTime
+from ostk.physics.time import Duration
+from ostk.physics.time import Instant
+from ostk.physics.time import Scale
+from ostk.physics.unit import Derived
+from ostk.physics.unit import Length
+from ostk.physics.unit import Mass
+
+from ostk.astrodynamics.event_condition import COECondition
+from ostk.astrodynamics.event_condition import InstantCondition
+from ostk.astrodynamics.event_condition import RealCondition
+from ostk.astrodynamics import Dynamics
+from ostk.astrodynamics import EventCondition
+from ostk.astrodynamics.dynamics import Thruster
+from ostk.astrodynamics.guidance_law import ConstantThrust
+from ostk.astrodynamics.flight.system import PropulsionSystem
+from ostk.astrodynamics.flight.system import SatelliteSystem
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameDirection
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory import Segment
+from ostk.astrodynamics.trajectory import Sequence
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import CoordinateBroker
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+from ostk.astrodynamics.trajectory.state import NumericalSolver
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+
+
+@pytest.fixture
+def propulsion_system() -> PropulsionSystem:
+    return PropulsionSystem(
+        1.0,
+        1500.0,
+    )
+
+
+@pytest.fixture
+def dry_mass() -> Mass:
+    return Mass.kilograms(100.0)
+
+
+@pytest.fixture
+def wet_mass() -> Mass:
+    return Mass.kilograms(10.0)
+
+
+@pytest.fixture
+def cross_sectional_surface_area() -> float:
+    return 1.0
+
+
+@pytest.fixture
+def drag_coefficient() -> float:
+    return 2.2
+
+
+@pytest.fixture
+def satellite_system(
+    dry_mass: Mass,
+    cross_sectional_surface_area: float,
+    drag_coefficient: float,
+    propulsion_system: PropulsionSystem,
+) -> SatelliteSystem:
+    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))
+
+    return SatelliteSystem(
+        dry_mass,
+        satellite_geometry,
+        inertia_tensor,
+        cross_sectional_surface_area,
+        drag_coefficient,
+        propulsion_system,
+    )
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment(
+        Instant.J2000(),
+        [
+            Earth.from_models(
+                EarthGravitationalModel(EarthGravitationalModel.Type.Spherical),
+                EarthMagneticModel(EarthMagneticModel.Type.Undefined),
+                EarthAtmosphericModel(EarthAtmosphericModel.Type.Exponential),
+            )
+        ],
+    )
+
+
+@pytest.fixture
+def coordinate_broker() -> CoordinateBroker:
+    return CoordinateBroker(
+        [
+            CartesianPosition.default(),
+            CartesianVelocity.default(),
+            CoordinateSubset.mass(),
+            CoordinateSubset.surface_area(),
+            CoordinateSubset.drag_coefficient(),
+        ]
+    )
+
+
+@pytest.fixture
+def cartesian_coordinates() -> list[float]:
+    return [
+        717094.039086306,
+        -6872433.2241124,
+        46175.9696673281,
+        -970.650826004612,
+        -45.4598114773158,
+        7529.82424886455,
+    ]
+
+
+@pytest.fixture
+def state(
+    cartesian_coordinates: list[float],
+    dry_mass: Mass,
+    wet_mass: Mass,
+    cross_sectional_surface_area: float,
+    drag_coefficient: float,
+    coordinate_broker: CoordinateBroker,
+) -> State:
+    frame: Frame = Frame.GCRF()
+    instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    coordinates = [
+        *cartesian_coordinates,
+        dry_mass.in_kilograms() + wet_mass.in_kilograms(),
+        cross_sectional_surface_area,
+        drag_coefficient,
+    ]
+
+    return State(
+        instant,
+        [
+            717094.039086306,
+            -6872433.2241124,
+            46175.9696673281,
+            -970.650826004612,
+            -45.4598114773158,
+            7529.82424886455,
+            dry_mass.in_kilograms() + wet_mass.in_kilograms(),
+            cross_sectional_surface_area,
+            drag_coefficient,
+        ],
+        frame,
+        coordinate_broker,
+    )
+
+
+@pytest.fixture
+def dynamics(environment: Environment) -> list:
+    return Dynamics.from_environment(environment)
+
+
+@pytest.fixture
+def numerical_solver() -> NumericalSolver:
+    return NumericalSolver.default_conditional()
+
+
+@pytest.fixture
+def duration() -> Duration:
+    return Duration.minutes(5.0)
+
+
+@pytest.fixture
+def instant_condition(state: State, duration: Duration) -> InstantCondition:
+    return InstantCondition(
+        RealCondition.Criterion.AnyCrossing, state.get_instant() + duration
+    )
+
+
+@pytest.fixture
+def sma() -> Length:
+    return Length.kilometers(6907.000)
+
+
+@pytest.fixture
+def gravitational_parameter() -> Derived:
+    return EarthGravitationalModel.spherical.gravitational_parameter
+
+
+@pytest.fixture
+def constant_thrust() -> ConstantThrust:
+    return ConstantThrust(
+        thrust_direction=LocalOrbitalFrameDirection(
+            vector=[1.0, 0.0, 0.0],
+            local_orbital_frame_factory=LocalOrbitalFrameFactory.VNC(Frame.GCRF()),
+        )
+    )
+
+
+@pytest.fixture
+def thruster_dynamics(
+    satellite_system: SatelliteSystem, constant_thrust: ConstantThrust
+) -> ConstantThrust:
+    return Thruster(
+        satellite_system=satellite_system,
+        guidance_law=constant_thrust,
+    )
+
+
+@pytest.fixture
+def sma_target(sma: Length) -> EventCondition.Target:
+    return EventCondition.Target(sma)
+
+
+@pytest.fixture
+def sma_condition(
+    sma_target: EventCondition.Target, gravitational_parameter: Derived
+) -> COECondition:
+    return COECondition.semi_major_axis(
+        criterion=RealCondition.Criterion.AnyCrossing,
+        frame=Frame.GCRF(),
+        semi_major_axis=sma_target,
+        gravitational_parameter=gravitational_parameter,
+    )
+
+
+@pytest.fixture
+def coast_duration_segment(
+    instant_condition: InstantCondition,
+    dynamics: list[Dynamics],
+    numerical_solver: NumericalSolver,
+):
+    return Segment.coast(
+        name="duration coast",
+        event_condition=instant_condition,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+    )
+
+
+@pytest.fixture
+def coast_sma_segment(
+    sma_condition: COECondition,
+    dynamics: list[Dynamics],
+    numerical_solver: NumericalSolver,
+):
+    return Segment.coast(
+        name="sma coast",
+        event_condition=sma_condition,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+    )
+
+
+@pytest.fixture
+def thrust_segment(
+    sma_condition: RealCondition,
+    thruster_dynamics: Thruster,
+    dynamics: list[Dynamics],
+    numerical_solver: NumericalSolver,
+):
+    return Segment.maneuver(
+        name="duration thrust",
+        event_condition=sma_condition,
+        thruster_dynamics=thruster_dynamics,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+    )
+
+
+@pytest.fixture
+def segments(
+    coast_duration_segment: Segment,
+    thrust_segment: Segment,
+) -> list[Segment]:
+    return [coast_duration_segment, thrust_segment]
+
+
+@pytest.fixture
+def maximum_propagation_duration() -> Duration:
+    return Duration.days(2.0)
+
+
+@pytest.fixture
+def repetition_count() -> int:
+    return 1
+
+
+@pytest.fixture
+def sequence(
+    segments: list[Segment],
+    numerical_solver: NumericalSolver,
+    dynamics: list,
+    maximum_propagation_duration: Duration,
+):
+    return Sequence(
+        segments=segments,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+        maximum_propagation_duration=maximum_propagation_duration,
+    )
+
+
+@pytest.fixture
+def segment_solution(
+    dynamics: list,
+    state: State,
+):
+    return Segment.Solution(
+        name="A Segment Solution",
+        dynamics=dynamics,
+        states=[
+            state,
+        ],
+        condition_is_satisfied=True,
+        segment_type=Segment.Type.Maneuver,
+    )
+
+
+@pytest.fixture
+def instants(state: State) -> list[Instant]:
+    return [state.get_instant(), state.get_instant() + Duration.minutes(1.0)]
+
+
+class TestSequence:
+    def test_get_segments(
+        self,
+        sequence: Sequence,
+        segments: list[Segment],
+    ):
+        assert len(sequence.get_segments()) == len(segments)
+
+    def test_get_numerical_solver(
+        self,
+        sequence: Sequence,
+        numerical_solver: NumericalSolver,
+    ):
+        assert sequence.get_numerical_solver() == numerical_solver
+
+    def test_get_dynamics(
+        self,
+        sequence: Sequence,
+        dynamics: list,
+    ):
+        assert len(sequence.get_dynamics()) == len(dynamics)
+
+    def test_get_maximum_propagation_duration(
+        self,
+        sequence: Sequence,
+        maximum_propagation_duration: Duration,
+    ):
+        assert sequence.get_maximum_propagation_duration() == maximum_propagation_duration
+
+    def test_add_segment(
+        self,
+        sequence: Sequence,
+        coast_duration_segment: Segment,
+    ):
+        segments_count: int = len(sequence.get_segments())
+
+        sequence.add_segment(coast_duration_segment)
+
+        assert len(sequence.get_segments()) == segments_count + 1
+
+        segments_count = len(sequence.get_segments())
+
+        sequence.add_segments([coast_duration_segment, coast_duration_segment])
+
+        assert len(sequence.get_segments()) == segments_count + 2
+
+    def test_add_coast_segment(
+        self,
+        sequence: Sequence,
+        instant_condition: InstantCondition,
+    ):
+        segments_count: int = len(sequence.get_segments())
+
+        sequence.add_coast_segment(instant_condition)
+
+        assert len(sequence.get_segments()) == segments_count + 1
+
+    def test_add_maneuver_segment(
+        self,
+        sequence: Sequence,
+        instant_condition: InstantCondition,
+        thruster_dynamics: Thruster,
+    ):
+        segments_count: int = len(sequence.get_segments())
+
+        sequence.add_maneuver_segment(instant_condition, thruster_dynamics)
+
+        assert len(sequence.get_segments()) == segments_count + 1
+
+    def test_create_sequence_solution(
+        self,
+        segment_solution: Segment.Solution,
+    ):
+        solution: Sequence.Solution = Sequence.Solution(
+            segment_solutions=[
+                segment_solution,
+            ],
+            execution_is_complete=True,
+        )
+
+        assert solution is not None
+        assert len(solution.segment_solutions) == 1
+        assert solution.execution_is_complete
+
+    def test_solve(
+        self,
+        state: State,
+        repetition_count: int,
+        sequence: Sequence,
+        segments: list[Segment],
+        instants: list[Instant],
+        numerical_solver: NumericalSolver,
+    ):
+        solution = sequence.solve(
+            state=state,
+            repetition_count=repetition_count,
+        )
+
+        assert len(solution.segment_solutions) == len(segments)
+
+        assert solution.execution_is_complete
+
+        assert solution.access_start_instant() is not None
+        assert solution.access_end_instant() is not None
+
+        assert solution.get_states() is not None
+        assert solution.get_initial_mass() is not None
+        assert solution.get_final_mass() is not None
+        assert solution.get_propagation_duration() is not None
+
+        assert solution.compute_delta_mass() is not None
+        assert solution.compute_delta_v(1500.0) is not None
+
+        propagated_states = solution.calculate_states_at(
+            instants,
+            numerical_solver,
+        )
+
+        assert propagated_states is not None
+        assert len(propagated_states) == len(instants)
+
+    def test_solve_to_condition(
+        self,
+        state: State,
+        sequence: Sequence,
+        instant_condition: InstantCondition,
+    ):
+        assert sequence.solve_to_condition(state, instant_condition) is not None
+        assert (
+            sequence.solve_to_condition(
+                state=state,
+                event_condition=instant_condition,
+                maximum_propagation_duration_limit=Duration.hours(1.0),
+            )
+            is not None
+        )

ostk/astrodynamics/test/trajectory/test_state.py

@@ -0,0 +1,237 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+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.trajectory.state import CoordinateBroker
+from ostk.astrodynamics.trajectory.state.coordinate_subset import (
+    CartesianPosition,
+    CartesianVelocity,
+)
+
+
+@pytest.fixture()
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture()
+def position(frame: Frame) -> Position:
+    return Position.meters([6371000.0, 0.0, 0.0], frame)
+
+
+@pytest.fixture()
+def velocity(frame: Frame) -> Velocity:
+    return Velocity.meters_per_second([7600.0, 0.0, 0.0], frame)
+
+
+@pytest.fixture()
+def attitude() -> Quaternion:
+    return Quaternion([0.0, 0.0, 0.0, 1.0], Quaternion.Format.XYZS)
+
+
+@pytest.fixture()
+def angular_velocity() -> np.ndarray:
+    return np.array([-1.0, -2.0, -3.0])
+
+
+@pytest.fixture
+def state(
+    instant: Instant,
+    position: Position,
+    velocity: Velocity,
+) -> State:
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def profile_state(
+    instant: Instant,
+    position: Position,
+    velocity: Velocity,
+    attitude: Quaternion,
+    angular_velocity: np.ndarray,
+    frame: Frame,
+) -> State:
+    return State(instant, position, velocity, attitude, angular_velocity, frame)
+
+
+@pytest.fixture
+def coordinate_broker() -> CoordinateBroker:
+    return CoordinateBroker([CartesianPosition.default(), CartesianVelocity.default()])
+
+
+class TestState:
+    def test_constructor_position_velocity(
+        self,
+        instant: Instant,
+        position: Position,
+        velocity: Velocity,
+    ):
+        state = State(instant, position, velocity)
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.is_defined()
+
+    def test_constructor_position_velocity_attitude_angular_velocity(
+        self,
+        instant: Instant,
+        frame: Frame,
+        position: Position,
+        velocity: Velocity,
+        attitude: Quaternion,
+        angular_velocity: np.ndarray,
+    ):
+        state = State(instant, position, velocity, attitude, angular_velocity, frame)
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.is_defined()
+
+    def test_explicit_constructor(
+        self,
+        instant: Instant,
+        position: Position,
+        velocity: Velocity,
+        frame: Frame,
+        coordinate_broker: CoordinateBroker,
+    ):
+        state = State(instant, position, velocity)
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.is_defined()
+
+        state = State(
+            instant,
+            np.append(position.get_coordinates(), velocity.get_coordinates()),
+            frame,
+            coordinate_broker,
+        )
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.is_defined()
+
+    def test_subsets_constructor(
+        self,
+        instant: Instant,
+        position: Position,
+        velocity: Velocity,
+        frame: Frame,
+    ):
+        state = State(
+            instant,
+            np.append(position.get_coordinates(), velocity.get_coordinates()),
+            frame,
+            [CartesianPosition.default(), CartesianVelocity.default()],
+        )
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.is_defined()
+
+    def test_custom_state_class_generator(
+        self,
+        instant: Instant,
+        position: Position,
+        velocity: Velocity,
+        frame: Frame,
+    ):
+        state = State(
+            instant,
+            np.append(position.get_coordinates(), velocity.get_coordinates()),
+            frame,
+            [CartesianPosition.default(), CartesianVelocity.default()],
+        )
+
+        MySuperFunState: type = State.template(
+            frame,
+            [CartesianPosition.default(), CartesianVelocity.default()],
+        )
+
+        custom_state: MySuperFunState = MySuperFunState(
+            instant,
+            np.append(position.get_coordinates(), velocity.get_coordinates()),
+        )
+
+        assert custom_state is not None
+        assert isinstance(custom_state, MySuperFunState)
+        assert isinstance(state, State)
+        assert custom_state.is_defined()
+
+        assert custom_state == state
+        assert custom_state is not state
+
+    def test_comparators(self, state: State):
+        assert (state == state) is True
+        assert (state != state) is False
+
+    def test_operators(self, state: State):
+        assert isinstance(state + state, State)
+        assert isinstance(state - state, State)
+
+    def test_getters(
+        self,
+        profile_state: State,
+        instant: Instant,
+        position: Position,
+        velocity: Velocity,
+        attitude: Quaternion,
+        angular_velocity: np.ndarray,
+        frame: Frame,
+    ):
+        assert profile_state.get_instant() == instant
+        assert profile_state.get_position() == position
+        assert profile_state.get_velocity() == velocity
+        assert profile_state.get_attitude() == attitude
+        assert np.all(profile_state.get_angular_velocity() == angular_velocity)
+        assert profile_state.has_subset(CartesianPosition.default())
+        assert profile_state.has_subset(CartesianVelocity.default())
+        assert profile_state.get_frame() == frame
+        assert profile_state.get_coordinates() is not None
+        assert profile_state.get_coordinate_subsets() is not None
+
+    def test_in_frame(
+        self,
+        state: State,
+        frame: Frame,
+    ):
+        assert state.in_frame(frame) == state
+        assert state.in_frame(Frame.ITRF()) != state
+
+    def test_extract_coordinate(
+        self,
+        state: State,
+    ):
+        position_coordinates = state.extract_coordinate(CartesianPosition.default())
+        velocity_coordinates = state.extract_coordinate(CartesianVelocity.default())
+
+        assert len(position_coordinates) == 3
+        assert len(velocity_coordinates) == 3
+        assert (position_coordinates == state.get_position().get_coordinates()).all()
+        assert (velocity_coordinates == state.get_velocity().get_coordinates()).all()
+
+    def test_extract_coordinates(
+        self,
+        state: State,
+    ):
+        pv_coordinates = state.extract_coordinates(
+            [CartesianPosition.default(), CartesianVelocity.default()]
+        )
+        assert len(pv_coordinates) == 6
+        assert (pv_coordinates == state.get_coordinates()).all()