`acceleration`#

Functions#

`point_mass_gravity`()	Creates settings for the point-mass gravity acceleration.
`aerodynamic`()	Creates settings for the aerodynamic acceleration.
`cannonball_radiation_pressure`()	Creates settings for the cannonball radiation pressure acceleration.
`spherical_harmonic_gravity`(maximum_degree, ...)	Creates settings for the spherical harmonic gravity acceleration.
`mutual_spherical_harmonic_gravity`(...[, ...])	Creates settings for the mutual spherical harmonic gravity acceleration.
`relativistic_correction`([use_schwarzschild, ...])	Creates settings for the relativistic acceleration correction.
`empirical`([constant_acceleration, ...])	Creates settings for empirical acceleration.
`custom_acceleration`(acceleration_function)	Creates settings for custom acceleration.
`direct_tidal_dissipation_acceleration`(...[, ...])	Creates settings for custom acceleration.
`quasi_impulsive_shots_acceleration`(...)	Creates settings for incorporating quasi-impulsive shots into the acceleration.
`thrust_from_engines`(engine_names)	Creates settings for thrust acceleration using a list of engine models.
`thrust_from_engine`(engine_name)	Creates settings for thrust acceleration using a single engine models.
`thrust_from_all_engines`()	Creates settings for thrust acceleration using a single engine models.

point_mass_gravity() → tudatpy.kernel.numerical_simulation.propagation_setup.acceleration.AccelerationSettings#

Creates settings for the point-mass gravity acceleration.

Creates settings for the point-mass 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 point-mass attraction (\(\mu=\mu_{B}\)), a central point-mass attraction (\(\mu=\mu_{B}+\mu_{A}\)) or a third-body point-mass attraction (see here for more details).

Returns:: Acceleration settings object.
Return type:: AccelerationSettings

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:: AccelerationSettings

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:: AccelerationSettings

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 body-fixed to inertial frame, and \(\nabla^{(B)}\) the gradient operator in a body-fixed frame, and \(U\) the spherical harmonic gravitational potential, expanded up to the provided maximum_degree and maximum_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 third-body spherical harmonic attraction (see here for more details).

Parameters:

maximum_degree (int) – Maximum degree of the spherical harmonic expansion.
maximum_order (int) – Maximum order of the spherical harmonic expansion.

Returns:

Spherical harmonic acceleration settings object.

Return type:

SphericalHarmonicAccelerationSettings

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 ‘figure-figure’ interactions (coupling between the two-bodies’ 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 third-body spherical harmonic attraction (see here for more details).

For the case where a third-body mutual spherical harmonic acceleration, additional parameters have to be provided that denote the expansion degree/order of the central body (maximum_degree_central_body and maximum_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:

MutualSphericalHarmonicAccelerationSettings

Examples

In this example, we define the spherical harmonic gravity accelerations exerted on Io by Jupiter and vice-versa.

# 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 third-body 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, Lense-Thirring 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 Lense-Thirring 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 Lense-Thirring 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 Earth-orbiting 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 Lense-Thirring acceleration

Returns:

Relativistic acceleration correction settings object.

Return type:

RelativisticAccelerationCorrectionSettings

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 De-Sitter term
de_sitter_central_body = "Sun"
# Define angular momentum for the Lense-Thirring 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:

EmpiricalAccelerationSettings

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:: CustomAccelerationSettings

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{t-t_{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 user-defined 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.0E-8, 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, explicit_libraional_tide_on_satellite: bool = False) → 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:

DirectTidalDissipationAccelerationSettings

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 quasi-impulsive shots into the acceleration.

The acceleration model is purpose-built 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 third-order polynomial to go from zero acceleration to the maximum acceleration level is employed. By using a 3rd-order 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 non-zero 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:

MomentumWheelDesaturationAccelerationSettings

Examples

In this example, we define an acceleration model to represent two quasi-impulsive 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 quasi-impulsive shot settings
mid_times = [ 86400.0, 2.0 * 86400.0]
delta_v_values = [ np.array([1.0E-3, 0.0, 0.0]), np.array([0.0, 1.0E-3, 0.0]) ]
maneuver_duration = 30
maneuver_duration = 5

# Create acceleration dict
acceleration_settings_on_spacecraft = dict()

# Add quasi-impulsive 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:: ThrustAccelerationSettings

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:: ThrustAccelerationSettings

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 thryst 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:: ThrustAccelerationSettings

Enumerations#

AvailableAcceleration

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 : No documentation found.

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#

`AccelerationSettings`	Functional base class to define settings for accelerations.
`SphericalHarmonicAccelerationSettings`	AccelerationSettings-derived class to define settings for the spherical harmonic acceleration.
`MutualSphericalHarmonicAccelerationSettings`	AccelerationSettings-derived class to define settings for the mutual spherical harmonic acceleration.
`RelativisticAccelerationCorrectionSettings`	AccelerationSettings-derived class to define settings for the relativistic acceleration correction.
`EmpiricalAccelerationSettings`	AccelerationSettings-derived class to define settings for the empirical acceleration.
`CustomAccelerationSettings`	AccelerationSettings-derived class to define settings for custom acceleration.
`DirectTidalDissipationAccelerationSettings`	AccelerationSettings-derived class to define settings for direct tidal dissipation acceleration.
`ThrustAccelerationSettings`	AccelerationSettings-derived class to define settings for thrust acceleration, listing the engine models that are to be used
`MomentumWheelDesaturationAccelerationSettings`	AccelerationSettings-derived 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#

AccelerationSettings-derived 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#

AccelerationSettings-derived 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#

AccelerationSettings-derived 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, Lense-Thirring and de Sitter terms (see ‘General relativity and Space Geodesy’ by L. Combrinck, 2012).

class EmpiricalAccelerationSettings#

AccelerationSettings-derived 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#

AccelerationSettings-derived 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#

AccelerationSettings-derived 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#

AccelerationSettings-derived 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#

AccelerationSettings-derived 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.

acceleration#

Functions#

Enumerations#

Classes#

`acceleration`#