# Available Acceleration Models

In this page, all the acceleration models available in TudatPy are explained. Regardless of the type of acceleration model, the procedure to link such acceleration model to the bodies exerting and undergoing the acceleration is explained in this page: Acceleration Model Setup. Therefore, this information will not be repeated in this page. Instead, for each model, a reference to the related API documentation entry and the requirements are provided.

Note

In TudatPy, acceleration models are defined through factory functions, which define the properties required of
the accelerations, but do not perform any calculations themselves. These properties are stored through instances
of the `AccelerationSettings`

class or of its
derived classes.

List of available acceleration models

In certain pieces of code, such as when requesting the saving of a single acceleration (see Dependent Variables
for saving of dependent variables), you will need to supply an identifier for the type of acceleration you are requesting.
See the list of supported identifier types in the API documentation: `AvailableAcceleration`

.

## Gravitational

TudatPy contains a number of different models for gravitational accelerations. In general, the gravitational acceleration exerted by a body B, with associated potential \(U_{B}\), on a body A can be expressed as follows:

with \(\mathbf{r}_{_{BA}}(=\mathbf{r}_{_{B}}-\mathbf{r}_{_{A}})\) denoting the relative position vector of body A with respect to Body B.

There are different gravitational models available in TudatPy:

These are explained in more detail below.

### Point Mass Gravity

**Description**

`point_mass_gravity()`

factory function.**Dependencies**

### Spherical Harmonic Gravity

**Description**

`spherical_harmonic_gravity()`

factory function.**Dependencies**

Note

The spherical harmonic acceleration up to degree N and order M includes the point-mass gravity acceleration (which is the degree and order 0 term).

### Mutual Spherical Harmonic Gravity

**Description**

`mutual_spherical_harmonic_gravity()`

factory function. This model is typically only used for detailed propagation of planetary systems. With additional
parameters, it can
be used even if the bodies mutually exerting the spherical harmonic gravity acceleration are not the central body.**Dependencies**

### Third Body Gravity vs. Central Gravity

**Description**

**third-body acceleration**. In Tudat, however, you do

*not*specify directly whether an acceleration is a ‘third-body’ acceleration. This is fully defined by what you’ve chosen as your center of propagation (see Translational Dynamics), and the bodies exerting and undergoing the acceleration. Similarly, when calculating the dynamics of a massive body, a correction is required for expressing the gravitational acceleration exerted by the propagation origin (

*e.g.*acceleration exerted by Earth on Moon, with Earth as propagation origin). We term this the ‘central’ acceleration.

**Dependencies**

See also

For more details: Third-body accelerations.

## Aerodynamic

**Description**

`aerodynamic()`

factory function.**Dependencies**

Note

The aerodynamic acceleration is calculated in the vehicles body-fixed or aerodynamic frame. Expressing the
acceleration in an inertial frame (as required by the propagation) requires the vehicle’s orientation to be defined.
For a simple definition, in which the body’s angle of attack, sideslip angle, and bank angle are all set to 0, see
`aerodynamic_angle_based()`

.

More details on aerodynamic guidance can be found on this page.

## Radiation Pressure

There are two different radiation pressure models available in TudatPy:

The distinction between them lies in the type of radiation pressure interface that is used for the body undergoing acceleration (see below).

### Cannonball Radiation Pressure

**Description**

`cannonball_radiation_pressure()`

factory function.**Dependencies**

### Panelled Radiation Pressure

**Description**

`panelled_radiation_pressure()`

factory function.**Dependencies**

## Relativistic Correction

**Description**

`relativistic_correction()`

factory function. This is a first-order (in 1/c^2) correction to the acceleration due to the influence of relativity
for a massless body (e.g. spacecraft) orbiting a massive body (e.g. Earth), which in turn orbits a third body (e.g.
Sun), consisting of three distinct effects: the Schwarzschild, Lense-Thirring and de Sitter accelerations.**Dependencies**

Mass of the orbited body and the third body (de Sitter only)

Current state of body undergoing acceleration, the orbited body, and the third body (de Sitter only)

## Empirical

**Description**

`empirical()`

factory function. This is constant/once-per-orbit acceleration, expressed in the RSW frame (see for instance
`inertial_to_rsw_rotation_matrix()`

), for which the magnitude is determined
empirically (typically during an orbit determination process).**Dependencies**

## Thrust

**Description**

`thrust_from_engine()`

(use single specific engine)

`thrust_from_engines()`

(use multiple specific engines)

`thrust_from_all_engines()`

(use all engines)Which differ only in the manner in which the user selects the engine model(s) this is(are) to be used for calculating the thrust. The details of the model used for the thrust is given on a dedicated page

**Dependencies**

## Tidal effect on natural satellites

**Description**

`direct_tidal_dissipation_acceleration()`

factory function. It is a rather specialist model, which is only relevant for the dynamics of natural satellites
themselves. When calculating the dynamics of spacecraft orbiting natural satellites, use gravity field variations
instead. Two types of accelerations can be computed: acceleration on the satellite due to tide on the planet, or
acceleration on the satellite due to tide on the satellite.**Dependencies**

## Quasi-Impulsive Shot

**Description**

`quasi_impulsive_shots_acceleration()`

factory function. This is a manner in which to incorporate short bursts of thrust into a numerical propagation.
When using this model, ensure that your integration step is sufficiently small to be able to capture the burst of
thrust.**Dependencies**