open-space-toolkit-astrodynamics 15.0.0__py313-none-manylinux2014_aarch64.whl → 15.2.0__py313-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/access/test_visibility_criterion.py

@@ -9,6 +9,7 @@ from ostk.physics import Environment
 from ostk.physics.time import Instant
 from ostk.physics.time import DateTime
 from ostk.physics.time import Scale
+from ostk.physics.unit import Angle
 
 from ostk.astrodynamics.access import VisibilityCriterion
 
@@ -152,9 +153,11 @@ class TestVisibilityCriterion:
         elevation_criterion = VisibilityCriterion.ElevationInterval(elevation_interval)
         elevation_valid = np.pi / 8  # 22.5 degrees
         assert elevation_criterion.is_satisfied(elevation_valid) is True
+        assert elevation_criterion.is_satisfied(Angle.radians(elevation_valid)) is True
 
         elevation_invalid = np.pi / 2  # 90 degrees
         assert elevation_criterion.is_satisfied(elevation_invalid) is False
+        assert elevation_criterion.is_satisfied(Angle.radians(elevation_invalid)) is False
 
     def test_line_of_sight_is_satisfied(
         self,

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)

ostk/astrodynamics/test/estimator/test_tle_solver.py

@@ -0,0 +1,215 @@
+# Apache License 2.0
+
+import pytest
+
+import pandas as pd
+
+from ostk.core.type import Real
+from ostk.core.type import Integer
+
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.solver import LeastSquaresSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import StateBuilder
+from ostk.astrodynamics.trajectory import Orbit
+from ostk.astrodynamics.trajectory.orbit.model.sgp4 import TLE
+from ostk.astrodynamics.estimator import TLESolver
+from ostk.astrodynamics.dataframe import generate_states_from_dataframe
+
+
+@pytest.fixture
+def least_squares_solver() -> LeastSquaresSolver:
+    return LeastSquaresSolver.default()
+
+
+@pytest.fixture
+def tle_solver(least_squares_solver: LeastSquaresSolver) -> TLESolver:
+    return TLESolver(
+        solver=least_squares_solver,
+        satellite_number=25544,  # ISS NORAD ID
+        international_designator="98067A",  # ISS Int'l Designator
+        revolution_number=12345,
+        estimate_b_star=True,
+    )
+
+
+@pytest.fixture
+def initial_tle() -> TLE:
+    return TLE(
+        "1 25544U 98067A   22253.00000622  .00000000  00000-0  71655-1 0    02",
+        "2 25544  97.5641  21.8296 0012030 155.5301 309.4836 15.14446734123455",
+    )
+
+
+@pytest.fixture
+def initial_state(observations: list[State]) -> State:
+    return observations[0]
+
+
+@pytest.fixture
+def initial_state_with_b_star(observations: list[State]) -> tuple[State, float]:
+    return observations[0], 1e-4
+
+
+@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(),
+    )
+
+
+class TestTLESolver:
+    def test_constructor(
+        self,
+        tle_solver: TLESolver,
+    ):
+        assert isinstance(tle_solver, TLESolver)
+        assert tle_solver.access_satellite_number() == 25544
+        assert tle_solver.access_international_designator() == "98067A"
+        assert tle_solver.access_revolution_number() == 12345
+        assert tle_solver.access_estimate_b_star() is True
+
+    def test_constructor_defaults(self):
+        solver = TLESolver()
+        assert solver.access_satellite_number() == 0
+        assert solver.access_international_designator() == "00001A"
+        assert solver.access_revolution_number() == 0
+        assert solver.access_estimate_b_star() is True
+
+    def test_access_methods(self, tle_solver: TLESolver):
+        assert isinstance(tle_solver.access_solver(), LeastSquaresSolver)
+        assert isinstance(tle_solver.access_default_b_star(), Real)
+        assert isinstance(
+            tle_solver.access_first_derivative_mean_motion_divided_by_2(), Real
+        )
+        assert isinstance(
+            tle_solver.access_second_derivative_mean_motion_divided_by_6(), Real
+        )
+        assert isinstance(tle_solver.access_ephemeris_type(), Integer)
+        assert isinstance(tle_solver.access_element_set_number(), Integer)
+        assert isinstance(tle_solver.access_tle_state_builder(), StateBuilder)
+
+    def test_estimate_from_tle(
+        self,
+        tle_solver: TLESolver,
+        initial_tle: TLE,
+        observations: list[State],
+    ):
+        analysis: TLESolver.Analysis = tle_solver.estimate(
+            initial_guess=initial_tle,
+            observations=observations,
+        )
+
+        assert isinstance(analysis, TLESolver.Analysis)
+        assert isinstance(analysis.estimated_tle, TLE)
+        assert isinstance(analysis.solver_analysis, LeastSquaresSolver.Analysis)
+
+        assert analysis.solver_analysis.termination_criteria == "RMS Update Threshold"
+
+    def test_estimate_from_state_b_star(
+        self,
+        tle_solver: TLESolver,
+        initial_state: State,
+        observations: list[State],
+    ):
+        analysis: TLESolver.Analysis = tle_solver.estimate(
+            initial_guess=(initial_state, 1e-4),
+            observations=observations,
+        )
+        assert isinstance(analysis, TLESolver.Analysis)
+        assert isinstance(analysis.estimated_tle, TLE)
+        assert isinstance(analysis.solver_analysis, LeastSquaresSolver.Analysis)
+
+        assert analysis.solver_analysis.termination_criteria == "RMS Update Threshold"
+
+    def test_estimate_from_state(
+        self,
+        initial_state: State,
+        observations: list[State],
+    ):
+        tle_solver_no_b_star = TLESolver(
+            satellite_number=25544,
+            international_designator="98067A",
+            revolution_number=12345,
+            estimate_b_star=False,
+        )
+        analysis: TLESolver.Analysis = tle_solver_no_b_star.estimate(
+            initial_guess=initial_state,
+            observations=observations,
+        )
+        assert isinstance(analysis, TLESolver.Analysis)
+        assert isinstance(analysis.estimated_tle, TLE)
+        assert isinstance(analysis.solver_analysis, LeastSquaresSolver.Analysis)
+
+        assert analysis.solver_analysis.termination_criteria == "RMS Update Threshold"
+
+    def test_estimate_invalid_initial_guess(
+        self,
+        tle_solver: TLESolver,
+        observations: list[State],
+    ):
+        with pytest.raises(RuntimeError) as e:
+            tle_solver.estimate(initial_guess="invalid", observations=observations)
+        assert "Initial guess must be a TLE, tuple[State, float], or State." in str(
+            e.value
+        )
+
+    def test_estimate_invalid_state_only(
+        self,
+        tle_solver: TLESolver,
+        initial_state: State,
+        observations: list[State],
+    ):
+        with pytest.raises(RuntimeError) as e:
+            tle_solver.estimate(initial_guess=initial_state, observations=observations)
+        assert (
+            "Initial guess must be a TLE or (State, B*) when also estimating B*."
+            in str(e.value)
+        )
+
+    def test_estimate_no_observations(
+        self,
+        tle_solver: TLESolver,
+        initial_state: State,
+    ):
+        with pytest.raises(Exception):
+            tle_solver.estimate(initial_guess=initial_state, observations=[])
+
+    def test_estimate_orbit(
+        self,
+        initial_state: State,
+        observations: list[State],
+    ):
+        tle_solver_no_b_star = TLESolver(
+            satellite_number=25544,
+            international_designator="98067A",
+            revolution_number=12345,
+            estimate_b_star=False,
+        )
+        orbit: Orbit = tle_solver_no_b_star.estimate_orbit(
+            initial_guess=initial_state,
+            observations=observations,
+        )
+
+        assert isinstance(orbit, Orbit)
+
+    def test_fit_with_different_frames(
+        self,
+        tle_solver: TLESolver,
+        initial_state_with_b_star: tuple[State, float],
+        observations: list[State],
+    ):
+        # Convert observations to TEME frame
+        teme_observations = [obs.in_frame(Frame.TEME()) for obs in observations]
+
+        analysis: TLESolver.Analysis = tle_solver.estimate(
+            initial_guess=initial_state_with_b_star, observations=teme_observations
+        )
+        assert isinstance(analysis, TLESolver.Analysis)
+        assert isinstance(analysis.estimated_tle, TLE)
+
+        assert analysis.solver_analysis.termination_criteria == "RMS Update Threshold"