propagation

Propagation of objects using orbital mechanics, this includes a simplified 2 body model as well as a N body model which includes some general relativistic effects.

class kete.propagation.NonGravModel

Non-gravitational force models.

This is used optionally by the N-Body propagation methods to compute orbits including non-gravitational forces, such as solar radiation pressure, or poynting-robertson force.

There are two generic non-gravitational models available, one is specifically intended for dust modeling, and includes the solar radiation pressure, the other model is a mathematical match to the JPL Horizons comet model.

See NonGravModel.new_dust() and NonGravModel.new_comet() for more details. Note that the Comet model can also represent asteroids which undergo the Yarkovsky effect, see NonGravModel.new_asteroid(), which is a convenience function over the NonGravModel.new_comet() method, but with 1/r^2 falloff.

static new_asteroid(a1, a2, a3, alpha=1.0, r_0=1.0, m=2.0, n=1.0, k=0.0, dt=0.0)

This is the same as NonGravModel.new_comet(), but with default values set so that \(g(r) = 1/r^2\).

See NonGravModel.new_comet() for more details.

static new_comet(a1=0.0, a2=0.0, a3=0.0, alpha=0.1112620426, r_0=2.808, m=2.15, n=5.093, k=4.6142, dt=0.0)

JPL’s non-gravitational forces are modeled as defined on page 139 of the Comets II textbook.

This model adds 3 “A” terms to the acceleration which the object feels. These A terms represent additional radial, tangential, and normal forces on the object.

The defaults of this method are the defaults that JPL Horizons uses for comets when they are not otherwise specified.

\[\text{accel} = A_1 g(r) \vec{r} + A_2 g(r) \vec{t} + A_3 g(r) \vec{n}\]

Where \(\vec{r}\), \(\vec{t}\), \(\vec{n}\) are the radial, tangential, and normal unit vectors for the object.

The \(g(r)\) function is defined by the equation:

\[g(r) = \alpha \big(\frac{r}{r_0}\big) ^ {-m} \bigg(1 + \big(\frac{r}{r_0}\big) ^ n\bigg) ^ {-k}\]

When alpha=1.0, n=0.0, k=0.0, r0=1.0, and m=2.0, this is equivalent to a \(1/r^2\) correction.

This includes an optional time delay, which the non-gravitational forces are time delayed.

static new_dust(beta)

Create a new non-gravitational forces Dust model.

This implements the radiative force model presented in: “Radiation forces on small particles in the solar system” Icarus, Vol 40, Issue 1, Pages 1-48, 1979 Oct https://doi.org/10.1016/0019-1035(79)90050-2

The model calculated has the acceleration of the form:

\[\text{accel} = \frac{L_0 A Q_{pr}}{r^2 c m} \bigg((1 - \frac{\dot{r}}{c}) \vec{S} - \vec{v} / c \bigg)\]

Where \(L_0\) is the luminosity of the Sun, A is the effective cross sectional area of the dust, \(Q_{pr}\) is a scattering coefficient (~1 for dust larger than about 0.1 micron), m mass, c speed of light, and r heliocentric distance.

The vectors on the right are \(\vec{S}\) the position with respect to the Sun. \(\vec{v}\) the velocity with respect to the Sun. \(\dot{r}\) is the radial velocity toward the sun.

This equation includes both the effects from solar radiation pressure in addition to the Poynting-Robertson effect. By neglecting the Poynting-Robertson components of the above formula, it is possible to find a mapping from the standard \(\beta\) formalism to the above coefficient:

\[\beta = \frac{L_0 A Q_{pr}}{c m G}\]

Where G is the solar standard gravitational parameter (GM). Making the above equation equivalent to:

\[\text{accel} = \frac{\beta G}{r^2} \bigg((1 - \frac{\dot{r}}{c}) \vec{S} - \vec{v} / c \bigg)\]

kete.propagation.moid(state_a, state_b=None)

Compute the MOID between the input state and an optional second state. If the second state is not provided, default to Earth.

Returns the MOID in units of au.

Parameters:

state_a – State of the first object.
state_b – Optional state of the second object, defaults to Earth.

kete.propagation.propagate_n_body(states, jd, include_asteroids=False, non_gravs=None, suppress_errors=True)

Propagate the provided State using N body mechanics to the specified times, no approximations are made, this can be very CPU intensive.

This does not compute light delay, however it does include corrections for general relativity due to the Sun.

Parameters:

states – The initial states, this is a list of multiple State objects.
jd – A JD to propagate the initial states to.
include_asteroids – If this is true, the computation will include the largest 5 asteroids. The asteroids are: Ceres, Pallas, Interamnia, Hygiea, and Vesta.
non_gravs – A list of non-gravitational terms for each object. If provided, then every object must have an associated NonGravModel or None.
suppress_errors – If True, errors during propagation will return NaN for the relevant state vectors, but propagation will continue.

Returns:

A State at the new time.

Return type:

Iterable

kete.propagation.propagate_n_body_long(states, jd_final, planet_states=None, non_gravs=None, batch_size=10)

It is STRONGLY recommended to use propagate_n_body instead of this function wherever possible. This function is specifically meant for kilo-year or longer simulations, it is slower and less accurate than propagate_n_body, but that function only works for as long as there are SPICE kernels for the planets available.

This is designed to not require SPICE kernels to function, and is meant for long term simulations on the other of less than a mega-year. It is not recommended for orbits longer than this.

Propagation using this will treat the Earth and Moon as a single object for performance reasons.

Propagate the provided State using N body mechanics to the specified times, very few approximations are made, this can be very CPU intensive.

This does not compute light delay, however it does include corrections for general relativity due to the Sun.

This returns two lists of states: - First one contains the states of the objects at the end of the integration - Second contains the states of the planets at the end of the integration.

The second set of states may be used as input for continuing the integration.

Parameters:

states – The initial states, this is a list of multiple State objects.
jd – A JD to propagate the initial states to.
planet_states – Optional list of the planet’s states at the same time as the provided states. If this is not provided, the planets positions are loaded from the Spice kernels if that information is available.
non_gravs – A list of non-gravitational terms for each object. If provided, then every object must have an associated NonGravModel.
batch_size – Number of objects to propagate at once with the planets. This is used to break up the simulation for multi-core support. It additionally has effects on the integrator stepsize which is difficult to predict before running. This can be manually tuned for increased performance, it should have no other effects than performance.

Returns:

A State at the new time.

Return type:

Iterable

kete.propagation.propagate_two_body(states, jd, observer_pos=None)

Propagate the State for all the objects to the specified time. This assumes 2 body interactions.

This is a multi-core operation.

Parameters:

state – List of states, which are in units of AU from the Sun and velocity is in AU/Day.
jd – Time to integrate to in JD days with TDB scaling.
observer_pos – A vector of length 3 describing the position of an observer. If this is provided then the estimated states will be returned as a result of light propagation delay.

Returns:

Final states after propagating to the target time.

Return type:

State