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

ostk/astrodynamics/test/dynamics/test_thruster.py

@@ -0,0 +1,157 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.geometry.d3.object import Cuboid
+from ostk.mathematics.geometry.d3.object import Composite
+from ostk.mathematics.geometry.d3.object import Point
+
+from ostk.physics.unit import Mass
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+from ostk.astrodynamics.trajectory.state import CoordinateBroker
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.flight.system import PropulsionSystem
+from ostk.astrodynamics.flight.system import SatelliteSystem
+from ostk.astrodynamics.dynamics import Thruster
+from ostk.astrodynamics.guidance_law import ConstantThrust
+
+
+@pytest.fixture
+def guidance_law() -> ConstantThrust:
+    return ConstantThrust.intrack(True)
+
+
+@pytest.fixture
+def propulsion_system() -> PropulsionSystem:
+    return PropulsionSystem(
+        1.0,
+        150.0,
+    )
+
+
+@pytest.fixture
+def satellite_system(propulsion_system: PropulsionSystem) -> SatelliteSystem:
+    mass = Mass(100.0, Mass.Unit.Kilogram)
+    satellite_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],
+        )
+    )
+    inertia_tensor = np.ndarray(shape=(3, 3))
+    surface_area = 0.8
+    drag_coefficient = 2.1
+
+    return SatelliteSystem(
+        mass,
+        satellite_geometry,
+        inertia_tensor,
+        surface_area,
+        drag_coefficient,
+        propulsion_system,
+    )
+
+
+@pytest.fixture
+def dynamics(
+    satellite_system: SatelliteSystem,
+    guidance_law: ConstantThrust,
+) -> Thruster:
+    return Thruster(
+        satellite_system=satellite_system,
+        guidance_law=guidance_law,
+        name="Constant Thrust Thruster Dynamics",
+    )
+
+
+@pytest.fixture
+def coordinate_broker() -> CoordinateBroker:
+    return CoordinateBroker(
+        [
+            CartesianPosition.default(),
+            CartesianVelocity.default(),
+            CoordinateSubset.mass(),
+        ]
+    )
+
+
+@pytest.fixture
+def state(coordinate_broker: CoordinateBroker) -> State:
+    instant: Instant = Instant.date_time(DateTime(2021, 3, 20, 12, 0, 0), Scale.UTC)
+    coordinates: list = [7000000.0, 0.0, 0.0, 0.0, 7546.05329, 0.0, 105.0]
+
+    return State(instant, coordinates, Frame.GCRF(), coordinate_broker)
+
+
+class TestThruster:
+    def test_constructors(
+        self,
+        guidance_law: ConstantThrust,
+        satellite_system: SatelliteSystem,
+    ):
+        thrusters = [
+            Thruster(
+                satellite_system=satellite_system,
+                guidance_law=guidance_law,
+            ),
+            Thruster(
+                satellite_system=satellite_system,
+                guidance_law=guidance_law,
+                name="A name",
+            ),
+        ]
+
+        for thruster in thrusters:
+            assert thruster is not None
+            assert isinstance(thruster, Thruster)
+            assert thruster.is_defined()
+
+    def test_getters(self, dynamics: Thruster):
+        assert dynamics.get_satellite_system() is not None
+        assert dynamics.get_guidance_law() is not None
+        assert dynamics.get_read_coordinate_subsets() is not None
+        assert dynamics.get_write_coordinate_subsets() is not None
+
+    def test_compute_contribution_success(self, dynamics: Thruster, state: State):
+        contribution = dynamics.compute_contribution(
+            state.get_instant(), state.get_coordinates(), state.get_frame()
+        )
+
+        assert len(contribution) == 4
+        assert contribution == pytest.approx(
+            [0.0, 0.009523809523809525, 0.0, -0.0006798108086519521], abs=5e-11
+        )
+
+    def test_compute_contribution_failure_out_of_fuel(
+        self,
+        satellite_system: SatelliteSystem,
+        coordinate_broker: CoordinateBroker,
+        dynamics: Thruster,
+    ):
+        instant: Instant = Instant.date_time(DateTime(2021, 3, 20, 12, 0, 0), Scale.UTC)
+        coordinates: list = [
+            7000000.0,
+            0.0,
+            0.0,
+            0.0,
+            7546.05329,
+            0.0,
+            satellite_system.get_mass().in_kilograms(),
+        ]
+        state = State(instant, coordinates, Frame.GCRF(), coordinate_broker)
+
+        with pytest.raises(RuntimeError):
+            contribution = dynamics.compute_contribution(
+                state.get_instant(), state.get_coordinates(), state.get_frame()
+            )

ostk/astrodynamics/test/eclipse/__init__.py

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

ostk/astrodynamics/test/eclipse/test_generator.py

@@ -0,0 +1,138 @@
+# Apache License 2.0
+
+import pytest
+
+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.physics.environment.utility import Eclipse
+from ostk.physics.environment.utility import EclipsePhase
+
+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.eclipse 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 search_step_size() -> Duration:
+    return Duration.seconds(30.0)
+
+
+@pytest.fixture
+def search_tolerance() -> Duration:
+    return Duration.milliseconds(10.0)
+
+
+@pytest.fixture
+def generator(
+    environment: Environment,
+    search_step_size: Duration,
+    search_tolerance: Duration,
+) -> Generator:
+    return Generator(
+        environment=environment,
+        search_step_size=search_step_size,
+        search_tolerance=search_tolerance,
+    )
+
+
+@pytest.fixture
+def trajectory(earth: Celestial) -> Trajectory:
+    return Orbit(
+        model=Kepler(
+            coe=COE(
+                semi_major_axis=Length.kilometers(6700.0),
+                eccentricity=0.0,
+                inclination=Angle.degrees(0.0),
+                raan=Angle.degrees(0.0),
+                aop=Angle.degrees(0.0),
+                true_anomaly=Angle.degrees(0.0),
+            ),
+            epoch=Instant.date_time(DateTime(2000, 1, 1, 0, 0, 0), Scale.UTC),
+            celestial_object=earth,
+            perturbation_type=Kepler.PerturbationType.No,
+        ),
+        celestial_object=earth,
+    )
+
+
+@pytest.fixture
+def analysis_interval() -> Interval:
+    return Interval.closed(
+        Instant.date_time(DateTime(2000, 1, 1, 14, 0, 0), Scale.UTC),
+        Instant.date_time(DateTime(2000, 1, 1, 17, 0, 0), Scale.UTC),
+    )
+
+
+class TestGenerator:
+    def test_constructor_and_properties_success(
+        self,
+        environment: Environment,
+        search_step_size: Duration,
+        search_tolerance: Duration,
+    ):
+        generator: Generator = Generator(
+            environment=environment,
+            search_step_size=search_step_size,
+            search_tolerance=search_tolerance,
+        )
+
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.is_defined() is True
+        assert generator.get_environment().is_defined()
+        assert generator.get_search_step_size() == search_step_size
+        assert generator.get_search_tolerance() == search_tolerance
+
+    def test_default_constructor_and_properties_success(self):
+        generator: Generator = Generator()
+        assert generator is not None
+        assert isinstance(generator, Generator)
+        assert generator.is_defined() is True
+
+    def test_generate_success(
+        self,
+        generator: Generator,
+        trajectory: Trajectory,
+        analysis_interval: Interval,
+    ):
+        eclipses: list[Eclipse] = generator.generate(
+            trajectory=trajectory,
+            analysis_interval=analysis_interval,
+            occulted_celestial_object_name="Sun",
+            occulting_celestial_object_name="Earth",
+        )
+
+        assert eclipses is not None
+        assert isinstance(eclipses, list)
+        assert len(eclipses) > 0
+
+        # Check that all returned objects are Eclipse instances
+        for eclipse in eclipses:
+            assert isinstance(eclipse, Eclipse)
+
+            # Check eclipse phases
+            phases: list[EclipsePhase] = eclipse.get_phases()
+            assert isinstance(phases, list)
+            assert len(phases) > 0
+
+            for phase in phases:
+                assert isinstance(phase, EclipsePhase)

ostk/astrodynamics/test/estimator/test_orbit_determination_solver.py

@@ -0,0 +1,261 @@
+# Apache License 2.0
+
+import pytest
+
+import pandas as pd
+
+import numpy as np
+
+from ostk.physics import Environment
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+from ostk.physics.environment.object.celestial import Earth
+
+from ostk.astrodynamics.solver import LeastSquaresSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory import Propagator
+from ostk.astrodynamics.trajectory.state import NumericalSolver
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+from ostk.astrodynamics.estimator import OrbitDeterminationSolver
+from ostk.astrodynamics.dataframe import generate_states_from_dataframe
+
+
+@pytest.fixture
+def environment() -> Environment:
+    return Environment(central_celestial_object=Earth.EGM96(10, 10), objects=[])
+
+
+@pytest.fixture
+def numerical_solver() -> NumericalSolver:
+    return NumericalSolver.default()
+
+
+@pytest.fixture
+def least_squares_solver() -> LeastSquaresSolver:
+    return LeastSquaresSolver.default()
+
+
+@pytest.fixture
+def orbit_determination_solver(
+    environment: Environment,
+    numerical_solver: NumericalSolver,
+    least_squares_solver: LeastSquaresSolver,
+) -> OrbitDeterminationSolver:
+    return OrbitDeterminationSolver(
+        environment=environment,
+        numerical_solver=numerical_solver,
+        solver=least_squares_solver,
+    )
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+    ]
+
+
+@pytest.fixture
+def initial_guess(
+    observations: list[State],
+) -> State:
+    return observations[0]
+
+
+@pytest.fixture
+def observations() -> list[State]:
+    return generate_states_from_dataframe(
+        pd.read_csv(
+            "/app/test/OpenSpaceToolkit/Astrodynamics/Estimator/OrbitDeterminationSolverData/gnss_data.csv"
+        ),
+        reference_frame=Frame.ITRF(),
+    )
+
+
+@pytest.fixture
+def initial_guess_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1, 1e-1, 1e-1],
+        coordinate_subsets[1]: [1e-2, 1e-2, 1e-2],
+    }
+
+
+@pytest.fixture
+def observation_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1, 1e-1, 1e-1],
+        coordinate_subsets[1]: [1e-2, 1e-2, 1e-2],
+    }
+
+
+@pytest.fixture
+def rms_error() -> float:
+    return 1.0
+
+
+@pytest.fixture
+def x_hat() -> np.ndarray:
+    return np.array([1.0, 0.0])
+
+
+@pytest.fixture
+def step(
+    rms_error: float,
+    x_hat: np.ndarray,
+) -> LeastSquaresSolver.Step:
+    return LeastSquaresSolver.Step(
+        rms_error=rms_error,
+        x_hat=x_hat,
+    )
+
+
+@pytest.fixture
+def observation_count() -> int:
+    return 5
+
+
+@pytest.fixture
+def termination_criteria() -> str:
+    return "RMS Update Threshold"
+
+
+@pytest.fixture
+def estimated_state() -> State:
+    return State(
+        Instant.J2000(),
+        [1.0, 0.0],
+        Frame.GCRF(),
+        [CoordinateSubset("Position", 1), CoordinateSubset("Velocity", 1)],
+    )
+
+
+@pytest.fixture
+def estimated_covariance() -> np.ndarray:
+    return np.array([[1.0, 0.0], [0.0, 1.0]])
+
+
+@pytest.fixture
+def estimated_frisbee_covariance() -> np.ndarray:
+    return np.array([[1.0, 0.0], [0.0, 1.0]])
+
+
+@pytest.fixture
+def computed_observations(
+    observations: list[State],
+) -> list[State]:
+    return observations
+
+
+@pytest.fixture
+def steps(step: LeastSquaresSolver.Step) -> list[LeastSquaresSolver.Step]:
+    return [step]
+
+
+@pytest.fixture
+def solver_analysis(
+    termination_criteria: str,
+    estimated_state: State,
+    estimated_covariance: np.ndarray,
+    estimated_frisbee_covariance: np.ndarray,
+    computed_observations: list[State],
+    steps: list[LeastSquaresSolver.Step],
+) -> LeastSquaresSolver.Analysis:
+    return LeastSquaresSolver.Analysis(
+        termination_criteria=termination_criteria,
+        estimated_state=estimated_state,
+        estimated_covariance=estimated_covariance,
+        estimated_frisbee_covariance=estimated_frisbee_covariance,
+        computed_observations=computed_observations,
+        steps=steps,
+    )
+
+
+@pytest.fixture
+def analysis(
+    initial_guess: State,
+    solver_analysis: LeastSquaresSolver.Analysis,
+) -> OrbitDeterminationSolver.Analysis:
+    return OrbitDeterminationSolver.Analysis(
+        estimated_state=initial_guess,
+        solver_analysis=solver_analysis,
+    )
+
+
+class TestOrbitDeterminationSolverAnalysis:
+    def test_constructor(
+        self,
+        analysis: OrbitDeterminationSolver.Analysis,
+    ):
+        assert isinstance(analysis, OrbitDeterminationSolver.Analysis)
+
+    def test_properties(
+        self,
+        analysis: OrbitDeterminationSolver.Analysis,
+    ):
+        assert isinstance(analysis.estimated_state, State)
+        assert isinstance(analysis.solver_analysis, LeastSquaresSolver.Analysis)
+
+
+class TestOrbitDeterminationSolver:
+    def test_constructor(
+        self,
+        orbit_determination_solver: OrbitDeterminationSolver,
+    ):
+        assert isinstance(orbit_determination_solver, OrbitDeterminationSolver)
+
+    def test_access_methods(
+        self,
+        orbit_determination_solver: OrbitDeterminationSolver,
+    ):
+        assert isinstance(orbit_determination_solver.access_environment(), Environment)
+        assert isinstance(orbit_determination_solver.access_propagator(), Propagator)
+        assert isinstance(orbit_determination_solver.access_solver(), LeastSquaresSolver)
+        assert isinstance(orbit_determination_solver.access_estimation_frame(), Frame)
+
+    def test_estimate(
+        self,
+        orbit_determination_solver: OrbitDeterminationSolver,
+        initial_guess: State,
+        observations: list[State],
+        coordinate_subsets: list[CoordinateSubset],
+        initial_guess_sigmas: dict[CoordinateSubset, list[float]],
+        observation_sigmas: dict[CoordinateSubset, list[float]],
+    ):
+        analysis: OrbitDeterminationSolver.Analysis = orbit_determination_solver.estimate(
+            initial_guess=initial_guess,
+            observations=observations,
+            estimation_coordinate_subsets=coordinate_subsets,
+            initial_guess_sigmas=initial_guess_sigmas,
+            observation_sigmas=observation_sigmas,
+        )
+
+        assert isinstance(analysis, OrbitDeterminationSolver.Analysis)
+        assert isinstance(analysis.estimated_state, State)
+        assert isinstance(analysis.solver_analysis, LeastSquaresSolver.Analysis)
+
+    def test_estimate_orbit(
+        self,
+        orbit_determination_solver: OrbitDeterminationSolver,
+        initial_guess: State,
+        observations: list[State],
+        coordinate_subsets: list[CoordinateSubset],
+        initial_guess_sigmas: dict[CoordinateSubset, list[float]],
+        observation_sigmas: dict[CoordinateSubset, list[float]],
+    ):
+        orbit: Orbit = orbit_determination_solver.estimate_orbit(
+            initial_guess=initial_guess,
+            observations=observations,
+            estimation_coordinate_subsets=coordinate_subsets,
+            initial_guess_sigmas=initial_guess_sigmas,
+            observation_sigmas=observation_sigmas,
+        )
+
+        assert isinstance(orbit, Orbit)