open-space-toolkit-astrodynamics 16.8.0__py310-none-manylinux2014_aarch64.whl → 16.10.0__py310-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/conjunction/close_approach/test_generator.py

@@ -0,0 +1,228 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.time import Duration
+from ostk.physics.time import Instant
+from ostk.physics.time import Interval
+from ostk.physics import Environment
+from ostk.physics.environment.object import Celestial
+
+from ostk.astrodynamics import Trajectory
+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.conjunction import CloseApproach
+from ostk.astrodynamics.conjunction.close_approach import Generator
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def earth(environment: Environment) -> Celestial:
+    return environment.access_celestial_object_with_name("Earth")
+
+
+@pytest.fixture
+def epoch() -> Instant:
+    return Instant.date_time(DateTime(2024, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def step() -> Duration:
+    return Duration.seconds(60.0)
+
+
+@pytest.fixture
+def tolerance() -> Duration:
+    return Duration.milliseconds(1.0)
+
+
+@pytest.fixture
+def reference_trajectory(earth: Celestial, epoch: Instant) -> Trajectory:
+    return Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(7000.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(0.0),
+                raan=Angle.degrees(0.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(0.0),
+            ),
+            epoch=epoch,
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+
+
+@pytest.fixture
+def other_trajectory(earth: Celestial, epoch: Instant) -> Trajectory:
+    return Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(7000.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(90.0),
+                raan=Angle.degrees(0.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(1.0 - 3),  # Avoid co-location
+            ),
+            epoch=epoch,
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+
+
+@pytest.fixture
+def generator(
+    reference_trajectory: Trajectory,
+    step: Duration,
+    tolerance: Duration,
+) -> Generator:
+    return Generator(
+        reference_trajectory=reference_trajectory,
+        step=step,
+        tolerance=tolerance,
+    )
+
+
+@pytest.fixture
+def search_interval(epoch: Instant) -> Interval:
+    return Interval.closed(
+        epoch,
+        epoch + Duration.hours(3.0),
+    )
+
+
+class TestGenerator:
+    def test_constructor_success(
+        self,
+        reference_trajectory: Trajectory,
+        step: Duration,
+        tolerance: Duration,
+    ):
+        generator = Generator(
+            reference_trajectory=reference_trajectory,
+            step=step,
+            tolerance=tolerance,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+
+    def test_constructor_with_defaults_success(
+        self,
+        reference_trajectory: Trajectory,
+    ):
+        generator = Generator(reference_trajectory=reference_trajectory)
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.is_defined() is True
+
+    def test_is_defined_success(self, generator: Generator):
+        assert generator.is_defined() is True
+
+    def test_undefined_success(self):
+        generator = Generator.undefined()
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.is_defined() is False
+
+    def test_get_reference_trajectory_success(
+        self,
+        generator: Generator,
+    ):
+        trajectory = generator.get_reference_trajectory()
+
+        assert trajectory is not None
+        assert isinstance(trajectory, Trajectory)
+
+    def test_get_step_success(
+        self,
+        generator: Generator,
+        step: Duration,
+    ):
+        result_step = generator.get_step()
+
+        assert result_step is not None
+        assert isinstance(result_step, Duration)
+        assert result_step == step
+
+    def test_get_tolerance_success(
+        self,
+        generator: Generator,
+        tolerance: Duration,
+    ):
+        result_tolerance = generator.get_tolerance()
+
+        assert result_tolerance is not None
+        assert isinstance(result_tolerance, Duration)
+        assert result_tolerance == tolerance
+
+    def test_set_step_success(self, generator: Generator):
+        new_step = Duration.seconds(30.0)
+
+        generator.set_step(step=new_step)
+
+        assert generator.get_step() == new_step
+
+    def test_set_tolerance_success(self, generator: Generator):
+        new_tolerance = Duration.microseconds(100.0)
+
+        generator.set_tolerance(tolerance=new_tolerance)
+
+        assert generator.get_tolerance() == new_tolerance
+
+    def test_compute_close_approaches_success(
+        self,
+        generator: Generator,
+        other_trajectory: Trajectory,
+        search_interval: Interval,
+    ):
+        close_approaches = generator.compute_close_approaches(
+            trajectory=other_trajectory,
+            search_interval=search_interval,
+        )
+
+        assert close_approaches is not None
+        assert isinstance(close_approaches, list)
+        assert len(close_approaches) > 1
+
+        for close_approach in close_approaches:
+            assert isinstance(close_approach, CloseApproach)
+            assert close_approach.is_defined() is True
+            assert search_interval.contains_instant(close_approach.get_instant())
+
+    def test_compute_close_approaches_empty_interval_success(
+        self,
+        generator: Generator,
+        other_trajectory: Trajectory,
+        epoch: Instant,
+    ):
+        search_interval = Interval.closed(
+            epoch + Duration.hours(10.0),
+            epoch + Duration.hours(10.0) + Duration.seconds(1.0),
+        )
+
+        close_approaches = generator.compute_close_approaches(
+            trajectory=other_trajectory,
+            search_interval=search_interval,
+        )
+
+        assert close_approaches is not None
+        assert isinstance(close_approaches, list)
+        assert len(close_approaches) == 0

ostk/astrodynamics/test/conjunction/test_close_approach.py

@@ -0,0 +1,244 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+from ostk.physics import Environment
+from ostk.physics.environment.object import Celestial
+
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
+from ostk.astrodynamics.trajectory.orbit.model import Kepler
+from ostk.astrodynamics.trajectory.orbit.model.kepler import COE
+from ostk.astrodynamics.conjunction import CloseApproach
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def earth(environment: Environment) -> Celestial:
+    return environment.access_celestial_object_with_name("Earth")
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2024, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def gcrf_frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def object_1_state(
+    instant: Instant,
+    earth: Celestial,
+) -> State:
+    orbit = Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(7000.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(0.0),
+                raan=Angle.degrees(0.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(0.0),
+            ),
+            epoch=instant,
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+    return orbit.get_state_at(instant)
+
+
+@pytest.fixture
+def object_2_state(
+    instant: Instant,
+    earth: Celestial,
+) -> State:
+    orbit = Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(7000.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(90.0),
+                raan=Angle.degrees(0.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(1.0),
+            ),
+            epoch=instant,
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+    return orbit.get_state_at(instant)
+
+
+@pytest.fixture
+def close_approach(
+    object_1_state: State,
+    object_2_state: State,
+) -> CloseApproach:
+    return CloseApproach(
+        object_1_state=object_1_state,
+        object_2_state=object_2_state,
+    )
+
+
+class TestCloseApproach:
+    def test_constructor_success(
+        self,
+        object_1_state: State,
+        object_2_state: State,
+    ):
+        close_approach = CloseApproach(
+            object_1_state=object_1_state,
+            object_2_state=object_2_state,
+        )
+
+        assert close_approach is not None
+        assert isinstance(close_approach, CloseApproach)
+
+    def test_is_defined_success(
+        self,
+        close_approach: CloseApproach,
+    ):
+        assert close_approach.is_defined() is True
+
+    def test_undefined_success(self):
+        close_approach = CloseApproach.undefined()
+
+        assert close_approach is not None
+        assert isinstance(close_approach, CloseApproach)
+        assert close_approach.is_defined() is False
+
+    def test_get_object_1_state_success(
+        self,
+        close_approach: CloseApproach,
+        object_1_state: State,
+    ):
+        state = close_approach.get_object_1_state()
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_instant() == object_1_state.get_instant()
+
+    def test_get_object_2_state_success(
+        self,
+        close_approach: CloseApproach,
+        object_2_state: State,
+    ):
+        state = close_approach.get_object_2_state()
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_instant() == object_2_state.get_instant()
+
+    def test_get_instant_success(
+        self,
+        close_approach: CloseApproach,
+        instant: Instant,
+    ):
+        ca_instant = close_approach.get_instant()
+
+        assert ca_instant is not None
+        assert isinstance(ca_instant, Instant)
+        assert ca_instant == instant
+
+    def test_get_miss_distance_success(
+        self,
+        close_approach: CloseApproach,
+    ):
+        miss_distance = close_approach.get_miss_distance()
+
+        assert miss_distance is not None
+        assert isinstance(miss_distance, Length)
+        assert miss_distance.in_meters() > 0.0
+
+    def test_get_relative_state_success(
+        self,
+        close_approach: CloseApproach,
+    ):
+        relative_state = close_approach.get_relative_state()
+
+        assert relative_state is not None
+        assert isinstance(relative_state, State)
+
+    def test_compute_miss_distance_components_in_frame_success(
+        self,
+        close_approach: CloseApproach,
+        gcrf_frame: Frame,
+    ):
+        components = close_approach.compute_miss_distance_components_in_frame(
+            frame=gcrf_frame
+        )
+
+        assert components is not None
+        assert isinstance(components, tuple)
+        assert len(components) == 3
+
+        # Check each component is a Length
+        for component in components:
+            assert isinstance(component, Length)
+
+    def test_compute_miss_distance_components_in_local_orbital_frame_success(
+        self,
+        close_approach: CloseApproach,
+        gcrf_frame: Frame,
+    ):
+        qsw_factory = LocalOrbitalFrameFactory.QSW(gcrf_frame)
+
+        components = (
+            close_approach.compute_miss_distance_components_in_local_orbital_frame(
+                local_orbital_frame_factory=qsw_factory
+            )
+        )
+
+        assert components is not None
+        assert isinstance(components, tuple)
+        assert len(components) == 3
+
+        # Check each component is a Length
+        for component in components:
+            assert isinstance(component, Length)
+
+    def test_equality_operators_success(
+        self,
+        object_1_state: State,
+        object_2_state: State,
+    ):
+        close_approach_1 = CloseApproach(
+            object_1_state=object_1_state,
+            object_2_state=object_2_state,
+        )
+
+        close_approach_2 = CloseApproach(
+            object_1_state=object_1_state,
+            object_2_state=object_2_state,
+        )
+
+        assert close_approach_1 == close_approach_2
+        assert not (close_approach_1 != close_approach_2)
+
+    def test_string_representation_success(
+        self,
+        close_approach: CloseApproach,
+    ):
+        string_repr = str(close_approach)
+
+        assert string_repr is not None
+        assert isinstance(string_repr, str)
+        assert len(string_repr) > 0

ostk/astrodynamics/test/dynamics/test_thruster.py

@@ -22,7 +22,6 @@ from ostk.astrodynamics.trajectory.state import CoordinateBroker
 from ostk.astrodynamics.trajectory import State
 from ostk.astrodynamics.flight.system import PropulsionSystem
 from ostk.astrodynamics.flight.system import SatelliteSystem
-from ostk.astrodynamics import Dynamics
 from ostk.astrodynamics.dynamics import Thruster
 from ostk.astrodynamics.guidance_law import ConstantThrust
 
@@ -96,11 +95,27 @@ def state(coordinate_broker: CoordinateBroker) -> State:
 
 
 class TestThruster:
-    def test_constructors(self, dynamics: Thruster):
-        assert dynamics is not None
-        assert isinstance(dynamics, Thruster)
-        assert isinstance(dynamics, Dynamics)
-        assert dynamics.is_defined()
+    def test_constructors(
+        self,
+        guidance_law: ConstantThrust,
+        satellite_system: SatelliteSystem,
+    ):
+        thrusters = [
+            Thruster(
+                satellite_system=satellite_system,
+                guidance_law=guidance_law,
+            ),
+            Thruster(
+                satellite_system=satellite_system,
+                guidance_law=guidance_law,
+                name="A name",
+            ),
+        ]
+
+        for thruster in thrusters:
+            assert thruster is not None
+            assert isinstance(thruster, Thruster)
+            assert thruster.is_defined()
 
     def test_getters(self, dynamics: Thruster):
         assert dynamics.get_satellite_system() is not None

ostk/astrodynamics/test/flight/test_maneuver.py

@@ -4,16 +4,18 @@ 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.dynamics import Tabulated as TabulatedDynamics
 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
@@ -184,12 +186,44 @@ class TestManeuver:
 
         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.constant_mass_flow_rate_profile(
+        maneuver: Maneuver = Maneuver.constant_mass_flow_rate_profile(
             states=states,
             mass_flow_rate=mass_flow_rate,
         )

ostk/astrodynamics/test/guidance_law/test_constant_thrust.py

@@ -2,16 +2,26 @@
 
 import pytest
 
-from ostk.physics.time import Instant
+import numpy as np
+
 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 Angle
 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.flight import Maneuver
 from ostk.astrodynamics.guidance_law import ConstantThrust
+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
@@ -54,6 +64,64 @@ def frame() -> Frame:
     return Frame.GCRF()
 
 
+@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 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 maneuver(
+    instants: list[Instant],
+    acceleration_profile: list[np.ndarray],
+    mass_flow_rate_profile: list[float],
+    frame: Frame,
+    coordinate_subsets: list[CoordinateSubset],
+) -> Maneuver:
+    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 Maneuver(states)
+
+
 class TestConstantThrust:
     def test_constructors(self, guidance_law: ConstantThrust):
         assert guidance_law is not None
@@ -89,3 +157,21 @@ class TestConstantThrust:
 
         assert len(contribution) == 3
         assert contribution == pytest.approx([0.0, 0.009523809523809525, 0.0], abs=5e-11)
+
+    def test_from_maneuver(self, maneuver: Maneuver):
+        constant_thrust = ConstantThrust.from_maneuver(
+            maneuver=maneuver,
+            local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+        )
+        assert isinstance(constant_thrust, ConstantThrust)
+
+        constant_thrust_with_maximum_allowed_angular_offset = (
+            ConstantThrust.from_maneuver(
+                maneuver=maneuver,
+                local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+                maximum_allowed_angular_offset=Angle.degrees(180.0),
+            )
+        )
+        assert isinstance(
+            constant_thrust_with_maximum_allowed_angular_offset, ConstantThrust
+        )