open-space-toolkit-physics 11.3.0__py311-none-manylinux2014_x86_64.whl

ostk/physics/environment/magnetic/__init__.pyi

@@ -0,0 +1,171 @@
+from __future__ import annotations
+import numpy
+import ostk.core.filesystem
+import ostk.physics.time
+import typing
+from . import earth
+__all__ = ['Dipole', 'Earth', 'earth']
+class Dipole:
+    """
+    
+                Magnetic dipole model.
+    
+                :reference: https://en.wikipedia.org/wiki/Magnetic_dipole
+                :reference: https://en.wikipedia.org/wiki/Magnetic_moment
+                :reference: https://en.wikipedia.org/wiki/Vacuum_permeability
+                :reference: https://en.wikipedia.org/wiki/Dipole_model_of_the_Earth%27s_magnetic_field
+            
+    """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, arg0: numpy.ndarray[numpy.float64[3, 1]]) -> None:
+        """
+                        Construct a dipole magnetic model.
+        
+                        Args:
+                            magnetic_moment (np.ndarray): Magnetic moment [A⋅m2].
+        """
+    def get_field_value_at(self, arg0: numpy.ndarray[numpy.float64[3, 1]], arg1: ostk.physics.time.Instant) -> numpy.ndarray[numpy.float64[3, 1]]:
+        """
+                        Get the magnetic field value at a given position and instant.
+        
+                        Args:
+                            position (np.ndarray): Position, expressed in the magnetic object frame [m].
+                            instant (Instant): Instant.
+        
+                        Returns:
+                            np.ndarray: Magnetic field value, expressed in the magnetic object frame [T].
+        """
+class Earth:
+    """
+    
+                Earth magnetic model.
+    
+                :reference: https://geographiclib.sourceforge.io/html/magnetic.html
+            
+    """
+    class Type:
+        """
+        Members:
+        
+          Undefined : 
+                        Undefined Earth model type.
+                    
+        
+          Dipole : 
+                        Dipole Earth model type.
+                    
+        
+          EMM2010 : 
+                        Enhanced Magnetic Model 2010: approximates the main and crustal magnetic fields for the period 2010–2015.
+                    
+        
+          EMM2015 : 
+                        Enhanced Magnetic Model 2015: approximates the main and crustal magnetic fields for the period 2000–2020.
+                    
+        
+          EMM2017 : 
+                        Enhanced Magnetic Model 2017: approximates the main and crustal magnetic fields for the period 2000–2022.
+                    
+        
+          IGRF11 : 
+                        International Geomagnetic Reference Field (11th generation): approximates the main magnetic field for the period 1900–2015.
+                    
+        
+          IGRF12 : 
+                        International Geomagnetic Reference Field (12th generation): approximates the main magnetic field for the period 1900–2020.
+                    
+        
+          WMM2010 : 
+                        World Magnetic Model 2010: approximates the main magnetic field for the period 2010–2015.
+                    
+        
+          WMM2015 : 
+                        World Magnetic Model 2015: approximates the main magnetic field for the period 2015–2020.
+                    
+        """
+        Dipole: typing.ClassVar[Earth.Type]  # value = <Type.Dipole: 1>
+        EMM2010: typing.ClassVar[Earth.Type]  # value = <Type.EMM2010: 2>
+        EMM2015: typing.ClassVar[Earth.Type]  # value = <Type.EMM2015: 3>
+        EMM2017: typing.ClassVar[Earth.Type]  # value = <Type.EMM2017: 4>
+        IGRF11: typing.ClassVar[Earth.Type]  # value = <Type.IGRF11: 5>
+        IGRF12: typing.ClassVar[Earth.Type]  # value = <Type.IGRF12: 6>
+        Undefined: typing.ClassVar[Earth.Type]  # value = <Type.Undefined: 0>
+        WMM2010: typing.ClassVar[Earth.Type]  # value = <Type.WMM2010: 7>
+        WMM2015: typing.ClassVar[Earth.Type]  # value = <Type.WMM2015: 8>
+        __members__: typing.ClassVar[dict[str, Earth.Type]]  # value = {'Undefined': <Type.Undefined: 0>, 'Dipole': <Type.Dipole: 1>, 'EMM2010': <Type.EMM2010: 2>, 'EMM2015': <Type.EMM2015: 3>, 'EMM2017': <Type.EMM2017: 4>, 'IGRF11': <Type.IGRF11: 5>, 'IGRF12': <Type.IGRF12: 6>, 'WMM2010': <Type.WMM2010: 7>, 'WMM2015': <Type.WMM2015: 8>}
+        @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):
+        ...
+    @typing.overload
+    def __init__(self, type: ..., directory: ostk.core.filesystem.Directory) -> None:
+        """
+                        Construct an Earth magnetic model.
+        
+                        Args:
+                            type (Earth.Type): Earth model type.
+                            directory (Directory): Directory containing the magnetic model data files.
+        """
+    @typing.overload
+    def __init__(self, type: ...) -> None:
+        """
+                        Construct an Earth magnetic model.
+        
+                        Args:
+                            type (Earth.Type): Earth model type.
+        """
+    def get_field_value_at(self, arg0: numpy.ndarray[numpy.float64[3, 1]], arg1: ostk.physics.time.Instant) -> numpy.ndarray[numpy.float64[3, 1]]:
+        """
+                        Get the magnetic field value at a given position and instant.
+        
+                        Args:
+                            position (np.ndarray): Position, expressed in the magnetic object frame [m].
+                            instant (Instant): Instant.
+        
+                        Returns:
+                            np.ndarray: Magnetic field value, expressed in the magnetic object frame [T].
+        """
+    def get_type(self) -> ...:
+        """
+                        Get Earth model type.
+        
+                        Returns:
+                            Earth.Type: Earth model type.
+        """
+    def is_defined(self) -> bool:
+        """
+                        Check if the magnetic model is defined.
+        
+                        Returns:
+                            bool: True if defined.
+        """

ostk/physics/environment/magnetic/earth.pyi

@@ -0,0 +1,56 @@
+from __future__ import annotations
+import ostk.core.filesystem
+import ostk.physics
+import ostk.physics.environment.magnetic
+__all__ = ['Manager']
+class Manager(ostk.physics.Manager):
+    """
+    
+                Earth magnetic model data manager
+    
+                Fetches and manages necessary magnetic model data files.
+    
+                The following environment variables can be defined:
+    
+                - "OSTK_PHYSICS_ENVIRONMENT_MAGNETIC_EARTH_MANAGER_ENABLED" will override "DefaultEnabled"
+                - "OSTK_PHYSICS_ENVIRONMENT_MAGNETIC_EARTH_MANAGER_LOCAL_REPOSITORY" will override "DefaultLocalRepository"
+            
+    """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @staticmethod
+    def get() -> Manager:
+        """
+                        Get manager singleton
+        
+                        Returns:
+                            Manager: Reference to manager
+        """
+    def fetch_data_files_for_type(self, model_type: ostk.physics.environment.magnetic.Earth.Type) -> None:
+        """
+                        Fetch data file from remote
+        
+                        Args:
+                            model_type (EarthMagneticModel.Type): Model type
+        """
+    def has_data_files_for_type(self, model_type: ostk.physics.environment.magnetic.Earth.Type) -> bool:
+        """
+                        Check if data files are available for the given type
+        
+                        Args:
+                            model_type (EarthMagneticModel.Type): Model type
+        
+                        Returns:
+                            bool: True if data files are available for the given type
+        """
+    def local_data_files_for_type(self, model_type: ostk.physics.environment.magnetic.Earth.Type) -> list[ostk.core.filesystem.File]:
+        """
+                        Get local data files for the given type
+        
+                        Args:
+                            model_type (EarthMagneticModel.Type): Model type
+        
+                        Returns:
+                            list[File]: Local data files
+        """

ostk/physics/environment/object/__init__.pyi

@@ -0,0 +1,430 @@
+from __future__ import annotations
+import ostk.core.type
+import ostk.mathematics.geometry.d3
+import ostk.mathematics.geometry.d3.object
+import ostk.physics.coordinate
+import ostk.physics.coordinate.spherical
+import ostk.physics.environment
+import ostk.physics.time
+import ostk.physics.unit
+import typing
+from . import celestial
+__all__ = ['Celestial', 'Geometry', 'celestial']
+class Celestial(ostk.physics.environment.Object):
+    """
+    
+                Celestial class
+            
+    """
+    class CelestialType:
+        """
+        Members:
+        
+          Undefined : 
+                        Undefined celestial object.
+                    
+        
+          Sun : 
+                        Sun.
+                    
+        
+          Mercury : 
+                        Mercury.
+                    
+        
+          Venus : 
+                        Venus.
+                    
+        
+          Earth : 
+                        Earth.
+                    
+        
+          Moon : 
+                        Moon.
+                    
+        
+          Mars : 
+                        Mars.
+                    
+        """
+        Earth: typing.ClassVar[Celestial.CelestialType]  # value = <CelestialType.Earth: 4>
+        Mars: typing.ClassVar[Celestial.CelestialType]  # value = <CelestialType.Mars: 6>
+        Mercury: typing.ClassVar[Celestial.CelestialType]  # value = <CelestialType.Mercury: 2>
+        Moon: typing.ClassVar[Celestial.CelestialType]  # value = <CelestialType.Moon: 5>
+        Sun: typing.ClassVar[Celestial.CelestialType]  # value = <CelestialType.Sun: 1>
+        Undefined: typing.ClassVar[Celestial.CelestialType]  # value = <CelestialType.Undefined: 0>
+        Venus: typing.ClassVar[Celestial.CelestialType]  # value = <CelestialType.Venus: 3>
+        __members__: typing.ClassVar[dict[str, Celestial.CelestialType]]  # value = {'Undefined': <CelestialType.Undefined: 0>, 'Sun': <CelestialType.Sun: 1>, 'Mercury': <CelestialType.Mercury: 2>, 'Venus': <CelestialType.Venus: 3>, 'Earth': <CelestialType.Earth: 4>, 'Moon': <CelestialType.Moon: 5>, 'Mars': <CelestialType.Mars: 6>}
+        @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 FrameType:
+        """
+        Members:
+        
+          Undefined : 
+                        Undefined frame.
+                    
+        
+          NED : 
+                        North-East-Down (NED) frame.
+                    
+        """
+        NED: typing.ClassVar[Celestial.FrameType]  # value = <FrameType.NED: 1>
+        Undefined: typing.ClassVar[Celestial.FrameType]  # value = <FrameType.Undefined: 0>
+        __members__: typing.ClassVar[dict[str, Celestial.FrameType]]  # value = {'Undefined': <FrameType.Undefined: 0>, 'NED': <FrameType.NED: 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:
+            ...
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @staticmethod
+    def string_from_frame_type(frame_type: ...) -> ostk.core.type.String:
+        """
+                        Get the string representation of a frame type.
+        
+                        Args:
+                            frame_type (Celestial.FrameType): Frame type.
+        
+                        Returns:
+                            str: String representation.
+        """
+    @staticmethod
+    def undefined() -> Celestial:
+        """
+                        Create an undefined celestial object.
+        
+                        Returns:
+                            Celestial: Undefined celestial object.
+        """
+    @typing.overload
+    def __init__(self, name: ostk.core.type.String, type: ..., gravitational_parameter: ostk.physics.unit.Derived, equatorial_radius: ostk.physics.unit.Length, flattening: ostk.core.type.Real, J2_parameter_value: ostk.core.type.Real, J4_parameter_value: ostk.core.type.Real, ephemeris: ..., gravitational_model: ..., magnetic_model: ..., atmospheric_model: ...) -> None:
+        """
+                        Constructor
+        
+                        Args:
+                            name (str): Name.
+                            type (CelestialType): Type.
+                            gravitational_parameter (Derived): Gravitational parameter [m³/s²].
+                            equatorial_radius (Length): Equatorial radius [m].
+                            flattening (Real): Flattening.
+                            J2_parameter_value (Real): J2 parameter value.
+                            J4_parameter_value (Real): J4 parameter value.
+                            ephemeris (Ephemeris): Ephemeris.
+                            gravitational_model (GravitationalModel): Gravitational model.
+                            magnetic_model (MagneticModel): Magnetic model.
+                            atmospheric_model (AtmosphericModel): Atmospheric model.
+        """
+    @typing.overload
+    def __init__(self, name: ostk.core.type.String, type: ..., gravitational_parameter: ostk.physics.unit.Derived, equatorial_radius: ostk.physics.unit.Length, flattening: ostk.core.type.Real, J2_parameter_value: ostk.core.type.Real, J4_parameter_value: ostk.core.type.Real, ephemeris: ..., gravitational_model: ..., magnetic_model: ..., atmospheric_model: ..., geometry: Geometry) -> None:
+        """
+                        Constructor
+        
+                        Args:
+                            name (str): Name.
+                            type (CelestialType): Type.
+                            gravitational_parameter (Derived): Gravitational parameter [m³/s²].
+                            equatorial_radius (Length): Equatorial radius [m].
+                            flattening (Real): Flattening.
+                            J2_parameter_value (Real): J2 parameter value.
+                            J4_parameter_value (Real): J4 parameter value.
+                            ephemeris (Ephemeris): Ephemeris
+                            gravitational_model (GravitationalModel): Gravitational model.
+                            magnetic_model (MagneticModel): Magnetic model.
+                            atmospheric_model (AtmosphericModel): Atmospheric model.
+                            geometry (Object.Geometry): Geometry.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def access_atmospheric_model(self) -> ...:
+        """
+                        Access the atmospheric model.
+        
+                        Returns:
+                            Atmospheric: Atmospheric model.
+        """
+    def access_ephemeris(self) -> ...:
+        """
+                        Access the ephemeris.
+        
+                        Returns:
+                            Ephemeris: Ephemeris.
+        """
+    def access_gravitational_model(self) -> ...:
+        """
+                        Access the gravitational model.
+        
+                        Returns:
+                            Gravitational: Gravitational model.
+        """
+    def access_magnetic_model(self) -> ...:
+        """
+                        Access the magnetic model.
+        
+                        Returns:
+                            Magnetic: Magnetic model.
+        """
+    def atmospheric_model_is_defined(self) -> bool:
+        """
+                        Check if the atmospheric model is defined.
+        
+                        Returns:
+                            bool: True if the atmospheric model is defined, false otherwise.
+        """
+    def get_axes_in(self, frame: ostk.physics.coordinate.Frame, instant: ostk.physics.time.Instant) -> ostk.physics.coordinate.Axes:
+        """
+                        Get the axes of the celestial object in a given frame at a given instant.
+        
+                        Args:
+                            frame (Frame): Frame.
+                            instant (Instant): Instant.
+        
+                        Returns:
+                            Axes: Axes.
+        """
+    def get_equatorial_radius(self) -> ostk.physics.unit.Length:
+        """
+                        Get the equatorial radius of the celestial object.
+        
+                        Returns:
+                            Length: Equatorial radius [m].
+        """
+    def get_flattening(self) -> ostk.core.type.Real:
+        """
+                        Get the flattening of the celestial object.
+        
+                        Returns:
+                            float: Flattening.
+        """
+    def get_frame_at(self, lla: ostk.physics.coordinate.spherical.LLA, frame_type: ...) -> ostk.physics.coordinate.Frame:
+        """
+                        Get the frame at a given LLA and frame type.
+        
+                        Args:
+                            lla (LLA): LLA
+                            frame_type (Celestial.FrameType): Frame type
+        
+                        Returns:
+                            Frame: Frame.
+        """
+    def get_gravitational_parameter(self) -> ostk.physics.unit.Derived:
+        """
+                        Get the gravitational parameter of the celestial object.
+        
+                        Returns:
+                            Derived: Gravitational parameter [m³/s²].
+        """
+    def get_j2(self) -> ostk.core.type.Real:
+        """
+                        Get the J2 parameter value of the celestial object.
+        
+                        Returns:
+                            float: J2 parameter value.
+        """
+    def get_j4(self) -> ostk.core.type.Real:
+        """
+                        Get the J4 parameter value of the celestial object.
+        
+                        Returns:
+                            float: J4 parameter value.
+        """
+    def get_position_in(self, frame: ostk.physics.coordinate.Frame, instant: ostk.physics.time.Instant) -> ostk.physics.coordinate.Position:
+        """
+                        Get the position of the celestial object in a given frame at a given instant.
+        
+                        Args:
+                            frame (Frame): Frame.
+                            instant (Instant): Instant.
+        
+                        Returns:
+                            Position: Position.
+        """
+    def get_transform_to(self, frame: ostk.physics.coordinate.Frame, instant: ostk.physics.time.Instant) -> ostk.physics.coordinate.Transform:
+        """
+                        Get the transform of the celestial object to a given frame at a given instant.
+        
+                        Args:
+                            frame (Frame): Frame.
+                            instant (Instant): Instant.
+        
+                        Returns:
+                            Transform: Transform.
+        """
+    def get_type(self) -> ...:
+        """
+                        Get the type of the celestial object.
+        
+                        Returns:
+                            Celestial.Type: Type.
+        """
+    def gravitational_model_is_defined(self) -> bool:
+        """
+                        Check if the gravitational model is defined.
+        
+                        Returns:
+                            bool: True if the gravitational model is defined, false otherwise.
+        """
+    def is_defined(self) -> bool:
+        """
+                        Check if the celestial object is defined.
+        
+                        Returns:
+                            bool: True if the celestial object is defined, false otherwise.
+        """
+    def magnetic_model_is_defined(self) -> bool:
+        """
+                        Check if the magnetic model is defined.
+        
+                        Returns:
+                            bool: True if the magnetic model is defined, false otherwise.
+        """
+class Geometry:
+    """
+    
+                Geometry.
+            
+    """
+    __hash__: typing.ClassVar[None] = None
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @staticmethod
+    def undefined() -> Geometry:
+        """
+                        Constructs an undefined geometry.
+        
+                        Returns:
+                            Geometry: Undefined geometry.
+        """
+    def __eq__(self, arg0: Geometry) -> bool:
+        ...
+    @typing.overload
+    def __init__(self, arg0: ostk.mathematics.geometry.d3.object.Composite, arg1: ostk.physics.coordinate.Frame) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: ostk.mathematics.geometry.d3.Object, arg1: ostk.physics.coordinate.Frame) -> None:
+        ...
+    def __ne__(self, arg0: Geometry) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def access_composite(self) -> ostk.mathematics.geometry.d3.object.Composite:
+        """
+                        Access composite.
+        
+                        Returns:
+                            Composite: Composite.
+        """
+    def access_frame(self) -> ostk.physics.coordinate.Frame:
+        """
+                        Access frame.
+        
+                        Returns:
+                            Frame: Frame.
+        """
+    def contains(self, arg0: Geometry) -> bool:
+        """
+                        Check if the geometry contains a point.
+        
+                        Args:
+                            aPoint (Point): A point.
+        
+                        Returns:
+                            bool: True if geometry contains point.
+        """
+    def in_frame(self, arg0: ostk.physics.coordinate.Frame, arg1: ostk.physics.time.Instant) -> Geometry:
+        """
+                        Get geometry expressed in a given frame.
+        
+                        Args:
+                            aFrame (Frame): Frame.
+                            anInstant (Instant): An instant.
+        
+                        Returns:
+                            Geometry: Geometry expressed in a given frame.
+        """
+    def intersection_with(self, arg0: Geometry) -> Geometry:
+        """
+                        Compute intersection of geometry with another geometry.
+        
+                        Args:
+                            aGeometry (Geometry): Another geometry.
+        
+                        Returns:
+                            Geometry: Intersection of geometry with another geometry.
+        """
+    def intersects(self, arg0: Geometry) -> bool:
+        """
+                        Check if the geometry intersects with another geometry.
+        
+                        Args:
+                            aGeometry (Geometry): Another geometry.
+        
+                        Returns:
+                            bool: True if geometries intersect.
+        """
+    def is_defined(self) -> bool:
+        """
+                        Check if the geometry is defined.
+        
+                        Returns:
+                            bool: True if defined.
+        """