open-space-toolkit-astrodynamics 1.2.0__py310-none-any.whl → 4.2.0__py310-none-any.whl

ostk/astrodynamics/test/flight/test_system.py

@@ -1,55 +0,0 @@
-# Apache License 2.0
-
-import pytest
-
-import numpy as np
-
-import ostk.mathematics as mathematics
-
-import ostk.physics as physics
-
-import ostk.astrodynamics as astrodynamics
-
-Cuboid = mathematics.geometry.d3.objects.Cuboid
-Composite = mathematics.geometry.d3.objects.Composite
-Point = mathematics.geometry.d3.objects.Point
-
-Mass = physics.units.Mass
-
-System = astrodynamics.flight.System
-
-
-@pytest.fixture
-def system_default_inputs():
-    mass = Mass(90.0, Mass.Unit.Kilogram)
-    geometry = Composite(
-        Cuboid(
-            Point(0.0, 0.0, 0.0),
-            [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
-            [1.0, 0.0, 0.0],
-        )
-    )
-
-    return (mass, geometry)
-
-
-@pytest.fixture
-def system(system_default_inputs) -> System:
-    return System(*system_default_inputs)
-
-
-class TestSatelliteSystem:
-    def test_constructors(self, system: System):
-        assert system is not None
-        assert isinstance(system, System)
-        assert system.is_defined()
-
-    def test_comparators(self, system: System):
-        assert (system == system) is True
-        assert (system != system) is False
-
-    def test_getters(self, system_default_inputs, system: System):
-        (mass, geometry) = system_default_inputs
-
-        assert system.get_mass() == mass
-        assert system.get_geometry() == geometry

ostk/astrodynamics/test/solvers/__init__.py

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

ostk/astrodynamics/test/solvers/test_temporal_condition_solver.py

@@ -1,153 +0,0 @@
-# Apache License 2.0
-
-import pytest
-
-from ostk.physics.units import Length
-from ostk.physics.units import Angle
-from ostk.physics.time import Instant
-from ostk.physics.time import Duration
-from ostk.physics.time import Interval
-from ostk.physics.time import DateTime
-from ostk.physics.time import Scale
-from ostk.physics import Environment
-
-from ostk.astrodynamics.trajectory import Orbit
-from ostk.astrodynamics.trajectory.orbit.models import Kepler
-from ostk.astrodynamics.trajectory.orbit.models.kepler import COE
-from ostk.astrodynamics.access import Generator
-from ostk.astrodynamics.solvers import TemporalConditionSolver
-
-
-@pytest.fixture
-def temporal_condition_solver() -> TemporalConditionSolver:
-    return TemporalConditionSolver(
-        time_step=Duration.seconds(30.0),
-        tolerance=Duration.milliseconds(1.0),
-        maximum_iteration_count=1234,
-    )
-
-
-@pytest.fixture
-def interval() -> Interval:
-    return 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),
-    )
-
-
-class TestTemporalConditionSolver:
-    def test_constructor_success(self):
-        temporal_condition_solver = TemporalConditionSolver(
-            time_step=Duration.seconds(30.0),
-            tolerance=Duration.milliseconds(1.0),
-            maximum_iteration_count=1234,
-        )
-
-        assert isinstance(temporal_condition_solver, TemporalConditionSolver)
-
-    def test_getters_success(
-        self,
-        temporal_condition_solver: TemporalConditionSolver,
-    ):
-        assert temporal_condition_solver.get_time_step() == Duration.seconds(30.0)
-        assert temporal_condition_solver.get_tolerance() == Duration.milliseconds(1.0)
-        assert temporal_condition_solver.get_maximum_iteration_count() == 1234
-
-    def test_solve_success_one_condition_always_true(
-        self,
-        temporal_condition_solver: TemporalConditionSolver,
-        interval: Interval,
-    ):
-        solution: list[Interval] = temporal_condition_solver.solve(
-            condition=lambda _: True,
-            interval=interval,
-        )
-
-        assert isinstance(solution, list)
-        assert solution == [interval]
-
-    def test_solve_success_one_condition_always_false(
-        self,
-        temporal_condition_solver: TemporalConditionSolver,
-        interval: Interval,
-    ):
-        solution: list[Interval] = temporal_condition_solver.solve(
-            condition=lambda _: False,
-            interval=interval,
-        )
-
-        assert isinstance(solution, list)
-        assert solution == []
-
-    def test_solve_success_multiple_conditions_always_true(
-        self,
-        temporal_condition_solver: TemporalConditionSolver,
-        interval: Interval,
-    ):
-        solution: list[Interval] = temporal_condition_solver.solve(
-            conditions=[
-                lambda _: True,
-                lambda _: True,
-            ],
-            interval=interval,
-        )
-
-        assert isinstance(solution, list)
-        assert solution == [interval]
-
-    def test_solve_success_multiple_conditions_one_always_false(
-        self,
-        temporal_condition_solver: TemporalConditionSolver,
-        interval: Interval,
-    ):
-        solution: list[Interval] = temporal_condition_solver.solve(
-            conditions=[
-                lambda _: True,
-                lambda _: False,
-            ],
-            interval=interval,
-        )
-
-        assert isinstance(solution, list)
-        assert solution == []
-
-    def test_solve_success_using_access_generator(
-        self,
-        temporal_condition_solver: TemporalConditionSolver,
-        interval: Interval,
-    ):
-        environment = Environment.default()
-
-        generator = Generator(
-            environment=environment,
-        )
-
-        earth = environment.access_celestial_object_with_name("Earth")
-
-        trajectory = 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,
-        )
-
-        solution: list[Interval] = temporal_condition_solver.solve(
-            condition=generator.get_condition_function(
-                from_trajectory=trajectory,
-                to_trajectory=trajectory,
-            ),
-            interval=interval,
-        )
-
-        assert isinstance(solution, list)
-        assert solution == [interval]

ostk/astrodynamics/test/test_numerical_solver.py

@@ -1,248 +0,0 @@
-# Apache License 2.0
-
-import pytest
-
-import numpy as np
-import math
-
-from ostk.astrodynamics import NumericalSolver, EventCondition
-
-
-def oscillator(x, dxdt, _):
-    dxdt[0] = x[1]
-    dxdt[1] = -x[0]
-    return dxdt
-
-
-def get_state_vec(time: float) -> np.ndarray:
-    return np.array([math.sin(time), math.cos(time)])
-
-
-@pytest.fixture
-def initial_state_vec() -> np.ndarray:
-    return get_state_vec(0.0)
-
-
-@pytest.fixture
-def custom_condition() -> EventCondition:
-    class CustomCondition(EventCondition):
-        def __init__(self, target: float, criteria: EventCondition.Criteria):
-            super().__init__("Custom", criteria)
-            self._target = target
-
-        def evaluate(self, state_vector, time: float) -> bool:
-            return time - self._target
-
-    return CustomCondition(5.0, EventCondition.Criteria.StrictlyPositive)
-
-
-@pytest.fixture
-def numerical_solver_default_inputs() -> (
-    tuple[NumericalSolver.LogType, NumericalSolver.StepperType, float, float, float]
-):
-    log_type = NumericalSolver.LogType.NoLog
-    stepper_type = NumericalSolver.StepperType.RungeKuttaCashKarp54
-    initial_time_step = 5.0
-    relative_tolerance = 1.0e-15
-    absolute_tolerance = 1.0e-15
-
-    return (
-        log_type,
-        stepper_type,
-        initial_time_step,
-        relative_tolerance,
-        absolute_tolerance,
-    )
-
-
-@pytest.fixture
-def numerical_solver(numerical_solver_default_inputs) -> NumericalSolver:
-    return NumericalSolver(*numerical_solver_default_inputs)
-
-
-@pytest.fixture
-def numerical_solver_conditional() -> NumericalSolver:
-    return NumericalSolver(
-        NumericalSolver.LogType.NoLog,
-        NumericalSolver.StepperType.RungeKuttaDopri5,
-        5.0,
-        1.0e-15,
-        1.0e-15,
-    )
-
-
-class TestNumericalSolver:
-    def test_constructors(self, numerical_solver: NumericalSolver):
-        assert numerical_solver is not None
-        assert isinstance(numerical_solver, NumericalSolver)
-        assert numerical_solver.is_defined()
-
-        numericalsolver_2: NumericalSolver = NumericalSolver(numerical_solver)
-
-        assert numericalsolver_2 is not None
-        assert isinstance(numericalsolver_2, NumericalSolver)
-        assert numericalsolver_2.is_defined()
-
-    def test_comparators(self, numerical_solver: NumericalSolver):
-        assert numerical_solver == numerical_solver
-        assert (numerical_solver != numerical_solver) is False
-
-    def test_get_types(
-        self,
-        numerical_solver_default_inputs: tuple[
-            NumericalSolver.LogType, NumericalSolver.StepperType, float, float, float
-        ],
-        numerical_solver: NumericalSolver,
-    ):
-        (
-            log_type,
-            stepper_type,
-            initial_time_step,
-            relative_tolerance,
-            absolute_tolerance,
-        ) = numerical_solver_default_inputs
-
-        assert numerical_solver.get_log_type() == log_type
-        assert numerical_solver.get_stepper_type() == stepper_type
-        assert numerical_solver.get_time_step() == initial_time_step
-        assert numerical_solver.get_relative_tolerance() == relative_tolerance
-        assert numerical_solver.get_absolute_tolerance() == absolute_tolerance
-        assert numerical_solver.get_root_solver() is not None
-
-    def test_get_string_from_types(self):
-        assert (
-            NumericalSolver.string_from_stepper_type(
-                NumericalSolver.StepperType.RungeKutta4
-            )
-            == "RungeKutta4"
-        )
-        assert (
-            NumericalSolver.string_from_stepper_type(
-                NumericalSolver.StepperType.RungeKuttaCashKarp54
-            )
-            == "RungeKuttaCashKarp54"
-        )
-        assert (
-            NumericalSolver.string_from_stepper_type(
-                NumericalSolver.StepperType.RungeKuttaFehlberg78
-            )
-            == "RungeKuttaFehlberg78"
-        )
-        assert (
-            NumericalSolver.string_from_log_type(NumericalSolver.LogType.NoLog)
-            == "NoLog"
-        )
-        assert (
-            NumericalSolver.string_from_log_type(NumericalSolver.LogType.LogConstant)
-            == "LogConstant"
-        )
-        assert (
-            NumericalSolver.string_from_log_type(NumericalSolver.LogType.LogAdaptive)
-            == "LogAdaptive"
-        )
-
-    def test_integrate_duration(
-        self, numerical_solver: NumericalSolver, initial_state_vec: np.ndarray
-    ):
-        integration_duration: float = 100.0
-
-        state_vector, _ = numerical_solver.integrate_duration(
-            initial_state_vec, integration_duration, oscillator
-        )
-
-        assert 5e-9 >= abs(state_vector[0] - math.sin(integration_duration))
-        assert 5e-9 >= abs(state_vector[1] - math.cos(integration_duration))
-
-        integration_durations = np.arange(100.0, 1000.0, 50.0)
-        solutions = numerical_solver.integrate_duration(
-            initial_state_vec, integration_durations, oscillator
-        )
-
-        for solution, integration_duration in zip(solutions, integration_durations):
-            state_vector, _ = solution
-
-            assert 5e-9 >= abs(state_vector[0] - math.sin(integration_duration))
-            assert 5e-9 >= abs(state_vector[1] - math.cos(integration_duration))
-
-    def test_integrate_time(self, numerical_solver: NumericalSolver):
-        start_time: float = 500.0
-        end_time: float = start_time + 100.0
-
-        initial_state_vec = get_state_vec(start_time)
-
-        state_vector, _ = numerical_solver.integrate_time(
-            initial_state_vec, start_time, end_time, oscillator
-        )
-
-        assert 5e-9 >= abs(state_vector[0] - math.sin(end_time))
-        assert 5e-9 >= abs(state_vector[1] - math.cos(end_time))
-
-        end_times = np.arange(600.0, 1000.0, 50.0)
-        solutions = numerical_solver.integrate_time(
-            initial_state_vec, start_time, end_times, oscillator
-        )
-
-        for solution, end_time in zip(solutions, end_times):
-            state_vector, _ = solution
-
-            assert 5e-9 >= abs(state_vector[0] - math.sin(end_time))
-            assert 5e-9 >= abs(state_vector[1] - math.cos(end_time))
-
-    def test_integrate_duration_with_condition(
-        self,
-        numerical_solver_conditional: NumericalSolver,
-        initial_state_vec: np.ndarray,
-        custom_condition: EventCondition,
-    ):
-        integration_duration: float = 100.0
-
-        condition_solution = numerical_solver_conditional.integrate_duration(
-            initial_state_vec, integration_duration, oscillator, custom_condition
-        )
-
-        assert condition_solution.condition_is_satisfied
-        assert (
-            condition_solution.iteration_count
-            < numerical_solver_conditional.get_root_solver().get_maximum_iteration_count()
-        )
-
-        state_vector, time = condition_solution.solution
-
-        assert abs(time - custom_condition._target) < 1e-6
-
-        assert 5e-9 >= abs(state_vector[0] - math.sin(time))
-        assert 5e-9 >= abs(state_vector[1] - math.cos(time))
-
-    def test_integrate_time_with_condition(
-        self,
-        numerical_solver_conditional: NumericalSolver,
-        custom_condition: EventCondition,
-    ):
-        start_time: float = 500.0
-        end_time: float = start_time + 100.0
-
-        initial_state_vec = get_state_vec(start_time)
-
-        condition_solution = numerical_solver_conditional.integrate_time(
-            initial_state_vec, start_time, end_time, oscillator, custom_condition
-        )
-
-        assert condition_solution.condition_is_satisfied
-        assert (
-            condition_solution.iteration_count
-            < numerical_solver_conditional.get_root_solver().get_maximum_iteration_count()
-        )
-
-        state_vector, time = condition_solution.solution
-
-        assert abs(time - start_time - custom_condition._target) < 1e-6
-
-        assert 5e-9 >= abs(state_vector[0] - math.sin(time))
-        assert 5e-9 >= abs(state_vector[1] - math.cos(time))
-
-    def test_default(self):
-        assert NumericalSolver.default() is not None
-
-    def test_undefined(self):
-        assert NumericalSolver.undefined() is not None
-        assert NumericalSolver.undefined().is_defined() is False

ostk/astrodynamics/test/trajectory/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/messages/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/messages/spacex/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/messages/spacex/conftest.py

@@ -1,18 +0,0 @@
-# Apache License 2.0
-
-import pytest
-
-import pathlib
-
-from ostk.core.filesystem import Path
-from ostk.core.filesystem import File
-
-
-@pytest.fixture
-def data_directory_path() -> str:
-    return f"{pathlib.Path(__file__).parent.absolute()}/data"
-
-
-@pytest.fixture
-def opm_file(data_directory_path: str) -> File:
-    return File.path(Path.parse(f"{data_directory_path}/opm_1.yaml"))

ostk/astrodynamics/test/trajectory/orbit/messages/spacex/data/opm_1.yaml

@@ -1,44 +0,0 @@
-# Dummy SpaceX OPM output
-
-# Notes:
-# - ECEF velocity is Earth relative
-# - Apogee/Perigee altitude assumes a spherical Earth, 6378.137 km radius
-# - Orbital elements are computed in an inertial frame realized by inertially
-#   freezing the WGS84 ECEF frame at time of current state
-# - State is post-deployment, so includes separation delta-velocity
-
-
-header:
-  generation_date: 2020-01-01T12:34:56.789Z
-  launch_date: 2020-01-02T12:34:56.789Z
-
-
-deployments:
-
-- name: satellite_a
-  sequence_number: 1
-  mission_time_s: 3600.0
-  date: 2020-01-02T13:34:56.789Z
-  r_ecef_m: [693289.644, 6876578.628, -133035.288]
-  v_ecef_m_per_s: [1305.783, 39.783, 7525.920]
-  mean_perigee_altitude_km: 526.768
-  mean_apogee_altitude_km: 568.430
-  mean_inclination_deg: 97.123
-  mean_argument_of_perigee_deg: -179.513
-  mean_longitude_ascending_node_deg: 85.057
-  mean_mean_anomaly_deg: 179.263
-  ballistic_coef_kg_per_m2: 47.55
-
-- name: satellite_b
-  sequence_number: 2
-  mission_time_s: 7200.0
-  date: 2020-01-02T14:34:56.789Z
-  r_ecef_m: [699863.059, 6875647.517, -123777.595]
-  v_ecef_m_per_s: [1504.658, 6.705, 7538.669]
-  mean_perigee_altitude_km: 536.779
-  mean_apogee_altitude_km: 529.851
-  mean_inclination_deg: 97.124
-  mean_argument_of_perigee_deg: 136.875
-  mean_longitude_ascending_node_deg: 85.032
-  mean_mean_anomaly_deg: -127.164
-  ballistic_coef_kg_per_m2: 44.26

ostk/astrodynamics/test/trajectory/orbit/messages/spacex/test_opm.py

@@ -1,108 +0,0 @@
-# Apache License 2.0
-
-import pytest
-
-from datetime import datetime
-
-from ostk.core.containers import Dictionary
-from ostk.core.filesystem import Path
-from ostk.core.filesystem import File
-
-from ostk.physics.units import Length
-from ostk.physics.units import Angle
-from ostk.physics.time import Instant
-from ostk.physics.time import Scale
-from ostk.physics.time import Duration
-from ostk.physics.coordinate import Position
-from ostk.physics.coordinate import Velocity
-from ostk.physics.coordinate import Frame
-
-from ostk.astrodynamics.trajectory.orbit.messages.spacex import OPM
-
-
-@pytest.fixture
-def opm() -> OPM:
-    return OPM(
-        header=OPM.Header(
-            generation_date=Instant.date_time(datetime(2020, 1, 2, 3, 4, 5), Scale.UTC),
-            launch_date=Instant.date_time(datetime(2020, 1, 3, 3, 4, 5), Scale.UTC),
-        ),
-        deployments=[
-            OPM.Deployment(
-                name="A",
-                sequence_number=1,
-                mission_time=Duration.hours(3600.0),
-                date=Instant.date_time(datetime(2020, 1, 4, 3, 4, 5), Scale.UTC),
-                position=Position.meters((1.0, 2.0, 3.0), Frame.ITRF()),
-                velocity=Velocity.meters_per_second((4.0, 5.0, 6.0), Frame.ITRF()),
-                mean_perigee_altitude=Length.kilometers(500.0),
-                mean_apogee_altitude=Length.kilometers(500.0),
-                mean_inclination=Angle.degrees(1.0),
-                mean_argument_of_perigee=Angle.degrees(2.0),
-                mean_longitude_ascending_node=Angle.degrees(3.0),
-                mean_mean_anomaly=Angle.degrees(4.0),
-                ballistic_coefficient=123.456,
-            ),
-        ],
-    )
-
-
-class TestOPM:
-    def test_constructor(self, opm: OPM):
-        assert opm is not None
-
-    def test_get_header(self, opm: OPM):
-        assert opm.get_header() is not None
-
-    def test_get_deployments(self, opm: OPM):
-        assert len(opm.get_deployments()) == 1
-
-    def test_get_deployment_at(self, opm: OPM):
-        assert opm.get_deployment_at(index=0).name == "A"
-
-    def test_get_deployment_with_name(self, opm: OPM):
-        assert opm.get_deployment_with_name(name="A").name == "A"
-
-    def test_undefined(self):
-        assert OPM.undefined().is_defined() is False
-
-    def test_dictionary(self):
-        dictionary = Dictionary(
-            {
-                "header": {
-                    "generation_date": "2020-01-01T12:34:56.789Z",
-                    "launch_date": "2020-01-02T12:34:56.789Z",
-                },
-                "deployments": [
-                    {
-                        "name": "satellite_a",
-                        "sequence_number": 1,
-                        "mission_time_s": 3600.0,
-                        "date": "2020-01-02T13:34:56.789Z",
-                        "r_ecef_m": [693289.644, 6876578.628, -133035.288],
-                        "v_ecef_m_per_s": [1305.783, 39.783, 7525.920],
-                        "mean_perigee_altitude_km": 526.768,
-                        "mean_apogee_altitude_km": 568.430,
-                        "mean_inclination_deg": 97.123,
-                        "mean_argument_of_perigee_deg": -179.513,
-                        "mean_longitude_ascending_node_deg": 85.057,
-                        "mean_mean_anomaly_deg": 179.263,
-                        "ballistic_coef_kg_per_m2": 47.55,
-                    }
-                ],
-            }
-        )
-
-        assert OPM.dictionary(dictionary) is not None
-
-    def test_parse(self, opm_file: File):
-        with open(str(opm_file.get_path().to_string()), "r") as stream:
-            assert OPM.parse(string=stream.read()) is not None
-
-    def test_load(self, opm_file: File):
-        assert OPM.load(file=opm_file) is not None
-
-
-class TestOPMDeployment:
-    def test_to_state(self, opm: OPM):
-        assert opm.get_deployment_with_name(name="A").to_state() is not None

ostk/astrodynamics/test/trajectory/orbit/models/__init__.py

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

ostk/astrodynamics/test/trajectory/orbit/models/kepler/__init__.py

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