open-space-toolkit-astrodynamics 15.6.0__py39-none-manylinux2014_x86_64.whl → 16.1.0__py39-none-manylinux2014_x86_64.whl

{open_space_toolkit_astrodynamics-15.6.0.dist-info → open_space_toolkit_astrodynamics-16.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: open-space-toolkit-astrodynamics
-Version: 15.6.0
+Version: 16.1.0
 Summary: Orbit, attitude, access.
 Author: Open Space Collective
 Author-email: contact@open-space-collective.org

{open_space_toolkit_astrodynamics-15.6.0.dist-info → open_space_toolkit_astrodynamics-16.1.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-39-x86_64-linux-gnu.so,sha256=EAp97vglXjLnBu4dq6QumO26Ii_9wlg_pQgawlbOnpg,2783456
+ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-39-x86_64-linux-gnu.so,sha256=hYcv26NaK9AHaPkJh3rLogej1VLlxftOHxQ_pnvEXAE,2836704
 ostk/astrodynamics/__init__.py,sha256=3gWyqFIbhAfcdeMhmfBPQPlPQTmaOzm-6flkJe745Zk,251
-ostk/astrodynamics/__init__.pyi,sha256=YZjTrv06Z4Ns_NfF1_uhJutkYkQdVnJjYLVSiHCgby0,31428
+ostk/astrodynamics/__init__.pyi,sha256=zD5K2CDpIoulVPA2rVR4ArSPYkMjF-4sgMb-8UydGVE,32193
 ostk/astrodynamics/access.pyi,sha256=t2CF0TU6_6ow_rkV_I4rVKap7ZIdC4jYKL3WkTDHRXg,25157
 ostk/astrodynamics/converters.py,sha256=luPh30qMp9bzEkN7hUccmxlLf7zRp_AzqmBe8IUjPhU,3314
 ostk/astrodynamics/converters.pyi,sha256=HrZFyizkc6Hv_K38ZKZ80fX_bAxd6keA_NFWNQygvbs,1745
@@ -9,12 +9,12 @@ ostk/astrodynamics/dataframe.py,sha256=v-36rBHKdf7kQw1jdvJWrvkR-ZjW5DKRchtTEJWhd
 ostk/astrodynamics/display.py,sha256=LZESZgx2wlrFO4cwAGMb3VPJfdtcjNgCgKFrqot0NYU,6339
 ostk/astrodynamics/dynamics.pyi,sha256=gZ95KoGex4SB-1z6yMrngkZN1Ir9X6bEmrZgdLxq1ZE,13270
 ostk/astrodynamics/estimator.pyi,sha256=MnahWzp8aACxrNKWlYRsgQr5zpBxogNr-yPm7hJob5k,14000
-ostk/astrodynamics/event_condition.pyi,sha256=LXvZCbKnX6kzES7iMG51lJRnIA64YFsU5mUY2RW9fkM,24798
+ostk/astrodynamics/event_condition.pyi,sha256=2c_1Sq7tkYKeAA_aRWBi43KDQXXxu6EMSmUpEWz_Fa4,45814
 ostk/astrodynamics/guidance_law.pyi,sha256=rVmbpV2Y5FsIXejaInxINS67nVHmTIxVEkhaDIn17SA,12171
-ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.15,sha256=wiX7NXvgBVERrXHEVvMrk_ckQiTd-JMebV4jAkJWLqs,120497008
+ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.16,sha256=K8Pnig_cKlxFlypbFxHQAIRtFp1_3pI_9ezyr5jjOR4,122033672
 ostk/astrodynamics/solver.pyi,sha256=sPqyYPXBfFGC24dzzYyFyt01VfMAlWQ5_gh_RpeaBFk,17734
 ostk/astrodynamics/utilities.py,sha256=y8mr3M46J5z-GhS1oIEnuEJA6otwcyJ9YDhvn_5JxHM,6976
-ostk/astrodynamics/viewer.py,sha256=-Q4migLFOB9dNzs6TRPIXHNewyV5udsDSpcSma0kv8A,16376
+ostk/astrodynamics/viewer.py,sha256=PLznIOEArRlx-pfMHpGoszNRf2F8mf2SHe8CGvZrVnw,16740
 ostk/astrodynamics/conjunction/__init__.pyi,sha256=HFvWl8bCmrq3cBkUh5X5RGIh8webmVGxaZdpsz3WN-E,79
 ostk/astrodynamics/conjunction/message/__init__.pyi,sha256=5H__sg_QUx7ybf9jtVWvXzrUHeK3ECotfhddAdHjJUc,75
 ostk/astrodynamics/conjunction/message/ccsds.pyi,sha256=1Peto19hRqlD7KHf1cyLP3CT4OAKzwtemqvO6_4FZ0g,28162
@@ -26,8 +26,8 @@ ostk/astrodynamics/flight/profile/__init__.pyi,sha256=WBTG17V59UwD-X1r6TOrXT_rA3
 ostk/astrodynamics/flight/profile/model.pyi,sha256=g5Uy2ZLxImuETrMP4jqXr5FXl2dGAoKuNgzOH07EdBo,6807
 ostk/astrodynamics/pytrajectory/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/pytrajectory/__init__.pyi,sha256=QWrGyQNiICBEI3pKku2wJYdu-SQCBKXjJ_93XTEgkP8,79
-ostk/astrodynamics/pytrajectory/pystate.py,sha256=c0wR5OJn070ImwVJtW25XhEW7d2_8jkAd168Fo9u6K8,7959
-ostk/astrodynamics/pytrajectory/pystate.pyi,sha256=dbYwAoyZo9ZgLjms8nH9s_OhxlmxMLLILR-wXGqphbw,3320
+ostk/astrodynamics/pytrajectory/pystate.py,sha256=HbWtj1_FXGXTuvSu52ewMaO3ahwLBLStyJ4e5xqL-jw,8415
+ostk/astrodynamics/pytrajectory/pystate.pyi,sha256=ljE5Q9Y56dpWgxY75ji9ibrTWIJTXeO29_foHBPxGs4,3413
 ostk/astrodynamics/test/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/conftest.py,sha256=stmQOt7UXjBlXKJzNN6RkS2miv1xXSOX-YNpFhaHTqI,2771
 ostk/astrodynamics/test/test_access.py,sha256=MCBsUPtuVm7NgHZR0z0DpWnPZ_qBu4aRhLI2PnRNUYs,3940
@@ -37,7 +37,7 @@ ostk/astrodynamics/test/test_display.py,sha256=6giw_i08YMOSRgqNpdVWtzDu6fFalEVKz
 ostk/astrodynamics/test/test_event_condition.py,sha256=fQ-rVYpQsa7xacxRMBOQDyn61CuAGX1QBOGZxGWR0_s,2204
 ostk/astrodynamics/test/test_import.py,sha256=py_hALBR0IYuUzv9dfgQZzrrLHJIpnyKvt3Oi1XBqCg,1251
 ostk/astrodynamics/test/test_root_solver.py,sha256=hQ8O6g-WP49gZH_H3Rdufv0F0gQorpzJyIcjBGGUQ34,1831
-ostk/astrodynamics/test/test_trajectory.py,sha256=0sgGPkMFy-u-33z6SF-sTvaBb_NU7OvaeMTVF6wevfY,3148
+ostk/astrodynamics/test/test_trajectory.py,sha256=GzH7RNRiL088nFeeMm1lhpG4-HEFz15cnWcbD-8VAow,3933
 ostk/astrodynamics/test/test_utilities.py,sha256=NNIyzqOxMdsNpK2z0wU0utX06iZNfbMJDE36Upard28,3048
 ostk/astrodynamics/test/test_viewer.py,sha256=kDstRH_WKufN_0JPSXttzLMk3Afv_ylcEBfHxc35yrA,8946
 ostk/astrodynamics/test/access/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
@@ -62,7 +62,8 @@ ostk/astrodynamics/test/estimator/test_orbit_determination_solver.py,sha256=Vg_y
 ostk/astrodynamics/test/estimator/test_tle_solver.py,sha256=hANdRtaVvlOShXeyUqMpDk7kJINxdwstZodxJzAAWwk,7277
 ostk/astrodynamics/test/event_condition/test_angular_condition.py,sha256=MDRwjU5zXIRBaIFZA3jG3hcnyIIFo_0QyBRtNIfH2aQ,3119
 ostk/astrodynamics/test/event_condition/test_boolean_condition.py,sha256=Ng6FLKD8XoUHUz6-gi3wvrYhSGNSB_iJ_n89ajN4O3s,1580
-ostk/astrodynamics/test/event_condition/test_coe_condition.py,sha256=AM0olK1s4jDRs_dJs0sk9raY9Nm1eZpdEEso6wyvipk,2580
+ostk/astrodynamics/test/event_condition/test_brouwer_lyddane_mean_long_condition.py,sha256=H5tXsj-oQRxaLS3CWvtFruUZp1LnvQGu4id3mBu4RJc,4440
+ostk/astrodynamics/test/event_condition/test_coe_condition.py,sha256=dAADq0WEIcA-CvUyhH_6c917bwoaqCQ-XT_ru06Pcqc,4098
 ostk/astrodynamics/test/event_condition/test_instant_condition.py,sha256=Qr5dN6nrK7XDff7L4vnGCqasMK-Fa6qvxwy_U0xgH5M,1438
 ostk/astrodynamics/test/event_condition/test_logical_condition.py,sha256=09h5TYWtwGt4NQW3k_tziiVs0Q2981rNII9wyKg7p2Q,3321
 ostk/astrodynamics/test/event_condition/test_real_condition.py,sha256=tle6HVzMFMIIkfRY7CuaA0mPtw3riJBG_JQkc1L0dpk,1374
@@ -87,8 +88,8 @@ ostk/astrodynamics/test/trajectory/test_model.py,sha256=epnVn2PwdQkUDZ1msqBRO5nE
 ostk/astrodynamics/test/trajectory/test_orbit.py,sha256=vp7gDMtjO7nqERe0yq1OQZ0p4QRtxGTjGKN5-I3LWZM,6739
 ostk/astrodynamics/test/trajectory/test_propagator.py,sha256=ALjMvzndO9r6dVVXllk0iqu61tEoqu2j25MtzEitDIQ,14076
 ostk/astrodynamics/test/trajectory/test_segment.py,sha256=aXdF5CpNLwN_hKRU5sG3ID3hJR-NZ1_kgtNA-xHMBkM,12223
-ostk/astrodynamics/test/trajectory/test_sequence.py,sha256=iCNDDqEGoo4WZIOOov0qKGzrxjg7yWVIk8ajfKMhgI4,14503
-ostk/astrodynamics/test/trajectory/test_state.py,sha256=th1BvTIhmgsPPFTbVnpR3URvqYFrf0oyluJyoPP7TPI,17135
+ostk/astrodynamics/test/trajectory/test_sequence.py,sha256=4piYpMZ9C_eCXxaOcdz2We67wZxhsNBnETgKwvq6dl0,15083
+ostk/astrodynamics/test/trajectory/test_state.py,sha256=JO-SnUCRZ6sfVNwB5soT5c1f8c5DXuFN5lHZkiiTcYc,18119
 ostk/astrodynamics/test/trajectory/test_state_builder.py,sha256=LpCCYdCaLu_D2npm9wgA2sMlcekrtbRqP-afe5IE5L4,4871
 ostk/astrodynamics/test/trajectory/orbit/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/orbit/test_model.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
@@ -118,18 +119,18 @@ ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_attitude_quatern
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_acceleration.py,sha256=1p37_FYN85d9SrOqO3iCkNecovJJayhnFeZ4QCOw2ao,3528
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_position.py,sha256=XvHdk1KjacTwtkgx2jUAc9I9N3nvjPDv03FAanpv8jQ,2702
 ostk/astrodynamics/test/trajectory/state/coordinate_subset/test_cartesian_velocity.py,sha256=-kd5TZO5TICihbkqDTew2i_tDpggdpe3Yf23046FATM,3057
-ostk/astrodynamics/trajectory/__init__.pyi,sha256=sxwiGWbo6b4KgJFDUnz4YX2mn0__NXKMUhkWf-cq7q8,75487
+ostk/astrodynamics/trajectory/__init__.pyi,sha256=uC9WD4s1XZpnJy8GhSTap818vHPMgMNieusLaxlzh4U,76264
 ostk/astrodynamics/trajectory/orbit/__init__.pyi,sha256=wbuRK7Yp_NYBr3ta5-NpnJYMX4baUl7yIlUWhaRlR4o,12899
 ostk/astrodynamics/trajectory/orbit/message/__init__.pyi,sha256=-GNBlYPrsjelhKxWorYQYhIWzFsibiIQNZvMXjhRpfM,77
 ostk/astrodynamics/trajectory/orbit/message/spacex.pyi,sha256=fnUVJGWlSPo8AmLVuu08LubsAuVGo-gFaT86yd4f4CI,10558
 ostk/astrodynamics/trajectory/orbit/model/__init__.pyi,sha256=DYgjafm4rMV9Cqzg6dciwqsJdzuyE8JJgzW8up8qUeE,20370
 ostk/astrodynamics/trajectory/orbit/model/brouwerLyddaneMean.pyi,sha256=t1jbWsK8JgXkx-l_WSg96xfEG9fsddZ_CjqLpC3GBVY,5874
-ostk/astrodynamics/trajectory/orbit/model/kepler.pyi,sha256=KZH_m7mqwXNKFTu4zLRMl_pG7ADQ9Zo6j3FYuVNnLwQ,26955
+ostk/astrodynamics/trajectory/orbit/model/kepler.pyi,sha256=OZMznHuU7e6m1rfqtOgXbgBguimv4tg1RRvxRFQVAlw,27171
 ostk/astrodynamics/trajectory/orbit/model/sgp4.pyi,sha256=OhFzoPPQHlYy7m3LiZ8TXF89M4uBTfNk6tGsBEp0sjI,14235
 ostk/astrodynamics/trajectory/state/__init__.pyi,sha256=bq__Fii35czVrTeNxc9eQVjXdqwbbQxUdNQWK3vLrMo,17649
 ostk/astrodynamics/trajectory/state/coordinate_subset.pyi,sha256=kYMfMwEjCqO1NepMYFT4QS6kIPBkVL6sGCLeLbogcMw,10176
-open_space_toolkit_astrodynamics-15.6.0.dist-info/METADATA,sha256=5Nm6f5thffoDOhAlypysgUY8KnkhTGONPBbGR8LSJOI,1913
-open_space_toolkit_astrodynamics-15.6.0.dist-info/WHEEL,sha256=Lf7t-kOlAeOyExg08NFEPC9xn1Q2CLFgwDRGfj0NsM4,109
-open_space_toolkit_astrodynamics-15.6.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
-open_space_toolkit_astrodynamics-15.6.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-open_space_toolkit_astrodynamics-15.6.0.dist-info/RECORD,,
+open_space_toolkit_astrodynamics-16.1.0.dist-info/METADATA,sha256=-oOEr23wSU5vy8jOZpmEflURSXpN7wm-K4nMa6S9JPc,1913
+open_space_toolkit_astrodynamics-16.1.0.dist-info/WHEEL,sha256=Lf7t-kOlAeOyExg08NFEPC9xn1Q2CLFgwDRGfj0NsM4,109
+open_space_toolkit_astrodynamics-16.1.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_astrodynamics-16.1.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_astrodynamics-16.1.0.dist-info/RECORD,,

ostk/astrodynamics/__init__.pyi

@@ -5,8 +5,8 @@ from ostk.astrodynamics.trajectory import State as PyState
 from ostk import core as OpenSpaceToolkitCorePy
 from ostk.core import container
 from ostk.core import filesystem
-import ostk.core.type
 from ostk.core import type
+import ostk.core.type
 from ostk import io as OpenSpaceToolkitIOPy
 from ostk.io import URL
 from ostk.io import ip
@@ -24,10 +24,10 @@ from ostk.physics import coordinate
 import ostk.physics.coordinate.spherical
 from ostk.physics import environment
 import ostk.physics.environment.object
-import ostk.physics.time
 from ostk.physics import time
-import ostk.physics.unit
+import ostk.physics.time
 from ostk.physics import unit
+import ostk.physics.unit
 import typing
 from . import access
 from . import conjunction
@@ -672,6 +672,19 @@ class Trajectory:
                             Trajectory: The `Trajectory` object representing the ground strip.
         """
     @staticmethod
+    def ground_strip_geodetic_nadir(orbit: typing.Any, instants: list[ostk.physics.time.Instant], celestial_object: ostk.physics.environment.object.Celestial = ...) -> Trajectory:
+        """
+                        Create a `Trajectory` object representing a ground strip that follows the geodetic nadir of the provided orbit.
+        
+                        Args:
+                            orbit (Orbit): The orbit.
+                            instants (list[Instant]): The instants.
+                            celestial_object (Celestial): The celestial object. Defaults to Earth.WGS84().
+        
+                        Returns:
+                            Trajectory: The `Trajectory` object representing the ground strip.  
+        """
+    @staticmethod
     def position(position: ostk.physics.coordinate.Position) -> Trajectory:
         """
                         Create a `Trajectory` object representing a position.

ostk/astrodynamics/event_condition.pyi

@@ -6,7 +6,7 @@ import ostk.physics.coordinate
 import ostk.physics.time
 import ostk.physics.unit
 import typing
-__all__ = ['AngularCondition', 'BooleanCondition', 'COECondition', 'InstantCondition', 'LogicalCondition', 'RealCondition']
+__all__ = ['AngularCondition', 'BooleanCondition', 'BrouwerLyddaneMeanLongCondition', 'COECondition', 'InstantCondition', 'LogicalCondition', 'RealCondition']
 class AngularCondition(ostk.astrodynamics.EventCondition):
     """
     
@@ -193,6 +193,244 @@ class BooleanCondition(RealCondition):
                         Returns:
                             bool: True if the condition is satisfied, False otherwise.
         """
+class BrouwerLyddaneMeanLongCondition:
+    """
+    
+                    A Brouwer-Lyddane Mean Long Event Condition.
+    
+                
+    """
+    @staticmethod
+    @typing.overload
+    def aop(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, aop: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the argument of perigee.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                aop (EventConditionTarget): The argument of perigee.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def aop(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the argument of perigee being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def argument_of_latitude(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, argument_of_latitude: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the argument of latitude.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                argument_of_latitude (EventConditionTarget): The argument of latitude.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def argument_of_latitude(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the argument of latitude being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def eccentric_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, eccentric_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the eccentric anomaly.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                eccentric_anomaly (EventConditionTarget): The eccentric anomaly.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def eccentric_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the eccentric anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    def eccentricity(criterion: RealCondition.Criterion, frame: ostk.physics.coordinate.Frame, eccentricity: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> RealCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the eccentricity.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                eccentricity (EventConditionTarget): The eccentricity.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def inclination(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, inclination: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the inclination.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                inclination (EventConditionTarget): The inclination.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def inclination(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the inclination being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def mean_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, mean_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the mean anomaly.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                mean_anomaly (EventConditionTarget): The mean anomaly.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def mean_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the mean anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def raan(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, raan: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the right ascension of the ascending node.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                raan (EventConditionTarget): The right ascension of the ascending node.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def raan(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the right ascension of the ascending node being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    def semi_major_axis(criterion: RealCondition.Criterion, frame: ostk.physics.coordinate.Frame, semi_major_axis: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> RealCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the semi-major axis.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                semi_major_axis (EventConditionTarget): The semi-major axis.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def true_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, true_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the true anomaly.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                true_anomaly (EventConditionTarget): The true anomaly.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
+    @staticmethod
+    @typing.overload
+    def true_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a Brouwer-Lyddane Mean Long condition based on the true anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                BrouwerLyddaneMeanLongCondition: The Brouwer-Lyddane Mean Long condition.
+        """
 class COECondition:
     """
     
@@ -201,6 +439,7 @@ class COECondition:
                 
     """
     @staticmethod
+    @typing.overload
     def aop(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, aop: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the argument of perigee.
@@ -209,12 +448,56 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 aop (EventConditionTarget): The argument of perigee.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def aop(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the argument of perigee being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def argument_of_latitude(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, argument_of_latitude: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the argument of latitude.
+        
+                            Args:
+                                criterion (Criterion): The criterion.
+                                frame (Frame): The reference frame.
+                                argument_of_latitude (EventConditionTarget): The argument of latitude.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
+    def argument_of_latitude(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the argument of latitude being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
     def eccentric_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, eccentric_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the eccentric anomaly.
@@ -223,7 +506,21 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 eccentric_anomaly (EventConditionTarget): The eccentric anomaly.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def eccentric_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the eccentric anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
@@ -237,12 +534,13 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 eccentricity (EventConditionTarget): The eccentricity.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
     def inclination(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, inclination: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the inclination.
@@ -251,12 +549,27 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 inclination (EventConditionTarget): The inclination.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def inclination(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the inclination being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
     def mean_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, mean_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the mean anomaly.
@@ -265,12 +578,27 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 mean_anomaly (EventConditionTarget): The mean anomaly.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
+    def mean_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the mean anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
     def raan(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, raan: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the right ascension of the ascending node.
@@ -279,7 +607,21 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 raan (EventConditionTarget): The right ascension of the ascending node.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def raan(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the right ascension of the ascending node being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
@@ -293,12 +635,13 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 semi_major_axis (EventConditionTarget): The semi-major axis.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.
         """
     @staticmethod
+    @typing.overload
     def true_anomaly(criterion: AngularCondition.Criterion, frame: ostk.physics.coordinate.Frame, true_anomaly: ostk.astrodynamics.EventCondition.Target, gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
         """
                             Create a COE condition based on the true anomaly.
@@ -307,7 +650,21 @@ class COECondition:
                                 criterion (Criterion): The criterion.
                                 frame (Frame): The reference frame.
                                 true_anomaly (EventConditionTarget): The true anomaly.
-                                gravitational_parameter (float): The gravitational parameter.
+                                gravitational_parameter (Derived): The gravitational parameter.
+        
+                            Returns:
+                                COECondition: The COE condition.
+        """
+    @staticmethod
+    @typing.overload
+    def true_anomaly(frame: ostk.physics.coordinate.Frame, target_range: tuple[ostk.physics.unit.Angle, ostk.physics.unit.Angle], gravitational_parameter: ostk.physics.unit.Derived) -> AngularCondition:
+        """
+                            Create a COE condition based on the true anomaly being within a range.
+        
+                            Args:
+                                frame (Frame): The reference frame.
+                                target_range (tuple[Angle, Angle]): A tuple of two angles defining the range.
+                                gravitational_parameter (Derived): The gravitational parameter.
         
                             Returns:
                                 COECondition: The COE condition.

ostk/astrodynamics/pytrajectory/pystate.py

@@ -18,7 +18,7 @@ from ostk.astrodynamics.trajectory.state.coordinate_subset import (
     AngularVelocity,
 )
 
-CANONICAL_FORMAT: str = r"(r|v)_(.*?)_(x|y|z)"
+POS_VEL_CANONICAL_FORMAT: str = r"(r|v)_(.*?)_(x|y|z)"
 
 
 def custom_class_generator(frame: Frame, coordinate_subsets: list) -> type:
@@ -68,6 +68,7 @@ def from_dict(data: dict) -> State:
     - 'drag_coefficient'/'cd': The drag coefficient. Optional.
     - 'cross_sectional_area'/'surface_area': The cross-sectional area. Optional.
     - 'mass': The mass. Optional.
+    - 'ballistic_coefficient'/'bc': The ballistic coefficient. Optional.
 
     Args:
         data (dict): The dictionary.
@@ -76,7 +77,7 @@ def from_dict(data: dict) -> State:
         State: The State.
     """
 
-    instant: Instant = coerce_to_instant(data["timestamp"])
+    # Position and velocity subsets
 
     eci_columns: list[str] = [
         "rx_eci",
@@ -123,7 +124,7 @@ def from_dict(data: dict) -> State:
     ]
 
     match_groups: list[re.Match] = [
-        re.match(CANONICAL_FORMAT, column) for column in data.keys()
+        re.match(POS_VEL_CANONICAL_FORMAT, column) for column in data.keys()
     ]
 
     if len(matches := [match for match in match_groups if match is not None]) == 6:
@@ -188,6 +189,8 @@ def from_dict(data: dict) -> State:
     else:
         raise ValueError("Invalid state data.")
 
+    # Attitude and angular velocity subsets
+
     if all(
         column in data for column in ["q_B_ECI_x", "q_B_ECI_y", "q_B_ECI_z", "q_B_ECI_s"]
     ):
@@ -216,6 +219,8 @@ def from_dict(data: dict) -> State:
             ],
         )
 
+    # Extra subsets
+
     if (data.get("drag_coefficient") is not None) or (data.get("cd") is not None):
         coordinate_subsets.append(CoordinateSubset.drag_coefficient())
         coordinates = np.append(
@@ -239,8 +244,15 @@ def from_dict(data: dict) -> State:
             data["mass"],
         )
 
+    if (data.get("ballistic_coefficient") is not None) or (data.get("bc") is not None):
+        coordinate_subsets.append(CoordinateSubset.ballistic_coefficient())
+        coordinates = np.append(
+            coordinates,
+            data.get("ballistic_coefficient", data.get("bc")),
+        )
+
     return State(
-        instant=instant,
+        instant=coerce_to_instant(data["timestamp"]),
         coordinates=coordinates,
         frame=frame,
         coordinate_subsets=coordinate_subsets,

ostk/astrodynamics/pytrajectory/pystate.pyi

@@ -13,7 +13,7 @@ import ostk.physics.coordinate
 from ostk.physics.coordinate import Frame
 from ostk.physics.time import Instant
 import re as re
-__all__ = ['AngularVelocity', 'AttitudeQuaternion', 'CANONICAL_FORMAT', 'CartesianPosition', 'CartesianVelocity', 'CoordinateSubset', 'Frame', 'Instant', 'State', 'StateBuilder', 'coerce_to_instant', 'custom_class_generator', 'from_dict', 'np', 're']
+__all__ = ['AngularVelocity', 'AttitudeQuaternion', 'CartesianPosition', 'CartesianVelocity', 'CoordinateSubset', 'Frame', 'Instant', 'POS_VEL_CANONICAL_FORMAT', 'State', 'StateBuilder', 'coerce_to_instant', 'custom_class_generator', 'from_dict', 'np', 're']
 def custom_class_generator(frame: ostk.physics.coordinate.Frame, coordinate_subsets: list) -> type:
     """
     
@@ -54,6 +54,7 @@ def from_dict(data: dict) -> ostk.astrodynamics.trajectory.State:
         - 'drag_coefficient'/'cd': The drag coefficient. Optional.
         - 'cross_sectional_area'/'surface_area': The cross-sectional area. Optional.
         - 'mass': The mass. Optional.
+        - 'ballistic_coefficient'/'bc': The ballistic coefficient. Optional.
     
         Args:
             data (dict): The dictionary.
@@ -62,4 +63,4 @@ def from_dict(data: dict) -> ostk.astrodynamics.trajectory.State:
             State: The State.
         
     """
-CANONICAL_FORMAT: str = '(r|v)_(.*?)_(x|y|z)'
+POS_VEL_CANONICAL_FORMAT: str = '(r|v)_(.*?)_(x|y|z)'

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

@@ -73,6 +73,11 @@ class TestCOECondition:
                 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(
@@ -85,3 +90,46 @@ class TestCOECondition:
     ):
         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/test_trajectory.py

@@ -9,9 +9,12 @@ from ostk.physics.coordinate import Frame
 from ostk.physics.time import Instant
 from ostk.physics.time import Duration
 from ostk.physics.unit import Derived
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
 
 from ostk.astrodynamics import Trajectory
 from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory import Orbit
 
 
 @pytest.fixture
@@ -61,6 +64,16 @@ def states(trajectory: Trajectory) -> list[State]:
     )
 
 
+@pytest.fixture
+def orbit() -> Orbit:
+    return Orbit.circular(
+        epoch=Instant.J2000(),
+        altitude=Length.meters(545000.0),
+        inclination=Angle.degrees(0.0),
+        celestial_object=Earth.WGS84(),
+    )
+
+
 class TestTrajectory:
     def test_trajectory(self, states: list[State]):
         assert Trajectory(states) is not None
@@ -116,3 +129,17 @@ class TestTrajectory:
 
         assert Trajectory.ground_strip(start_lla, end_lla, instants, earth) is not None
         assert Trajectory.ground_strip(start_lla, end_lla, instants) is not None
+
+    def test_ground_strip_geodetic_nadir(
+        self, orbit: Orbit, instants: list[Instant], earth: Earth
+    ):
+        assert (
+            Trajectory.ground_strip_geodetic_nadir(
+                orbit=orbit, instants=instants, celestial_object=earth
+            )
+            is not None
+        )
+        assert (
+            Trajectory.ground_strip_geodetic_nadir(orbit=orbit, instants=instants)
+            is not None
+        )

ostk/astrodynamics/test/trajectory/test_sequence.py

@@ -156,17 +156,7 @@ def state(
 
     return State(
         instant,
-        [
-            717094.039086306,
-            -6872433.2241124,
-            46175.9696673281,
-            -970.650826004612,
-            -45.4598114773158,
-            7529.82424886455,
-            dry_mass.in_kilograms() + wet_mass.in_kilograms(),
-            cross_sectional_surface_area,
-            drag_coefficient,
-        ],
+        coordinates,
         frame,
         coordinate_broker,
     )
@@ -351,6 +341,28 @@ def sequence_solution(
     )
 
 
+@pytest.fixture
+def minimum_maneuver_duration():
+    return Duration.minutes(1.0)
+
+
+@pytest.fixture
+def sequence_with_minimum_maneuver_duration(
+    segments: list[Segment],
+    numerical_solver: NumericalSolver,
+    dynamics: list,
+    maximum_propagation_duration: Duration,
+    minimum_maneuver_duration: Duration,
+):
+    return Sequence(
+        segments=segments,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+        maximum_propagation_duration=maximum_propagation_duration,
+        minimum_maneuver_duration=minimum_maneuver_duration,
+    )
+
+
 class TestSequenceSolution:
     def test_properties(
         self,
@@ -421,6 +433,16 @@ class TestSequence:
     ):
         assert sequence.get_maximum_propagation_duration() == maximum_propagation_duration
 
+    def test_get_minimum_maneuver_duration(
+        self,
+        sequence_with_minimum_maneuver_duration: Sequence,
+        minimum_maneuver_duration: Duration,
+    ):
+        assert (
+            sequence_with_minimum_maneuver_duration.get_minimum_maneuver_duration()
+            == minimum_maneuver_duration
+        )
+
     def test_add_segment(
         self,
         sequence: Sequence,

ostk/astrodynamics/test/trajectory/test_state.py

@@ -458,6 +458,41 @@ class TestState:
         assert isinstance(state, State)
         assert state.get_size() == 6
 
+    def test_from_dict_with_ballistic_coefficient(self):
+        data: dict = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "rx_eci": 7000.0,
+            "ry_eci": 0.0,
+            "rz_eci": 0.0,
+            "vx_eci": 0.0,
+            "vy_eci": 7.5,
+            "vz_eci": 0.0,
+            "ballistic_coefficient": 2.2,
+        }
+
+        state: State = State.from_dict(data)
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_size() == 7
+
+        data: dict = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "rx_eci": 7000.0,
+            "ry_eci": 0.0,
+            "rz_eci": 0.0,
+            "vx_eci": 0.0,
+            "vy_eci": 7.5,
+            "vz_eci": 0.0,
+            "ballistic_coefficient": None,
+        }
+
+        state: State = State.from_dict(data)
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.get_size() == 6
+
     @pytest.mark.parametrize(
         ("data", "expected_length", "expected_frame"),
         [

ostk/astrodynamics/trajectory/__init__.pyi

@@ -1270,16 +1270,17 @@ class Sequence:
             
                             :type: list[SegmentSolution]
             """
-    def __init__(self: typing.Sequence, segments: list[Segment] = [], numerical_solver: state.NumericalSolver = ..., dynamics: list[...] = [], maximum_propagation_duration: ostk.physics.time.Duration = ..., verbosity: int = 1) -> None:
+    def __init__(self: typing.Sequence, segments: list[Segment] = [], numerical_solver: state.NumericalSolver = ..., dynamics: list[...] = [], maximum_propagation_duration: ostk.physics.time.Duration = ..., minimum_maneuver_duration: ostk.physics.time.Duration = ..., verbosity: int = 1) -> None:
         """
                             Construct a new `Sequence` object.
         
                             Args:
-                            segments (list[Segment], optional): The segments.
-                            numerical_solver (NumericalSolver, optional): The numerical solver.
-                            dynamics (list[Dynamics], optional): The dynamics.
-                            maximum_propagation_duration (Duration, optional): The maximum propagation duration.
-                            verbosity (int, optional): The verbosity level.
+                            segments (list[Segment], optional): The segments. Defaults to an empty list.
+                            numerical_solver (NumericalSolver, optional): The numerical solver. Defaults to the default conditional numerical solver.
+                            dynamics (list[Dynamics], optional): The dynamics. Defaults to an empty list.
+                            maximum_propagation_duration (Duration, optional): The maximum propagation duration. Defaults to 30 days.
+                            minimum_maneuver_duration (Duration, optional): The minimum maneuver duration. Defaults to Undefined. If defined, maneuvers less than this duration will be skipped.
+                            verbosity (int, optional): The verbosity level. Defaults to 1.
         
                             Returns:
                                 Sequence: The new `Sequence` object.
@@ -1331,6 +1332,13 @@ class Sequence:
                             Returns:
                                 Duration: The maximum propagation duration.
         """
+    def get_minimum_maneuver_duration(self: typing.Sequence) -> ostk.physics.time.Duration:
+        """
+                            Get the minimum maneuver duration.
+        
+                            Returns:
+                                Duration: The minimum maneuver duration.
+        """
     def get_numerical_solver(self: typing.Sequence) -> state.NumericalSolver:
         """
                             Get the numerical solver.
@@ -1406,6 +1414,7 @@ class State:
             - 'drag_coefficient'/'cd': The drag coefficient. Optional.
             - 'cross_sectional_area'/'surface_area': The cross-sectional area. Optional.
             - 'mass': The mass. Optional.
+            - 'ballistic_coefficient'/'bc': The ballistic coefficient. Optional.
         
             Args:
                 data (dict): The dictionary.

ostk/astrodynamics/trajectory/orbit/model/kepler.pyi

@@ -100,8 +100,11 @@ class COE:
           MeanAnomaly : Mean Anomaly
         
           EccentricAnomaly : Eccentric Anomaly
+        
+          ArgumentOfLatitude : Argument of Latitude
         """
         Aop: typing.ClassVar[COE.Element]  # value = <Element.Aop: 4>
+        ArgumentOfLatitude: typing.ClassVar[COE.Element]  # value = <Element.ArgumentOfLatitude: 8>
         EccentricAnomaly: typing.ClassVar[COE.Element]  # value = <Element.EccentricAnomaly: 7>
         Eccentricity: typing.ClassVar[COE.Element]  # value = <Element.Eccentricity: 1>
         Inclination: typing.ClassVar[COE.Element]  # value = <Element.Inclination: 2>
@@ -109,7 +112,7 @@ class COE:
         Raan: typing.ClassVar[COE.Element]  # value = <Element.Raan: 3>
         SemiMajorAxis: typing.ClassVar[COE.Element]  # value = <Element.SemiMajorAxis: 0>
         TrueAnomaly: typing.ClassVar[COE.Element]  # value = <Element.TrueAnomaly: 5>
-        __members__: typing.ClassVar[dict[str, COE.Element]]  # value = {'SemiMajorAxis': <Element.SemiMajorAxis: 0>, 'Eccentricity': <Element.Eccentricity: 1>, 'Inclination': <Element.Inclination: 2>, 'Aop': <Element.Aop: 4>, 'Raan': <Element.Raan: 3>, 'TrueAnomaly': <Element.TrueAnomaly: 5>, 'MeanAnomaly': <Element.MeanAnomaly: 6>, 'EccentricAnomaly': <Element.EccentricAnomaly: 7>}
+        __members__: typing.ClassVar[dict[str, COE.Element]]  # value = {'SemiMajorAxis': <Element.SemiMajorAxis: 0>, 'Eccentricity': <Element.Eccentricity: 1>, 'Inclination': <Element.Inclination: 2>, 'Aop': <Element.Aop: 4>, 'Raan': <Element.Raan: 3>, 'TrueAnomaly': <Element.TrueAnomaly: 5>, 'MeanAnomaly': <Element.MeanAnomaly: 6>, 'EccentricAnomaly': <Element.EccentricAnomaly: 7>, 'ArgumentOfLatitude': <Element.ArgumentOfLatitude: 8>}
         def __eq__(self, other: typing.Any) -> bool:
             ...
         def __getstate__(self) -> int:

ostk/astrodynamics/viewer.py

@@ -105,7 +105,7 @@ class Viewer:
         show_orbital_track: bool = False,
         color: str | None = None,
         image: str | None = None,
-    ) -> None:
+    ) -> Viewer:
         """
         Add Orbit to Viewer.
 
@@ -116,6 +116,9 @@ class Viewer:
             show_orbital_track (bool, optional): Whether to show the orbital track. Defaults to False.
             color (str, optional): Color of the orbit. Defaults to None.
             image (str, optional): Logo to be added. Defaults to None.
+
+        Returns:
+            Viewer: The Viewer.
         """
         instants: list[Instant] = self._interval.generate_grid(step)
         states: list[State] = orbit.get_states_at(instants)
@@ -164,6 +167,8 @@ class Viewer:
                 )
             )
 
+        return self
+
     def add_profile(
         self,
         profile: Profile,
@@ -172,7 +177,7 @@ class Viewer:
         cesium_asset_id: int | None = None,
         sensors: list[Sensor] | None = None,
         show_xyz_axes: bool = False,
-    ) -> None:
+    ) -> Viewer:
         """
         Add Profile to Viewer.
 
@@ -183,6 +188,9 @@ class Viewer:
             cesium_asset_id (int, optional): The Cesium asset ID. Defaults to None.
             sensors (list[Sensor], optional): Sensors to be added to the asset. Defaults to None.
             show_xyz_axes (bool, optional): Whether to show the XYZ axes. Defaults to False.
+
+        Returns:
+            Viewer: The Viewer.
         """
 
         instants: list[Instant] = self._interval.generate_grid(step)
@@ -257,13 +265,15 @@ class Viewer:
                 )
             )
 
+        return self
+
     def add_target(
         self,
         position: Position,
         size: int | None = None,
         color: str | None = None,
         label: str | None = None,
-    ) -> None:
+    ) -> Viewer:
         """
         Add target to Viewer.
 
@@ -272,6 +282,9 @@ class Viewer:
             size (int, optional): Target size. Defaults to None.
             color (str, optional): Target color. Defaults to None.
             label (str, optional): Target label. Defaults to None.
+
+        Returns:
+            Viewer: The Viewer.
         """
 
         self._viewer.entities.add(
@@ -285,12 +298,14 @@ class Viewer:
         if label:
             self.add_label(position, label, size, color)
 
+        return self
+
     def add_line(
         self,
         positions: list[Position],
         size: int | None = None,
         color: str | None = None,
-    ) -> None:
+    ) -> Viewer:
         """
         Add line to Viewer.
 
@@ -298,6 +313,9 @@ class Viewer:
             positions (list[Position]): Line positions.
             size (int, optional): Line size. Defaults to None.
             color (str, optional): Line color. Defaults to None.
+
+        Returns:
+            Viewer: The Viewer.
         """
 
         self._viewer.entities.add(
@@ -321,13 +339,15 @@ class Viewer:
             )
         )
 
+        return self
+
     def add_label(
         self,
         position: Position,
         text: str,
         size: int | None = None,
         color: str | None = None,
-    ) -> None:
+    ) -> Viewer:
         """
         Add label to Viewer.
 
@@ -337,6 +357,8 @@ class Viewer:
             size (int, optional): Label size. Defaults to None.
             color (str, optional): Label color. Defaults to None.
 
+        Returns:
+            Viewer: The Viewer.
         """
 
         self._viewer.entities.add(
@@ -348,6 +370,8 @@ class Viewer:
             )
         )
 
+        return self
+
     def render(self) -> str:
         """
         Render Viewer as HTML string.