acceleration
#
This module provides the functionality for creating acceleration settings.
Functions#
Creates settings for the pointmass gravity acceleration. 

Creates settings for the aerodynamic 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 relativistic acceleration correction. 

Creates settings for empirical acceleration. 

Creates settings for custom acceleration. 

Creates settings for custom acceleration. 
Creates settings for incorporating quasiimpulsive shots into the acceleration. 

Creates settings for thrust acceleration from thrust guidance settings. 

Creates settings for thrust acceleration using a custom userdefined thrust function. 

Creates settings for thrust acceleration using a custom userdefined thrust and specific impulse functions. 
 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 (gravity_field 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()]
 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 aerodynamic acceleration exerted by Earth 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)]
 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 (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_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( custom_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) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings #
Creates settings for custom 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 :math:`x`direction, and the second one exclusively in :math:`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_direction_and_magnitude(thrust_direction_settings: tudatpy.kernel.numerical_simulation.propagation_setup.thrust.ThrustDirectionSettings, thrust_magnitude_settings: tudatpy.kernel.numerical_simulation.propagation_setup.thrust.ThrustMagnitudeSettings) tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings #
Creates settings for thrust acceleration from thrust guidance settings.
Creates settings for thrust acceleration from thrust guidance settings. The thrust direction and magnitude are supplied separately in the form of dedicated settings objects (see the API for the respective classes in the thrust module).
 Parameters
thrust_direction_settings (ThrustDirectionSettings) – Thrust direction settings object.
thrust_magnitude_settings (ThrustMagnitudeSettings) – Thrust magnitude settings object.
 Returns
Thrust acceleration settings object.
 Return type
Examples
In this example, we define thrust along the velocity vector (w.r.t. Earth), with a constant magnitude of 10 N and \(I_{sp}\) of 300 s
# Define thrust direction and magnitude thrust_direction_settings = ( propagation_setup.thrust.thrust_direction_from_state_guidance( central_body="Earth", is_colinear_with_velocity=True, direction_is_opposite_to_vector=False ) ) thrust_magnitude_settings = ( propagation_setup.thrust.constant_thrust_magnitude( thrust_magnitude=10, specific_impulse=300 ) ) # Create acceleration dict acceleration_settings_on_spacecraft = dict() # Add thrust exerted by Spacecraft itself (!) acceleration_settings_on_spacecraft ["Spacecraft" ] =[ propagation_setup.acceleration.thrust_from_direction_and_magnitude( thrust_direction_settings=thrust_direction_settings, thrust_magnitude_settings=thrust_magnitude_settings, ) ]
 thrust_from_custom_function(thrust_force_function: Callable[[float], numpy.ndarray[numpy.float64[3, 1]]], specific_impulse_function: Callable[[float], float], thrust_frame: tudatpy.kernel.numerical_simulation.propagation_setup.thrust.ThrustFrames = <ThrustFrames.inertial_thrust_frame_type: 0>, central_body: str = '') tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings #
Creates settings for thrust acceleration using a custom userdefined thrust function.
Creates settings for thrust acceleration from a userdefined function providing the thrust as a function of time. This function may be defined in any number of ways, such as an interpolator, or a custom function that directly accesses the environment. The custom thrust function returns the total thrust force vector in the specified frame (default inertial, e.g. axes along the global orientation of the environment).
 Parameters
thrust_force_function (callable[[float], numpy.ndarray[numpy.float64[3, 1]]]) – Function returning the thrust force vector, in the specified frame, as a function of time
constant_specific_impulse (float) – Constant specific impulse.
thrust_frame (ThrustFrames, default=inertial_thrust_frame) – Frame in which the thrust direction vector is represented.
central_body (str, default="") – Central body that is the origin of the thrust frame (if different from the vehicle, otherwise empty by default).
 Returns
Thrust acceleration settings object.
 Return type
Examples
In this example, we define the full thrust force using a cubicspline interpolator, and a constant specific impulse. In this example, the thrust in the interpolated dict is applied in the TNW frame
# Define dict that is to hold thrust at data points that are to be interpolated thrust_per_epoch = dict( ) # Define thrust per epoch (manually or externally) thrust_per_epoch[ ... ] = ... # Create thrust interpolator interpolator_settings = math.interpolators.cubic_spline_interpolation( ) thrust_interpolator = math.interpolators.create_one_dimensional_interpolator( thrust_per_epoch, interpolator_settings ) # Create acceleration dict acceleration_settings_on_spacecraft = dict() # Add thrust exerted by Spacecraft itself (!) acceleration_settings_on_spacecraft ["Spacecraft" ] =[ propagation_setup.acceleration.thrust_from_custom_function( thrust_force_function = thrust_interpolator.interpolate, constant_specific_impulse = 300.0, thrust_frame = propagation_setup.thrust.tnw_thrust_frame_type ) ]
 thrust_and_isp_from_custom_function(thrust_force_function: Callable[[float], numpy.ndarray[numpy.float64[3, 1]]], constant_specific_impulse: float, thrust_frame: tudatpy.kernel.numerical_simulation.propagation_setup.thrust.ThrustFrames = <ThrustFrames.inertial_thrust_frame_type: 0>, central_body: str = '') tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings #
Creates settings for thrust acceleration using a custom userdefined thrust and specific impulse functions.
As
thrust_from_custom_function()
, but with the specific impulse defined by a custom function (with time as input) Parameters
thrust_force_function (callable[[float], numpy.ndarray[numpy.float64[3, 1]]]) – Function returning the thrust force vector, in the specified frame, as a function of time
specific_impulse_function (callable[[float], float]) – Specific impulse provided as a function of time.
thrust_frame (ThrustFrames, default=inertial_thrust_frame) – Frame in which the thrust direction vector is represented.
central_body (str, default="") – Central body that is the origin of the thrust frame (if different from the vehicle, otherwise empty by default).
 Returns
Thrust 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 :
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 :
panelled_radiation_pressure_acceleration_type :
quasi_impulsive_shots_acceleration_type : No documentation found.
solar_sail_acceleration_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 direct tidal dissipation acceleration. 

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 direct tidal dissipation acceleration.
Class to provide settings for thrust acceleration. Settings for the direction and magnitude of the thrust are included.
 direction_settings#
Thrust direction settings object.
 magnitude_settings#
Thrust magnitude settings object.
 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.