open-space-toolkit-astrodynamics 13.0.2__py39-none-manylinux2014_x86_64.whl → 14.0.0__py39-none-manylinux2014_x86_64.whl

ostk/astrodynamics/guidance_law.pyi

@@ -0,0 +1,282 @@
+from __future__ import annotations
+import numpy
+import ostk.astrodynamics
+import ostk.astrodynamics.trajectory
+import ostk.astrodynamics.trajectory.orbit.model.kepler
+import ostk.core.type
+import ostk.physics.coordinate
+import ostk.physics.time
+import ostk.physics.unit
+import typing
+__all__ = ['ConstantThrust', 'QLaw']
+class ConstantThrust(ostk.astrodynamics.GuidanceLaw):
+    """
+    
+                    Constant Thrust, Constant Direction dynamics.
+    
+                
+    """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @staticmethod
+    def intrack(velocity_direction: bool = True) -> ConstantThrust:
+        """
+                            Create a constant thrust in the in-track direction.
+        
+                            Args:
+                                satellite_system (SatelliteSystem): The satellite system.
+                                velocity_direction (bool, optional): If True, the thrust is applied in the velocity direction. Otherwise, it is applied in the opposite direction.
+                                frame (Frame, optional): The reference frame.
+        
+                            Returns:
+                                ConstantThrust: The constant thrust.
+        """
+    def __init__(self, thrust_direction: ostk.astrodynamics.trajectory.LocalOrbitalFrameDirection) -> None:
+        """
+                            Constructor.
+        
+                            Args:
+                                thrust_direction (LocalOrbitalFrameDirection): The thrust direction.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def calculate_thrust_acceleration_at(self, instant: ostk.physics.time.Instant, position_coordinates: numpy.ndarray[numpy.float64[3, 1]], velocity_coordinates: numpy.ndarray[numpy.float64[3, 1]], thrust_acceleration: ostk.core.type.Real, output_frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[3, 1]]:
+        """
+                            Compute the acceleration due to constant thrust.
+        
+                            Args:
+                                instant (Instant): The instant of the state vector.
+                                position_coordinates (numpy.ndarray): The position coordinates.
+                                velocity_coordinates (numpy.ndarray): The velocity coordinates.
+                                thrust_acceleration (float): The thrust acceleration magnitude.
+                                output_frame (Frame): The frame the acceleration will be expressed in.
+        
+                            Returns:
+                                numpy.ndarray: The contribution of the constant thrust to the state vector.
+        """
+    def get_local_thrust_direction(self) -> ostk.astrodynamics.trajectory.LocalOrbitalFrameDirection:
+        """
+                            Get the local thrust direction.
+        
+                            Returns:
+                                LocalOrbitalFrameDirection: The local thrust direction.
+        """
+class QLaw(ostk.astrodynamics.GuidanceLaw):
+    """
+    
+                This class implements the Q-law guidance law.
+    
+                - Ref: https://dataverse.jpl.nasa.gov/api/access/datafile/10307?gbrecs=true
+                - Ref: https://www.researchgate.net/publication/370849580_Analytic_Calculation_and_Application_of_the_Q-Law_Guidance_Algorithm_Partial_Derivatives
+                - Ref for derivations: https://dataverse.jpl.nasa.gov/api/access/datafile/13727?gbrecs=true
+    
+                The Q-law is a Lyapunov feedback control law developed by Petropoulos,
+                based on analytic expressions for maximum rates of change of the orbit elements and
+                the desired changes in the elements. Q, the proximity quotient, serves as a candidate Lyapunov
+                function. As the spacecraft approaches the target orbit, Q decreases monotonically (becoming zero at the target orbit).
+    
+            
+    """
+    class GradientStrategy:
+        """
+        
+                    Gradient strategy.
+                
+        
+        Members:
+        
+          Analytical : Analytical
+        
+          FiniteDifference : Finite Differenced
+        """
+        Analytical: typing.ClassVar[QLaw.GradientStrategy]  # value = <GradientStrategy.Analytical: 0>
+        FiniteDifference: typing.ClassVar[QLaw.GradientStrategy]  # value = <GradientStrategy.FiniteDifference: 1>
+        __members__: typing.ClassVar[dict[str, QLaw.GradientStrategy]]  # value = {'Analytical': <GradientStrategy.Analytical: 0>, 'FiniteDifference': <GradientStrategy.FiniteDifference: 1>}
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __eq__(self, other: typing.Any) -> bool:
+            ...
+        def __getstate__(self) -> int:
+            ...
+        def __hash__(self) -> int:
+            ...
+        def __index__(self) -> int:
+            ...
+        def __init__(self, value: int) -> None:
+            ...
+        def __int__(self) -> int:
+            ...
+        def __ne__(self, other: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        def __setstate__(self, state: int) -> None:
+            ...
+        def __str__(self) -> str:
+            ...
+        @property
+        def name(self) -> str:
+            ...
+        @property
+        def value(self) -> int:
+            ...
+    class Parameters:
+        """
+        
+                    Q-law parameters.
+        
+                
+        """
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __init__(self, element_weights: dict[ostk.astrodynamics.trajectory.orbit.model.kepler.COE.Element, tuple[float, float]], m: int = 3, n: int = 4, r: int = 2, b: float = 0.01, k: int = 100, periapsis_weight: float = 0.0, minimum_periapsis_radius: ostk.physics.unit.Length = ..., absolute_effectivity_threshold: ostk.core.type.Real = ..., relative_effectivity_threshold: ostk.core.type.Real = ...) -> None:
+            """
+                            Constructor.
+            
+                            Args:
+                                element_weights (dict): Key-value pair of COE elements and the (weights, tolerances) for the targeter.
+                                m (int): Scaling parameter for Semi-Major Axis delta. Default to 3.
+                                n (int): Scaling parameter for Semi-Major Axis delta. Default to 4.
+                                r (int): Scaling parameter for Semi-Major Axis delta. Default to 2.
+                                b (float): Scaling parameter for Argument of Periapsis maximal change. Default to 0.01.
+                                k (int): Penalty parameter for periapsis. Default to 100.
+                                periapsis_weight (float): Periapsis weight. Default to 0.0.
+                                minimum_periapsis_radius (Length): Minimum periapsis radius. Default to 6578.0 km.
+                                absolute_effectivity_threshold (Real): Absolute effectivity threshold. Default to undefined (not used).
+                                relative_effectivity_threshold (Real): Relative effectivity threshold. Default to undefined (not used).
+            """
+        def get_control_weights(self) -> numpy.ndarray[numpy.float64[5, 1]]:
+            """
+                            Get the control weights.
+            
+                            Returns:
+                                np.array: The control weights.
+            """
+        def get_minimum_periapsis_radius(self) -> ostk.physics.unit.Length:
+            """
+                            Get the minimum periapsis radius.
+            
+                            Returns:
+                                Length: The minimum periapsis radius.
+            """
+        @property
+        def absolute_effectivity_threshold(self) -> ostk.core.type.Real:
+            """
+                            Absolute effectivity threshold.
+            
+                            Type:
+                                Real
+            """
+        @property
+        def b(self) -> float:
+            """
+                            Scaling parameter for Argument of Periapsis.
+            
+                            Type:
+                                float
+            """
+        @property
+        def k(self) -> float:
+            """
+                            Penalty parameter for periapsis.
+            
+                            Type:
+                                int
+            """
+        @property
+        def m(self) -> float:
+            """
+                            Scaling parameter for Semi-Major Axis delta.
+            
+                            Type:
+                                int
+            """
+        @property
+        def n(self) -> float:
+            """
+                            Scaling parameter for Semi-Major Axis delta.
+            
+                            Type:
+                                int
+            """
+        @property
+        def periapsis_weight(self) -> float:
+            """
+                            Periapsis weight.
+            
+                            Type:
+                                float
+            """
+        @property
+        def r(self) -> float:
+            """
+                            Scaling parameter for Semi-Major Axis delta.
+            
+                            Type:
+                                int
+            """
+        @property
+        def relative_effectivity_threshold(self) -> ostk.core.type.Real:
+            """
+                            Relative effectivity threshold.
+            
+                            Type:
+                                Real
+            """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, target_coe: ostk.astrodynamics.trajectory.orbit.model.kepler.COE, gravitational_parameter: ostk.physics.unit.Derived, parameters: QLaw.Parameters, gradient_strategy: QLaw.GradientStrategy = ...) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            coe (COE): The target orbit described by Classical Orbital Elements.
+                            gravitational_parameter (float): The gravitational parameter of the central body.
+                            parameters (QLaw.Parameters): A set of parameters for the QLaw.
+                            gradient_strategy (QLaw.GradientStrategy): The strategy used to compute the gradient dQ_dOE. Defaults to FiniteDifference.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def calculate_thrust_acceleration_at(self, instant: ostk.physics.time.Instant, position_coordinates: numpy.ndarray[numpy.float64[3, 1]], velocity_coordinates: numpy.ndarray[numpy.float64[3, 1]], thrust_acceleration: ostk.core.type.Real, output_frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[3, 1]]:
+        """
+                        Calculate the thrust acceleration at the provided coordinates and instant.
+        
+                        Args:
+                            instant (Instant): Instant of computation.
+                            position_coordinates (np.array): Position coordinates.
+                            velocity_coordinates (np.array): Velocity coordinates.
+                            thrust_acceleration (float): Thrust acceleration magnitude.
+                            output_frame (Frame): The frame the acceleration is expressed in.
+        
+                        Returns:
+                            np.array: The acceleration.
+        """
+    def get_gradient_strategy(self) -> QLaw.GradientStrategy:
+        """
+                        Get the gradient strategy.
+        
+                        Returns:
+                            QLaw.GradientStrategy: The gradient strategy.
+        """
+    def get_parameters(self) -> QLaw.Parameters:
+        """
+                        Get the parameters.
+        
+                        Returns:
+                            QLaw.Parameters: The parameters.
+        """
+    def get_target_coe(self) -> ostk.astrodynamics.trajectory.orbit.model.kepler.COE:
+        """
+                        Get the target COE.
+        
+                        Returns:
+                            COE: The target COE.
+        """

ostk/astrodynamics/pytrajectory/__init__.pyi

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

ostk/astrodynamics/pytrajectory/pystate.py

@@ -21,7 +21,6 @@ from ostk.astrodynamics.trajectory.state.coordinate_subset import (
 CANONICAL_FORMAT: str = r"(r|v)_(.*?)_(x|y|z)"
 
 
-@staticmethod
 def custom_class_generator(frame: Frame, coordinate_subsets: list) -> type:
     """
     Emit a custom class type for States. This is meta-programming syntactic sugar on top of the StateBuilder class.
@@ -44,7 +43,6 @@ def custom_class_generator(frame: Frame, coordinate_subsets: list) -> type:
     return StateTemplateType
 
 
-@staticmethod
 def from_dict(data: dict) -> State:
     """
     Create a State from a dictionary.
@@ -247,5 +245,5 @@ def from_dict(data: dict) -> State:
     )
 
 
-State.from_dict = from_dict
-State.template = custom_class_generator
+State.from_dict = staticmethod(from_dict)
+State.template = staticmethod(custom_class_generator)

ostk/astrodynamics/pytrajectory/pystate.pyi

@@ -0,0 +1,65 @@
+from __future__ import annotations
+import numpy as np
+from ostk.astrodynamics.converters import coerce_to_instant
+import ostk.astrodynamics.trajectory
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import StateBuilder
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import AngularVelocity
+from ostk.astrodynamics.trajectory.state.coordinate_subset import AttitudeQuaternion
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+import ostk.physics.coordinate
+from ostk.physics.coordinate import Frame
+from ostk.physics.time import Instant
+import re as re
+__all__ = ['AngularVelocity', 'AttitudeQuaternion', 'CANONICAL_FORMAT', 'CartesianPosition', 'CartesianVelocity', 'CoordinateSubset', 'Frame', 'Instant', 'State', 'StateBuilder', 'coerce_to_instant', 'custom_class_generator', 'from_dict', 'np', 're']
+def custom_class_generator(frame: ostk.physics.coordinate.Frame, coordinate_subsets: list) -> type:
+    """
+    
+        Emit a custom class type for States. This is meta-programming syntactic sugar on top of the StateBuilder class.
+    
+        StateType = State.template(frame, coordinate_subsets)
+        state = StateType(instant, coordinates)
+    
+        is equivalent to
+    
+        state_builder = StateBuilder(frame, coordinate_subsets)
+        state = state_builder.build(instant, coordinates)
+        
+    """
+def from_dict(data: dict) -> ostk.astrodynamics.trajectory.State:
+    """
+    
+        Create a State from a dictionary.
+    
+        Note: Implicit assumption that ECEF = ITRF, and ECI = GCRF.
+    
+        The dictionary must contain the following:
+        - 'timestamp': The timestamp of the state.
+        - 'r_ITRF_x'/'rx'/'rx_eci'/'rx_ecef': The x-coordinate of the position.
+        - 'r_ITRF_y'/'ry'/'ry_eci'/'ry_ecef': The y-coordinate of the position.
+        - 'r_ITRF_z'/'rz'/'rz_eci'/'rz_ecef': The z-coordinate of the position.
+        - 'v_ITRF_x'/'vx'/'vx_eci'/'vx_ecef': The x-coordinate of the velocity.
+        - 'v_ITRF_y'/'vy'/'vy_eci'/'vy_ecef': The y-coordinate of the velocity.
+        - 'v_ITRF_z'/'vz'/'vz_eci'/'vz_ecef': The z-coordinate of the velocity.
+        - 'frame': The frame of the state. Required if 'rx', 'ry', 'rz', 'vx', 'vy', 'vz' are provided.
+        - 'q_B_ECI_x': The x-coordinate of the quaternion. Optional.
+        - 'q_B_ECI_y': The y-coordinate of the quaternion. Optional.
+        - 'q_B_ECI_z': The z-coordinate of the quaternion. Optional.
+        - 'q_B_ECI_s': The s-coordinate of the quaternion. Optional.
+        - 'w_B_ECI_in_B_x': The x-coordinate of the angular velocity. Optional.
+        - 'w_B_ECI_in_B_y': The y-coordinate of the angular velocity. Optional.
+        - 'w_B_ECI_in_B_z': The z-coordinate of the angular velocity. Optional.
+        - 'drag_coefficient'/'cd': The drag coefficient. Optional.
+        - 'cross_sectional_area'/'surface_area': The cross-sectional area. Optional.
+        - 'mass': The mass. Optional.
+    
+        Args:
+            data (dict): The dictionary.
+    
+        Returns:
+            State: The State.
+        
+    """
+CANONICAL_FORMAT: str = '(r|v)_(.*?)_(x|y|z)'

ostk/astrodynamics/solver.pyi

@@ -0,0 +1,232 @@
+from __future__ import annotations
+import numpy
+import ostk.core.type
+import ostk.physics.time
+import typing
+__all__ = ['FiniteDifferenceSolver', 'TemporalConditionSolver']
+class FiniteDifferenceSolver:
+    """
+    
+                A Finite Difference Solver to compute the gradient, state transition matrix, and jacobian of a function.
+    
+            
+    """
+    class Type:
+        """
+        
+                    Type of finite difference scheme.
+        
+                
+        
+        Members:
+        
+          Forward : Forward difference scheme.
+        
+          Backward : Backward difference scheme.
+        
+          Central : Central difference scheme.
+        """
+        Backward: typing.ClassVar[FiniteDifferenceSolver.Type]  # value = <Type.Backward: 1>
+        Central: typing.ClassVar[FiniteDifferenceSolver.Type]  # value = <Type.Central: 2>
+        Forward: typing.ClassVar[FiniteDifferenceSolver.Type]  # value = <Type.Forward: 0>
+        __members__: typing.ClassVar[dict[str, FiniteDifferenceSolver.Type]]  # value = {'Forward': <Type.Forward: 0>, 'Backward': <Type.Backward: 1>, 'Central': <Type.Central: 2>}
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __eq__(self, other: typing.Any) -> bool:
+            ...
+        def __getstate__(self) -> int:
+            ...
+        def __hash__(self) -> int:
+            ...
+        def __index__(self) -> int:
+            ...
+        def __init__(self, value: int) -> None:
+            ...
+        def __int__(self) -> int:
+            ...
+        def __ne__(self, other: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        def __setstate__(self, state: int) -> None:
+            ...
+        def __str__(self) -> str:
+            ...
+        @property
+        def name(self) -> str:
+            ...
+        @property
+        def value(self) -> int:
+            ...
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @staticmethod
+    def default() -> FiniteDifferenceSolver:
+        """
+                        Get the default Finite Difference Solver.
+        
+                        Returns:
+                            FiniteDifferenceSolver: The default Finite Difference Solver.
+        """
+    @staticmethod
+    def string_from_type(type: FiniteDifferenceSolver.Type) -> ostk.core.type.String:
+        """
+                        Convert a type to string.
+        
+                        Args:
+                            type (FiniteDifferenceSolver.Type): The type.
+        
+                        Returns:
+                            str: The string name of the type.
+        """
+    def __init__(self, type: FiniteDifferenceSolver.Type, step_percentage: ostk.core.type.Real, step_duration: ostk.physics.time.Duration) -> None:
+        """
+                        Construct a FiniteDifferenceSolver.
+        
+                        Args:
+                            type (FiniteDifferenceSolver.Type): Type of finite difference scheme.
+                            step_percentage (float): The step percentage to use for computing the STM/Jacobian.
+                            step_duration (Duration): The step duration to use for computing the gradient.
+        
+                        Returns:
+                            FiniteDifferenceSolver: The FiniteDifferenceSolver.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def compute_gradient(self, state: ..., generate_state_coordinates: typing.Callable[[..., ostk.physics.time.Instant], numpy.ndarray[numpy.float64[m, 1]]]) -> numpy.ndarray[numpy.float64[m, 1]]:
+        """
+                        Compute the gradient.
+        
+                        Args:
+                            state (State): The state.
+                            generate_state_coordinates (function): The function to generate the state coordinates.
+        
+                        Returns:
+                            np.array: The gradient.
+        """
+    def compute_jacobian(self, state: ..., generate_state_coordinates: typing.Callable[[..., ostk.physics.time.Instant], numpy.ndarray[numpy.float64[m, 1]]]) -> numpy.ndarray[numpy.float64[m, n]]:
+        """
+                        Compute the jacobian.
+        
+                        Args:
+                            state (State): The state.
+                            generate_state_coordinates (function): The function to generate the state coordinates.
+        
+                        Returns:
+                            np.array: The jacobian.
+        """
+    @typing.overload
+    def compute_state_transition_matrix(self, state: ..., instants: list[ostk.physics.time.Instant], generate_states_coordinates: typing.Callable[[..., list[ostk.physics.time.Instant]], numpy.ndarray[numpy.float64[m, n]]]) -> list[numpy.ndarray[numpy.float64[m, n]]]:
+        """
+                        Compute a list of state transition matrix (STM) at the provided instants.
+        
+                        Args:
+                            state (State): The state.
+                            instants (Array(Instant)): The instants at which to calculate the STM.
+                            generate_states_coordinates (callable): The function to get the states coordinates as a matrix. Each column is a set of state coordinates.
+        
+                        Returns:
+                            np.array: The list of state transition matrices.
+        """
+    @typing.overload
+    def compute_state_transition_matrix(self, state: ..., instant: ostk.physics.time.Instant, generate_state_coordinates: typing.Callable[[..., ostk.physics.time.Instant], numpy.ndarray[numpy.float64[m, 1]]]) -> numpy.ndarray[numpy.float64[m, n]]:
+        """
+                        Compute the state transition matrix (STM).
+        
+                        Args:
+                            state (State): The state.
+                            instant (Instant): The instant at which to calculate the STM.
+                            generate_state_coordinates (callable): The function to get the state coordinates. Must be a column vector.
+        
+                        Returns:
+                            np.array: The state transition matrix.
+        """
+    def get_step_duration(self) -> ostk.physics.time.Duration:
+        """
+                        Get the step duration used for computing the gradient.
+        
+                        Returns:
+                            Duration: The step duration.
+        """
+    def get_step_percentage(self) -> ostk.core.type.Real:
+        """
+                        Get the step percentage used for computing the STM.
+        
+                        Returns:
+                            float: The step percentage.
+        """
+    def get_type(self) -> FiniteDifferenceSolver.Type:
+        """
+                        Get the type.
+        
+                        Returns:
+                            FiniteDifferenceSolver.Type: The type.
+        """
+class TemporalConditionSolver:
+    """
+    
+                Given a set of conditions and a time interval, the solver computes all sub-intervals over which conditions are met.
+    
+            
+    """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, time_step: ostk.physics.time.Duration, tolerance: ostk.physics.time.Duration, maximum_iteration_count: int = 500) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            time_step (Duration): The time step.
+                            tolerance (Duration): The tolerance of the solver.
+                            maximum_iteration_count (int): The maximum number of iterations allowed.
+        """
+    def get_maximum_iteration_count(self) -> int:
+        """
+                        Get the maximum number of iterations allowed.
+        
+                        Returns:
+                            int: The maximum number of iterations allowed.
+        """
+    def get_time_step(self) -> ostk.physics.time.Duration:
+        """
+                        Get the time step.
+        
+                        Returns:
+                            Duration: The time step.
+        """
+    def get_tolerance(self) -> ostk.physics.time.Duration:
+        """
+                        Get the tolerance.
+        
+                        Returns:
+                            Duration: The tolerance.
+        """
+    @typing.overload
+    def solve(self, condition: typing.Callable[[ostk.physics.time.Instant], bool], interval: ostk.physics.time.Interval) -> list[ostk.physics.time.Interval]:
+        """
+                        Solve a temporal condition.
+        
+                        Args:
+                            condition (function): The condition to solve.
+                            interval (Interval): The interval to solve the condition over.
+        
+                        Returns:
+                            Duration: The time at which the condition is satisfied.
+        """
+    @typing.overload
+    def solve(self, conditions: list[typing.Callable[[ostk.physics.time.Instant], bool]], interval: ostk.physics.time.Interval) -> list[ostk.physics.time.Interval]:
+        """
+                        Solve an array of temporal conditions.
+        
+                        Args:
+                            conditions (list): The conditions to solve.
+                            interval (Interval): The interval to solve the conditions over.
+        
+                        Returns:
+                            list: The times at which the conditions are satisfied.
+        """