open-space-toolkit-astrodynamics 13.1.0__py313-none-manylinux2014_x86_64.whl

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)

ostk/astrodynamics/test/guidance_law/test_qlaw.py

@@ -0,0 +1,138 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+from ostk.physics.unit import Derived
+from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+
+
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+from ostk.astrodynamics import GuidanceLaw
+from ostk.astrodynamics.guidance_law import QLaw
+
+
+@pytest.fixture
+def target_COE() -> COE:
+    return COE(
+        Length.meters(42000.0e3),
+        0.01,
+        Angle.degrees(0.05),
+        Angle.degrees(0.0),
+        Angle.degrees(0.0),
+        Angle.degrees(0.0),
+    )
+
+
+@pytest.fixture
+def gravitational_parameter() -> Derived:
+    return Derived(
+        3.986004418e14,
+        EarthGravitationalModel.EGM2008.gravitational_parameter.get_unit(),
+    )
+
+
+@pytest.fixture
+def parameters() -> QLaw.Parameters:
+    return QLaw.Parameters(
+        element_weights={
+            COE.Element.SemiMajorAxis: (1.0, 100.0),
+            COE.Element.Eccentricity: (1.0, 1e-3),
+        },
+    )
+
+
+@pytest.fixture
+def gradient_strategy() -> QLaw.GradientStrategy:
+    return QLaw.GradientStrategy.FiniteDifference
+
+
+@pytest.fixture
+def q_law(
+    target_COE: COE,
+    gravitational_parameter: Derived,
+    parameters: QLaw.Parameters,
+    gradient_strategy: QLaw.GradientStrategy,
+) -> QLaw:
+    return QLaw(
+        target_coe=target_COE,
+        gravitational_parameter=gravitational_parameter,
+        parameters=parameters,
+        gradient_strategy=gradient_strategy,
+    )
+
+
+@pytest.fixture
+def thrust_acceleration() -> float:
+    return 1.0 / 300.0
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def position_coordinates() -> list[float]:
+    return [6930000.0, 0.0, 0.0]
+
+
+@pytest.fixture
+def velocity_coordinates() -> list[float]:
+    return [0.0, 7621.89248591193, 6.65135764404186]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+class TestQLawParameters:
+    def test_constructors(self, parameters: QLaw.Parameters):
+        assert parameters is not None
+        assert isinstance(parameters, QLaw.Parameters)
+
+    def test_getters(self, parameters: QLaw.Parameters):
+        assert parameters.get_control_weights() is not None
+        assert parameters.m is not None
+        assert parameters.n is not None
+        assert parameters.r is not None
+        assert parameters.b is not None
+
+
+class TestQLaw:
+    def test_constructors(self, q_law: QLaw):
+        assert q_law is not None
+        assert isinstance(q_law, QLaw)
+        assert isinstance(q_law, GuidanceLaw)
+
+    def test_getters(self, q_law: QLaw):
+        assert q_law.get_parameters() is not None
+        assert q_law.get_target_coe() is not None
+        assert q_law.get_gradient_strategy() is not None
+
+    def test_calculate_thrust_acceleration_at(
+        self,
+        q_law: QLaw,
+        position_coordinates: list[float],
+        velocity_coordinates: list[float],
+        thrust_acceleration: float,
+        instant: Instant,
+        frame: Frame,
+    ):
+        assert pytest.approx(
+            q_law.calculate_thrust_acceleration_at(
+                instant=instant,
+                position_coordinates=position_coordinates,
+                velocity_coordinates=velocity_coordinates,
+                thrust_acceleration=thrust_acceleration,
+                output_frame=frame,
+            )
+        ) == np.array([0.0, 0.0033333320640941645, 2.9088817174504986e-06])

ostk/astrodynamics/test/solvers/__init__.py

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

ostk/astrodynamics/test/solvers/test_finite_difference_solver.py

@@ -0,0 +1,181 @@
+# Apache License 2.0
+
+import pytest
+import math
+
+import numpy as np
+
+from ostk.physics.coordinate import Frame
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+
+from ostk.astrodynamics.solver import FiniteDifferenceSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+
+
+@pytest.fixture
+def step_percentage() -> float:
+    return 1e-3
+
+
+@pytest.fixture
+def step_duration() -> Duration:
+    return Duration.seconds(1e-6)
+
+
+@pytest.fixture(
+    params=[
+        FiniteDifferenceSolver.Type.Forward,
+        FiniteDifferenceSolver.Type.Backward,
+        FiniteDifferenceSolver.Type.Central,
+    ]
+)
+def finite_difference_solver(request, step_percentage: float, step_duration: Duration):
+    return FiniteDifferenceSolver(request.param, step_percentage, step_duration)
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [CoordinateSubset("Position", 1), CoordinateSubset("Velocity", 1)]
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def state(
+    initial_instant: Instant, frame: Frame, coordinate_subsets: list[CoordinateSubset]
+):
+    return State(initial_instant, [1, 0], frame, coordinate_subsets)
+
+
+@pytest.fixture
+def initial_instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def instant(initial_instant: Instant) -> Instant:
+    return initial_instant + Duration.seconds(100.0)
+
+
+@pytest.fixture
+def instants(initial_instant: Instant) -> list[Instant]:
+    return [
+        initial_instant + Duration.seconds(100.0),
+        initial_instant + Duration.seconds(200.0),
+    ]
+
+
+@pytest.fixture
+def generate_states_coordinates() -> callable:
+    def state_fn(state, instants) -> np.ndarray:
+        x0: float = state.get_coordinates()[0]
+        v0: float = state.get_coordinates()[1]
+        omega: float = 1.0
+
+        states_coordinates: list[list[float]] = []
+
+        for instant in instants:
+            t: float = (instant - state.get_instant()).in_seconds()
+            x: float = x0 * math.cos(omega * t) + v0 / omega * math.sin(omega * t)
+            v: float = -x0 * omega * math.sin(omega * t) + v0 * math.cos(omega * t)
+
+            coordinates: list[float] = [x, v]
+
+            states_coordinates.append(coordinates)
+
+        return np.array(states_coordinates)
+
+    return state_fn
+
+
+@pytest.fixture
+def generate_state_coordinates() -> callable:
+    def state_fn(state, instant) -> np.ndarray:
+        x0: float = state.get_coordinates()[0]
+        v0: float = state.get_coordinates()[1]
+        omega: float = 1.0
+
+        t: float = (instant - state.get_instant()).in_seconds()
+        x: float = x0 * math.cos(omega * t) + v0 / omega * math.sin(omega * t)
+        v: float = -x0 * omega * math.sin(omega * t) + v0 * math.cos(omega * t)
+
+        return np.array([x, v])
+
+    return state_fn
+
+
+class TestFiniteDifferenceSolver:
+    def test_constructor(self, finite_difference_solver: FiniteDifferenceSolver):
+        assert isinstance(finite_difference_solver, FiniteDifferenceSolver)
+
+    def test_getters(self, finite_difference_solver: FiniteDifferenceSolver):
+        assert isinstance(
+            finite_difference_solver.get_type(), FiniteDifferenceSolver.Type
+        )
+        assert finite_difference_solver.get_step_percentage() is not None
+        assert isinstance(finite_difference_solver.get_step_duration(), Duration)
+
+    def test_string_from_type(self):
+        assert (
+            FiniteDifferenceSolver.string_from_type(FiniteDifferenceSolver.Type.Forward)
+            == "Forward"
+        )
+
+    def test_compute_jacobian_array(
+        self,
+        finite_difference_solver: FiniteDifferenceSolver,
+        state: State,
+        instants: list[Instant],
+        generate_states_coordinates: callable,
+    ):
+        stm = finite_difference_solver.compute_jacobian(
+            state=state,
+            instants=instants,
+            generate_states_coordinates=generate_states_coordinates,
+            coordinates_dimension=2,
+        )
+        assert isinstance(stm, np.ndarray)
+        assert stm.shape == (
+            len(state.get_coordinates()) * len(instants),
+            len(state.get_coordinates()),
+        )
+
+    def test_compute_jacobian_single(
+        self,
+        finite_difference_solver: FiniteDifferenceSolver,
+        state: State,
+        generate_state_coordinates: callable,
+        instant: Instant,
+    ):
+        stm = finite_difference_solver.compute_jacobian(
+            state=state,
+            instant=instant,
+            generate_state_coordinates=generate_state_coordinates,
+            coordinates_dimension=2,
+        )
+        assert isinstance(stm, np.ndarray)
+        assert stm.shape == (
+            len(state.get_coordinates()),
+            len(state.get_coordinates()),
+        )
+
+    def test_compute_gradient(
+        self,
+        finite_difference_solver: FiniteDifferenceSolver,
+        state: State,
+        generate_state_coordinates: callable,
+    ):
+        gradient = finite_difference_solver.compute_gradient(
+            state=state,
+            generate_state_coordinates=generate_state_coordinates,
+        )
+        assert isinstance(gradient, np.ndarray)
+        assert all(gradient - np.array([0.0, -1.0]) < 1e-6)
+
+    def test_default(self):
+        assert isinstance(FiniteDifferenceSolver.default(), FiniteDifferenceSolver)

ostk/astrodynamics/test/solvers/test_temporal_condition_solver.py

@@ -0,0 +1,153 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.time import Interval
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics import Environment
+
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory.orbit.model import Kepler
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+from ostk.astrodynamics.access import Generator
+from ostk.astrodynamics.solver import TemporalConditionSolver
+
+
+@pytest.fixture
+def temporal_condition_solver() -> TemporalConditionSolver:
+    return TemporalConditionSolver(
+        time_step=Duration.seconds(30.0),
+        tolerance=Duration.milliseconds(1.0),
+        maximum_iteration_count=1234,
+    )
+
+
+@pytest.fixture
+def interval() -> Interval:
+    return Interval.closed(
+        Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+        Instant.date_time(DateTime(2018, 1, 1, 2, 0, 0), Scale.UTC),
+    )
+
+
+class TestTemporalConditionSolver:
+    def test_constructor_success(self):
+        temporal_condition_solver = TemporalConditionSolver(
+            time_step=Duration.seconds(30.0),
+            tolerance=Duration.milliseconds(1.0),
+            maximum_iteration_count=1234,
+        )
+
+        assert isinstance(temporal_condition_solver, TemporalConditionSolver)
+
+    def test_getters_success(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+    ):
+        assert temporal_condition_solver.get_time_step() == Duration.seconds(30.0)
+        assert temporal_condition_solver.get_tolerance() == Duration.milliseconds(1.0)
+        assert temporal_condition_solver.get_maximum_iteration_count() == 1234
+
+    def test_solve_success_one_condition_always_true(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        solution: list[Interval] = temporal_condition_solver.solve(
+            condition=lambda _: True,
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == [interval]
+
+    def test_solve_success_one_condition_always_false(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        solution: list[Interval] = temporal_condition_solver.solve(
+            condition=lambda _: False,
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == []
+
+    def test_solve_success_multiple_conditions_always_true(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        solution: list[Interval] = temporal_condition_solver.solve(
+            conditions=[
+                lambda _: True,
+                lambda _: True,
+            ],
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == [interval]
+
+    def test_solve_success_multiple_conditions_one_always_false(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        solution: list[Interval] = temporal_condition_solver.solve(
+            conditions=[
+                lambda _: True,
+                lambda _: False,
+            ],
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == []
+
+    def test_solve_success_using_access_generator(
+        self,
+        temporal_condition_solver: TemporalConditionSolver,
+        interval: Interval,
+    ):
+        environment = Environment.default()
+
+        generator = Generator(
+            environment=environment,
+        )
+
+        earth = environment.access_celestial_object_with_name("Earth")
+
+        trajectory = Orbit(
+            model=Kepler(
+                coe=COE(
+                    semi_major_axis=Length.kilometers(7000.0),
+                    eccentricity=0.0,
+                    inclination=Angle.degrees(45.0),
+                    raan=Angle.degrees(0.0),
+                    aop=Angle.degrees(0.0),
+                    true_anomaly=Angle.degrees(0.0),
+                ),
+                epoch=Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+                celestial_object=earth,
+                perturbation_type=Kepler.PerturbationType.No,
+            ),
+            celestial_object=earth,
+        )
+
+        solution: list[Interval] = temporal_condition_solver.solve(
+            condition=generator.get_condition_function(
+                from_trajectory=trajectory,
+                to_trajectory=trajectory,
+            ),
+            interval=interval,
+        )
+
+        assert isinstance(solution, list)
+        assert solution == [interval]

ostk/astrodynamics/test/test_access.py

@@ -0,0 +1,128 @@
+# 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
+
+RealInterval = mathematics.object.RealInterval
+Quaternion = mathematics.geometry.d3.transformation.rotation.Quaternion
+Length = physics.unit.Length
+Angle = physics.unit.Angle
+DateTime = physics.time.DateTime
+Scale = physics.time.Scale
+Duration = physics.time.Duration
+Instant = physics.time.Instant
+Interval = physics.time.Interval
+Transform = physics.coordinate.Transform
+Frame = physics.coordinate.Frame
+Axes = physics.coordinate.Axes
+DynamicProvider = physics.coordinate.frame.provider.Dynamic
+Environment = physics.Environment
+Earth = physics.environment.object.celestial.Earth
+Trajectory = astrodynamics.Trajectory
+Profile = astrodynamics.flight.Profile
+Orbit = astrodynamics.trajectory.Orbit
+State = astrodynamics.trajectory.State
+Pass = astrodynamics.trajectory.orbit.Pass
+Kepler = astrodynamics.trajectory.orbit.model.Kepler
+COE = astrodynamics.trajectory.orbit.model.kepler.COE
+SGP4 = astrodynamics.trajectory.orbit.model.sgp4
+Access = astrodynamics.Access
+
+
+def test_access_constructors():
+    acquisition_of_signal = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    time_at_closest_approach = Instant.date_time(DateTime(2018, 1, 1, 0, 1, 0), Scale.UTC)
+    loss_of_signal = Instant.date_time(DateTime(2018, 1, 1, 0, 2, 0), Scale.UTC)
+    max_elevation = Angle.degrees(54.3)
+
+    access: Access = Access(
+        Access.Type.Complete,
+        acquisition_of_signal,
+        time_at_closest_approach,
+        loss_of_signal,
+        max_elevation,
+    )
+
+    assert access is not None
+    assert isinstance(access, Access)
+
+
+def test_access_undefined():
+    access: Access = Access.undefined()
+
+    assert access is not None
+    assert isinstance(access, Access)
+    assert access.is_defined() is False
+
+
+def test_access_getters():
+    acquisition_of_signal = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    time_at_closest_approach = Instant.date_time(DateTime(2018, 1, 1, 0, 1, 0), Scale.UTC)
+    loss_of_signal = Instant.date_time(DateTime(2018, 1, 1, 0, 2, 0), Scale.UTC)
+    max_elevation = Angle.degrees(54.3)
+
+    access: Access = Access(
+        Access.Type.Complete,
+        acquisition_of_signal,
+        time_at_closest_approach,
+        loss_of_signal,
+        max_elevation,
+    )
+
+    # get_type
+    access_type: Access.Type = access.get_type()
+
+    assert access_type is not None
+    assert isinstance(access_type, Access.Type)
+    assert access_type == Access.Type.Complete
+
+    # get_acquisition_of_signal
+    acq_signal: Instant = access.get_acquisition_of_signal()
+
+    assert acq_signal is not None
+    assert isinstance(acq_signal, Instant)
+    assert acq_signal == acquisition_of_signal
+
+    # get_time_of_closest_approach
+    closest_approach: Instant = access.get_time_of_closest_approach()
+
+    assert closest_approach is not None
+    assert isinstance(closest_approach, Instant)
+    assert closest_approach == time_at_closest_approach
+
+    # get_loss_of_signal
+    loss_signal: Instant = access.get_loss_of_signal()
+
+    assert loss_signal is not None
+    assert isinstance(loss_signal, Instant)
+    assert loss_signal == loss_of_signal
+
+    # get_interval
+    interval = access.get_interval()
+    assert interval is not None
+    assert isinstance(interval, Interval)
+
+    # get_duration
+    duration: Duration = access.get_duration()
+
+    assert duration is not None
+    assert isinstance(duration, Duration)
+
+    # get_max_elevation
+    max_el: Angle = access.get_max_elevation()
+
+    assert max_el is not None
+    assert isinstance(max_el, Angle)
+
+
+def test_access_string_from_type():
+    assert Access.string_from_type(Access.Type.Undefined) == "Undefined"
+    assert Access.string_from_type(Access.Type.Complete) == "Complete"
+    assert Access.string_from_type(Access.Type.Partial) == "Partial"