acceleration
¶
Functions¶
Creates settings for the pointmass gravity acceleration. 

Creates settings for the aerodynamic acceleration. 


Creates settings for the radiation pressure acceleration. 
Creates settings for the cannonball radiation pressure acceleration. 


Creates settings for the spherical harmonic gravity acceleration. 

Creates settings for the mutual spherical harmonic gravity acceleration. 
Creates settings for the polyhedron gravity acceleration. 

Creates settings for the ring gravity acceleration. 


Creates settings for the relativistic acceleration correction. 

Creates settings for empirical acceleration. 

Creates settings for custom acceleration. 

Overloaded function. 
Creates settings for incorporating quasiimpulsive shots into the acceleration. 


Creates settings for thrust acceleration using a list of engine models. 

Creates settings for thrust acceleration using a single engine models. 
Creates settings for thrust acceleration using a single engine models. 


Creates settings for the Yarkovsky acceleration. 
 point_mass_gravity() tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the pointmass gravity acceleration.
Creates settings for the pointmass gravity acceleration. The direct acceleration (acceleration w.r.t. an inertial frame) is computed from:
\[\mathbf{a}=\frac{\mu}{{r}^{2}}\hat{\mathbf{r}}\]with \(\mathbf{r}\) the position vector measured from the center of mass of the body exerting the acceleration.
The body exerting the acceleration needs to have a gravity field model (gravity_field module) defined to use this acceleration.
Depending on the body undergoing the acceleration \(A\), the body exerting the acceleration \(B\), and the central body of propagation math:C, choosing this option may create a direct pointmass attraction (\(\mu=\mu_{B}\)), a central pointmass attraction (\(\mu=\mu_{B}+\mu_{A}\)) or a thirdbody pointmass attraction (see here for more details).
 Returns:
Acceleration settings object.
 Return type:
Examples
In this example, we define the point mass gravity acceleration exerted by the Earth on the vehicle:
# Create acceleration dict accelerations_acting_on_vehicle = dict() # Add aerodynamic acceleration exerted by Earth accelerations_acting_on_vehicle["Earth"] = [propagation_setup.acceleration.point_mass_gravity()]
 aerodynamic() tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the aerodynamic acceleration.
Creates settings for the aerodynamic acceleration. The acceleration is computed from:
\[\begin{split}\mathbf{a}=\frac{1}{m}\mathbf{R}^{(I/\text{Aero})}\left(\frac{1}{2}\rho v_{\text{air}}^{2}S_{ref}\begin{pmatrix} C_{D} \\ C_{S} \\ C_{L}\end{pmatrix}\right)\end{split}\]with \(\mathbf{R}^{(I/\text{Aero})}\) the rotation matrix from the aerodynamic frame of the body undergoing acceleration to the inertial frame (computed from the body’s current state, and the rotation of the body exerting the acceleration), \(\rho\) the local freesream atmospheric density, \(v_{\text{air}}\) the airspeed, \(C_{D,S,L}\) the drag, side and lift coefficients (which may depend on any number of properties of the body/environment) with reference area \(S_{ref}\), and \(m\) the mass of the body undergoing acceleration The body exerting the acceleration needs to have an atmosphere (atmosphere module), shape (shape module) and rotation model (rotation_model module) defined. The body undergoing the acceleration needs to have aerodynamic coefficients (aerodynamic_coefficients module) defined.
 Returns:
Acceleration settings object.
 Return type:
Examples
In this example, we define the aerodynamic acceleration exerted by the Earth on the vehicle:
# Create acceleration dict accelerations_acting_on_vehicle = dict() # Add aerodynamic acceleration exerted by Earth accelerations_acting_on_vehicle["Earth"] = [propagation_setup.acceleration.aerodynamic()]
 radiation_pressure(target_type: tudatpy.kernel.numerical_simulation.environment_setup.radiation_pressure.RadiationPressureTargetModelType = <RadiationPressureTargetModelType.undefined_target: 3>) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the radiation pressure acceleration.
Creates settings for the radiation pressure acceleration. This function takes the source model of the body exerting the acceleration, and the target model of the body undergoing the acceleration, and links these models to set up the specific acceleration model, regardless of how the source and target models are defined. For more extensive details on how this is done, check out the radiation pressure acceleration page.
 Returns:
Acceleration settings object.
 Return type:
 cannonball_radiation_pressure() tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the cannonball radiation pressure acceleration.
Creates settings for the radiation pressure acceleration, for which a cannonball model is used. The acceleration is computed from:
\[\mathbf{a}=\left(\frac{P}{4\pi c}\right)\left(\frac{C_{r}S_{ref}}{m}\right)\frac{\hat{\mathbf{r}}}{r^{2}}\]with \(P\) the total emitted radiation power for the body exerting the acceleration, \(C_{r}\) the radiation pressure coefficient with reference area \(S_{ref}\), \(\mathbf{r}\) the vector from the body exerting the acceleration to the body undergoing the acceleration, and \(m\) the mass of the body undergoing acceleration
In this model, the effective acceleration is colinear with the vector connecting the source of radiation and the target. The body undergoing the acceleration needs to have a radiation pressure model defined, while the body emitting radiation needs to have radiative properties defined.
 Returns:
Acceleration settings object.
 Return type:
Examples
In this example, we define the aerodynamic acceleration exerted by the Sun on the vehicle:
# Create acceleration dict accelerations_acting_on_vehicle = dict() # Add cannonball radiation pressure acceleration exerted by Sun accelerations_acting_on_vehicle["Sun"] = [propagation_setup.acceleration.cannonball_radiation_pressure()]
 spherical_harmonic_gravity(maximum_degree: int, maximum_order: int) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the spherical harmonic gravity acceleration.
Creates settings for the spherical harmonic gravity acceleration, accounting for a finite (given as input) number of degrees and orders. The direct acceleration (acceleration w.r.t. an inertial origin) is computed from:
\[\mathbf{a}=\mathbf{R}^{(I/B)}\nabla^{(B)}U(\mathbf{r})\]with \(\mathbf{r}\) the position vector measured from the center of mass of the body exerting the acceleration, \(\mathbf{R}^{(I/B)}\) the rotation matrix from bodyfixed to inertial frame, and \(\nabla^{(B)}\) the gradient operator in a bodyfixed frame, and \(U\) the spherical harmonic gravitational potential, expanded up to the provided
maximum_degree
andmaximum_order
.The body exerting the acceleration needs to have a spherical harmonic gravity field model (see
spherical_harmonic
) and a rotation model (rotation_model module) defined.Depending on the body undergoing the acceleration \(A\), the body exerting the acceleration \(B\), and the central body of propagation \(C\), choosing this option may create a direct spherical harmonic attraction (\(\mu=\mu_{B}\)), a central spherical harmonic attraction (\(\mu=\mu_{B}+\mu_{A}\)) or a thirdbody spherical harmonic attraction (see here for more details).
 Parameters:
 Returns:
Spherical harmonic acceleration settings object.
 Return type:
Examples
In this example, we define the spherical harmonic gravity acceleration (where the gravity field is expanded up to degree 12 and order 6) exerted by the Earth on the vehicle:
# Define the maximum degree and order maximum_degree = 12 maximum_order = 6 # Create acceleration dict accelerations_acting_on_vehicle = dict() # Add aerodynamic acceleration exerted by Earth accelerations_acting_on_vehicle["Earth"] = [propagation_setup.acceleration.spherical_harmonic_gravity( maximum_degree, maximum_order)]
 mutual_spherical_harmonic_gravity(maximum_degree_body_exerting: int, maximum_order_body_exerting: int, maximum_degree_body_undergoing: int, maximum_order_body_undergoing: int, maximum_degree_central_body: int = 0, maximum_order_central_body: int = 0) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the mutual spherical harmonic gravity acceleration.
Creates settings for the mutual spherical harmonic gravity acceleration. This model computes the total spherical harmonic acceleration exerted by a body \(B\) on a body \(A\), where the influence of the gravity field coefficients of body \(A\) itself has been included. The model includes couplings between the mass of each body, and the gravity field coefficients of the other body. It does not include the ‘figurefigure’ interactions (coupling between the twobodies’ gravity field coefficients). It corresponds to the model presented by Lainey et al. (2004); Dirkx et al. (2016). The model combines the spherical harmonic accelerations of the two bodies (see
spherical_harmonic()
) on each other. The direct acceleration (acceleration w.r.t. an inertial origin) is computed from:\[\mathbf{a}={\frac{\mu_{_{B}}}{{r}^{2}}\hat{\mathbf{r}}}+{\mathbf{R}^{(I/B)}\nabla^{(B)}U_{\hat{B}}(\mathbf{r})}{\frac{\mu_{_{B}}}{\mu_{_{A}}}\mathbf{R}^{(I/A)}\nabla^{(A)}U_{\hat{A}}(\mathbf{r})}\]where \(U_{\hat{B}}\) and \(U_{\hat{A}}\) denote the spherical harmonic gravity fields a degree \(>=1\) of bodies \(B\) and \(A\), respectively. Both the body exerting the acceleration and the body undergoing it need to have spherical harmonic gravity field and rotation models defined.
Depending on the body undergoing the acceleration \(A\), the body exerting the acceleration \(B\), and the central body of propagation \(C\), choosing this option may create a direct spherical harmonic attraction (as above), a central spherical harmonic attraction (\(\mu_{B}\rightarrow\mu_{B}+\mu_{A}\), in the above equation and in \(U_{\hat{B}}\)) or a thirdbody spherical harmonic attraction (see here for more details).
For the case where a thirdbody mutual spherical harmonic acceleration, additional parameters have to be provided that denote the expansion degree/order of the central body (
maximum_degree_central_body
andmaximum_order_central_body
) Parameters:
maximum_degree_body_exerting (int) – Maximum degree of the spherical harmonic expansion for the body exerting the acceleration.
maximum_order_body_exerting (int) – Maximum order of the spherical harmonic expansion for the body exerting the acceleration.
maximum_degree_body_undergoing (int) – Maximum degree of the spherical harmonic expansion for the body undergoing the acceleration.
maximum_order_body_undergoing (int) – Maximum order of the spherical harmonic expansion for the body undergoing the acceleration.
maximum_degree_central_body (int, default=0) – Maximum degree of the spherical harmonic expansion for the central body, if needed.
maximum_order_central_body (int, default=0) – Maximum order of the spherical harmonic expansion for the central body, if needed.
 Returns:
Spherical harmonic acceleration settings object.
 Return type:
Examples
In this example, we define the spherical harmonic gravity accelerations exerted on Io by Jupiter and viceversa.
# Define the maximum degree and order for both bodies maximum_degree_of_io = 12 maximum_order_of_io = 12 maximum_degree_of_jupiter = 4 maximum_order_of_jupiter = 4 # Create acceleration dict acceleration_settings_on_io = dict() # Add aerodynamic acceleration exerted by Earth acceleration_settings_on_io["Jupiter"] = [propagation_setup.acceleration.mutual_spherical_harmonic_gravity( maximum_degree_of_jupiter, maximum_order_of_jupiter, maximum_degree_of_io, maximum_order_of_io)]
For the case where the mutual spherical harmonic acceleration is a thirdbody acceleration, additional parameters have to be provided to denote the expansion of the spherical harmonics of the central body. In the following example, we consider the spherical harmonic gravity acceleration mutually exerted between Ganymede and Io when propagating w.r.t. Jupiter:
# Define the maximum degree and order for both bodies maximum_degree_of_jupiter = 4 maximum_order_of_jupiter = 4 maximum_degree_of_ganymede = 4 maximum_order_of_ganymede = 4 maximum_degree_of_io = 12 maximum_order_of_io = 12 # Create acceleration dict acceleration_settings_on_io = dict() # Add the acceleration to the dict acceleration_settings_on_io["Jupiter"] = [propagation_setup.acceleration.mutual_spherical_harmonic_gravity( maximum_degree_of_jupiter, maximum_order_of_jupiter, maximum_degree_of_ganymede, maximum_order_of_ganymede, maximum_degree_of_io, maximum_order_of_io)]
 polyhedron_gravity() tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the polyhedron gravity acceleration.
Creates settings for the polyhedron gravity acceleration, which follows from defining a body to have polyhedral gravity.
 Returns:
Acceleration settings object.
 Return type:
 ring_gravity() tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the ring gravity acceleration.
Creates settings for the ring gravity acceleration, which follows from defining a body to have ring gravity.
 Returns:
Acceleration settings object.
 Return type:
 relativistic_correction(use_schwarzschild: bool = False, use_lense_thirring: bool = False, use_de_sitter: bool = False, de_sitter_central_body: str = '', lense_thirring_angular_momentum: numpy.ndarray[numpy.float64[3, 1]] = array([0., 0., 0.])) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the relativistic acceleration correction.
Creates settings for typical relativistic acceleration corrections: the Schwarzschild, LenseThirring and de Sitter terms, where each of the three terms can be toggled on or of (see ‘General relativity and Space Geodesy’ by L. Combrinck, 2012). It implements the model of 2010 Conventions (chapter 10, section 3). Here, the ‘primary body’ for a planetary orbiter should always be set as the Sun (only relevant for de Sitter correction). The angular momentum vector of the orbited body is only relevant for LenseThirring correction.
 Parameters:
use_schwarzschild (bool, default=False) – Boolean defining whether or not to use the Schwarzschild contribution to the acceleration correction
use_lense_thirring (bool) – Boolean defining whether or not to use the LenseThirring contribution to the acceleration correction
use_de_sitter (bool, default=False) – Boolean defining whether or not to use the de Sitter contribution to the acceleration correction
de_sitter_central_body (str, default="") – Body used as ‘perturbed’ in the calculation of the de Sitter acceleration. For the case of an Earthorbiting satellite, this would be the Sun
lense_thirring_angular_momentum (numpy.ndarray, default=numpy.array([0, 0, 0])) – Angular momentum vector per unit mass (in global frame) that is to be used for the calculation of the LenseThirring acceleration
 Returns:
Relativistic acceleration correction settings object.
 Return type:
Examples
In this example, we define the relativistic correction acceleration for a Mars orbiter:
# Select terms to be used use_schwarzschild = True use_lense_thirring = True use_de_sitter = True # Define central body for DeSitter term de_sitter_central_body = "Sun" # Define angular momentum for the LenseThirring term lense_thirring_angular_momentum = ... # numpy.ndarray 3D vector # Create acceleration dict acceleration_settings_on_vehicle = dict() # Add the acceleration to the dict acceleration_settings_on_vehicle["Mars"] = [propagation_setup.acceleration.relativistic_correction( use_schwarzschild, use_lense_thirring, use_de_sitter, de_sitter_central_body, lense_thirring_angular_momentum)]
 empirical(constant_acceleration: numpy.ndarray[numpy.float64[3, 1]] = array([0., 0., 0.]), sine_acceleration: numpy.ndarray[numpy.float64[3, 1]] = array([0., 0., 0.]), cosine_acceleration: numpy.ndarray[numpy.float64[3, 1]] = array([0., 0., 0.])) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for empirical acceleration.
Creates settings for empirical accelerations. These are expressed in the RSW frame, for which the magnitude is determined empirically (typically during an orbit determination process). The acceleration components are defined according to Montenbruck and Gill (2000), with a total of 9 components: a constant, sine and cosine term (with true anomaly as argument) for each of the three independent directions of the RSW frame. The empirical acceleration is calculated as:
\[\mathbf{a}=R^{I/RSW}\left(\mathbf{a}_{\text{const.}}+\mathbf{a}_{\sin}\sin\theta+\mathbf{a}_{\cos}\cos\theta \right)\]Here, \(R^{I/RSW}\) is the rotation matrix from the RSW frame (of the body undergoing the acceleration w.r.t. the body exerting the acceleration), \(theta\) is the true anomaly, and the three constituent acceleration vectors are the inputs provided in the above code block. The body ‘exerting’ the acceleration is considered to be the central body, w.r.t. which the true anomaly is calculated.
 Parameters:
constant_acceleration (numpy.ndarray, default=numpy.array([0, 0, 0])) – Constant term, defined in the RSW frame.
sine_acceleration (numpy.ndarray, default=numpy.array([0, 0, 0])) – Sine term (function of the true anomaly), defined in the RSW frame..
cosine_acceleration (numpy.ndarray, default=numpy.array([0, 0, 0])) – Cosine term (function of the true anomaly), defined in the RSW frame..
 Returns:
Empirical acceleration settings object.
 Return type:
Examples
In this example, we define the empirical acceleration acting on the vehicle. The body that ‘exerts’ the acceleration is here used to determine the body w.r.t. which the true anomaly has o be calculated when determining the sine/cosine contributions. This central body must be endowed with a gravity field (so that it possesses a gravitational parameter for the Cartesian to Keplerian conversion)
# Define the nine terms (constant, sine and cosine) constant_acceleration = ... # 3D numpy.ndarray vector sine_acceleration = ... # 3D numpy.ndarray vector cosine_acceleration = ... # 3D numpy.ndarray vector # Create acceleration dict acceleration_settings_on_vehicle = dict() # Add the acceleration to the dict acceleration_settings_on_vehicle["Sun"] = [propagation_setup.acceleration.empirical( constant_acceleration, sine_acceleration, cosine_acceleration)]
 custom_acceleration(acceleration_function: Callable[[float], numpy.ndarray[numpy.float64[3, 1]]]) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for custom acceleration.
Creates settings for a custom accelerations, this acceleration must be parameterized as a function of time, and expressed with an inertial orientation.
 Parameters:
acceleration_function (callable[[float], list]) – Custom acceleration function with time as an independent variable, returning the acceleration in an inertial frame (e.g. with global frame orientation) as a function of time.
 Returns:
Custom acceleration settings object.
 Return type:
Examples
In this example, we define a simple, standalone, custom acceleration (depending only on time), with the following (arbitrary, for the sake of example) mathematical definition:
\[\begin{split}\mathbf{a}=\begin{pmatrix}C\\0\\0 \end{pmatrix}\sin\left(\frac{tt_{0}}{T}\right)\end{split}\]with \(C=10^{8}\), \(t_{0}=0\) and \(T=86400\). More complex custom acceleration functions can be created by, for instance, extracting the custom function from a userdefined class, which may in turn have other simulation objects (e.g.
SystemOfBodies
) as members, allowing the custom acceleration to depend on the current simulation state/environment# Define custom function def custom_function( current_time ): period = 86400.0 reference_time = 0.0 phase = np.pi * ( current_time  reference_time ) / period return np.array([1.0E8, 0.0, 0.0]) * np.sin(phase) acceleration_settings_on_vehicle["Vehicle"] = [propagation_setup.acceleration.custom_acceleration( custom_function)]
 direct_tidal_dissipation_acceleration(*args, **kwargs)¶
Overloaded function.
direct_tidal_dissipation_acceleration(k2_love_number: float, time_lag: float, include_direct_radial_component: bool = True, use_tide_raised_on_planet: bool = True, explicit_libraional_tide_on_satellite: bool = False) > tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings
Creates settings for tidal acceleration.
Creates settings for tidal accelerations. The direct of tidal effects in a satellite system is applied directly as an acceleration (as opposed to a modification of spherical harmonic coefficients). The model is based on Lainey et al. (2007, 2012). It can compute the acceleration due to tides, and in particular tidal dissipation, on a planetary satellite. The acceleration computed can account for either the effect of tide raised on the satellite by the planet or on the planet by the satellite. The satellite is assumed to be tidally locked to the planet.
 Parameters:
k2_love_number (float) – Value of the k2 Love number.
time_lag (float) – Value of the tidal time lag.
include_direct_radial_component (bool, default=True) – It denotes whether the term independent of the time lag is to be computed.
use_tide_raised_on_planet (bool, default=True) – It denotes whether the tide raised on the planet is to be modelled (if true) or the tide raised on the satellite (if false).
 Returns:
Direct tidal dissipation acceleration settings object.
 Return type:
Examples
In this example, we define the tidal dissipation exerted by Jupiter on Io directly, instead of computing it through the spherical harmonic gravity:
# Define parameters love_number = 0.1 time_lag = 100.0 # Add entry to acceleration settings dict acceleration_settings_on_io["Jupiter"] = [propagation_setup.acceleration.direct_tidal_dissipation( love_number, time_lag, False, False)]
direct_tidal_dissipation_acceleration(k2_love_number: float, inverse_tidal_quality_factor: float, tidal_period: float, include_direct_radial_component: bool = True, use_tide_raised_on_planet: bool = True, explicit_libraional_tide_on_satellite: bool = False) > tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings
Creates settings for tidal acceleration.
Creates settings for tidal accelerations. The direct of tidal effects in a satellite system is applied directly as an acceleration (as opposed to a modification of spherical harmonic coefficients). The model is based on Lainey et al. (2007, 2012). It can compute the acceleration due to tides, and in particular tidal dissipation, on a planetary satellite. The acceleration computed can account for either the effect of tide raised on the satellite by the planet or on the planet by the satellite. The satellite is assumed to be tidally locked to the planet.
 Parameters:
k2_love_number (float) – Value of the k2 Love number.
time_lag (float) – Value of the tidal time lag.
include_direct_radial_component (bool, default=True) – It denotes whether the term independent of the time lag is to be computed.
use_tide_raised_on_planet (bool, default=True) – It denotes whether the tide raised on the planet is to be modelled (if true) or the tide raised on the satellite (if false).
 Returns:
Direct tidal dissipation acceleration settings object.
 Return type:
Examples
In this example, we define the tidal dissipation exerted by Jupiter on Io directly, instead of computing it through the spherical harmonic gravity:
# Define parameters love_number = 0.1 time_lag = 100.0 # Add entry to acceleration settings dict acceleration_settings_on_io["Jupiter"] = [propagation_setup.acceleration.direct_tidal_dissipation( love_number, time_lag, False, False)]
 quasi_impulsive_shots_acceleration(thrust_mid_times: list[float], delta_v_values: list[numpy.ndarray[numpy.float64[3, 1]]], total_maneuver_time: float, maneuver_rise_time: float) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for incorporating quasiimpulsive shots into the acceleration.
The acceleration model is purposebuilt to represent short bursts of thrust, such as a momentum wheel desaturation. A typical use case is precise orbit determination, but the functionality can be used just as well in propagation (for instance to model an impulsive manuever in a continuous manner when going from preliminary modelling to full modelling). The thrust is modelled similarly to Fig. 3 of Alessi et al. (2012), with the main difference being that a thirdorder polynomial to go from zero acceleration to the maximum acceleration level is employed. By using a 3rdorder polynomial and imposing continuity in the value and first derivative of the acceleration, defining the rise time (time it takes acceleration to go from 0 to its maximum level), the total time where there is nonzero thrust (total maneuver time), and the total Delta V exerted by a single maneuver, the acceleration profile is fully defined.
 Parameters:
thrust_mid_times (list[float]) – Set of middle point in times in the maneuver denoting the epoch of each maneuver.
delta_v_values (list[numpy.ndarray]) – Set of delta V, one for each maneuver.
total_maneuver_time (float) – Total duration of every maneuver.
maneuver_rise_time (float) – Time taken by the acceleration to go from zero to its maximum level.
 Returns:
Momentum wheel desaturation acceleration settings object.
 Return type:
Examples
In this example, we define an acceleration model to represent two quasiimpulsive shots, with a total duration of 30 seconds, and a rise time of 5 seconds. The maneuvers are to be done at \(t=86400\) and \(t=2*86400\). The first maneuver is exclusively in \(x\)direction, and the second one exclusively in \(y\)direction, with both maneuvers having a magnitude of 1 mm/s
# Define the quasiimpulsive shot settings mid_times = [ 86400.0, 2.0 * 86400.0] delta_v_values = [ np.array([1.0E3, 0.0, 0.0]), np.array([0.0, 1.0E3, 0.0]) ] maneuver_duration = 30 maneuver_duration = 5 # Create acceleration dict acceleration_settings_on_spacecraft = dict() # Add quasiimpulsive acceleration exerted by Spacecraft itself (!) acceleration_settings_on_spacecraft["Spacecraft"] = [propagation_setup.acceleration.quasi_impulsive_shots_acceleration( mid_times, delta_v_values, maneuver_duration, maneuver_duration)]
 thrust_from_engines(engine_names: list[str]) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for thrust acceleration using a list of engine models.
Creates settings for thrust acceleration using a list of engine models. See the user guide for more details on the definition of a thrust model in Tudat.
 Parameters:
engine_names (List[str]) – List of engine names to use when computing thrust.
 Returns:
Thrust acceleration settings object.
 Return type:
 thrust_from_engine(engine_name: str) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for thrust acceleration using a single engine models.
Creates settings for thrust acceleration using a single engine models. See the user guide for more details on the definition of a thrust model in Tudat.
 Parameters:
engine_name (str) – Name of engine to use when computing thrust.
 Returns:
Thrust acceleration settings object.
 Return type:
 thrust_from_all_engines() tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for thrust acceleration using a single engine models.
Creates settings for thrust acceleration by combining thrust from all engines defined in the body. See the user guide for more details on the definition of a thrust model in Tudat.
 Returns:
Thrust acceleration settings object.
 Return type:
 yarkovsky(yarkovsky_parameter: float) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings ¶
Creates settings for the Yarkovsky acceleration.
Creates settings for the Yarkovsky acceleration, which is calculated based on PérezHernández & Benet (2022). The acceleration is only considered in the tangential direction and is proportional to:
\[\mathbf{a}=A_{2} \cdot (\frac{r_{0}}{r_{S}})^{2}\]where \(A_{2}\) is the Yarkovsky parameter, \(r_{0} = 1\) AU and \(r_{S}\) is the heliocentric distance in AU.
 Parameters:
yarkovsky_parameter (float) – Value of the Yarkovsky parameter.
 Returns:
Acceleration settings object.
 Return type:
Enumerations¶
Enumeration of available acceleration types. 
 class AvailableAcceleration¶
Enumeration of available acceleration types.
Enumeration of acceleration types supported by tudat.
Members:
undefined_acceleration_type :
point_mass_gravity_type :
aerodynamic_type :
cannonball_radiation_pressure_type :
spherical_harmonic_gravity_type :
mutual_spherical_harmonic_gravity_type :
polyhedron_gravity_type :
ring_gravity_type :
thrust_acceleration_type :
relativistic_correction_acceleration_type :
empirical_acceleration_type :
direct_tidal_dissipation_in_central_body_acceleration_type :
direct_tidal_dissipation_in_orbiting_body_acceleration_type :
quasi_impulsive_shots_acceleration_type :
custom_acceleration_type :
radiation_pressure_type :
 property name¶
Classes¶
Functional base class to define settings for accelerations. 

AccelerationSettingsderived class to define settings for the spherical harmonic acceleration. 

AccelerationSettingsderived class to define settings for the mutual spherical harmonic acceleration. 

AccelerationSettingsderived class to define settings for the relativistic acceleration correction. 

AccelerationSettingsderived class to define settings for the empirical acceleration. 

AccelerationSettingsderived class to define settings for custom acceleration. 

AccelerationSettingsderived class to define settings for direct tidal dissipation acceleration. 

AccelerationSettingsderived class to define settings for thrust acceleration, listing the engine models that are to be used 

AccelerationSettingsderived class to define settings for momentum wheel desaturation acceleration. 
 class AccelerationSettings¶
Functional base class to define settings for accelerations.
Class for providing settings for acceleration model. This class is a functional (base) class for settings of acceleration models that require no information in addition to their type. Classes defining settings for acceleration models requiring additional information must be derived from this class. Bodies exerting and undergoing acceleration are set externally from this class. This class can be used for the easy setup of acceleration models (see createAccelerationModels.h), but users may also chose to do so manually. (Derived) Class members are all public, for ease of access and modification.
 class SphericalHarmonicAccelerationSettings¶
AccelerationSettingsderived class to define settings for the spherical harmonic acceleration.
Class for providing settings for spherical harmonics acceleration model, including the maximum degree and order up to which the field is to be expanded. Note that the minimum degree and order are currently always set to zero.
 class MutualSphericalHarmonicAccelerationSettings¶
AccelerationSettingsderived class to define settings for the mutual spherical harmonic acceleration.
Class for providing settings for the mutual spherical harmonics acceleration model, including the maximum degree and order up to which the fields of the bodies are to be expanded. Note that the minimum degree and order are currently always set to zero.
 class RelativisticAccelerationCorrectionSettings¶
AccelerationSettingsderived class to define settings for the relativistic acceleration correction.
Class to provide settings for typical relativistic corrections to the dynamics of an orbiter: the Schwarzschild, LenseThirring and de Sitter terms (see ‘General relativity and Space Geodesy’ by L. Combrinck, 2012).
 class EmpiricalAccelerationSettings¶
AccelerationSettingsderived class to define settings for the empirical acceleration.
Class to provide settings for empirical accelerations. These are expressed in the RSW frame, for which the magnitude is determined empirically (typically during an orbit determination process). The acceleration components are defined according to Montenbruck and Gill (2000), with a total of 9 components: a constant, sine and cosine term (with true anomaly as argument) for each of the three independent directions of the RSW frame.
 class CustomAccelerationSettings¶
AccelerationSettingsderived class to define settings for custom acceleration.
Class to provide settings for custom accelerations. This is done by means of a function and, if necessary, an associated scaling function.
 class DirectTidalDissipationAccelerationSettings¶
AccelerationSettingsderived class to define settings for direct tidal dissipation acceleration.
Class to provide settings for direct tidal dissipation accelerations. Creates settings for tidal accelerations. The direct of tidal effects in a satellite system is applied directly as an acceleration (as opposed to a modification of spherical harmonic coefficients).
 class ThrustAccelerationSettings¶
AccelerationSettingsderived class to define settings for thrust acceleration, listing the engine models that are to be used
Class to provide settings for thrust acceleration, listing the engine models that are to be used
 class MomentumWheelDesaturationAccelerationSettings¶
AccelerationSettingsderived class to define settings for momentum wheel desaturation acceleration.
Class to provide settings for momentum wheel desaturation acceleration. Settings for the direction and magnitude of the thrust are included.