open-space-toolkit-astrodynamics 13.1.0__py313-none-manylinux2014_x86_64.whl

ostk/astrodynamics/pytrajectory/pystate.py

@@ -0,0 +1,251 @@
+# Apache License 2.0
+
+# Python-only State functionality
+import re
+
+import numpy as np
+
+from ostk.physics.coordinate import Frame
+from ostk.physics.time import Instant
+
+from ostk.astrodynamics.trajectory import State, StateBuilder
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+from ostk.astrodynamics.converters import coerce_to_instant
+from ostk.astrodynamics.trajectory.state.coordinate_subset import (
+    CartesianPosition,
+    CartesianVelocity,
+    AttitudeQuaternion,
+    AngularVelocity,
+)
+
+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.
+
+    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)
+    """
+
+    class StateTemplateType(State):
+        state_builder: StateBuilder = StateBuilder(frame, coordinate_subsets)
+
+        def __init__(self, instant: Instant, coordinates: np.ndarray):
+            super().__init__(StateTemplateType.state_builder.build(instant, coordinates))
+
+    return StateTemplateType
+
+
+@staticmethod
+def from_dict(data: dict) -> 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.
+    """
+
+    instant: Instant = coerce_to_instant(data["timestamp"])
+
+    eci_columns: list[str] = [
+        "rx_eci",
+        "ry_eci",
+        "rz_eci",
+        "vx_eci",
+        "vy_eci",
+        "vz_eci",
+    ]
+    ecef_columns: list[str] = [
+        "rx_ecef",
+        "ry_ecef",
+        "rz_ecef",
+        "vx_ecef",
+        "vy_ecef",
+        "vz_ecef",
+    ]
+    generic_columns: list[str] = [
+        "rx",
+        "ry",
+        "rz",
+        "vx",
+        "vy",
+        "vz",
+    ]
+
+    # Replace non-standard position keys with canonical representation
+    if all(key in data.keys() for key in ("x_eci", "y_eci", "z_eci")):
+        data["rx_eci"] = data["x_eci"]
+        data["ry_eci"] = data["y_eci"]
+        data["rz_eci"] = data["z_eci"]
+
+    if all(key in data.keys() for key in ("x_ecef", "y_ecef", "z_ecef")):
+        data["rx_ecef"] = data["x_ecef"]
+        data["ry_ecef"] = data["y_ecef"]
+        data["rz_ecef"] = data["z_ecef"]
+
+    frame: Frame
+    coordinates: np.ndarray
+
+    coordinate_subsets: list[CoordinateSubset] = [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+    ]
+
+    match_groups: list[re.Match] = [
+        re.match(CANONICAL_FORMAT, column) for column in data.keys()
+    ]
+
+    if len(matches := [match for match in match_groups if match is not None]) == 6:
+        frame_name: str = matches[0].group(2)
+        try:
+            frame: Frame = Frame.with_name(frame_name) or getattr(Frame, frame_name)()
+        except Exception:
+            raise ValueError(f"No frame exists with name [{frame_name}].")
+
+        coordinates = np.array([data[match.group(0)] for match in matches])
+
+    elif all(column in data for column in eci_columns):
+        frame: Frame = Frame.GCRF()
+        coordinates = np.array(
+            [
+                data["rx_eci"],
+                data["ry_eci"],
+                data["rz_eci"],
+                data["vx_eci"],
+                data["vy_eci"],
+                data["vz_eci"],
+            ]
+        )
+
+    elif all(column in data for column in ecef_columns):
+        frame = Frame.ITRF()
+        coordinates = np.array(
+            [
+                data["rx_ecef"],
+                data["ry_ecef"],
+                data["rz_ecef"],
+                data["vx_ecef"],
+                data["vy_ecef"],
+                data["vz_ecef"],
+            ]
+        )
+
+    elif all(column in data for column in generic_columns):
+        if "frame" not in data:
+            raise ValueError("Frame must be provided for generic columns.")
+
+        if isinstance(data["frame"], str):
+            if Frame.exists(data["frame"]):
+                frame = Frame.with_name(data["frame"])
+            else:
+                raise ValueError(f"No frame exists with name [{data['frame']}].")
+        elif isinstance(data["frame"], Frame):
+            frame = data["frame"]
+        else:
+            raise ValueError(f"Invalid frame data [{data['frame']}].")
+
+        coordinates = np.array(
+            [
+                data["rx"],
+                data["ry"],
+                data["rz"],
+                data["vx"],
+                data["vy"],
+                data["vz"],
+            ]
+        )
+    else:
+        raise ValueError("Invalid state data.")
+
+    if all(
+        column in data for column in ["q_B_ECI_x", "q_B_ECI_y", "q_B_ECI_z", "q_B_ECI_s"]
+    ):
+        coordinate_subsets.append(AttitudeQuaternion.default())
+        coordinates = np.append(
+            coordinates,
+            [
+                data["q_B_ECI_x"],
+                data["q_B_ECI_y"],
+                data["q_B_ECI_z"],
+                data["q_B_ECI_s"],
+            ],
+        )
+
+    if all(
+        column in data
+        for column in ["w_B_ECI_in_B_x", "w_B_ECI_in_B_y", "w_B_ECI_in_B_z"]
+    ):
+        coordinate_subsets.append(AngularVelocity.default())
+        coordinates = np.append(
+            coordinates,
+            [
+                data["w_B_ECI_in_B_x"],
+                data["w_B_ECI_in_B_y"],
+                data["w_B_ECI_in_B_z"],
+            ],
+        )
+
+    if "drag_coefficient" in data or "cd" in data:
+        coordinate_subsets.append(CoordinateSubset.drag_coefficient())
+        coordinates = np.append(
+            coordinates,
+            data.get("drag_coefficient", data.get("cd")),
+        )
+
+    if "cross_sectional_area" in data or "surface_area" in data:
+        coordinate_subsets.append(CoordinateSubset.surface_area())
+        coordinates = np.append(
+            coordinates,
+            data.get("cross_sectional_area", data.get("surface_area")),
+        )
+
+    if "mass" in data:
+        coordinate_subsets.append(CoordinateSubset.mass())
+        coordinates = np.append(
+            coordinates,
+            data["mass"],
+        )
+
+    return State(
+        instant=instant,
+        coordinates=coordinates,
+        frame=frame,
+        coordinate_subsets=coordinate_subsets,
+    )
+
+
+State.from_dict = from_dict
+State.template = custom_class_generator

ostk/astrodynamics/test/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/astrodynamics/test/access/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/astrodynamics/test/access/test_generator.py

@@ -0,0 +1,248 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.mathematics.object import RealInterval
+
+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 import Access
+from ostk.astrodynamics.access 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 generator(environment: Environment) -> Generator:
+    return Generator(
+        environment=environment,
+        aer_filter=lambda aer: True,
+        access_filter=lambda access: True,
+        state_filter=lambda state_1, state_2: True,
+    )
+
+
+@pytest.fixture
+def from_trajectory(earth: Celestial) -> Trajectory:
+    return Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(7000.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(45.0),
+                raan=Angle.degrees(0.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(0.0),
+            ),
+            epoch=Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+
+
+@pytest.fixture
+def to_trajectory(earth: Celestial) -> Trajectory:
+    return Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(7000.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(45.0),
+                raan=Angle.degrees(180.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(180.0),
+            ),
+            epoch=Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+
+
+class TestGenerator:
+    def test_constructor_success_environment(self, environment: Environment):
+        generator = Generator(
+            environment=environment,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+
+    def test_constructor_success_environment_aer_filter(self, environment: Environment):
+        generator = Generator(
+            environment=environment,
+            aer_filter=lambda aer: True,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+
+    def test_constructor_success_environment_access_filter(
+        self,
+        environment: Environment,
+    ):
+        generator = Generator(
+            environment=environment,
+            access_filter=lambda access: True,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+
+    def test_constructor_success_environment_state_filter(
+        self,
+        environment: Environment,
+    ):
+        generator = Generator(
+            environment=environment,
+            state_filter=lambda state_1, state_2: True,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+
+    def test_constructor_success_environment_step_tolerance(
+        self,
+        environment: Environment,
+    ):
+        generator = Generator(
+            environment=environment,
+            step=Duration.seconds(1.0),
+            tolerance=Duration.minutes(1.0),
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.get_step() == Duration.seconds(1.0)
+        assert generator.get_tolerance() == Duration.minutes(1.0)
+
+    def test_getters_success(self, generator: Generator):
+        assert generator.get_step() == Duration.minutes(1.0)
+        assert generator.get_tolerance() == Duration.microseconds(1.0)
+        assert generator.get_aer_filter() is not None
+        assert generator.get_access_filter() is not None
+        assert generator.get_state_filter() is not None
+
+    def test_get_condition_function_success(
+        self,
+        generator: Generator,
+        from_trajectory: Trajectory,
+        to_trajectory: Trajectory,
+    ):
+        condition_function = generator.get_condition_function(
+            from_trajectory=from_trajectory,
+            to_trajectory=to_trajectory,
+        )
+
+        assert condition_function is not None
+        assert (
+            condition_function(
+                Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+            )
+            is True
+        )
+
+    def test_compute_accesses_success(
+        self,
+        generator: Generator,
+        from_trajectory: Trajectory,
+        to_trajectory: Trajectory,
+    ):
+        accesses = generator.compute_accesses(
+            interval=Interval.closed(
+                Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC),
+                Instant.date_time(DateTime(2018, 1, 1, 2, 0, 0), Scale.UTC),
+            ),
+            from_trajectory=from_trajectory,
+            to_trajectory=to_trajectory,
+        )
+
+        assert accesses is not None
+        assert isinstance(accesses, list)
+        assert accesses[0] is not None
+        assert isinstance(accesses[0], Access)
+
+    def test_set_step_success(self, generator: Generator):
+        generator.set_step(Duration.seconds(1.0))
+
+    def test_set_tolerance_success(self, generator: Generator):
+        generator.set_tolerance(Duration.seconds(1.0))
+
+    def test_set_aer_filter_success(self, generator: Generator):
+        generator.set_aer_filter(aer_filter=lambda aer: True)
+
+    def test_set_access_filter_success(self, generator: Generator):
+        generator.set_access_filter(access_filter=lambda access: True)
+
+    def test_set_state_filter_success(self, generator: Generator):
+        generator.set_state_filter(state_filter=lambda state_1, state_2: 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_aer_ranges_success(self, environment: Environment):
+        # Construct arbitrary AER ranges
+        azimuth_interval = RealInterval.closed(0.0, 360.0)
+        elevation_interval = RealInterval.closed(0.0, 90.0)
+        range_interval = RealInterval.closed(0.0, 7000e3)
+
+        generator = Generator.aer_ranges(
+            azimuth_range=azimuth_interval,
+            elevation_range=elevation_interval,
+            range_range=range_interval,
+            environment=environment,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.is_defined()
+
+    def test_aer_mask_success(self, environment: Environment):
+        # Construct arbitrary anAzimuthElevationMask using python dict
+        an_azimuth_elevation_mask = {
+            0.0: 30.0,
+            90.0: 60.0,
+            180.0: 60.0,
+            270.0: 30.0,
+            359.0: 30.0,
+        }
+
+        # Construct arbitrary aRangerange
+        a_range_range = RealInterval(0.0, 10e4, RealInterval.Type.Closed)
+
+        generator = Generator.aer_mask(
+            azimuth_elevation_mask=an_azimuth_elevation_mask,
+            range_range=a_range_range,
+            environment=environment,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.is_defined()

ostk/astrodynamics/test/conftest.py

@@ -0,0 +1,119 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics import Environment
+from ostk.physics.unit import Angle
+from ostk.physics.unit import Length
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.time import Interval
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Velocity
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.coordinate.spherical import AER
+
+from ostk.astrodynamics import Trajectory
+from ostk.astrodynamics.trajectory import State
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment.default()
+
+
+@pytest.fixture
+def scale() -> Scale:
+    return Scale.UTC
+
+
+@pytest.fixture
+def instant_1(scale: Scale) -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 8, 13, 45, 34), scale)
+
+
+@pytest.fixture
+def instant_2(scale: Scale) -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 8, 13, 46, 34), scale)
+
+
+@pytest.fixture
+def instant_3(scale: Scale) -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 8, 13, 47, 34), scale)
+
+
+@pytest.fixture
+def instant(instant_1: Instant) -> Instant:
+    return instant_1
+
+
+@pytest.fixture
+def interval(instant_1: Instant, instant_2: Instant) -> Interval:
+    return Interval(instant_1, instant_2, Interval.Type.Closed)
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def position(frame: Frame) -> Position:
+    return Position.meters([7000000.0, 0.0, 0.0], frame)
+
+
+@pytest.fixture
+def velocity(frame: Frame) -> Velocity:
+    return Velocity.meters_per_second([7600.0, 0.0, 0.0], frame)
+
+
+@pytest.fixture
+def state(instant: Instant, position: Position, velocity: Velocity) -> State:
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def latitude() -> Angle:
+    return Angle(30.0, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def longitude() -> Angle:
+    return Angle(-111.0, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def altitude() -> Length:
+    return Length(10000.0, Length.Unit.Meter)
+
+
+@pytest.fixture
+def lla(latitude: Angle, longitude: Angle, altitude: Length) -> LLA:
+    return LLA(latitude, longitude, altitude)
+
+
+@pytest.fixture
+def azimuth() -> Angle:
+    return Angle(270.0, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def elevation() -> Angle:
+    return Angle(10.45, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def range() -> Length:
+    return Length(100000.0, Length.Unit.Meter)
+
+
+@pytest.fixture
+def aer(azimuth: Angle, elevation: Angle, range: Length) -> LLA:
+    return AER(azimuth, elevation, range)
+
+
+@pytest.fixture
+def trajectory(position: Position, instant_1: Instant) -> Trajectory:
+    return Trajectory.position(position.in_frame(Frame.ITRF(), instant_1))

ostk/astrodynamics/test/conjunction/message/ccsds/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0