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

ostk/astrodynamics/test/estimator/test_tle_solver.py

@@ -0,0 +1,216 @@
+# 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 ITRF frame
+        itrf_observations = [obs.in_frame(Frame.ITRF()) for obs in observations]
+
+        analysis: TLESolver.Analysis = tle_solver.estimate(
+            initial_guess=initial_state_with_b_star, observations=itrf_observations
+        )
+        assert isinstance(analysis, TLESolver.Analysis)
+        assert isinstance(analysis.estimated_tle, TLE)
+
+        assert analysis.solver_analysis.termination_criteria == "RMS Update Threshold"

ostk/astrodynamics/test/event_condition/test_angular_condition.py

@@ -0,0 +1,113 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant, DateTime, Scale
+from ostk.physics.coordinate import Frame, Position, Velocity
+from ostk.physics.unit import Angle
+
+from ostk.astrodynamics.trajectory import State
+
+from ostk.astrodynamics.event_condition import AngularCondition
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters([7500000.0, 0.0, 0.0], frame)
+    velocity: Velocity = Velocity.meters_per_second(
+        [0.0, 5335.865450622126, 5335.865450622126], frame
+    )
+
+    instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def criterion() -> AngularCondition.Criterion:
+    return AngularCondition.Criterion.PositiveCrossing
+
+
+@pytest.fixture
+def evaluator():
+    return lambda state: state.get_coordinates()[0]
+
+
+@pytest.fixture
+def target_angle() -> Angle:
+    return Angle.degrees(0.0)
+
+
+@pytest.fixture
+def target_range() -> tuple[Angle, Angle]:
+    return (Angle.degrees(0.0), Angle.degrees(10.0))
+
+
+@pytest.fixture
+def event_condition(
+    criterion: AngularCondition.Criterion, evaluator, target_angle: Angle
+) -> AngularCondition:
+    return AngularCondition(
+        "My Condition",
+        criterion,
+        evaluator,
+        target_angle,
+    )
+
+
+@pytest.fixture
+def within_range_condition(
+    evaluator, target_range: tuple[Angle, Angle]
+) -> AngularCondition:
+    return AngularCondition.within_range("My Condition", evaluator, target_range)
+
+
+class TestAngularCondition:
+    def test_constructor(
+        self,
+        criterion: AngularCondition.Criterion,
+        evaluator,
+        target_angle: Angle,
+    ):
+        assert (
+            AngularCondition("My Condition", criterion, evaluator, target_angle)
+            is not None
+        )
+
+    def test_get_criterion(
+        self,
+        event_condition: AngularCondition,
+        criterion: AngularCondition.Criterion,
+    ):
+        assert event_condition.get_criterion() == criterion
+
+    def test_get_target_angle(
+        self,
+        event_condition: AngularCondition,
+        within_range_condition: AngularCondition,
+        target_angle: Angle,
+    ):
+        assert event_condition.get_target_angle() == target_angle
+
+        with pytest.raises(RuntimeError):
+            within_range_condition.get_target_angle()
+
+    def test_get_target_range(
+        self,
+        event_condition: AngularCondition,
+        within_range_condition: AngularCondition,
+        target_range: tuple[Angle, Angle],
+    ):
+        with pytest.raises(RuntimeError):
+            event_condition.get_target_range()
+
+        assert within_range_condition.get_target_range() == target_range
+
+    def test_is_satisfied(self, state: State, event_condition: AngularCondition):
+        assert (
+            event_condition.is_satisfied(previous_state=state, current_state=state)
+            is not None
+        )
+
+    def test_string_from_criterion(self, criterion: AngularCondition.Criterion):
+        assert AngularCondition.string_from_criterion(criterion) is not None

ostk/astrodynamics/test/event_condition/test_boolean_condition.py

@@ -0,0 +1,55 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant, DateTime, Scale
+from ostk.physics.coordinate import Frame, Position, Velocity
+
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.event_condition import BooleanCondition
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters([7500000.0, 0.0, 0.0], frame)
+    velocity: Velocity = Velocity.meters_per_second(
+        [0.0, 5335.865450622126, 5335.865450622126], frame
+    )
+
+    instant: Instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def evaluator():
+    return lambda state: state.get_coordinates()[0]
+
+
+@pytest.fixture
+def is_inversed() -> bool:
+    return False
+
+
+@pytest.fixture
+def event_condition(evaluator, is_inversed: bool) -> BooleanCondition:
+    return BooleanCondition(
+        "My Condition",
+        BooleanCondition.Criterion.StrictlyPositive,
+        evaluator,
+        is_inversed,
+    )
+
+
+class TestBooleanCondition:
+    def test_is_inversed(self, event_condition: BooleanCondition, is_inversed: bool):
+        assert event_condition.is_inversed() == is_inversed
+
+    def test_evaluate(self, state: State, event_condition: BooleanCondition):
+        assert event_condition.evaluate(state) is not None
+
+    def test_is_satisfied(self, state: State, event_condition: BooleanCondition):
+        assert (
+            event_condition.is_satisfied(previous_state=state, current_state=state)
+            is not None
+        )

ostk/astrodynamics/test/event_condition/test_brouwer_lyddane_mean_long_condition.py

@@ -0,0 +1,135 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.environment.gravitational import Earth
+from ostk.physics.unit import Derived, Length, Angle
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics import EventCondition
+from ostk.astrodynamics.event_condition import (
+    BrouwerLyddaneMeanLongCondition,
+    AngularCondition,
+    RealCondition,
+)
+
+
+@pytest.fixture
+def criterion() -> AngularCondition.Criterion:
+    return AngularCondition.Criterion.AnyCrossing
+
+
+@pytest.fixture
+def gravitational_parameter() -> Derived:
+    return Earth.spherical.gravitational_parameter
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+class TestBrouwerLyddaneMeanLongCondition:
+    @pytest.mark.parametrize(
+        "static_constructor,target,criterion",
+        (
+            (
+                BrouwerLyddaneMeanLongCondition.semi_major_axis,
+                EventCondition.Target(Length.meters(7e6)),
+                RealCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.eccentricity,
+                EventCondition.Target(0.1),
+                RealCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.inclination,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.aop,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.raan,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.true_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.mean_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.eccentric_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.argument_of_latitude,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+        ),
+    )
+    def test_static_constructors(
+        self,
+        static_constructor,
+        target,
+        criterion,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
+        condition = static_constructor(criterion, frame, target, gravitational_parameter)
+        assert condition is not None
+
+    @pytest.mark.parametrize(
+        "static_constructor,target_range",
+        (
+            (
+                BrouwerLyddaneMeanLongCondition.inclination,
+                (Angle.degrees(10.0), Angle.degrees(20.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.aop,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.raan,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.true_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.mean_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.eccentric_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                BrouwerLyddaneMeanLongCondition.argument_of_latitude,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+        ),
+    )
+    def test_static_constructors_within_range(
+        self,
+        static_constructor,
+        target_range,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
+        condition = static_constructor(frame, target_range, gravitational_parameter)
+        assert condition is not None

ostk/astrodynamics/test/event_condition/test_coe_condition.py

@@ -0,0 +1,135 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.environment.gravitational import Earth
+from ostk.physics.unit import Derived, Length, Angle
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics import EventCondition
+from ostk.astrodynamics.event_condition import (
+    COECondition,
+    AngularCondition,
+    RealCondition,
+)
+
+
+@pytest.fixture
+def criterion() -> AngularCondition.Criterion:
+    return AngularCondition.Criterion.AnyCrossing
+
+
+@pytest.fixture
+def gravitational_parameter() -> Derived:
+    return Earth.spherical.gravitational_parameter
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+class TestCOECondition:
+    @pytest.mark.parametrize(
+        "static_constructor,target,criterion",
+        (
+            (
+                COECondition.semi_major_axis,
+                EventCondition.Target(Length.meters(7e6)),
+                RealCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.eccentricity,
+                EventCondition.Target(0.1),
+                RealCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.inclination,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.aop,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.raan,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.true_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.mean_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.eccentric_anomaly,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+            (
+                COECondition.argument_of_latitude,
+                EventCondition.Target(Angle.degrees(0.0)),
+                AngularCondition.Criterion.PositiveCrossing,
+            ),
+        ),
+    )
+    def test_static_constructors(
+        self,
+        static_constructor,
+        target,
+        criterion,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
+        condition = static_constructor(criterion, frame, target, gravitational_parameter)
+        assert condition is not None
+
+    @pytest.mark.parametrize(
+        "static_constructor,target_range",
+        (
+            (
+                COECondition.inclination,
+                (Angle.degrees(10.0), Angle.degrees(20.0)),
+            ),
+            (
+                COECondition.aop,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.raan,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.true_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.mean_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.eccentric_anomaly,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+            (
+                COECondition.argument_of_latitude,
+                (Angle.degrees(0.0), Angle.degrees(90.0)),
+            ),
+        ),
+    )
+    def test_static_constructors_within_range(
+        self,
+        static_constructor,
+        target_range,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
+        condition = static_constructor(frame, target_range, gravitational_parameter)
+        assert condition is not None

ostk/astrodynamics/test/event_condition/test_instant_condition.py

@@ -0,0 +1,48 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.coordinate import Frame, Position, Velocity
+from ostk.physics.time import DateTime, Instant, Scale
+
+from ostk.astrodynamics.event_condition import InstantCondition
+from ostk.astrodynamics.trajectory import State
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2023, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def criterion() -> InstantCondition.Criterion:
+    return InstantCondition.Criterion.StrictlyPositive
+
+
+@pytest.fixture
+def instant_condition(
+    criterion: InstantCondition.Criterion, instant: Instant
+) -> InstantCondition:
+    return InstantCondition(criterion, instant)
+
+
+@pytest.fixture
+def state() -> State:
+    frame: Frame = Frame.GCRF()
+    position: Position = Position.meters(
+        [717094.039086306, -6872433.2241124, 46175.9696673281], frame
+    )
+    velocity: Velocity = Velocity.meters_per_second(
+        [-970.650826004612, -45.4598114773158, 7529.82424886455], frame
+    )
+
+    instant: Instant = Instant.date_time(DateTime(2023, 1, 1, 0, 1, 0), Scale.UTC)
+    return State(instant, position, velocity)
+
+
+class TestInstantCondition:
+    def test_get_instant(self, instant_condition: InstantCondition, instant: Instant):
+        assert instant_condition.get_instant() == instant
+
+    def test_evaluate(self, instant_condition: InstantCondition, state: State):
+        assert instant_condition.evaluate(state) == 60.0