open-space-toolkit-astrodynamics 15.0.0__py39-none-manylinux2014_x86_64.whl → 15.2.0__py39-none-manylinux2014_x86_64.whl

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"

ostk/astrodynamics/test/solvers/test_least_squares_solver.py

@@ -0,0 +1,334 @@
+# Apache License 2.0
+
+from typing import Callable
+
+import pytest
+import numpy as np
+
+from ostk.core.type import Real
+from ostk.core.type import String
+
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.solver import LeastSquaresSolver
+from ostk.astrodynamics.solver import FiniteDifferenceSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+
+
+@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 termination_criteria() -> str:
+    return "RMS Update Threshold"
+
+
+@pytest.fixture
+def estimated_state(coordinate_subsets: list[CoordinateSubset]) -> State:
+    return State(
+        Instant.J2000(),
+        [1.0, 0.0],
+        Frame.GCRF(),
+        coordinate_subsets,
+    )
+
+
+@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 observation_count() -> int:
+    return 10
+
+
+@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 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 max_iteration_count() -> int:
+    return 20
+
+
+@pytest.fixture
+def rms_update_threshold() -> float:
+    return 1.0
+
+
+@pytest.fixture
+def finite_difference_solver() -> FiniteDifferenceSolver:
+    return FiniteDifferenceSolver.default()
+
+
+@pytest.fixture
+def least_squares_solver(
+    max_iteration_count: int,
+    rms_update_threshold: float,
+    finite_difference_solver: FiniteDifferenceSolver,
+) -> LeastSquaresSolver:
+    return LeastSquaresSolver(
+        maximum_iteration_count=max_iteration_count,
+        rms_update_threshold=rms_update_threshold,
+        finite_difference_solver=finite_difference_solver,
+    )
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [CoordinateSubset("Position", 1), CoordinateSubset("Velocity", 1)]
+
+
+@pytest.fixture
+def initial_guess_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1],
+        coordinate_subsets[1]: [1e-2],
+    }
+
+
+@pytest.fixture
+def observation_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1],
+        coordinate_subsets[1]: [1e-2],
+    }
+
+
+@pytest.fixture
+def initial_instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def initial_guess(
+    initial_instant: Instant,
+    coordinate_subsets: list[CoordinateSubset],
+    frame: Frame,
+) -> State:
+    return State(initial_instant, [1.0, 0.0], frame, coordinate_subsets)
+
+
+@pytest.fixture
+def observations(
+    initial_instant: Instant,
+    coordinate_subsets: list[CoordinateSubset],
+    frame: Frame,
+    observation_count: int,
+) -> list[State]:
+    return [
+        State(
+            initial_instant + Duration.seconds(float(x)),
+            [np.cos(x), -np.sin(x)],
+            frame,
+            coordinate_subsets,
+        )
+        for x in range(0, observation_count)
+    ]
+
+
+@pytest.fixture
+def state_generator() -> Callable:
+    def state_fn(state, instants) -> list[State]:
+        x0: float = state.get_coordinates()[0]
+        v0: float = state.get_coordinates()[1]
+        omega: float = 1.0
+
+        states: list[State] = []
+
+        for instant in instants:
+            t: float = float((instant - state.get_instant()).in_seconds())
+            x: float = x0 * np.cos(omega * t) + v0 / omega * np.sin(omega * t)
+            v: float = -x0 * omega * np.sin(omega * t) + v0 * np.cos(omega * t)
+
+            states.append(
+                State(instant, [x, v], Frame.GCRF(), state.get_coordinate_subsets())
+            )
+
+        return states
+
+    return state_fn
+
+
+class TestLeastSquaresSolverStep:
+
+    def test_constructor(
+        self,
+        step: LeastSquaresSolver.Step,
+    ):
+        assert isinstance(step, LeastSquaresSolver.Step)
+
+    def test_getters(
+        self,
+        step: LeastSquaresSolver.Step,
+        rms_error: float,
+        x_hat: np.ndarray,
+    ):
+        assert step.rms_error == rms_error
+        assert np.array_equal(step.x_hat, x_hat)
+
+
+class TestLeastSquaresSolverAnalysis:
+
+    def test_constructor(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+    ):
+        assert isinstance(analysis, LeastSquaresSolver.Analysis)
+
+    def test_getters(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+    ):
+        assert isinstance(analysis.rms_error, Real)
+        assert isinstance(analysis.observation_count, int)
+        assert isinstance(analysis.iteration_count, int)
+        assert isinstance(analysis.termination_criteria, String)
+        assert isinstance(analysis.estimated_state, State)
+        assert isinstance(analysis.estimated_covariance, np.ndarray)
+        assert isinstance(analysis.estimated_frisbee_covariance, np.ndarray)
+        assert isinstance(analysis.computed_observations, list)
+        assert isinstance(analysis.steps, list)
+
+    def test_compute_residual_states(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+        observations: list[State],
+    ):
+        residuals: list[State] = analysis.compute_residual_states(
+            observations=observations
+        )
+
+        assert isinstance(residuals, list)
+        assert len(residuals) == len(observations)
+
+
+class TestLeastSquaresSolver:
+    def test_constructor(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+    ):
+        assert isinstance(least_squares_solver, LeastSquaresSolver)
+
+    def test_getters(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        max_iteration_count: int,
+        rms_update_threshold: float,
+    ):
+        assert least_squares_solver.get_max_iteration_count() == max_iteration_count
+        assert least_squares_solver.get_rms_update_threshold() == rms_update_threshold
+        assert least_squares_solver.get_finite_difference_solver() is not None
+
+    def test_solve_defaults(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        initial_guess: State,
+        observations: list[State],
+        state_generator: callable,
+    ):
+        analysis = least_squares_solver.solve(
+            initial_guess=initial_guess,
+            observations=observations,
+            state_generator=state_generator,
+        )
+
+        assert analysis is not None
+
+    def test_solve(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        initial_guess: State,
+        observations: list[State],
+        state_generator: callable,
+        initial_guess_sigmas: dict[CoordinateSubset, list[float]],
+        observation_sigmas: dict[CoordinateSubset, list[float]],
+    ):
+        analysis = least_squares_solver.solve(
+            initial_guess=initial_guess,
+            observations=observations,
+            state_generator=state_generator,
+            initial_guess_sigmas=initial_guess_sigmas,
+            observation_sigmas=observation_sigmas,
+        )
+
+        assert analysis is not None
+
+    def test_calculate_empirical_covariance(
+        self,
+        observations: list[State],
+    ):
+        covariance: np.ndarray = LeastSquaresSolver.calculate_empirical_covariance(
+            observations
+        )
+
+        assert isinstance(covariance, np.ndarray)
+        assert covariance.shape == (2, 2)
+
+    def test_default(self):
+        default_solver: LeastSquaresSolver = LeastSquaresSolver.default()
+
+        assert isinstance(default_solver, LeastSquaresSolver)

ostk/astrodynamics/test/test_viewer.py

@@ -36,6 +36,24 @@ def orbit(environment: Environment) -> Orbit:
     )
 
 
+@pytest.fixture
+def orbits(environment: Environment) -> list[Orbit]:
+    return [
+        Orbit.sun_synchronous(
+            epoch=Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+            altitude=Length.kilometers(500.0),
+            local_time_at_descending_node=Time(14, 0, 0),
+            celestial_object=environment.access_celestial_object_with_name("Earth"),
+        ),
+        Orbit.sun_synchronous(
+            epoch=Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+            altitude=Length.kilometers(500.0),
+            local_time_at_descending_node=Time(12, 0, 0),
+            celestial_object=environment.access_celestial_object_with_name("Earth"),
+        ),
+    ]
+
+
 @pytest.fixture
 def profile(orbit: Orbit) -> Profile:
     return Profile.local_orbital_frame_pointing(
@@ -56,6 +74,8 @@ def interval() -> Interval:
 def viewer(interval: Interval) -> Viewer:
     return Viewer(
         interval=interval,
+        zoom_to_entity=False,
+        track_entity=False,
     )
 
 
@@ -74,6 +94,50 @@ class TestViewer:
         assert "var widget = new Cesium.Viewer" in rendered_html
         assert rendered_html.endswith("</script>")
 
+    def test_add_orbit_success(
+        self,
+        viewer: Viewer,
+        orbit: Orbit,
+    ):
+        viewer.add_orbit(
+            orbit=orbit,
+            step=Duration.seconds(5.0),
+            show_orbital_track=True,
+        )
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert "new Cesium.SampledProperty(Cesium.Cartesian3)" in rendered_html
+        assert " widget.entities.add({position: widget" in rendered_html
+        assert "widget.entities.add({polyline:" in rendered_html
+        assert "billboard: {image:" in rendered_html
+        assert rendered_html.endswith("</script>")
+
+    def test_add_orbit_multiple_success(
+        self,
+        viewer: Viewer,
+        orbits: list[Orbit],
+    ):
+        for i, orbit in enumerate(orbits):
+            viewer.add_orbit(
+                orbit=orbit,
+                step=Duration.seconds(5.0),
+                show_orbital_track=True,
+                name=f"Satellite {i}",
+            )
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert "new Cesium.SampledProperty(Cesium.Cartesian3)" in rendered_html
+        assert " widget.entities.add({position: widget" in rendered_html
+        assert "widget.entities.add({polyline:" in rendered_html
+        assert "billboard: {image:" in rendered_html
+        assert rendered_html.endswith("</script>")
+
     def test_add_profile_success(
         self,
         viewer: Viewer,