open-space-toolkit-astrodynamics 16.8.0__py313-none-manylinux2014_aarch64.whl → 16.9.0__py313-none-manylinux2014_aarch64.whl

{open_space_toolkit_astrodynamics-16.8.0.dist-info → open_space_toolkit_astrodynamics-16.9.0.dist-info}/METADATA

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

{open_space_toolkit_astrodynamics-16.8.0.dist-info → open_space_toolkit_astrodynamics-16.9.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-313-aarch64-linux-gnu.so,sha256=UloSW5i0-b6rlxGKjo8_9ONH3NhjTxi9sXzDLk2JXhA,2664832
+ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-313-aarch64-linux-gnu.so,sha256=A8Qv3TCkK7bZUxzT1ZaSXgGslyBF8RNv4-FArg6smQo,2693512
 ostk/astrodynamics/__init__.py,sha256=3gWyqFIbhAfcdeMhmfBPQPlPQTmaOzm-6flkJe745Zk,251
-ostk/astrodynamics/__init__.pyi,sha256=l39uJ41QUoFdQXjRXzara_EPHNnf_9Q086T1-Jv-9X4,32224
+ostk/astrodynamics/__init__.pyi,sha256=wUzGQSogTjxlQuTfsfV5CkW1PHTiA2zBY0O7_nd8bGA,32224
 ostk/astrodynamics/access.pyi,sha256=pp2t81kKH4sP4BcGb8nAZHmpwhISjFODMpbZ4ucLFAw,25157
 ostk/astrodynamics/converters.py,sha256=luPh30qMp9bzEkN7hUccmxlLf7zRp_AzqmBe8IUjPhU,3314
 ostk/astrodynamics/converters.pyi,sha256=tTUT0xGbiUkKxUj79Hq5EEtxV3b2uR6Wsnj_vwyj-mk,1625
 ostk/astrodynamics/dataframe.py,sha256=v-36rBHKdf7kQw1jdvJWrvkR-ZjW5DKRchtTEJWhdxk,25012
 ostk/astrodynamics/display.py,sha256=D9PrX1G-XmXk2j3Jl7Na7q52PTc4WKWB1-oRFJPT6w0,8606
-ostk/astrodynamics/dynamics.pyi,sha256=gZ95KoGex4SB-1z6yMrngkZN1Ir9X6bEmrZgdLxq1ZE,13270
+ostk/astrodynamics/dynamics.pyi,sha256=12t5esJJ18YmCeD2-8Glcb4JPOs6vl2c6QeUaDCel9E,13308
 ostk/astrodynamics/eclipse.pyi,sha256=Q8fzdukA7fyxbUM3wjEXAHukT-Ovl4FM00NbjsMPnUM,3211
 ostk/astrodynamics/estimator.pyi,sha256=MnahWzp8aACxrNKWlYRsgQr5zpBxogNr-yPm7hJob5k,14000
 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.16,sha256=r2QRZUN_s_w90Bu6E5_BWFfIdnfdGlU6w3TEnue8xSU,4027856
+ostk/astrodynamics/guidance_law.pyi,sha256=Xtqneu5PLpidOoSH4YIAY3D8rWZ0QH_ESqEdfbiTBVQ,16936
+ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.16,sha256=64f3DTQELHsOR76LlOG8924thWDsmLMbodCKz2JgDQM,4036632
 ostk/astrodynamics/solver.pyi,sha256=dRdR9RLqwSaBBX_ZRmpeBv06WvM_BFNo3WUdNzorYTY,17805
 ostk/astrodynamics/utilities.py,sha256=y8mr3M46J5z-GhS1oIEnuEJA6otwcyJ9YDhvn_5JxHM,6976
 ostk/astrodynamics/viewer.py,sha256=SlKyOWKjaF3V9HFB3I7ZgHy7n_GLeHTWM9q2wXkpxe8,27077
@@ -21,7 +21,7 @@ ostk/astrodynamics/conjunction/message/__init__.pyi,sha256=5H__sg_QUx7ybf9jtVWvX
 ostk/astrodynamics/conjunction/message/ccsds.pyi,sha256=1Peto19hRqlD7KHf1cyLP3CT4OAKzwtemqvO6_4FZ0g,28162
 ostk/astrodynamics/data/__init__.pyi,sha256=4l_mfVbnU_L7wImwgTCe8fVI81gK_tUmd0z7BY9lLi8,81
 ostk/astrodynamics/data/provider.pyi,sha256=O4Lg9FBq9itufgATnic5SMg90pn8vJJJMUdNcWP72NI,1492
-ostk/astrodynamics/flight/__init__.pyi,sha256=OnR2OxLLvmVSp18nLzM7R_QHoJvoikIaz2qiIZgH0bA,23606
+ostk/astrodynamics/flight/__init__.pyi,sha256=VL6OTS5uFz9xEVQ-enHz5FinFTS283nBAztEn4uGNJw,25865
 ostk/astrodynamics/flight/system.pyi,sha256=WVxy6Oe4q3C81c0AOxSwAmnwUHcpXO7JCEvESjs2g4A,10508
 ostk/astrodynamics/flight/profile/__init__.pyi,sha256=WBTG17V59UwD-X1r6TOrXT_rA3WjKY-2ML1cWfji_4g,3688
 ostk/astrodynamics/flight/profile/model.pyi,sha256=wwnVaTjTytxPqKyNo1tpdZRedabQlIHgyxfT0nivO5M,7777
@@ -56,7 +56,7 @@ ostk/astrodynamics/test/dynamics/test_dynamics.py,sha256=4VHL3Khbh8qTBKZw7m-4gSU
 ostk/astrodynamics/test/dynamics/test_position_derivative.py,sha256=JRuq-oRrJfisbN75OnE-ldm6TeYcIc0qYaGVMflbn2g,1610
 ostk/astrodynamics/test/dynamics/test_tabulated.py,sha256=qFHA7nmcvJtWucpCOYHAFmNRtImhTGlAZ0CHGEadeX8,4029
 ostk/astrodynamics/test/dynamics/test_third_body_gravity.py,sha256=7xBOKbVio-zZ2-QQaje152cP38n_ALAaR5x6QIdBmXE,1879
-ostk/astrodynamics/test/dynamics/test_thruster.py,sha256=cCJtKWuNcRHmcreCv7BajwuJnHCat9m88OHh_o0cB7w,4383
+ostk/astrodynamics/test/dynamics/test_thruster.py,sha256=MJicjTLJCiULNgBk10ZVrZF5Bi3nRb3UZPWVcrpnxz8,4746
 ostk/astrodynamics/test/dynamics/data/Tabulated_Earth_Gravity.csv,sha256=jJWOMJcQ83Vy1Wrb9PTh3ffOdoDF98kk6w5b-_E0uWg,47419
 ostk/astrodynamics/test/dynamics/data/Tabulated_Earth_Gravity_Truth.csv,sha256=f4x-zmxZADxD_doAbACt24k36VSTp3rSIJiSzuSroKs,8377
 ostk/astrodynamics/test/eclipse/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
@@ -71,7 +71,7 @@ ostk/astrodynamics/test/event_condition/test_instant_condition.py,sha256=Qr5dN6n
 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
 ostk/astrodynamics/test/flight/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/test/flight/test_maneuver.py,sha256=HonAvD9qtax72lizoDLR6ELI-poC3LWk_umg-WYygYA,5388
+ostk/astrodynamics/test/flight/test_maneuver.py,sha256=7ZiMHrmGfSopjXm2Z3L1fXvDCJ646zVRcVyTk8f7rxY,6905
 ostk/astrodynamics/test/flight/test_profile.py,sha256=U1l7pbFYrUjjxYBotQ3ujrvBxnBcyWgTrKwVHHClStc,8602
 ostk/astrodynamics/test/flight/test_system.py,sha256=5kJCULHdpkwAC7i6xLV7vdJnGfOdrOuhi0G22p_L160,1224
 ostk/astrodynamics/test/flight/profile/model/test_tabulated_profile.py,sha256=NZVa9dXzp4UDmohAlBaYeY594CPbqIv5j3VSEzlbYHk,3168
@@ -79,8 +79,9 @@ ostk/astrodynamics/test/flight/system/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5n
 ostk/astrodynamics/test/flight/system/test_propulsion_system.py,sha256=SoxOt-fjHvs_86f6Xb3jAsHDOShJ6Puz7eO5wrqibaM,1835
 ostk/astrodynamics/test/flight/system/test_satellite_system.py,sha256=dCFcl2RKiLxDKLI0sytPBXr3vHOFQIVNNCzpw5WzlAA,2437
 ostk/astrodynamics/test/flight/system/test_satellite_system_builder.py,sha256=QCk70dPcptvdpWQOxtYR0-iGnlbtOIx2V6oO0UhYIQ0,2426
-ostk/astrodynamics/test/guidance_law/test_constant_thrust.py,sha256=YpMkMvat4YnE1Fyy5vZ1Sf3VvbvDaC_UvbIKNNCG_B4,2635
+ostk/astrodynamics/test/guidance_law/test_constant_thrust.py,sha256=y7VaKuJ8oCVEDeZL62oWepcmmYKG-9Za2Ebjn8lVR7Y,5381
 ostk/astrodynamics/test/guidance_law/test_guidance_law.py,sha256=4ElWLS9ovnYBcj5HwJI3a6R9wrSLxyb_VMvxcCLDrKE,1560
+ostk/astrodynamics/test/guidance_law/test_heterogeneous_guidance_law.py,sha256=qqIahgqFNhBjAe6RrztR0mR1XQ7ztXO-q7_pkpiKLWo,5076
 ostk/astrodynamics/test/guidance_law/test_qlaw.py,sha256=kZaBZeU_J8Qk2nFnnpSuu-2NXT_13g3vLamG--eZfeU,3634
 ostk/astrodynamics/test/solvers/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/solvers/test_finite_difference_solver.py,sha256=0tcarIg2HTpcdzItWlL5Kd6q2nHcDBA8ZE0D3ugUN_s,5953
@@ -92,7 +93,7 @@ ostk/astrodynamics/test/trajectory/test_local_orbital_frame_factory.py,sha256=s1
 ostk/astrodynamics/test/trajectory/test_model.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/test_orbit.py,sha256=EwqQejhcSqYhKPCAkjxyBLgEc82fOhrh1zrJ86RGO9Q,7011
 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_segment.py,sha256=u4AdttP27r2usLaaBthoSivofxKUyoQdH7dAeKEc9-E,16046
 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
@@ -128,7 +129,7 @@ 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=zcowdlUplPRFZovsYG2Tj2Scd_0ZnIhUtYirtq6UUc8,76551
+ostk/astrodynamics/trajectory/__init__.pyi,sha256=W7m5x95ofyR-GnBdVVrBf4uQQ9_GfXXzheDtlXq9ZgA,78464
 ostk/astrodynamics/trajectory/model.pyi,sha256=SIneZx3pQ6XAo6iBccr4B1OsATbs1PEsCngtaTvja00,10473
 ostk/astrodynamics/trajectory/orbit/__init__.pyi,sha256=wbuRK7Yp_NYBr3ta5-NpnJYMX4baUl7yIlUWhaRlR4o,12899
 ostk/astrodynamics/trajectory/orbit/message/__init__.pyi,sha256=-GNBlYPrsjelhKxWorYQYhIWzFsibiIQNZvMXjhRpfM,77
@@ -139,8 +140,8 @@ ostk/astrodynamics/trajectory/orbit/model/kepler.pyi,sha256=KL-FwPbG4OUkPjhQb1Pa
 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-16.8.0.dist-info/METADATA,sha256=EfkYJE8PmXGgbf8PpG_rAkZgnWlv8XFvMDYSXiMxVV8,1913
-open_space_toolkit_astrodynamics-16.8.0.dist-info/WHEEL,sha256=SoYeZtqoiLCL_G4rzH07IDMwRvSqG334rWZuI48h-Rk,111
-open_space_toolkit_astrodynamics-16.8.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
-open_space_toolkit_astrodynamics-16.8.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-open_space_toolkit_astrodynamics-16.8.0.dist-info/RECORD,,
+open_space_toolkit_astrodynamics-16.9.0.dist-info/METADATA,sha256=gBHINQ0oyiWejSohb8XPjnxzlfl27qPJf5UrIM4YD-k,1913
+open_space_toolkit_astrodynamics-16.9.0.dist-info/WHEEL,sha256=SoYeZtqoiLCL_G4rzH07IDMwRvSqG334rWZuI48h-Rk,111
+open_space_toolkit_astrodynamics-16.9.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_astrodynamics-16.9.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_astrodynamics-16.9.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
-from ostk.core import type
 import ostk.core.type
+from ostk.core import type
 from ostk import io as OpenSpaceToolkitIOPy
 from ostk.io import URL
 from ostk.io import ip
@@ -14,18 +14,18 @@ from ostk import mathematics as OpenSpaceToolkitMathematicsPy
 from ostk.mathematics import curve_fitting
 from ostk.mathematics import geometry
 from ostk.mathematics import object
-from ostk import physics as OpenSpaceToolkitPhysicsPy
 import ostk.physics
+from ostk import physics as OpenSpaceToolkitPhysicsPy
 from ostk.physics import Environment
 from ostk.physics import Manager
 from ostk.physics import Unit
-import ostk.physics.coordinate
 from ostk.physics import coordinate
+import ostk.physics.coordinate
 import ostk.physics.coordinate.spherical
 from ostk.physics import environment
 import ostk.physics.environment.object
-from ostk.physics import time
 import ostk.physics.time
+from ostk.physics import time
 from ostk.physics import unit
 import ostk.physics.unit
 import typing

ostk/astrodynamics/dynamics.pyi

@@ -270,7 +270,7 @@ class Thruster(ostk.astrodynamics.Dynamics):
                         Args:
                             satellite_system (SatelliteSystem): The satellite system.
                             guidance_law (GuidanceLaw): The guidance law used to compute the acceleration vector.
-                            name (str): The name of the thruster.
+                            name (str, optional): The name of the thruster. Defaults to String.empty().
         """
     def __repr__(self) -> str:
         ...

ostk/astrodynamics/flight/__init__.pyi

@@ -84,6 +84,16 @@ class Maneuver:
                         Returns:
                             float: The delta-v value (m/s).
         """
+    def calculate_mean_thrust_direction_and_maximum_angular_offset(self, local_orbital_frame_factory: ostk.astrodynamics.trajectory.LocalOrbitalFrameFactory) -> tuple[ostk.astrodynamics.trajectory.LocalOrbitalFrameDirection, ostk.physics.unit.Angle]:
+        """
+                        Calculate the mean thrust direction in the Local Orbital Frame and its maximum angular offset w.r.t. the maneuver's thrust acceleration directions.
+                    
+                        Args:
+                            local_orbital_frame_factory (LocalOrbitalFrameFactory): The local orbital frame factory.
+        
+                        Returns:
+                            Tuple[LocalOrbitalFrameDirection, Angle]: The mean thrust direction and its maximum angular offset.
+        """
     def get_interval(self) -> ostk.physics.time.Interval:
         """
                         Get the interval of the maneuver.
@@ -105,6 +115,24 @@ class Maneuver:
                         Returns:
                             bool: True if the maneuver is defined, False otherwise. (Always returns true).
         """
+    def to_constant_local_orbital_frame_direction_maneuver(self, local_orbital_frame_factory: ostk.astrodynamics.trajectory.LocalOrbitalFrameFactory, maximum_allowed_angular_offset: ostk.physics.unit.Angle = ...) -> Maneuver:
+        """
+                        Create a maneuver with a constant thrust acceleration direction in the Local Orbital Frame.
+        
+                        The new Maneuver contains the same states as the original Maneuver, but the thrust acceleration direction is 
+                        constant in the Local Orbital Frame. Said direction is the mean direction of the thrust acceleration directions 
+                        in the Local Orbital Frame of the original Maneuver. The thrust acceleration magnitude profile is the same as the original.
+        
+                        If defined, a runtime error will be thrown if the maximum allowed angular offset between the original thrust acceleration direction 
+                        and the mean thrust direction is violated.
+        
+                        Args:
+                            local_orbital_frame_factory (LocalOrbitalFrameFactory): The local orbital frame factory.
+                            maximum_allowed_angular_offset (Angle, optional): The maximum allowed angular offset to consider (if any). Defaults to Undefined.
+        
+                        Returns:
+                            Maneuver: The constant local orbital frame direction maneuver.
+        """
     def to_tabulated_dynamics(self, frame: ostk.physics.coordinate.Frame = ..., interpolation_type: ostk.mathematics.curve_fitting.Interpolator.Type = ...) -> ...:
         """
                         Convert the maneuver to tabulated dynamics.
@@ -200,7 +228,7 @@ class Profile:
                             Constructor.
             
                             Args:
-                                orientation_profile (list[Tuple[Instant, Vector3d]]): The orientation profile.
+                                orientation_profile (list[tuple[Instant, Vector3d]]): The orientation profile.
                                 axis (Profile.Axis): The axis.
                                 anti_direction (bool): True if the direction is flipped, False otherwise. Defaults to False.
             """

ostk/astrodynamics/guidance_law.pyi

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import numpy
 import ostk.astrodynamics
+import ostk.astrodynamics.flight
 import ostk.astrodynamics.trajectory
 import ostk.astrodynamics.trajectory.orbit.model.kepler
 import ostk.core.type
@@ -8,26 +9,43 @@ import ostk.physics.coordinate
 import ostk.physics.time
 import ostk.physics.unit
 import typing
-__all__ = ['ConstantThrust', 'QLaw']
+__all__ = ['ConstantThrust', 'HeterogeneousGuidanceLaw', 'QLaw']
 class ConstantThrust(ostk.astrodynamics.GuidanceLaw):
     """
     
-                    Constant Thrust, Constant Direction dynamics.
+                    Constant Thrust, Constant Direction guidance law.
     
                 
     """
     @staticmethod
+    def from_maneuver(maneuver: ostk.astrodynamics.flight.Maneuver, local_orbital_frame_factory: ostk.astrodynamics.trajectory.LocalOrbitalFrameFactory, maximum_allowed_angular_offset: ostk.physics.unit.Angle = ...) -> ConstantThrust:
+        """
+                            Create a constant thrust guidance law from a maneuver.
+        
+                            The local orbital frame maneuver's mean thrust direction is calculated and used to create a 
+                            constant thrust guidance law in said direction.
+                            
+                            If defined, a runtime error will be thrown if the maximum allowed angular offset between the original thrust acceleration 
+                            direction and the mean thrust direction is violated.
+        
+                            Args:
+                                maneuver (Maneuver): The maneuver.
+                                local_orbital_frame_factory (LocalOrbitalFrameFactory): The local orbital frame factory.
+                                maximum_allowed_angular_offset (Angle, optional): The maximum allowed angular offset to consider (if any). Defaults to Undefined.
+        
+                            Returns:
+                                ConstantThrust: The constant thrust guidance law.
+        """
+    @staticmethod
     def intrack(velocity_direction: bool = True) -> ConstantThrust:
         """
-                            Create a constant thrust in the in-track direction.
+                            Create a constant thrust guidance law in the in-track direction.
         
                             Args:
-                                satellite_system (SatelliteSystem): The satellite system.
-                                velocity_direction (bool, optional): If True, the thrust is applied in the velocity direction. Otherwise, it is applied in the opposite direction.
-                                frame (Frame, optional): The reference frame.
+                                velocity_direction (bool, optional): If True, the thrust is applied in the velocity direction. Otherwise, it is applied in the opposite direction. Defaults to True.
         
                             Returns:
-                                ConstantThrust: The constant thrust.
+                                ConstantThrust: The constant thrust guidance law in the in-track direction.
         """
     def __init__(self, thrust_direction: ostk.astrodynamics.trajectory.LocalOrbitalFrameDirection) -> None:
         """
@@ -61,6 +79,63 @@ class ConstantThrust(ostk.astrodynamics.GuidanceLaw):
                             Returns:
                                 LocalOrbitalFrameDirection: The local thrust direction.
         """
+class HeterogeneousGuidanceLaw(ostk.astrodynamics.GuidanceLaw):
+    """
+    
+                A guidance law that sequences multiple guidance laws over specific time intervals.
+                
+                At each point in time, the applicable guidance law is selected and used to calculate
+                the thrust acceleration. Guidance laws don't need to be contiguous, and can be added
+                in any order. If the instant does not fall within any of the intervals, the thrust
+                acceleration is zero. The guidance law intervals must not intersect each other.
+            
+    """
+    def __init__(self, guidance_laws_with_intervals: list[tuple[ostk.astrodynamics.GuidanceLaw, ostk.physics.time.Interval]] = []) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            guidance_laws_with_intervals (list[tuple[GuidanceLaw, Interval]], optional): Array of tuples containing the guidance laws and their corresponding intervals. Defaults to empty array.
+        
+                        Raises:
+                            RuntimeError: If any interval is undefined, if the guidance law is null or if the interval intersects with an existing interval.
+        """
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def add_guidance_law(self, guidance_law: ostk.astrodynamics.GuidanceLaw, interval: ostk.physics.time.Interval) -> None:
+        """
+                        Add a guidance law with its corresponding interval.
+        
+                        Args:
+                            guidance_law (GuidanceLaw): The guidance law to add.
+                            interval (Interval): The interval during which the guidance law is active.
+        
+                        Raises:
+                            RuntimeError: If the interval is undefined, if the guidance law is null or if the interval intersects with an existing interval.
+        """
+    def calculate_thrust_acceleration_at(self, instant: ostk.physics.time.Instant, position_coordinates: numpy.ndarray[numpy.float64[3, 1]], velocity_coordinates: numpy.ndarray[numpy.float64[3, 1]], thrust_acceleration: ostk.core.type.Real, output_frame: ostk.physics.coordinate.Frame) -> numpy.ndarray[numpy.float64[3, 1]]:
+        """
+                        Calculate thrust acceleration at a given instant and state.
+        
+                        Args:
+                            instant (Instant): The instant.
+                            position_coordinates (numpy.ndarray): The position coordinates.
+                            velocity_coordinates (numpy.ndarray): The velocity coordinates.
+                            thrust_acceleration (float): The thrust acceleration magnitude.
+                            output_frame (Frame): The frame in which the acceleration is expressed.
+        
+                        Returns:
+                            numpy.ndarray: The acceleration vector at the provided coordinates.
+        """
+    def get_guidance_laws_with_intervals(self) -> list[tuple[ostk.astrodynamics.GuidanceLaw, ostk.physics.time.Interval]]:
+        """
+                        Get the guidance laws with their corresponding intervals.
+        
+                        Returns:
+                            list[tuple[GuidanceLaw, Interval]]: Array of tuples containing the guidance laws and their corresponding intervals.
+        """
 class QLaw(ostk.astrodynamics.GuidanceLaw):
     """
     

ostk/astrodynamics/test/dynamics/test_thruster.py

@@ -22,7 +22,6 @@ from ostk.astrodynamics.trajectory.state import CoordinateBroker
 from ostk.astrodynamics.trajectory import State
 from ostk.astrodynamics.flight.system import PropulsionSystem
 from ostk.astrodynamics.flight.system import SatelliteSystem
-from ostk.astrodynamics import Dynamics
 from ostk.astrodynamics.dynamics import Thruster
 from ostk.astrodynamics.guidance_law import ConstantThrust
 
@@ -96,11 +95,27 @@ def state(coordinate_broker: CoordinateBroker) -> State:
 
 
 class TestThruster:
-    def test_constructors(self, dynamics: Thruster):
-        assert dynamics is not None
-        assert isinstance(dynamics, Thruster)
-        assert isinstance(dynamics, Dynamics)
-        assert dynamics.is_defined()
+    def test_constructors(
+        self,
+        guidance_law: ConstantThrust,
+        satellite_system: SatelliteSystem,
+    ):
+        thrusters = [
+            Thruster(
+                satellite_system=satellite_system,
+                guidance_law=guidance_law,
+            ),
+            Thruster(
+                satellite_system=satellite_system,
+                guidance_law=guidance_law,
+                name="A name",
+            ),
+        ]
+
+        for thruster in thrusters:
+            assert thruster is not None
+            assert isinstance(thruster, Thruster)
+            assert thruster.is_defined()
 
     def test_getters(self, dynamics: Thruster):
         assert dynamics.get_satellite_system() is not None

ostk/astrodynamics/test/flight/test_maneuver.py

@@ -4,16 +4,18 @@ import pytest
 
 import numpy as np
 
-
 from ostk.physics.time import Instant
 from ostk.physics.time import Interval
 from ostk.physics.time import Duration
 from ostk.physics.coordinate import Frame
 from ostk.physics.unit import Mass
+from ostk.physics.unit import Angle
 
+from ostk.astrodynamics.dynamics import Tabulated as TabulatedDynamics
 from ostk.astrodynamics.flight import Maneuver
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameDirection
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
 from ostk.astrodynamics.trajectory import State
-from ostk.astrodynamics.dynamics import Tabulated as TabulatedDynamics
 from ostk.astrodynamics.trajectory.state import CoordinateSubset
 from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
 from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
@@ -184,12 +186,44 @@ class TestManeuver:
 
         assert tabulated_dynamics.access_frame() == frame
 
+    def test_calculate_mean_thrust_direction_and_maximum_angular_offset(
+        self,
+        maneuver: Maneuver,
+    ):
+        mean_thrust_direction_and_maximum_angular_offset = (
+            maneuver.calculate_mean_thrust_direction_and_maximum_angular_offset(
+                local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+            )
+        )
+        assert isinstance(
+            mean_thrust_direction_and_maximum_angular_offset[0],
+            LocalOrbitalFrameDirection,
+        )
+        assert isinstance(mean_thrust_direction_and_maximum_angular_offset[1], Angle)
+
+    def test_to_constant_local_orbital_frame_direction_maneuver(
+        self,
+        maneuver: Maneuver,
+    ):
+        maneuver: Maneuver = maneuver.to_constant_local_orbital_frame_direction_maneuver(
+            local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+        )
+        assert maneuver.is_defined()
+
+        maneuver_with_maximum_allowed_angular_offset: Maneuver = (
+            maneuver.to_constant_local_orbital_frame_direction_maneuver(
+                local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+                maximum_allowed_angular_offset=Angle.degrees(180.0),
+            )
+        )
+        assert maneuver_with_maximum_allowed_angular_offset.is_defined()
+
     def test_from_constant_mass_flow_rate(
         self,
         states: list[State],
     ):
         mass_flow_rate: float = -1.0e-5
-        maneuver = Maneuver.constant_mass_flow_rate_profile(
+        maneuver: Maneuver = Maneuver.constant_mass_flow_rate_profile(
             states=states,
             mass_flow_rate=mass_flow_rate,
         )

ostk/astrodynamics/test/guidance_law/test_constant_thrust.py

@@ -2,16 +2,26 @@
 
 import pytest
 
-from ostk.physics.time import Instant
+import numpy as np
+
 from ostk.physics.time import DateTime
+from ostk.physics.time import Duration
+from ostk.physics.time import Instant
 from ostk.physics.time import Scale
+from ostk.physics.unit import Angle
 from ostk.physics.coordinate import Frame
 
 from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
 from ostk.astrodynamics.trajectory import LocalOrbitalFrameDirection
 
 from ostk.astrodynamics import GuidanceLaw
+from ostk.astrodynamics.flight import Maneuver
 from ostk.astrodynamics.guidance_law import ConstantThrust
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianPosition
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianVelocity
+from ostk.astrodynamics.trajectory.state.coordinate_subset import CartesianAcceleration
 
 
 @pytest.fixture
@@ -54,6 +64,64 @@ def frame() -> Frame:
     return Frame.GCRF()
 
 
+@pytest.fixture
+def instants() -> list[Instant]:
+    return [
+        Instant.J2000(),
+        Instant.J2000() + Duration.seconds(30.0),
+        Instant.J2000() + Duration.seconds(35.0),
+        Instant.J2000() + Duration.seconds(37.0),
+    ]
+
+
+@pytest.fixture
+def acceleration_profile() -> list[np.ndarray]:
+    return [
+        np.array([1.0e-3, 0.0e-3, 0.0e-3]),
+        np.array([0.0e-3, 1.0e-3, 0.0e-3]),
+        np.array([0.0e-3, 0.0e-3, 1.0e-3]),
+        np.array([1.0e-3, 1.0e-3, 1.0e-3]),
+    ]
+
+
+@pytest.fixture
+def mass_flow_rate_profile() -> list[float]:
+    return [-1.0e-5, -1.1e-5, -0.9e-5, -1.0e-5]
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [
+        CartesianPosition.default(),
+        CartesianVelocity.default(),
+        CartesianAcceleration.thrust_acceleration(),
+        CoordinateSubset.mass_flow_rate(),
+    ]
+
+
+@pytest.fixture
+def maneuver(
+    instants: list[Instant],
+    acceleration_profile: list[np.ndarray],
+    mass_flow_rate_profile: list[float],
+    frame: Frame,
+    coordinate_subsets: list[CoordinateSubset],
+) -> Maneuver:
+    states = []
+    for instant, acceleration, mass_flow_rate in zip(
+        instants, acceleration_profile, mass_flow_rate_profile
+    ):
+        states.append(
+            State(
+                instant,
+                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, *acceleration, mass_flow_rate],
+                frame,
+                coordinate_subsets,
+            )
+        )
+    return Maneuver(states)
+
+
 class TestConstantThrust:
     def test_constructors(self, guidance_law: ConstantThrust):
         assert guidance_law is not None
@@ -89,3 +157,21 @@ class TestConstantThrust:
 
         assert len(contribution) == 3
         assert contribution == pytest.approx([0.0, 0.009523809523809525, 0.0], abs=5e-11)
+
+    def test_from_maneuver(self, maneuver: Maneuver):
+        constant_thrust = ConstantThrust.from_maneuver(
+            maneuver=maneuver,
+            local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+        )
+        assert isinstance(constant_thrust, ConstantThrust)
+
+        constant_thrust_with_maximum_allowed_angular_offset = (
+            ConstantThrust.from_maneuver(
+                maneuver=maneuver,
+                local_orbital_frame_factory=LocalOrbitalFrameFactory.TNW(Frame.GCRF()),
+                maximum_allowed_angular_offset=Angle.degrees(180.0),
+            )
+        )
+        assert isinstance(
+            constant_thrust_with_maximum_allowed_angular_offset, ConstantThrust
+        )

ostk/astrodynamics/test/guidance_law/test_heterogeneous_guidance_law.py

@@ -0,0 +1,164 @@
+# Apache License 2.0
+
+import numpy as np
+
+import pytest
+
+from ostk.physics.coordinate import Frame
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.time import Interval
+from ostk.astrodynamics import GuidanceLaw
+from ostk.astrodynamics.guidance_law import HeterogeneousGuidanceLaw
+
+
+@pytest.fixture
+def interval_1() -> Interval:
+    return Interval.closed(
+        start_instant=Instant.J2000(),
+        end_instant=Instant.J2000() + Duration.seconds(100.0),
+    )
+
+
+@pytest.fixture
+def guidance_law_1() -> GuidanceLaw:
+    class GuidanceLaw1(GuidanceLaw):
+
+        def __init__(
+            self,
+            name: str,
+        ):
+            super().__init__(name)
+
+        def calculate_thrust_acceleration_at(
+            self,
+            instant: Instant,
+            position_coordinates: np.array,
+            velocity_coordinates: np.array,
+            thrust_acceleration: float,
+            output_frame: Frame,
+        ) -> np.array:
+            return np.array([1.0, 2.0, 3.0])
+
+    return GuidanceLaw1("My Guidance Law 1")
+
+
+@pytest.fixture
+def interval_2() -> Interval:
+    return Interval.closed(
+        start_instant=Instant.J2000() + Duration.seconds(200.0),
+        end_instant=Instant.J2000() + Duration.seconds(300.0),
+    )
+
+
+@pytest.fixture
+def guidance_law_2() -> GuidanceLaw:
+    class GuidanceLaw2(GuidanceLaw):
+
+        def __init__(
+            self,
+            name: str,
+        ):
+            super().__init__(name)
+
+        def calculate_thrust_acceleration_at(
+            self,
+            instant: Instant,
+            position_coordinates: np.array,
+            velocity_coordinates: np.array,
+            thrust_acceleration: float,
+            output_frame: Frame,
+        ) -> np.array:
+            return np.array([4.0, 5.0, 6.0])
+
+    return GuidanceLaw2("My Guidance Law 2")
+
+
+@pytest.fixture
+def heterogeneous_guidance_law(
+    interval_1: Interval,
+    guidance_law_1: GuidanceLaw,
+    interval_2: Interval,
+    guidance_law_2: GuidanceLaw,
+) -> HeterogeneousGuidanceLaw:
+    return HeterogeneousGuidanceLaw(
+        guidance_laws_with_intervals=[
+            (guidance_law_1, interval_1),
+            (guidance_law_2, interval_2),
+        ],
+    )
+
+
+class TestHeterogeneousGuidanceLaw:
+    def test_constructor_and_getters(
+        self,
+        interval_1: Interval,
+        guidance_law_1: GuidanceLaw,
+        interval_2: Interval,
+        guidance_law_2: GuidanceLaw,
+    ):
+        heterogeneous_guidance_law = HeterogeneousGuidanceLaw(
+            guidance_laws_with_intervals=[
+                (guidance_law_1, interval_1),
+                (guidance_law_2, interval_2),
+            ],
+        )
+        assert heterogeneous_guidance_law is not None
+        assert isinstance(heterogeneous_guidance_law, HeterogeneousGuidanceLaw)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
+            (guidance_law_1, interval_1),
+            (guidance_law_2, interval_2),
+        ]
+
+    def test_add_guidance_law(
+        self,
+        interval_1: Interval,
+        guidance_law_1: GuidanceLaw,
+        interval_2: Interval,
+        guidance_law_2: GuidanceLaw,
+    ):
+        heterogeneous_guidance_law = HeterogeneousGuidanceLaw()
+
+        assert isinstance(heterogeneous_guidance_law, HeterogeneousGuidanceLaw)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == []
+
+        heterogeneous_guidance_law.add_guidance_law(guidance_law_1, interval_1)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
+            (guidance_law_1, interval_1),
+        ]
+
+        heterogeneous_guidance_law.add_guidance_law(guidance_law_2, interval_2)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
+            (guidance_law_1, interval_1),
+            (guidance_law_2, interval_2),
+        ]
+
+    @pytest.mark.parametrize(
+        (
+            "instant",
+            "expected_thrust_acceleration",
+        ),
+        [
+            (Instant.J2000() - Duration.seconds(50.0), np.array([0.0, 0.0, 0.0])),
+            (Instant.J2000() + Duration.seconds(50.0), np.array([1.0, 2.0, 3.0])),
+            (Instant.J2000() + Duration.seconds(150.0), np.array([0.0, 0.0, 0.0])),
+            (Instant.J2000() + Duration.seconds(250.0), np.array([4.0, 5.0, 6.0])),
+            (Instant.J2000() + Duration.seconds(350.0), np.array([0.0, 0.0, 0.0])),
+        ],
+    )
+    def test_calculate_thrust_acceleration_at(
+        self,
+        heterogeneous_guidance_law: HeterogeneousGuidanceLaw,
+        instant: Instant,
+        expected_thrust_acceleration: np.array,
+    ):
+        assert np.array_equal(
+            heterogeneous_guidance_law.calculate_thrust_acceleration_at(
+                instant=instant,
+                position_coordinates=np.array([0.0, 0.0, 0.0]),
+                velocity_coordinates=np.array([0.0, 0.0, 0.0]),
+                thrust_acceleration=1.0,
+                output_frame=Frame.GCRF(),
+            ),
+            expected_thrust_acceleration,
+        )

ostk/astrodynamics/test/trajectory/test_segment.py

@@ -10,6 +10,7 @@ from ostk.physics.time import Scale
 from ostk.physics.time import Duration
 from ostk.physics.coordinate import Frame
 from ostk.physics.environment.object.celestial import Earth
+from ostk.physics.unit import Angle
 
 from ostk.astrodynamics.flight.system import SatelliteSystem
 from ostk.astrodynamics import Dynamics
@@ -17,6 +18,7 @@ from ostk.astrodynamics.dynamics import CentralBodyGravity
 from ostk.astrodynamics.dynamics import PositionDerivative
 from ostk.astrodynamics.dynamics import Thruster
 from ostk.astrodynamics.guidance_law import ConstantThrust
+from ostk.astrodynamics.trajectory import LocalOrbitalFrameFactory
 from ostk.astrodynamics.trajectory import State
 from ostk.astrodynamics.trajectory import Segment
 from ostk.astrodynamics.event_condition import InstantCondition
@@ -75,6 +77,11 @@ def dynamics(
     ]
 
 
+@pytest.fixture
+def local_orbital_frame_factory() -> LocalOrbitalFrameFactory:
+    return LocalOrbitalFrameFactory.VNC(Frame.GCRF())
+
+
 @pytest.fixture
 def numerical_solver() -> NumericalSolver:
     return NumericalSolver.default_conditional()
@@ -122,6 +129,51 @@ def maneuver_segment(
     )
 
 
+@pytest.fixture
+def maximum_allowed_angular_offset() -> Angle:
+    return Angle.degrees(180.0)
+
+
+@pytest.fixture
+def constant_local_orbital_frame_direction_maneuver_segment(
+    name: str,
+    instant_condition: InstantCondition,
+    thruster_dynamics: Thruster,
+    dynamics: list,
+    numerical_solver: NumericalSolver,
+    local_orbital_frame_factory: LocalOrbitalFrameFactory,
+) -> Segment:
+    return Segment.constant_local_orbital_frame_direction_maneuver(
+        name=name,
+        event_condition=instant_condition,
+        thruster_dynamics=thruster_dynamics,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+        local_orbital_frame_factory=local_orbital_frame_factory,
+    )
+
+
+@pytest.fixture
+def constant_local_orbital_frame_direction_maneuver_segment_with_maximum_allowed_angular_offset(
+    name: str,
+    instant_condition: InstantCondition,
+    thruster_dynamics: Thruster,
+    dynamics: list,
+    numerical_solver: NumericalSolver,
+    local_orbital_frame_factory: LocalOrbitalFrameFactory,
+    maximum_allowed_angular_offset: Angle,
+) -> Segment:
+    return Segment.constant_local_orbital_frame_direction_maneuver(
+        name=name,
+        event_condition=instant_condition,
+        thruster_dynamics=thruster_dynamics,
+        dynamics=dynamics,
+        numerical_solver=numerical_solver,
+        local_orbital_frame_factory=local_orbital_frame_factory,
+        maximum_allowed_angular_offset=maximum_allowed_angular_offset,
+    )
+
+
 @pytest.fixture
 def instants(state: State) -> list[Instant]:
     return [state.get_instant(), state.get_instant() + Duration.minutes(1.0)]
@@ -293,6 +345,41 @@ class TestSegment:
             is not None
         )
 
+    def test_constant_local_orbital_frame_direction_maneuver(
+        self,
+        name: str,
+        instant_condition: InstantCondition,
+        thruster_dynamics: ConstantThrust,
+        dynamics: list,
+        numerical_solver: NumericalSolver,
+        local_orbital_frame_factory: LocalOrbitalFrameFactory,
+        maximum_allowed_angular_offset: Angle,
+    ):
+        assert (
+            Segment.constant_local_orbital_frame_direction_maneuver(
+                name=name,
+                event_condition=instant_condition,
+                thruster_dynamics=thruster_dynamics,
+                dynamics=dynamics,
+                numerical_solver=numerical_solver,
+                local_orbital_frame_factory=local_orbital_frame_factory,
+            )
+            is not None
+        )
+
+        assert (
+            Segment.constant_local_orbital_frame_direction_maneuver(
+                name=name,
+                event_condition=instant_condition,
+                thruster_dynamics=thruster_dynamics,
+                dynamics=dynamics,
+                numerical_solver=numerical_solver,
+                local_orbital_frame_factory=local_orbital_frame_factory,
+                maximum_allowed_angular_offset=maximum_allowed_angular_offset,
+            )
+            is not None
+        )
+
     def test_create_solution(
         self,
         dynamics: list,
@@ -310,7 +397,7 @@ class TestSegment:
 
         assert segment_solution is not None
 
-    def test_solve(
+    def test_solve_maneuver_segment(
         self,
         state: State,
         end_instant: Instant,
@@ -318,7 +405,7 @@ class TestSegment:
         instants: list[Instant],
         numerical_solver: NumericalSolver,
     ):
-        solution = maneuver_segment.solve(state)
+        solution: Segment.Solution = maneuver_segment.solve(state)
 
         assert (
             pytest.approx(
@@ -400,3 +487,21 @@ class TestSegment:
             solution.get_dynamics_acceleration_contribution(
                 solution.dynamics[0], state.get_frame()
             )
+
+    def test_solve_constant_local_orbital_frame_direction_maneuver_segment(
+        self,
+        state: State,
+        constant_local_orbital_frame_direction_maneuver_segment: Segment,
+        constant_local_orbital_frame_direction_maneuver_segment_with_maximum_allowed_angular_offset: Segment,
+    ):
+        solution: Segment.Solution = (
+            constant_local_orbital_frame_direction_maneuver_segment.solve(state)
+        )
+        assert solution is not None
+
+        solution_with_maximum_allowed_angular_offset: Segment.Solution = (
+            constant_local_orbital_frame_direction_maneuver_segment_with_maximum_allowed_angular_offset.solve(
+                state
+            )
+        )
+        assert solution_with_maximum_allowed_angular_offset is not None

ostk/astrodynamics/trajectory/__init__.pyi

@@ -1094,6 +1094,30 @@ class Segment:
                             Segment: The coast segment.
         """
     @staticmethod
+    def constant_local_orbital_frame_direction_maneuver(name: ostk.core.type.String, event_condition: typing.Any, thruster_dynamics: typing.Any, dynamics: list[...], numerical_solver: state.NumericalSolver, local_orbital_frame_factory: LocalOrbitalFrameFactory, maximum_allowed_angular_offset: ostk.physics.unit.Angle = ...) -> Segment:
+        """
+                        Create a maneuvering segment that produces maneuvers with a constant direction in the local orbital frame.
+        
+                        The provided thruster dynamics are used to solve the segment at first. The maneuvers produced by this segement solution
+                        are then used to create a new thruster dynamics with a constant direction in the local orbital frame. This new thruster dynamics
+                        is then used to actually solve the segment.
+        
+                        If defined, a runtime error will be thrown if the maximum allowed angular offset between the original thruster dynamics
+                        and the mean thrust direction is violated.
+        
+                        Args:
+                            name (str): The name of the segment.
+                            event_condition (EventCondition): The event condition.
+                            thruster_dynamics (ThrusterDynamics): The thruster dynamics.
+                            dynamics (Dynamics): The dynamics.
+                            numerical_solver (NumericalSolver): The numerical solver.
+                            local_orbital_frame_factory (LocalOrbitalFrameFactory): The local orbital frame factory.
+                            maximum_allowed_angular_offset (Angle, optional): The maximum allowed angular offset to consider (if any). Defaults to Angle.undefined().
+        
+                        Returns:
+                            Segment: The maneuver segment.
+        """
+    @staticmethod
     def maneuver(name: ostk.core.type.String, event_condition: typing.Any, thruster_dynamics: typing.Any, dynamics: list[...], numerical_solver: state.NumericalSolver) -> Segment:
         """
                         Create a maneuver segment.