open-space-toolkit-astrodynamics 17.2.0__py312-none-manylinux2014_x86_64.whl

ostk/astrodynamics/conjunction/__init__.pyi

@@ -0,0 +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__ = ['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,89 @@
+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. Set it to a duration smaller than the minimum possible
+                                interval where both objects can be moving apart - which is about a quarter of an orbital period. Defaults to
+                                Duration.minutes(20.0) - but it should be set lower for low velocity conjunctions as they tend to exhibit more than two
+                                close approaches per orbit in a non deterministic manner.
+                            tolerance (Duration): The tolerance to use during the close approach search. Defaults to Duration.milliseconds(1.0) - which
+                                means that objects moving at 7km/s will be up to 7m away from their “true” position.
+        """
+    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/conjunction/message/__init__.pyi

@@ -0,0 +1,3 @@
+from __future__ import annotations
+from . import ccsds
+__all__ = ['ccsds']