open-space-toolkit-astrodynamics 1.3.0__py38-none-any.whl → 2.1.0__py38-none-any.whl

{open_space_toolkit_astrodynamics-1.3.0.dist-info → open_space_toolkit_astrodynamics-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: open-space-toolkit-astrodynamics
-Version: 1.3.0
+Version: 2.1.0
 Summary: Orbit, attitude, access.
 Author: Open Space Collective
 Author-email: contact@open-space-collective.org
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: POSIX :: Linux
 Description-Content-Type: text/markdown
-Requires-Dist: open-space-toolkit-physics (~=1.2.0)
+Requires-Dist: open-space-toolkit-physics (~=2.0.0)
 
 # Open Space Toolkit ▸ Astrodynamics
 

{open_space_toolkit_astrodynamics-1.3.0.dist-info → open_space_toolkit_astrodynamics-2.1.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
 ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-38-x86_64-linux-gnu.so,sha256=-NScfpfyZQ_ihsFshGqj68zv4LCfDvw8WHMMuv9-fc4,1213624
+ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-38-x86_64-linux-gnu.so,sha256=BtJCIbcnMBY4AKqmSFiCt9iRkTPiVNEqCdZDCE2hWvI,1332600
 ostk/astrodynamics/__init__.py,sha256=BE7yyrOnPqFCTPT3GhYEI4IWR5nzs96VSjKphhQ09ew,97
 ostk/astrodynamics/converters.py,sha256=sBZ3_JMjowWbQ9gBPA2cSEkbBfAwXmt1IBbLks76-Vk,3502
 ostk/astrodynamics/display.py,sha256=y9FnoQbPFGM6LzkUdgXgeqtuVGhv57GuTKbeDdcFPgw,6306
-ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.1,sha256=emofzIM0g2iAiGcuguQUsor8Gizw9vU9hBum0o5MMnE,67177200
+ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.2,sha256=3xgJFd7EtUQR97QzanL9AnZbbrxA6IxRInCFSKd6X-A,67701896
 ostk/astrodynamics/utilities.py,sha256=NbeKN_CtcCRHIinhoNWTEosBMR7xc924S-ZFD97mduw,4478
-ostk/astrodynamics/viewer.py,sha256=5YFPBiv0YSBZrI42G4UANmOeW8tnJj86_f9gfSpHGgY,8938
+ostk/astrodynamics/viewer.py,sha256=_4uucNtZrIADtKtEYHbiu91RVVvKRG3vPULUAshPLJU,8912
 ostk/astrodynamics/test/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/conftest.py,sha256=J3SbQibnMVaPktAF6Z6cwVCa7xhW3uXpkOJRom6YtCo,2719
 ostk/astrodynamics/test/test_access.py,sha256=4I5r4Hukv0fkByHVARhaYpcDu5EOQ7dtbs-ZK7siTqg,3961
 ostk/astrodynamics/test/test_converters.py,sha256=ktkLH0xpeRdQ7kN6i5a_agmGqovUxVtCwlwcCdCUaa0,5847
 ostk/astrodynamics/test/test_display.py,sha256=8YeiYRYMpokzqprbRoDBI_xhHI5B8uxcdSzmqmF3AIc,3738
-ostk/astrodynamics/test/test_event_condition.py,sha256=i9B5OX3FVwzSHRDVhXEtKBmylp1aIaeM9r5KRhFenG8,2041
+ostk/astrodynamics/test/test_event_condition.py,sha256=a503h3sHj-Q8c6jo1z_CcgW1kplZqtugPH-jhf3Huvk,1413
 ostk/astrodynamics/test/test_import.py,sha256=y62-SI3pmSkIgyOIrDDXeWqWI3DhnjnUl7SgWAp99kA,1212
-ostk/astrodynamics/test/test_numerical_solver.py,sha256=HsL6WI4uh1yYTsQJMxQMC13yYfPjusyvlL0CeHd36h0,8169
+ostk/astrodynamics/test/test_numerical_solver.py,sha256=kM1zx_D1Tot1hmnVOUK1Zw5CnwUlq5BvB9ugrzOOlY4,8366
 ostk/astrodynamics/test/test_root_solver.py,sha256=hQ8O6g-WP49gZH_H3Rdufv0F0gQorpzJyIcjBGGUQ34,1831
 ostk/astrodynamics/test/test_trajectory.py,sha256=4AhlAaIrCrP17ZycJqYlYskj8SC2MH7fp3_4eqWdF9s,1366
 ostk/astrodynamics/test/test_utilities.py,sha256=edAPLXNMflCPa0gzhU4e05pa6HbAq7UV0JzMMRx3VlQ,3252
@@ -24,11 +24,13 @@ ostk/astrodynamics/test/conjunction/messages/ccsds/__init__.py,sha256=epnVn2PwdQ
 ostk/astrodynamics/test/conjunction/messages/ccsds/conftest.py,sha256=xyTd24828Ue2HgOWY8UhizIc5mzgRgoH2VSOfVfKCdw,14632
 ostk/astrodynamics/test/conjunction/messages/ccsds/test_cdm.py,sha256=SqtYXB8qhKzbQEWmCzz13xi0Uu64-VSKXuMObcFV7EI,18518
 ostk/astrodynamics/test/conjunction/messages/ccsds/data/cdm.json,sha256=-CL8Bu-ivigzkrqHs9Q5snSubHJ_D0YMroatEInkidc,12965
-ostk/astrodynamics/test/event_condition/test_coe_condition.py,sha256=uTL4vtAL9NebK7YwmVyrHfGNX46ZTbpAPi2_ZEz0XaE,2809
-ostk/astrodynamics/test/event_condition/test_conjunctive.py,sha256=X8fNUgUfXcBJB5CPip6mRDBFMNAqCHw9Mt9r3Wubjl8,1982
-ostk/astrodynamics/test/event_condition/test_disjunctive.py,sha256=71eNzfqtCyNeHkw6-g2i_OIWveJv40nbZU2EPfGm9Ro,1968
+ostk/astrodynamics/test/event_condition/test_boolean_event_condition.py,sha256=2QOgkLM5ROhOx2uNNQQfn0XDC34sx4k0ZXn9Zm6SD_0,1184
+ostk/astrodynamics/test/event_condition/test_coe_condition.py,sha256=aUQrgLUYvz5yzmlhic5-ti6Gn8kdo4G6wU1MRrF6pRk,3289
+ostk/astrodynamics/test/event_condition/test_conjunctive.py,sha256=LGzxK6_qTcE8FMLap0WZ-4maJuXNU1DtXeJjodoWy9w,1916
+ostk/astrodynamics/test/event_condition/test_disjunctive.py,sha256=dVmEILtS_Cj0BYNWSMA5z6T7B-mmYexQB8gXatJqrz4,1902
 ostk/astrodynamics/test/event_condition/test_duration_condition.py,sha256=wyDBde1vc06-cUjOwmJP6Po8cHbQTGHIDWB3e6eoO_o,973
-ostk/astrodynamics/test/event_condition/test_logical_connective.py,sha256=WQQQn1FdQEbAs7UxXawzAnX3ON8-UgKqYmKeOGkufN8,1117
+ostk/astrodynamics/test/event_condition/test_logical_connective.py,sha256=DjBFecD9hNjF379if3mWUAeCnDF_vhUhJbnRZEhvb-8,1197
+ostk/astrodynamics/test/event_condition/test_real_event_condition.py,sha256=HQu545o1ViLIRsNkx-3Ivmn84IUOssnLIFIcD1JxU7I,1103
 ostk/astrodynamics/test/flight/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/flight/test_profile.py,sha256=27g5Atvr2RGslvFujdP90cA9qldkNb7C0U1RgbOAws0,5197
 ostk/astrodynamics/test/flight/test_system.py,sha256=YPrjoV3o67_1zCXCZqohlSAR7zkU0LXP2fF20M2s0C8,1326
@@ -39,6 +41,7 @@ ostk/astrodynamics/test/flight/system/test_satellite_system.py,sha256=-5KOGVTWRI
 ostk/astrodynamics/test/flight/system/dynamics/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/flight/system/dynamics/test_atmospheric_drag.py,sha256=nZ2lBGq5Ni3ypuqGbTfluxTXYERpwol49d0DrgnYsIo,3115
 ostk/astrodynamics/test/flight/system/dynamics/test_central_body_gravity.py,sha256=r3JIIX7cD63BhrgvLtjFaK7ew1BqHdKP5_VxwGmuv1Q,1818
+ostk/astrodynamics/test/flight/system/dynamics/test_dynamics.py,sha256=arNkAOj2y4CDmc9CXxItbFtC4QYjaByuJefdi5S6alw,914
 ostk/astrodynamics/test/flight/system/dynamics/test_position_derivative.py,sha256=ZVVewpqZwqiBLDqoNQDHDgDodtj6_M0J6ZmgHe_1gz8,1646
 ostk/astrodynamics/test/flight/system/dynamics/test_third_body_gravity.py,sha256=Z8OkM-EFafFpWziu3bfatlSlZA4Tic2fsVLU35rDp5E,1915
 ostk/astrodynamics/test/solvers/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
@@ -46,8 +49,8 @@ ostk/astrodynamics/test/solvers/test_temporal_condition_solver.py,sha256=s7r7Vel
 ostk/astrodynamics/test/trajectory/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/test_model.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/test_orbit.py,sha256=SlCBZ_broPaJ6L8khMuvbdPem9-zmqG6IZwxr9cECB4,3155
-ostk/astrodynamics/test/trajectory/test_propagator.py,sha256=cvRuIAq9OOGKj2jRaJxNMWdp0gdpJuva7dEID0BJHdo,7412
-ostk/astrodynamics/test/trajectory/test_state.py,sha256=HHBhJUfPhR1by7qTetRyF-51u9XzWUVKtu3XzTRHJtk,2079
+ostk/astrodynamics/test/trajectory/test_propagator.py,sha256=PHeZgFO8-xaH1ItFMZdjXxyQ792z8yROYMx0HnsfSSo,7570
+ostk/astrodynamics/test/trajectory/test_state.py,sha256=okpjRPixi7AUSV1YG8hNFFEo0AayfIK50X2vor9yOB0,3199
 ostk/astrodynamics/test/trajectory/orbit/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/orbit/test_model.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/orbit/test_pass.py,sha256=MtPRKhVz4hCzfFuE0p1x89Ps68M9s7miT7VtPIDVeOo,1898
@@ -62,11 +65,15 @@ ostk/astrodynamics/test/trajectory/orbit/models/test_propagated.py,sha256=MpGL1F
 ostk/astrodynamics/test/trajectory/orbit/models/test_sgp4.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/orbit/models/test_tabulated.py,sha256=tL3gGDitdEYCCRwGtu2RP-9d4JWsujV53ck9DRkyeG4,11183
 ostk/astrodynamics/test/trajectory/orbit/models/kepler/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/test/trajectory/orbit/models/kepler/test_coe.py,sha256=aAb3lr3IIFF5V4szhdHsPsLwHJAFXq3ZbCmvBuc69tA,2583
+ostk/astrodynamics/test/trajectory/orbit/models/kepler/test_coe.py,sha256=uWgUO9zHrcqEKGJ-SWUiHfEbWDm8YcgptnS2I2y_V1U,2728
 ostk/astrodynamics/test/trajectory/orbit/models/sgp4/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/orbit/models/sgp4/test_tle.py,sha256=lbPqHd87ExTNbBFcFSTMWRnWbpe_4BDJ2g2APlQLJkY,11486
-open_space_toolkit_astrodynamics-1.3.0.dist-info/METADATA,sha256=x10QyfcOARLh7Qf-1e86FIVUbTC6DAt9EohxorT9BXA,1779
-open_space_toolkit_astrodynamics-1.3.0.dist-info/WHEEL,sha256=pruk-ncpSL7wyHyfRUEyLDsvov8r7FCaWTBJ2klfed4,93
-open_space_toolkit_astrodynamics-1.3.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
-open_space_toolkit_astrodynamics-1.3.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-open_space_toolkit_astrodynamics-1.3.0.dist-info/RECORD,,
+ostk/astrodynamics/test/trajectory/state/test_coordinates_broker.py,sha256=kB_gsJHxvCDY9kfuqVkwHt5ZmMuaAoRk_3YZGxoXOwg,2515
+ostk/astrodynamics/test/trajectory/state/test_coordinates_subset.py,sha256=eMmifR5rJMk2yFN7pfAHq2Ub3FPvknb6gvS-nBDidro,1201
+ostk/astrodynamics/test/trajectory/state/coordinates_subset/test_cartesian_position.py,sha256=V5d7UnV6KIJjJvh5R0i3imRfyN04JCDvCUsKdvfKmhE,2708
+ostk/astrodynamics/test/trajectory/state/coordinates_subset/test_cartesian_velocity.py,sha256=5a7yeOVt7gY4oQdINSElb_U2jznJmuWPrT_YJrI6KaM,3070
+open_space_toolkit_astrodynamics-2.1.0.dist-info/METADATA,sha256=f4RCJAapR8IVLJRap7NK1HBhX_FX9RB8Dr0q-PsZl7E,1779
+open_space_toolkit_astrodynamics-2.1.0.dist-info/WHEEL,sha256=pruk-ncpSL7wyHyfRUEyLDsvov8r7FCaWTBJ2klfed4,93
+open_space_toolkit_astrodynamics-2.1.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_astrodynamics-2.1.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_astrodynamics-2.1.0.dist-info/RECORD,,

ostk/astrodynamics/test/event_condition/test_boolean_event_condition.py

@@ -0,0 +1,44 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.event_condition import BooleanEventCondition
+
+
+@pytest.fixture
+def evaluator():
+    return lambda state_vector, time: time > 0.0
+
+
+@pytest.fixture
+def is_inversed() -> bool:
+    return False
+
+
+@pytest.fixture
+def event_condition(evaluator, is_inversed: bool) -> BooleanEventCondition:
+    return BooleanEventCondition(
+        "My Condition",
+        BooleanEventCondition.Criteria.StrictlyPositive,
+        evaluator,
+        is_inversed,
+    )
+
+
+class TestBooleanEventCondition:
+    def test_is_inversed(self, event_condition: BooleanEventCondition, is_inversed: bool):
+        assert event_condition.is_inversed() == is_inversed
+
+    def test_evaluate(self, event_condition: BooleanEventCondition):
+        assert event_condition.evaluate(state_vector=[0.0], time=10.0) is not None
+
+    def test_is_satisfied(self, event_condition: BooleanEventCondition):
+        assert (
+            event_condition.is_satisfied(
+                previous_state_vector=[-1.0],
+                previous_time=-1.0,
+                current_state_vector=[1.0],
+                current_time=10.0,
+            )
+            == True
+        )

ostk/astrodynamics/test/event_condition/test_coe_condition.py

@@ -4,11 +4,17 @@ import pytest
 
 from ostk.physics.environment.gravitational import Earth
 from ostk.physics.units import Derived, Length, Angle
+from ostk.physics.coordinate import Frame
 
 from ostk.astrodynamics.event_condition import COECondition
 from ostk.astrodynamics.trajectory.orbit.models.kepler import COE
 
 
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
 @pytest.fixture
 def criteria() -> COECondition.Criteria:
     return COECondition.Criteria.AnyCrossing
@@ -34,10 +40,11 @@ def condition(
     criteria: COECondition.Criteria,
     element: COE.Element,
     target: float,
+    frame: Frame,
     gravitational_parameter: Derived,
 ) -> COECondition:
     return COECondition(
-        "Test COECondition", criteria, element, target, gravitational_parameter
+        "Test COECondition", criteria, element, target, frame, gravitational_parameter
     )
 
 
@@ -54,13 +61,28 @@ def state_vector() -> list[float]:
 
 
 class TestCOECondition:
-    def test_constructor(self, criteria, element, target, gravitational_parameter):
+    def test_constructor(
+        self,
+        criteria: COECondition.Criteria,
+        element: COE.Element,
+        target: float,
+        frame: Frame,
+        gravitational_parameter: Derived,
+    ):
         name = "Test COECondition"
-        condition = COECondition(name, criteria, element, target, gravitational_parameter)
+        condition = COECondition(
+            name, criteria, element, target, frame, gravitational_parameter
+        )
 
         assert condition is not None
 
-    def test_getters(self, condition, element, target, gravitational_parameter):
+    def test_getters(
+        self,
+        condition: COECondition,
+        element: COE.Element,
+        target: float,
+        gravitational_parameter: Derived,
+    ):
         assert condition.get_element() == element
         assert condition.get_target() == target
         assert condition.get_gravitational_parameter() == gravitational_parameter
@@ -79,15 +101,22 @@ class TestCOECondition:
         ),
     )
     def test_static_constructors(
-        self, static_constructor, target, criteria, gravitational_parameter
+        self,
+        static_constructor,
+        target: float,
+        criteria: COECondition.Criteria,
+        frame: Frame,
+        gravitational_parameter: Derived,
+        state_vector: list[float],
     ):
-        assert static_constructor(criteria, target, gravitational_parameter) is not None
+        condition = static_constructor(criteria, target, frame, gravitational_parameter)
+        assert condition is not None
+
+        assert condition.evaluate(state_vector, 0.0) is not None
 
-    def test_evaluate(self, condition, state_vector, target):
+    def test_evaluate(
+        self, condition: COECondition, state_vector: list[float], target: float
+    ):
         assert condition.evaluate(state_vector, 0.0) == pytest.approx(
             6904757.8910061345 - target, abs=1e-9
         )
-
-    def test_string_from_element(self):
-        element_str = COECondition.string_from_element(COE.Element.SemiMajorAxis)
-        assert element_str == "Semi-major axis"

ostk/astrodynamics/test/event_condition/test_conjunctive.py

@@ -2,42 +2,43 @@
 
 import pytest
 
-from ostk.astrodynamics import EventCondition
-from ostk.astrodynamics.event_condition import Conjunctive
+from ostk.astrodynamics.event_condition import Conjunctive, RealEventCondition
 
 
 @pytest.fixture
-def first_condition() -> EventCondition:
-    class FirstCondition(EventCondition):
-        def evaluate(self, state_vector, time):
-            return state_vector[0]
-
-    return FirstCondition("First Condition", EventCondition.Criteria.PositiveCrossing)
+def first_condition() -> RealEventCondition:
+    return RealEventCondition(
+        "First Condition",
+        RealEventCondition.Criteria.PositiveCrossing,
+        lambda state_vector, time: state_vector[0],
+        0.0,
+    )
 
 
 @pytest.fixture
-def second_condition() -> EventCondition:
-    class SecondCondition(EventCondition):
-        def evaluate(self, state_vector, time):
-            return state_vector[1] - 0.1
-
-    return SecondCondition("Second condition", EventCondition.Criteria.StrictlyNegative)
+def second_condition() -> RealEventCondition:
+    return RealEventCondition(
+        "Second condition",
+        RealEventCondition.Criteria.StrictlyNegative,
+        lambda state_vector, time: state_vector[1],
+        0.1,
+    )
 
 
 @pytest.fixture
 def event_conditions(
-    first_condition: EventCondition, second_condition: EventCondition
-) -> list[EventCondition]:
+    first_condition: RealEventCondition, second_condition: RealEventCondition
+) -> list[RealEventCondition]:
     return [first_condition, second_condition]
 
 
 @pytest.fixture
-def conjunction_condition(event_conditions: list[EventCondition]) -> Conjunctive:
+def conjunction_condition(event_conditions: list[RealEventCondition]) -> Conjunctive:
     return Conjunctive(event_conditions)
 
 
 class TestConjunctiveCondition:
-    def test_constructor(self, event_conditions: list[EventCondition]):
+    def test_constructor(self, event_conditions: list[RealEventCondition]):
         assert Conjunctive(event_conditions) is not None
 
     def test_is_satisfied(self, conjunction_condition: Conjunctive):

ostk/astrodynamics/test/event_condition/test_disjunctive.py

@@ -2,42 +2,43 @@
 
 import pytest
 
-from ostk.astrodynamics import EventCondition
-from ostk.astrodynamics.event_condition import Disjunctive
+from ostk.astrodynamics.event_condition import Disjunctive, RealEventCondition
 
 
 @pytest.fixture
-def first_condition() -> EventCondition:
-    class FirstCondition(EventCondition):
-        def evaluate(self, state_vector, time):
-            return state_vector[0]
-
-    return FirstCondition("First Condition", EventCondition.Criteria.PositiveCrossing)
+def first_condition() -> RealEventCondition:
+    return RealEventCondition(
+        "First Condition",
+        RealEventCondition.Criteria.PositiveCrossing,
+        lambda state_vector, time: state_vector[0],
+        0.0,
+    )
 
 
 @pytest.fixture
-def second_condition() -> EventCondition:
-    class SecondCondition(EventCondition):
-        def evaluate(self, state_vector, time):
-            return state_vector[1] - 0.1
-
-    return SecondCondition("Second condition", EventCondition.Criteria.StrictlyNegative)
+def second_condition() -> RealEventCondition:
+    return RealEventCondition(
+        "Second condition",
+        RealEventCondition.Criteria.StrictlyNegative,
+        lambda state_vector, time: state_vector[1],
+        0.1,
+    )
 
 
 @pytest.fixture
 def event_conditions(
-    first_condition: EventCondition, second_condition: EventCondition
-) -> list[EventCondition]:
+    first_condition: RealEventCondition, second_condition: RealEventCondition
+) -> list[RealEventCondition]:
     return [first_condition, second_condition]
 
 
 @pytest.fixture
-def disjunction_condition(event_conditions: list[EventCondition]) -> Disjunctive:
+def disjunction_condition(event_conditions: list[RealEventCondition]) -> Disjunctive:
     return Disjunctive(event_conditions)
 
 
 class TestDisjunctiveCondition:
-    def test_constructor(self, event_conditions: list[EventCondition]):
+    def test_constructor(self, event_conditions: list[RealEventCondition]):
         assert Disjunctive(event_conditions) is not None
 
     def test_is_satisfied(self, disjunction_condition: Disjunctive):

ostk/astrodynamics/test/event_condition/test_logical_connective.py

@@ -9,8 +9,10 @@ from ostk.astrodynamics.event_condition import LogicalConnective
 @pytest.fixture
 def event_condition() -> EventCondition:
     class MyCondition(EventCondition):
-        def evaluate(self, state_vector, time):
-            return time
+        def is_satisfied(
+            self, current_state_vector, current_time, previous_state_vector, previous_time
+        ):
+            return True
 
     return MyCondition("My Condition", EventCondition.Criteria.StrictlyNegative)
 

ostk/astrodynamics/test/event_condition/test_real_event_condition.py

@@ -0,0 +1,41 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.event_condition import RealEventCondition
+
+
+@pytest.fixture
+def evaluator():
+    return lambda state_vector, time: time
+
+
+@pytest.fixture
+def target() -> float:
+    return 10.0
+
+
+@pytest.fixture
+def event_condition(evaluator, target: float) -> RealEventCondition:
+    return RealEventCondition(
+        "My Condition", RealEventCondition.Criteria.PositiveCrossing, evaluator, target
+    )
+
+
+class TestRealEventCondition:
+    def test_get_target(self, event_condition: RealEventCondition, target: float):
+        assert event_condition.get_target() == target
+
+    def test_evaluate(self, event_condition: RealEventCondition):
+        assert event_condition.evaluate(state_vector=[0.0], time=10.0) is not None
+
+    def test_is_satisfied(self, event_condition: RealEventCondition):
+        assert (
+            event_condition.is_satisfied(
+                previous_state_vector=[-1.0],
+                previous_time=5.0,
+                current_state_vector=[1.0],
+                current_time=15.0,
+            )
+            == True
+        )

ostk/astrodynamics/test/flight/system/dynamics/test_dynamics.py

@@ -0,0 +1,37 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.flight.system import Dynamics
+from ostk.astrodynamics.trajectory.state.coordinates_subset import CartesianPosition
+
+
+@pytest.fixture
+def name() -> str:
+    return "MyDynamics"
+
+
+@pytest.fixture
+def dynamics(name: str) -> Dynamics:
+    class MyDynamics(Dynamics):
+        def is_defined():
+            return True
+
+        def get_read_coordinates_subsets(self):
+            return [CartesianPosition.default()]
+
+        def get_write_coordinates_subsets(self):
+            return [CartesianPosition.default()]
+
+        def compute_contribution(self, instant, state_vector, frame):
+            return state_vector
+
+    return MyDynamics(name)
+
+
+class TestDynamics:
+    def test_subclass(self, dynamics: Dynamics):
+        assert dynamics is not None
+
+    def test_get_name(self, dynamics: Dynamics, name: str):
+        assert dynamics.get_name() == name

ostk/astrodynamics/test/test_event_condition.py

@@ -18,26 +18,14 @@ def criteria() -> EventCondition.Criteria:
 @pytest.fixture
 def event_condition(name: str, criteria: EventCondition.Criteria) -> EventCondition:
     class MyEventCondition(EventCondition):
-        def evaluate(self, state_vector, time):
-            return state_vector[0]
+        def is_satisfied(
+            self, current_state_vector, current_time, previous_state_vector, previous_time
+        ):
+            return current_state_vector[0] > 0.0 and previous_state_vector[0] < 0.0
 
     return MyEventCondition(name, criteria)
 
 
-@pytest.fixture
-def event_condition_overloaded() -> EventCondition:
-    class OverloadedEventCondition(EventCondition):
-        def is_satisfied(self, current_value, previous_value):
-            return (current_value > 0.0) and (previous_value < 0.0)
-
-        def evaluate(self, aStateVector, aTime):
-            return aStateVector[0]
-
-    return OverloadedEventCondition(
-        "OverloadedEventCondition", EventCondition.Criteria.Undefined
-    )
-
-
 class TestEventCondition:
     def test_subclass(self, event_condition: EventCondition):
         assert event_condition is not None
@@ -52,18 +40,11 @@ class TestEventCondition:
 
     def test_is_satisfied(self, event_condition: EventCondition):
         assert (
-            event_condition.is_satisfied(current_value=1.0, previous_value=-1.0) == True
-        )
-
-    def test_overloaded_is_satisfied(self, event_condition_overloaded: EventCondition):
-        assert event_condition_overloaded is not None
-        assert (
-            event_condition_overloaded.is_satisfied(
-                current_value=1.0, previous_value=-1.0
+            event_condition.is_satisfied(
+                previous_state_vector=[-1.0],
+                previous_time=0.0,
+                current_state_vector=[1.0],
+                current_time=1.0,
             )
             == True
         )
-        assert (
-            event_condition_overloaded.is_satisfied(current_value=1.0, previous_value=1.0)
-            == False
-        )

ostk/astrodynamics/test/test_numerical_solver.py

@@ -5,7 +5,8 @@ import pytest
 import numpy as np
 import math
 
-from ostk.astrodynamics import NumericalSolver, EventCondition
+from ostk.astrodynamics import NumericalSolver
+from ostk.astrodynamics.event_condition import RealEventCondition
 
 
 def oscillator(x, dxdt, _):
@@ -24,16 +25,13 @@ def initial_state_vec() -> np.ndarray:
 
 
 @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)
+def custom_condition() -> RealEventCondition:
+    return RealEventCondition(
+        "Custom",
+        RealEventCondition.Criteria.StrictlyPositive,
+        lambda state_vector, time: time,
+        5.0,
+    )
 
 
 @pytest.fixture
@@ -87,6 +85,12 @@ class TestNumericalSolver:
         assert numerical_solver == numerical_solver
         assert (numerical_solver != numerical_solver) is False
 
+    def test_accessors(
+        self,
+        numerical_solver: NumericalSolver,
+    ):
+        assert numerical_solver.access_observed_states() is not None
+
     def test_get_types(
         self,
         numerical_solver_default_inputs: tuple[
@@ -108,6 +112,7 @@ class TestNumericalSolver:
         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
+        assert numerical_solver.get_observed_states() is not None
 
     def test_get_string_from_types(self):
         assert (
@@ -191,7 +196,7 @@ class TestNumericalSolver:
         self,
         numerical_solver_conditional: NumericalSolver,
         initial_state_vec: np.ndarray,
-        custom_condition: EventCondition,
+        custom_condition: RealEventCondition,
     ):
         integration_duration: float = 100.0
 
@@ -207,7 +212,7 @@ class TestNumericalSolver:
 
         state_vector, time = condition_solution.solution
 
-        assert abs(time - custom_condition._target) < 1e-6
+        assert abs(float(time - custom_condition.get_target())) < 1e-6
 
         assert 5e-9 >= abs(state_vector[0] - math.sin(time))
         assert 5e-9 >= abs(state_vector[1] - math.cos(time))
@@ -215,7 +220,7 @@ class TestNumericalSolver:
     def test_integrate_time_with_condition(
         self,
         numerical_solver_conditional: NumericalSolver,
-        custom_condition: EventCondition,
+        custom_condition: RealEventCondition,
     ):
         start_time: float = 500.0
         end_time: float = start_time + 100.0
@@ -234,7 +239,7 @@ class TestNumericalSolver:
 
         state_vector, time = condition_solution.solution
 
-        assert abs(time - start_time - custom_condition._target) < 1e-6
+        assert abs(float(time - start_time - custom_condition.get_target())) < 1e-6
 
         assert 5e-9 >= abs(state_vector[0] - math.sin(time))
         assert 5e-9 >= abs(state_vector[1] - math.cos(time))
@@ -242,6 +247,9 @@ class TestNumericalSolver:
     def test_default(self):
         assert NumericalSolver.default() is not None
 
+    def test_default_conditional(self):
+        assert NumericalSolver.default_conditional() is not None
+
     def test_undefined(self):
         assert NumericalSolver.undefined() is not None
         assert NumericalSolver.undefined().is_defined() is False

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

@@ -105,3 +105,8 @@ def test_trajectory_orbit_models_kepler_coe_static_methods():
     assert (
         COE.eccentric_anomaly_from_mean_anomaly(Angle.degrees(0.0), 0.0, 0.0) is not None
     )
+
+
+def test_string_from_element():
+    element_str = COE.string_from_element(COE.Element.SemiMajorAxis)
+    assert element_str == "SemiMajorAxis"

ostk/astrodynamics/test/trajectory/state/coordinates_subset/test_cartesian_position.py

@@ -0,0 +1,103 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinatesBroker, CoordinatesSubset
+from ostk.astrodynamics.trajectory.state.coordinates_subset import CartesianPosition
+
+
+@pytest.fixture
+def name() -> str:
+    return "Position"
+
+
+@pytest.fixture
+def cartesian_position() -> CartesianPosition:
+    return CartesianPosition.default()
+
+
+@pytest.fixture
+def coordinates_subsets(cartesian_position: CartesianPosition) -> list[CoordinatesSubset]:
+    return [cartesian_position]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinates_broker(coordinates_subsets: list[CoordinatesSubset]) -> CoordinatesBroker:
+    return CoordinatesBroker(coordinates_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [7000000.0, 0.0, 0.0]
+
+
+@pytest.fixture
+def another_coordinates() -> list[float]:
+    return [0.0, 7000000.0, 0.0]
+
+
+class TestCoordinatesSubset:
+    def test_constructor(self, name: str):
+        assert CartesianPosition(name) is not None
+
+    def test_add(
+        self,
+        cartesian_position: CartesianPosition,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        assert all(
+            cartesian_position.add(
+                instant, coordinates, another_coordinates, frame, coordinates_broker
+            )
+            == [7000000.0, 7000000.0, 0.0]
+        )
+
+    def test_subtract(
+        self,
+        cartesian_position: CartesianPosition,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        assert all(
+            cartesian_position.subtract(
+                instant, coordinates, another_coordinates, frame, coordinates_broker
+            )
+            == [7000000.0, -7000000.0, 0.0]
+        )
+
+    def test_in_frame(
+        self,
+        cartesian_position: CartesianPosition,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        for value, expected in zip(
+            cartesian_position.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinates_broker
+            ),
+            [1238864.12746338, 6889500.39136482, -176.262107699686],
+        ):
+            assert value == pytest.approx(expected, rel=1e-14)

ostk/astrodynamics/test/trajectory/state/coordinates_subset/test_cartesian_velocity.py

@@ -0,0 +1,113 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.trajectory.state import CoordinatesBroker, CoordinatesSubset
+from ostk.astrodynamics.trajectory.state.coordinates_subset import (
+    CartesianVelocity,
+    CartesianPosition,
+)
+
+
+@pytest.fixture
+def name() -> str:
+    return "Position"
+
+
+@pytest.fixture
+def cartesian_position() -> CartesianPosition:
+    return CartesianPosition.default()
+
+
+@pytest.fixture
+def cartesian_velocity() -> CartesianVelocity:
+    return CartesianVelocity.default()
+
+
+@pytest.fixture
+def coordinates_subsets(
+    cartesian_position: CartesianPosition, cartesian_velocity: CartesianVelocity
+) -> list[CoordinatesSubset]:
+    return [cartesian_position, cartesian_velocity]
+
+
+@pytest.fixture
+def instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinates_broker(coordinates_subsets: list[CoordinatesSubset]) -> CoordinatesBroker:
+    return CoordinatesBroker(coordinates_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [7000000.0, 0.0, 0.0, 0.0, 5335.865450622126, 5335.865450622126]
+
+
+@pytest.fixture
+def another_coordinates() -> list[float]:
+    return [0.0, 7000000.0, 0.0, 5335.865450622126, 0.0, 0.0]
+
+
+class TestCoordinatesSubset:
+    def test_constructor(self, name: str):
+        assert CartesianVelocity(CartesianPosition.default(), name) is not None
+
+    def test_add(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        assert all(
+            cartesian_velocity.add(
+                instant, coordinates, another_coordinates, frame, coordinates_broker
+            )
+            == [5335.865450622126, 5335.865450622126, 5335.865450622126]
+        )
+
+    def test_subtract(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        assert all(
+            cartesian_velocity.subtract(
+                instant, coordinates, another_coordinates, frame, coordinates_broker
+            )
+            == [-5335.865450622126, 5335.865450622126, 5335.865450622126]
+        )
+
+    def test_in_frame(
+        self,
+        cartesian_velocity: CartesianVelocity,
+        instant: Instant,
+        frame: Frame,
+        coordinates: list[float],
+        another_coordinates: list[float],
+        coordinates_broker: CoordinatesBroker,
+    ):
+        for value, expected in zip(
+            cartesian_velocity.in_frame(
+                instant, coordinates, frame, Frame.ITRF(), coordinates_broker
+            ),
+            [-4749.36551256577, 854.163395375881, 5335.71857543495],
+        ):
+            assert value == pytest.approx(expected, rel=1e-14)

ostk/astrodynamics/test/trajectory/state/test_coordinates_broker.py

@@ -0,0 +1,71 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state import CoordinatesBroker, CoordinatesSubset
+
+
+@pytest.fixture
+def coordinates_subsets() -> list:
+    return [CoordinatesSubset("Subset1", 2), CoordinatesSubset("Subset2", 3)]
+
+
+@pytest.fixture
+def coordinates_broker(coordinates_subsets) -> CoordinatesBroker:
+    return CoordinatesBroker(coordinates_subsets)
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [1.0, 2.0, 3.0, 4.0, 5.0]
+
+
+class TestCoordinatesBroker:
+    def test_constructor(self, coordinates_broker: CoordinatesBroker):
+        assert coordinates_broker is not None
+
+    def test_eq(self, coordinates_broker: CoordinatesBroker):
+        assert coordinates_broker == coordinates_broker
+
+    def test_ne(self, coordinates_broker: CoordinatesBroker):
+        assert (coordinates_broker != coordinates_broker) == False
+
+    def test_access_subsets(
+        self, coordinates_broker: CoordinatesBroker, coordinates_subsets: list
+    ):
+        assert coordinates_broker.access_subsets() == coordinates_subsets
+
+    def test_get_number_of_coordinates(self, coordinates_broker: CoordinatesBroker):
+        assert coordinates_broker.get_number_of_coordinates() == 5
+
+    def test_get_number_of_subsets(self, coordinates_broker: CoordinatesBroker):
+        assert coordinates_broker.get_number_of_subsets() == 2
+
+    def test_get_subsets(
+        self, coordinates_broker: CoordinatesBroker, coordinates_subsets: list
+    ):
+        assert coordinates_broker.get_subsets() == coordinates_subsets
+
+    def test_add_subset(self, coordinates_broker: CoordinatesBroker):
+        new_subset = CoordinatesSubset("NewSubset", 4)
+        number_of_coordinates = coordinates_broker.get_number_of_coordinates()
+        assert coordinates_broker.add_subset(new_subset) == number_of_coordinates
+        assert coordinates_broker.has_subset(new_subset)
+
+    def test_has_subset(
+        self, coordinates_broker: CoordinatesBroker, coordinates_subsets: list
+    ):
+        assert coordinates_broker.has_subset(coordinates_subsets[0])
+
+    def extract_coordinates(
+        self,
+        coordinates_broker: CoordinatesBroker,
+        coordinates: list[float],
+        coordinates_subsets: list[CoordinatesSubset],
+    ):
+        assert coordinates_broker.extract_coordinates(
+            coordinates, coordinates_subsets[0]
+        ) == [1.0, 2.0]
+        assert coordinates_broker.extract_coordinates(
+            coordinates, coordinates_subsets[1]
+        ) == [3.0, 4.0, 5.0]

ostk/astrodynamics/test/trajectory/state/test_coordinates_subset.py

@@ -0,0 +1,43 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.astrodynamics.trajectory.state import CoordinatesSubset
+
+
+@pytest.fixture
+def name() -> str:
+    return "MySubset"
+
+
+@pytest.fixture
+def size() -> int:
+    return 3
+
+
+@pytest.fixture
+def coordinates_subset(name: str, size: int) -> CoordinatesSubset:
+    return CoordinatesSubset(name, size)
+
+
+class TestCoordinatesSubset:
+    def test_constructor(self, coordinates_subset: CoordinatesSubset):
+        assert coordinates_subset is not None
+
+    def test_eq(self, coordinates_subset: CoordinatesSubset):
+        assert coordinates_subset == coordinates_subset
+
+    def test_ne(self, coordinates_subset: CoordinatesSubset):
+        assert (coordinates_subset != coordinates_subset) == False
+
+    def test_get_id(self, coordinates_subset: CoordinatesSubset):
+        assert coordinates_subset.get_id() is not None
+
+    def test_get_name(self, coordinates_subset: CoordinatesSubset, name: str):
+        assert coordinates_subset.get_name() == name
+
+    def test_get_size(self, coordinates_subset: CoordinatesSubset, size: int):
+        assert coordinates_subset.get_size() == size
+
+    def test_mass(self):
+        assert CoordinatesSubset.mass() is not None

ostk/astrodynamics/test/trajectory/test_propagator.py

@@ -13,6 +13,7 @@ from ostk.physics.units import Mass
 from ostk.physics.time import Instant
 from ostk.physics.time import DateTime
 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
@@ -25,7 +26,7 @@ from ostk.astrodynamics.flight.system.dynamics import CentralBodyGravity
 from ostk.astrodynamics.flight.system.dynamics import PositionDerivative
 from ostk.astrodynamics.trajectory import State
 from ostk.astrodynamics.trajectory import Propagator
-from ostk.astrodynamics import EventCondition
+from ostk.astrodynamics.event_condition import DurationCondition
 
 
 @pytest.fixture
@@ -104,12 +105,10 @@ def conditional_numerical_solver() -> NumericalSolver:
 
 
 @pytest.fixture
-def event_condition() -> EventCondition:
-    class MyEventCondition(EventCondition):
-        def evaluate(self, state_vector, time):
-            return time - 42.0
-
-    return MyEventCondition("42 Seconds", EventCondition.Criteria.StrictlyPositive)
+def event_condition() -> DurationCondition:
+    return DurationCondition(
+        DurationCondition.Criteria.StrictlyPositive, Duration.seconds(42.0)
+    )
 
 
 @pytest.fixture
@@ -123,6 +122,11 @@ class TestPropagator:
         assert isinstance(propagator, Propagator)
         assert propagator.is_defined()
 
+    def test_access_numerical_solver(
+        self, propagator: Propagator, numerical_solver: NumericalSolver
+    ):
+        assert propagator.access_numerical_solver() == numerical_solver
+
     def test_get_dynamics(self, propagator: Propagator, dynamics: list):
         assert propagator.get_dynamics() == dynamics
 
@@ -186,7 +190,7 @@ class TestPropagator:
         conditional_numerical_solver: NumericalSolver,
         dynamics: list[Dynamics],
         state: State,
-        event_condition: EventCondition,
+        event_condition: DurationCondition,
     ):
         propagator: Propagator = Propagator(conditional_numerical_solver, dynamics)
 

ostk/astrodynamics/test/trajectory/test_state.py

@@ -12,26 +12,77 @@ from ostk.physics.coordinate import Velocity
 from ostk.physics.coordinate import Frame
 
 from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import CoordinatesBroker
+from ostk.astrodynamics.trajectory.state.coordinates_subset import (
+    CartesianPosition,
+    CartesianVelocity,
+)
+
+
+@pytest.fixture()
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
 
 
 @pytest.fixture
-def state_default_inputs() -> tuple[Instant, Position, Velocity, Frame]:
-    frame: Frame = Frame.GCRF()
-    position: Position = Position.meters([6371000.0, 0.0, 0.0], frame)
-    velocity: Velocity = Velocity.meters_per_second([7600.0, 0.0, 0.0], frame)
+def frame() -> Frame:
+    return Frame.GCRF()
+
 
-    instant = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+@pytest.fixture()
+def position(frame: Frame) -> Position:
+    return Position.meters([6371000.0, 0.0, 0.0], frame)
 
-    return (instant, position, velocity, frame)
+
+@pytest.fixture()
+def velocity(frame: Frame) -> Velocity:
+    return Velocity.meters_per_second([7600.0, 0.0, 0.0], frame)
 
 
 @pytest.fixture
-def state(state_default_inputs) -> State:
-    return State(*state_default_inputs[0:-1])
+def state(
+    instant: Instant, position: Position, velocity: Velocity, frame: Frame
+) -> State:
+    return State(instant, position, velocity)
+
+
+@pytest.fixture
+def coordinates_broker() -> CoordinatesBroker:
+    return CoordinatesBroker([CartesianPosition.default(), CartesianVelocity.default()])
 
 
 class TestState:
-    def test_constructor(self, state: State):
+    def test_constructor(
+        self,
+        instant: Instant,
+        position: Position,
+        velocity: Velocity,
+    ):
+        state = State(instant, position, velocity)
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.is_defined()
+
+    def test_explicit_constructor(
+        self,
+        instant: Instant,
+        position: Position,
+        velocity: Velocity,
+        frame: Frame,
+        coordinates_broker: CoordinatesBroker,
+    ):
+        state = State(instant, position, velocity)
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.is_defined()
+
+        state = State(
+            instant,
+            np.append(position.get_coordinates(), velocity.get_coordinates()),
+            frame,
+            coordinates_broker,
+        )
+
         assert state is not None
         assert isinstance(state, State)
         assert state.is_defined()
@@ -47,13 +98,15 @@ class TestState:
     def test_getters(
         self,
         state: State,
-        state_default_inputs: tuple[Instant, Position, Velocity, Frame],
+        instant: Instant,
+        position: Position,
+        velocity: Velocity,
+        frame: Frame,
     ):
-        (instant, position, velocity, _) = state_default_inputs
-
         assert state.get_instant() == instant
         assert state.get_position() == position
         assert state.get_velocity() == velocity
+        assert state.get_frame() == frame
         assert (
             state.get_coordinates()
             == np.append(position.get_coordinates(), velocity.get_coordinates())
@@ -62,9 +115,7 @@ class TestState:
     def test_in_frame(
         self,
         state: State,
-        state_default_inputs: tuple[Instant, Position, Velocity, Frame],
+        frame: Frame,
     ):
-        (_, _, _, frame) = state_default_inputs
-
         assert state.in_frame(frame) == state
         assert state.in_frame(Frame.ITRF()) != state

ostk/astrodynamics/viewer.py

@@ -303,7 +303,7 @@ def _cesium_from_ostk_sensor(sensor: Sensor) -> cesiumpy.ConicSensor:
     return cesiumpy.ConicSensor(
         name=sensor.name,
         direction=cesiumpy.Cartesian3(*sensor.direction),
-        half_angle=cesiumpy.math.to_radians(float(sensor.half_angle.in_radians())),
+        half_angle=float(sensor.half_angle.in_radians()),
         length=float(sensor.length.in_meters()),
         material=sensor.color or cesiumpy.color.RED,
     )