open-space-toolkit-astrodynamics 16.9.0__py313-none-manylinux2014_x86_64.whl → 16.10.0__py313-none-manylinux2014_x86_64.whl

{open_space_toolkit_astrodynamics-16.9.0.dist-info → open_space_toolkit_astrodynamics-16.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: open-space-toolkit-astrodynamics
-Version: 16.9.0
+Version: 16.10.0
 Summary: Orbit, attitude, access.
 Author: Open Space Collective
 Author-email: contact@open-space-collective.org

{open_space_toolkit_astrodynamics-16.9.0.dist-info → open_space_toolkit_astrodynamics-16.10.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-313-x86_64-linux-gnu.so,sha256=td13l_Mx2sn4AWJvcqrDg3THpIwQ9OycJ4jgo91r2_E,3029496
+ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-313-x86_64-linux-gnu.so,sha256=_bkSMpoY3gGZ7KFYdgCek0NvilsEVV0IWYvmHUhWH0U,3074584
 ostk/astrodynamics/__init__.py,sha256=3gWyqFIbhAfcdeMhmfBPQPlPQTmaOzm-6flkJe745Zk,251
-ostk/astrodynamics/__init__.pyi,sha256=tmYS8pvUiJNxU5fDCOWHoGB36E0ImAVKQQDo2MfllXk,32224
+ostk/astrodynamics/__init__.pyi,sha256=3oFac7idhJ9COTt9FdIVYba1kQB-Knbs6DcmDxGvGmA,32224
 ostk/astrodynamics/access.pyi,sha256=pp2t81kKH4sP4BcGb8nAZHmpwhISjFODMpbZ4ucLFAw,25157
 ostk/astrodynamics/converters.py,sha256=luPh30qMp9bzEkN7hUccmxlLf7zRp_AzqmBe8IUjPhU,3314
 ostk/astrodynamics/converters.pyi,sha256=tTUT0xGbiUkKxUj79Hq5EEtxV3b2uR6Wsnj_vwyj-mk,1625
@@ -12,11 +12,12 @@ ostk/astrodynamics/eclipse.pyi,sha256=Q8fzdukA7fyxbUM3wjEXAHukT-Ovl4FM00NbjsMPnU
 ostk/astrodynamics/estimator.pyi,sha256=MnahWzp8aACxrNKWlYRsgQr5zpBxogNr-yPm7hJob5k,14000
 ostk/astrodynamics/event_condition.pyi,sha256=2c_1Sq7tkYKeAA_aRWBi43KDQXXxu6EMSmUpEWz_Fa4,45814
 ostk/astrodynamics/guidance_law.pyi,sha256=Xtqneu5PLpidOoSH4YIAY3D8rWZ0QH_ESqEdfbiTBVQ,16936
-ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.16,sha256=5D-qWSAurqGG-_6sV1KXruQZ1gey3CFK_XzY7rTgpSk,133661616
+ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.16,sha256=zqmjdqyKyqR0GHGqWrfpvZUoRqrsmnq1I0lBW4w9hsI,136595472
 ostk/astrodynamics/solver.pyi,sha256=dRdR9RLqwSaBBX_ZRmpeBv06WvM_BFNo3WUdNzorYTY,17805
 ostk/astrodynamics/utilities.py,sha256=y8mr3M46J5z-GhS1oIEnuEJA6otwcyJ9YDhvn_5JxHM,6976
 ostk/astrodynamics/viewer.py,sha256=SlKyOWKjaF3V9HFB3I7ZgHy7n_GLeHTWM9q2wXkpxe8,27077
-ostk/astrodynamics/conjunction/__init__.pyi,sha256=HFvWl8bCmrq3cBkUh5X5RGIh8webmVGxaZdpsz3WN-E,79
+ostk/astrodynamics/conjunction/__init__.pyi,sha256=TEfTmgCRKr68B1GPJscDOgI130jQf7GLbtoKZPtx_SU,4918
+ostk/astrodynamics/conjunction/close_approach.pyi,sha256=lDGzezf8ELdReQ0TGaqW36gpS9TwBN9QiCNrMi9X8v0,3690
 ostk/astrodynamics/conjunction/message/__init__.pyi,sha256=5H__sg_QUx7ybf9jtVWvXzrUHeK3ECotfhddAdHjJUc,75
 ostk/astrodynamics/conjunction/message/ccsds.pyi,sha256=1Peto19hRqlD7KHf1cyLP3CT4OAKzwtemqvO6_4FZ0g,28162
 ostk/astrodynamics/data/__init__.pyi,sha256=4l_mfVbnU_L7wImwgTCe8fVI81gK_tUmd0z7BY9lLi8,81
@@ -44,6 +45,9 @@ ostk/astrodynamics/test/test_viewer.py,sha256=6IxHjSrwnLkmLiTTzRcnwAdEeWdIF_b2Kj
 ostk/astrodynamics/test/access/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/access/test_generator.py,sha256=i7TnM80kF0Q_9KmyoqKt5n1ufg3ZjAIEMPVVds8ZDdI,10315
 ostk/astrodynamics/test/access/test_visibility_criterion.py,sha256=VA6WDQTj3q-f2YGIIkrrNp8G23Nf_0g9nKmfZAgAlWQ,6568
+ostk/astrodynamics/test/conjunction/test_close_approach.py,sha256=vuvVNj2xG8MhM-N5zsAtH7kFciM0V1KMWDd_vNvkCMg,6864
+ostk/astrodynamics/test/conjunction/close_approach/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ostk/astrodynamics/test/conjunction/close_approach/test_generator.py,sha256=NEDVdhL_Ll2iTo8dCBFuLdE1soFC0FUlx-tuuA8tGIg,6536
 ostk/astrodynamics/test/conjunction/message/ccsds/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/conjunction/message/ccsds/conftest.py,sha256=xyTd24828Ue2HgOWY8UhizIc5mzgRgoH2VSOfVfKCdw,14632
 ostk/astrodynamics/test/conjunction/message/ccsds/test_cdm.py,sha256=ztpnOHI3ZiIV0QwijJ6Si_lIna8jLZF45r1KtPVK4ws,18514
@@ -140,8 +144,8 @@ ostk/astrodynamics/trajectory/orbit/model/kepler.pyi,sha256=KL-FwPbG4OUkPjhQb1Pa
 ostk/astrodynamics/trajectory/orbit/model/sgp4.pyi,sha256=OhFzoPPQHlYy7m3LiZ8TXF89M4uBTfNk6tGsBEp0sjI,14235
 ostk/astrodynamics/trajectory/state/__init__.pyi,sha256=bq__Fii35czVrTeNxc9eQVjXdqwbbQxUdNQWK3vLrMo,17649
 ostk/astrodynamics/trajectory/state/coordinate_subset.pyi,sha256=kYMfMwEjCqO1NepMYFT4QS6kIPBkVL6sGCLeLbogcMw,10176
-open_space_toolkit_astrodynamics-16.9.0.dist-info/METADATA,sha256=gBHINQ0oyiWejSohb8XPjnxzlfl27qPJf5UrIM4YD-k,1913
-open_space_toolkit_astrodynamics-16.9.0.dist-info/WHEEL,sha256=mg_J2-vBxmW0UA4lbss-1qkxaUbm-OTIuSSaNWv6mlo,110
-open_space_toolkit_astrodynamics-16.9.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
-open_space_toolkit_astrodynamics-16.9.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-open_space_toolkit_astrodynamics-16.9.0.dist-info/RECORD,,
+open_space_toolkit_astrodynamics-16.10.0.dist-info/METADATA,sha256=VRCTKInuQXRzjAIDnrl4EOduGokQYU72xGWdlk--r1I,1914
+open_space_toolkit_astrodynamics-16.10.0.dist-info/WHEEL,sha256=mg_J2-vBxmW0UA4lbss-1qkxaUbm-OTIuSSaNWv6mlo,110
+open_space_toolkit_astrodynamics-16.10.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_astrodynamics-16.10.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_astrodynamics-16.10.0.dist-info/RECORD,,

ostk/astrodynamics/__init__.pyi

@@ -24,8 +24,8 @@ import ostk.physics.coordinate
 import ostk.physics.coordinate.spherical
 from ostk.physics import environment
 import ostk.physics.environment.object
-import ostk.physics.time
 from ostk.physics import time
+import ostk.physics.time
 import ostk.physics.unit
 from ostk.physics import unit
 import typing

ostk/astrodynamics/conjunction/__init__.pyi

@@ -1,3 +1,121 @@
 from __future__ import annotations
+import ostk.astrodynamics.trajectory
+import ostk.physics.coordinate
+import ostk.physics.time
+import ostk.physics.unit
+import typing
+from . import close_approach
 from . import message
-__all__ = ['message']
+__all__ = ['CloseApproach', 'close_approach', 'message']
+class CloseApproach:
+    """
+    
+                Close approach between two objects.
+    
+                This class represents a close approach event between two objects, providing access to the states of both
+                objects at the time of closest approach, the miss distance, and the relative state.
+            
+    """
+    __hash__: typing.ClassVar[None] = None
+    @staticmethod
+    def undefined() -> CloseApproach:
+        """
+                        Construct an undefined close approach.
+        
+                        Returns:
+                            CloseApproach: An undefined close approach.
+        """
+    def __eq__(self, arg0: CloseApproach) -> bool:
+        """
+                        Equal to operator.
+        
+                        Args:
+                            other (CloseApproach): Another close approach.
+        
+                        Returns:
+                            bool: True if close approaches are equal.
+        """
+    def __init__(self, object_1_state: ostk.astrodynamics.trajectory.State, object_2_state: ostk.astrodynamics.trajectory.State) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            object_1_state (State): The state of Object 1.
+                            object_2_state (State): The state of Object 2.
+        """
+    def __ne__(self, arg0: CloseApproach) -> bool:
+        """
+                        Not equal to operator.
+        
+                        Args:
+                            other (CloseApproach): Another close approach.
+        
+                        Returns:
+                            bool: True if close approaches are not equal.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def compute_miss_distance_components_in_frame(self, frame: ostk.physics.coordinate.Frame) -> tuple[ostk.physics.unit.Length, ostk.physics.unit.Length, ostk.physics.unit.Length]:
+        """
+                        Compute the miss distance components in the desired frame.
+        
+                        Args:
+                            frame (Frame): The frame in which to resolve the miss distance components.
+        
+                        Returns:
+                            tuple[Length, Length, Length]: The miss distance components (x, y, z).
+        """
+    def compute_miss_distance_components_in_local_orbital_frame(self, local_orbital_frame_factory: ostk.astrodynamics.trajectory.LocalOrbitalFrameFactory) -> tuple[ostk.physics.unit.Length, ostk.physics.unit.Length, ostk.physics.unit.Length]:
+        """
+                        Compute the miss distance components in a local orbital frame (generated from Object 1 state).
+        
+                        Args:
+                            local_orbital_frame_factory (LocalOrbitalFrameFactory): The local orbital frame factory.
+        
+                        Returns:
+                            tuple[Length, Length, Length]: The miss distance components (radial, in-track, cross-track or similar depending on the factory).
+        """
+    def get_instant(self) -> ostk.physics.time.Instant:
+        """
+                        Get the instant of the close approach.
+        
+                        Returns:
+                            Instant: The instant of closest approach.
+        """
+    def get_miss_distance(self) -> ostk.physics.unit.Length:
+        """
+                        Get the miss distance.
+        
+                        Returns:
+                            Length: The miss distance between the two objects.
+        """
+    def get_object_1_state(self) -> ostk.astrodynamics.trajectory.State:
+        """
+                        Get the state of Object 1.
+        
+                        Returns:
+                            State: The state of Object 1.
+        """
+    def get_object_2_state(self) -> ostk.astrodynamics.trajectory.State:
+        """
+                        Get the state of Object 2.
+        
+                        Returns:
+                            State: The state of Object 2.
+        """
+    def get_relative_state(self) -> ostk.astrodynamics.trajectory.State:
+        """
+                        Get the relative state (Object 2 relative to Object 1).
+        
+                        Returns:
+                            State: The relative state.
+        """
+    def is_defined(self) -> bool:
+        """
+                        Check if the close approach is defined.
+        
+                        Returns:
+                            bool: True if close approach is defined, False otherwise.
+        """

ostk/astrodynamics/conjunction/close_approach.pyi

@@ -0,0 +1,85 @@
+from __future__ import annotations
+import ostk.astrodynamics
+import ostk.astrodynamics.conjunction
+import ostk.physics.time
+__all__ = ['Generator']
+class Generator:
+    """
+    
+                Compute close approaches to a reference trajectory.
+    
+                This class computes close approach events between a reference trajectory and other object trajectories
+                over a specified time interval. It uses a temporal condition solver to identify time periods when objects
+                are approaching and then determines the exact time of closest approach.
+            
+    """
+    @staticmethod
+    def undefined() -> Generator:
+        """
+                        Construct an undefined generator.
+        
+                        Returns:
+                            Generator: An undefined generator.
+        """
+    def __init__(self, reference_trajectory: ostk.astrodynamics.Trajectory, step: ostk.physics.time.Duration = ..., tolerance: ostk.physics.time.Duration = ...) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            reference_trajectory (Trajectory): The reference trajectory for which to compute close approaches (Object 1).
+                            step (Duration): The step to use during the close approach search. Defaults to Duration.seconds(15.0).
+                            tolerance (Duration): The tolerance to use during the close approach search. Defaults to Duration.milliseconds(1.0).
+        """
+    def compute_close_approaches(self, trajectory: ostk.astrodynamics.Trajectory, search_interval: ostk.physics.time.Interval) -> list[ostk.astrodynamics.conjunction.CloseApproach]:
+        """
+                        Compute close approaches between the reference trajectory and another object over a search interval.
+        
+                        Args:
+                            trajectory (Trajectory): The trajectory of the other object (Object 2).
+                            search_interval (Interval): The interval over which close approaches are searched.
+        
+                        Returns:
+                            list[CloseApproach]: Array of close approaches over the search interval (with Object 1 being the reference trajectory).
+        """
+    def get_reference_trajectory(self) -> ostk.astrodynamics.Trajectory:
+        """
+                        Get the reference trajectory.
+        
+                        Returns:
+                            Trajectory: The reference trajectory.
+        """
+    def get_step(self) -> ostk.physics.time.Duration:
+        """
+                        Get the step.
+        
+                        Returns:
+                            Duration: The step.
+        """
+    def get_tolerance(self) -> ostk.physics.time.Duration:
+        """
+                        Get the tolerance.
+        
+                        Returns:
+                            Duration: The tolerance.
+        """
+    def is_defined(self) -> bool:
+        """
+                        Check if the generator is defined.
+        
+                        Returns:
+                            bool: True if generator is defined, False otherwise.
+        """
+    def set_step(self, step: ostk.physics.time.Duration) -> None:
+        """
+                        Set the step.
+        
+                        Args:
+                            step (Duration): The step.
+        """
+    def set_tolerance(self, tolerance: ostk.physics.time.Duration) -> None:
+        """
+                        Set the tolerance.
+        
+                        Args:
+                            tolerance (Duration): The tolerance.
+        """

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