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

ostk/astrodynamics/display.py

@@ -0,0 +1,281 @@
+# Apache License 2.0
+
+from __future__ import annotations
+
+import warnings
+from typing import Any
+
+import pandas as pd
+
+import plotly.graph_objs as go
+
+from ostk.mathematics.object import RealInterval
+
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.environment.object import Celestial
+from ostk.physics.time import Duration
+from ostk.physics.time import Instant
+
+from ostk.astrodynamics import Access
+from ostk.astrodynamics import Trajectory
+
+
+DEFAULT_COLOR: str = "rgba(255, 0, 0, 0.5)"
+
+DEFAULT_LAYOUT_2D: go.Layout = go.Layout(
+    title=None,
+    showlegend=False,
+    height=1000,
+    geo=go.layout.Geo(
+        showland=True,
+        landcolor="rgb(243, 243, 243)",
+        countrycolor="rgb(204, 204, 204)",
+        lonaxis=dict(
+            showgrid=True,
+            gridcolor="rgb(102, 102, 102)",
+            gridwidth=0.1,
+        ),
+        lataxis=dict(
+            showgrid=True,
+            gridcolor="rgb(102, 102, 102)",
+            gridwidth=0.1,
+        ),
+    ),
+)
+
+DEFAULT_LAYOUT_3D: go.Layout = go.Layout(
+    title=None,
+    showlegend=False,
+    height=1000,
+    geo=go.layout.Geo(
+        showland=True,
+        showlakes=True,
+        showcountries=False,
+        showocean=True,
+        countrywidth=0.0,
+        landcolor="rgb(100, 100, 100)",
+        lakecolor="rgb(240, 240, 240)",
+        oceancolor="rgb(240, 240, 240)",
+        projection=dict(
+            type="orthographic",
+            rotation=dict(
+                lon=0,
+                lat=0,
+                roll=0,
+            ),
+        ),
+        lonaxis=dict(
+            showgrid=True,
+            gridcolor="rgb(102, 102, 102)",
+            gridwidth=0.5,
+        ),
+        lataxis=dict(
+            showgrid=True,
+            gridcolor="rgb(102, 102, 102)",
+            gridwidth=0.5,
+        ),
+    ),
+)
+
+
+def convert_to_ground_track_plotting_data(
+    longitude: list,
+    latitude: list,
+    color: str = DEFAULT_COLOR,
+) -> go.Scattergeo:
+    return go.Scattergeo(
+        lon=longitude,
+        lat=latitude,
+        mode="lines",
+        line=dict(
+            width=1,
+            color=color,
+        ),
+    )
+
+
+def create_plotly_figure(
+    data: Any,
+    layout: go.Layout,
+) -> go.Figure:
+    return go.Figure(
+        data=data,
+        layout=layout,
+    )
+
+
+def create_2d_map(
+    data: Any,
+) -> go.Figure:
+    return create_plotly_figure(data, DEFAULT_LAYOUT_2D)
+
+
+def create_3d_globe(
+    data: Any,
+) -> go.Figure:
+    return create_plotly_figure(data, DEFAULT_LAYOUT_3D)
+
+
+class AccessesPlot:
+    """
+    Accesses plot. Display a 2D world map, with 1 ground station and
+    multiple satellites, highlighting the accesses.
+    """
+
+    def __init__(
+        self,
+        earth: Celestial,
+        interval: RealInterval,
+        trajectory_step: Duration,
+        access_step: Duration,
+    ):
+        self._data = []
+        self._earth = earth
+        self._trajectory_grid: list[Instant] = interval.generate_grid(trajectory_step)
+        self._access_step: Duration = access_step
+
+    def _generate_and_append_data(
+        self,
+        data: list[list[float]],
+        trajectory: Trajectory,
+        grid: list[Instant],
+    ) -> None:
+        for state in trajectory.get_states_at(grid):
+            lla: LLA = LLA.cartesian(
+                state.get_position()
+                .in_frame(Frame.ITRF(), state.get_instant())
+                .get_coordinates(),
+                self._earth.get_equatorial_radius(),
+                self._earth.get_flattening(),
+            )
+            data.append(
+                [
+                    float(lla.get_longitude().in_degrees()),
+                    float(lla.get_latitude().in_degrees()),
+                ]
+            )
+
+    def _append_line(
+        self,
+        df: pd.DataFrame,
+        width: int,
+        rgb: str,
+    ) -> None:
+        self._data.append(
+            dict(
+                type="scattergeo",
+                lon=df["Longitude"],
+                lat=df["Latitude"],
+                mode="lines",
+                line=dict(
+                    width=width,
+                    color=rgb,
+                ),
+            )
+        )
+
+    def add_ground_station(
+        self,
+        ground_station_lla: LLA,
+        color: str | tuple[int, int, int],
+    ) -> None:
+        """
+        Add a ground station to the plot.
+
+        Args:
+            ground_station_lla (LLA): The ground station location.
+            color (str | tuple[int, int, int]): The color of the ground station.
+        """
+        if isinstance(color, (tuple, list)):
+            color = f"rgba({str(color[0])},{str(color[1])},{str(color[2])},1.0)"
+
+        self._data.append(
+            dict(
+                type="scattergeo",
+                lon=[float(ground_station_lla.get_longitude().in_degrees())],
+                lat=[float(ground_station_lla.get_latitude().in_degrees())],
+                mode="markers",
+                marker=dict(
+                    size=10,
+                    color=color,
+                ),
+            )
+        )
+
+    def add_accesses(
+        self,
+        trajectory: Trajectory,
+        accesses: list[Access],
+        rgb: str | tuple[int, int, int],
+    ) -> None:
+        """
+        Add accesses to the plot.
+
+        Args:
+            trajectory (Trajectory): The satellite trajectory.
+            accesses (list[Access]): The list of accesses.
+            rgb (str | tuple[int, int, int]): The color of the accesses, as a string or tuple of RGB values.
+        """
+        if isinstance(rgb, (tuple, list)):
+            rgb = f"rgba({str(rgb[0])},{str(rgb[1])},{str(rgb[2])},1.0)"
+
+        for access in accesses:
+            satellite_access_data: list[list[float]] = []
+            self._generate_and_append_data(
+                satellite_access_data,
+                trajectory,
+                access.get_interval().generate_grid(self._access_step),
+            )
+            satellite_access_df: pd.DataFrame = pd.DataFrame(
+                satellite_access_data,
+                columns=["Longitude", "Latitude"],
+            )
+            self._append_line(
+                satellite_access_df,
+                2,
+                rgb,
+            )
+
+    def add_satellite(
+        self,
+        trajectory: Trajectory,
+        rgb: str | tuple[int, int, int] | None = None,
+        opacity: float = 0.3,
+    ) -> None:
+        """
+        Add a satellite trajectory to the plot.
+
+        Args:
+            trajectory (Trajectory): The satellite trajectory.
+            rgb (str | tuple[int, int, int] | None, optional): The color of the satellite, as a string or tuple of RGB values.
+            opacity (float, optional): Opacity of the satellite trajectory line.
+        """
+        if rgb is None:
+            rgb = f"rgba(255, 0, 0, {opacity})"
+
+        elif isinstance(rgb, (tuple, list)):
+            rgb = f"rgba({str(rgb[0])},{str(rgb[1])},{str(rgb[2])},{opacity})"
+
+        satellite_trajectory_data: list[list[float]] = []
+        self._generate_and_append_data(
+            satellite_trajectory_data,
+            trajectory,
+            self._trajectory_grid,
+        )
+        satellite_trajectory_df: pd.DataFrame = pd.DataFrame(
+            satellite_trajectory_data,
+            columns=["Longitude", "Latitude"],
+        )
+        self._append_line(
+            satellite_trajectory_df,
+            1,
+            rgb,
+        )
+
+    def show(self):
+        """
+        Display the figure.
+        """
+        figure = create_2d_map(data=self._data)
+        figure.show()

ostk/astrodynamics/dynamics.pyi

@@ -0,0 +1,311 @@
+from __future__ import annotations
+import numpy
+import ostk.astrodynamics
+import ostk.astrodynamics.flight.system
+import ostk.astrodynamics.trajectory.state
+import ostk.core.type
+import ostk.mathematics.curve_fitting
+import ostk.physics.coordinate
+import ostk.physics.environment.object
+import ostk.physics.time
+__all__ = ['AtmosphericDrag', 'CentralBodyGravity', 'PositionDerivative', 'Tabulated', 'ThirdBodyGravity', 'Thruster']
+class AtmosphericDrag(ostk.astrodynamics.Dynamics):
+    """
+    
+                    The atmospheric drag dynamics.
+    
+                
+    """
+    def __init__(self, celestial: ostk.physics.environment.object.Celestial) -> None:
+        """
+                            Constructor.
+        
+                            Args:
+                                celestial (Celestial): The celestial body.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def compute_contribution(self, instant: ostk.physics.time.Instant, x: numpy.ndarray[numpy.float64[m, 1]], frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[m, 1]]:
+        """
+                            Compute the contribution of the atmospheric drag to the state vector.
+        
+                            Args:
+                                instant (Instant): The instant of the state vector.
+                                x (numpy.ndarray): The state vector.
+                                frame (Frame): The reference frame.
+        
+                            Returns:
+                                numpy.ndarray: The contribution of the atmospheric drag to the state vector.
+        """
+    def get_celestial(self) -> ostk.physics.environment.object.Celestial:
+        """
+                            Get the celestial body.
+        
+                            Returns:
+                                Celestial: The celestial body.
+        """
+    def is_defined(self) -> bool:
+        """
+                            Check if the atmospheric drag is defined.
+        
+                            Returns:
+                                bool: True if the atmospheric drag is defined, False otherwise.
+        """
+class CentralBodyGravity(ostk.astrodynamics.Dynamics):
+    """
+    
+                    The central-body gravity model.
+    
+                
+    """
+    def __init__(self, celestial: ostk.physics.environment.object.Celestial) -> None:
+        """
+                            Constructor.
+        
+                            Args:
+                                celestial (Celestial): The central body.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def compute_contribution(self, instant: ostk.physics.time.Instant, x: numpy.ndarray[numpy.float64[m, 1]], frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[m, 1]]:
+        """
+                            Compute the contribution of the central-body gravity to the state vector.
+        
+                            Args:
+                                instant (Instant): The instant of the state vector.
+                                x (numpy.ndarray): The state vector.
+                                frame (Frame): The reference frame.
+        
+                            Returns:
+                                numpy.ndarray: The contribution of the central-body gravity to the state vector.
+        """
+    def get_celestial(self) -> ostk.physics.environment.object.Celestial:
+        """
+                            Get the central body.
+        
+                            Returns:
+                                Celestial: The central body.
+        """
+    def is_defined(self) -> bool:
+        """
+                            Check if the central-body gravity is defined.
+        
+                            Returns:
+                                bool: True if the central-body gravity is defined, False otherwise.
+        """
+class PositionDerivative(ostk.astrodynamics.Dynamics):
+    """
+    
+                    The position derivative model.
+    
+                
+    """
+    def __init__(self) -> None:
+        """
+                            Constructor.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def compute_contribution(self, instant: ostk.physics.time.Instant, x: numpy.ndarray[numpy.float64[m, 1]], frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[m, 1]]:
+        """
+                            Compute the contribution of the position derivative to the state vector.
+        
+                            Args:
+                                instant (Instant): The instant of the state vector.
+                                x (numpy.ndarray): The state vector.
+                                frame (Frame): The reference frame.
+        
+                            Returns:
+                                numpy.ndarray: The contribution of the position derivative to the state vector.
+        """
+    def is_defined(self) -> bool:
+        """
+                            Check if the position derivative is defined.
+        
+                            Returns:
+                                bool: True if the position derivative is defined, False otherwise.
+        """
+class Tabulated(ostk.astrodynamics.Dynamics):
+    """
+    
+                    The tabulated dynamics.
+    
+                
+    """
+    def __init__(self, instants: list[ostk.physics.time.Instant], contribution_profile: numpy.ndarray[numpy.float64[m, n]], coordinate_subsets: list[ostk.astrodynamics.trajectory.state.CoordinateSubset], frame: ostk.physics.coordinate.Frame, interpolation_type: ostk.mathematics.curve_fitting.Interpolator.Type = ...) -> None:
+        """
+                            Constructor.
+        
+                            Args:
+                                instants (list[Instant]): An array of instants.
+                                contribution_profile (numpy.ndarray): A contribution profile.
+                                coordinate_subsets (list[CoordinateSubset]): An array of coordinate subsets related to the contribution profile.
+                                frame (Frame): A frame.
+                                interpolation_type (Interpolator.Type, optional): The interpolation type. Defaults to Barycentric Rational.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def access_contribution_profile(self) -> numpy.ndarray[numpy.float64[m, n]]:
+        """
+                            Access the contribution profile.
+        
+                            Returns:
+                                np.ndarray: The contribution profile.
+        """
+    def access_frame(self) -> ostk.physics.coordinate.Frame:
+        """
+                            Access the reference frame.
+        
+                            Returns:
+                                Frame: The reference frame.
+        """
+    def access_instants(self) -> list[ostk.physics.time.Instant]:
+        """
+                            Access the contribution instants.
+        
+                            Returns:
+                                list[Instant]: The contribution instants.
+        """
+    def compute_contribution(self, instant: ostk.physics.time.Instant, x: numpy.ndarray[numpy.float64[m, 1]], frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[m, 1]]:
+        """
+                            Compute the contribution from the contribution profile to the state vector.
+        
+                            Args:
+                                instant (Instant): The instant of the state vector.
+                                x (numpy.ndarray): The state vector.
+                                frame (Frame): The reference frame.
+        
+                            Returns:
+                                numpy.ndarray: The contribution from the contribution profile to the state vector.
+        """
+    def get_contribution_profile_from_coordinate_subsets(self, coordinate_subsets: list[ostk.astrodynamics.trajectory.state.CoordinateSubset]) -> numpy.ndarray[numpy.float64[m, n]]:
+        """
+                            Get the contribution profile corresponding to a subset of coordinates.
+        
+                            Args:
+                                coordinate_subsets (list[CoordinateSubset]): The coordinate subsets.
+        
+                            Returns:
+                                numpy.ndarray: The contribution profile.
+        """
+    def get_interpolation_type(self) -> ostk.mathematics.curve_fitting.Interpolator.Type:
+        """
+                            Get the interpolation type used for each row of the contribution profile (they are all the same).
+        
+                            Returns:
+                                Interpolator.Type: The interpolation type.
+        """
+    def is_defined(self) -> bool:
+        """
+                            Check if the tabulated dynamics is defined.
+        
+                            Returns:
+                                bool: True if the tabulated dynamics is defined, False otherwise.
+        """
+class ThirdBodyGravity(ostk.astrodynamics.Dynamics):
+    """
+    
+                    The third body gravity model.
+    
+                
+    """
+    def __init__(self, celestial: ostk.physics.environment.object.Celestial) -> None:
+        """
+                            Constructor.
+        
+                            Args:
+                                celestial (Celestial): The celestial body.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def compute_contribution(self, instant: ostk.physics.time.Instant, x: numpy.ndarray[numpy.float64[m, 1]], frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[m, 1]]:
+        """
+                            Compute the contribution of the third-body gravity to the state vector.
+        
+                            Args:
+                                instant (Instant): The instant of the state vector.
+                                x (numpy.ndarray): The state vector.
+                                frame (Frame): The reference frame.
+        
+                            Returns:
+                                numpy.ndarray: The contribution of the third-body gravity to the state vector.
+        """
+    def get_celestial(self) -> ostk.physics.environment.object.Celestial:
+        """
+                            Get the celestial body.
+        
+                            Returns:
+                                Celestial: The celestial body.
+        """
+    def is_defined(self) -> bool:
+        """
+                            Check if the third-body gravity is defined.
+        
+                            Returns:
+                                bool: True if the third-body gravity is defined, False otherwise.
+        """
+class Thruster(ostk.astrodynamics.Dynamics):
+    """
+    
+                Abstract Thruster Class.
+    
+                Base class to derive other thruster classes from. Cannot be instantiated.
+    
+            
+    """
+    def __init__(self, satellite_system: ostk.astrodynamics.flight.system.SatelliteSystem, guidance_law: typing.Any, name: ostk.core.type.String = ...) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            satellite_system (SatelliteSystem): The satellite system.
+                            guidance_law (GuidanceLaw): The guidance law used to compute the acceleration vector.
+                            name (str, optional): The name of the thruster. Defaults to String.empty().
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def compute_contribution(self, instant: ostk.physics.time.Instant, state_vector: numpy.ndarray[numpy.float64[m, 1]], frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[m, 1]]:
+        """
+                        Compute the contribution of the thruster to the state vector.
+        
+                        Args:
+                            instant (Instant): The instant of the state vector.
+                            state_vector (numpy.ndarray): The state vector.
+                            frame (Frame): The reference frame.
+        
+                        Returns:
+                            numpy.ndarray: The contribution of the thruster to the state vector.
+        """
+    def get_guidance_law(self) -> ...:
+        """
+                        Get the guidance law of the thruster.
+        
+                        Returns:
+                            GuidanceLaw: The guidance law.
+        """
+    def get_satellite_system(self) -> ostk.astrodynamics.flight.system.SatelliteSystem:
+        """
+                        Get the satellite system of the thruster.
+        
+                        Returns:
+                            SatelliteSystem: The satellite system.
+        """
+    def is_defined(self) -> bool:
+        """
+                        Check if the thruster is defined.
+        
+                        Returns:
+                            bool: True if the thruster is defined, False otherwise.
+        """

ostk/astrodynamics/eclipse.pyi

@@ -0,0 +1,70 @@
+from __future__ import annotations
+import ostk.astrodynamics
+import ostk.core.type
+import ostk.physics
+import ostk.physics.environment.utility
+import ostk.physics.time
+import typing
+__all__ = ['Generator']
+class Generator:
+    """
+    
+                An eclipse generator.            
+            
+    """
+    @typing.overload
+    def __init__(self, environment: ostk.physics.Environment = ..., search_step_size: ostk.physics.time.Duration = ..., search_tolerance: ostk.physics.time.Duration = ...) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            environment (Environment): The Environment to use during the search. Defaults to the Environment.default().
+                            search_step_size (Duration): The step size to use during the search. Defaults to Duration.seconds(60.0).
+                            search_tolerance (Duration): The tolerance to use during the search. Defaults to Duration.milliseconds(1.0).
+        """
+    @typing.overload
+    def __init__(self) -> None:
+        """
+                        Default constructor with default parameters.
+        """
+    def generate(self, trajectory: ostk.astrodynamics.Trajectory, analysis_interval: ostk.physics.time.Interval, occulted_celestial_object_name: ostk.core.type.String = 'Sun', occulting_celestial_object_name: ostk.core.type.String = 'Earth') -> list[ostk.physics.environment.utility.Eclipse]:
+        """
+                        Generate eclipses for a given trajectory over the provided analysis interval.
+        
+                        Args:
+                            trajectory (Trajectory): The trajectory to search for eclipses.
+                            analysis_interval (Interval): The analysis interval.
+                            occulted_celestial_object_name (str): The name of the occulted celestial object. Defaults to "Sun".
+                            occulting_celestial_object_name (str): The name of the occulting celestial object. Defaults to "Earth".
+        
+                        Returns:
+                            Array[Eclipse]: Array of eclipses found within the analysis interval.
+        """
+    def get_environment(self) -> ostk.physics.Environment:
+        """
+                        Get the environment.
+        
+                        Returns:
+                            Environment: The environment used during the search.
+        """
+    def get_search_step_size(self) -> ostk.physics.time.Duration:
+        """
+                        Get the search step size.
+        
+                        Returns:
+                            Duration: The step size used during the search.
+        """
+    def get_search_tolerance(self) -> ostk.physics.time.Duration:
+        """
+                        Get the search tolerance.
+        
+                        Returns:
+                            Duration: The tolerance used during the search.
+        """
+    def is_defined(self) -> bool:
+        """
+                        Check if eclipse generator is defined.
+        
+                        Returns:
+                            bool: True if eclipse generator is defined, False otherwise.
+        """