`gravity_field_variation`¶

This module contains a set of factory functions for setting up the gravity field variations of a (spherical harmonic) gravity field.

The main interfaces with Tudat is the gravity_field_variation_settings list attribute of the body settings, which defines settings for time-variations of spherical harmonic coefficients of a body. The functions in this submodule are used to create the settings objects that go into this list.

Once created, the gravity field variation settings defined through the settings in this submodule each compute a \(\Delta \bar{C}_{j,lm}\) and \(\Delta \bar{S}_{j,lm}\) variation to the cosine and sine coefficients at degree \(l\) and order \(m\). Each of the \(N\) gravity field variation models defined for a given body is evaluated at each time step to produce:

\[\begin{split}\bar{C}_{lm}=\bar{C}_{0,lm}+\sum_{j=1}^{N}\Delta \bar{C}_{j,lm}(t)\\ \bar{S}_{lm}=\bar{S}_{0,lm}+\sum_{j=1}^{N}\Delta \bar{S}_{j,lm}(t)\end{split}\]

where \(\bar{C}_{0,lm}\) and \(\bar{S}_{0,lm}\) are the static coefficients (defined through gravity_field_settings for a given body)

Functions¶

`solid_body_tide`(tide_raising_body, ...)	Function for creating solid body tides.
`solid_body_tide_complex_k`(tide_raising_body, ...)	Function for creating solid body tides.
`solid_body_tide_degree_variable_k`(...)	Function for creating solid body tides.
`solid_body_tide_degree_variable_complex_k`(...)	Function for creating solid body tides.
`solid_body_tide_degree_order_variable_k`(...)	Function for creating solid body tides.
`solid_body_tide_degree_order_variable_complex_k`(...)	Function for creating solid body tides.
`solid_multi_body_tide_degree_order_variable_k`(...)	Function for creating solid body tides raised by multiple bodies.
`mode_coupled_solid_body_tide`(...)	Function for creating solid body tides with coupling between different forcing degree and orders.
`periodic`(...[, minimum_degree, minimum_order])	Function for creating time-periodic gravity field variations.
`single_period_periodic`(...[, ...])	Function for creating time-periodic gravity field variations at a single variation period.
`polynomial`(cosine_amplitudes_per_power, ...)	Function for creating time-polynomial gravity field variations.
`single_power_polynomial`(cosine_amplitudes, ...)	Function for creating polynomial gravity field variations at a single variation period.
`tabulated`(cosine_variations_table, ...)	Function for creating gravity field variations from tabular variation values as a function of time.

solid_body_tide(tide_raising_body: str, love_number: float, degree: int) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating solid body tides.

Function for creating solid body tides, using a single real Love number \(k_{l}\) at a single degree \(l\) (e.g. \(k_{2}\), \(k_{3}\), etc.). This function evaluates Eq. (6.6) from the IERS Conventions 2010, with real \(k_{l}=k_{lm}\), a single value of \(l\) and a single tide-raising body \(j\).

\[\Delta \bar{C}_{lm}-i\Delta \bar{S}_{lm}=\frac{1}{2l+1}k_{l}\frac{\mu_{j}}{\mu}\left(\frac{R}{r_{j}}\right)^{l+1}\bar{P}_{lm}(\sin\phi_{j})\left(\cos m\theta_{j}-i\sin m\theta_{j}\right)\]

where quantities without subscripts represent properties of the body \(B\) for which the gravity field’s time variations are computed. Here, \(\mu_{j}\) is the gravitational parameter of the tide-raising body \(j\), and \(r_{j}\), \(\phi_{j}\) and \(\theta_{j}\) represent the spherical position of body \(j\) in a frame fixed to body \(B\), and \(\bar{P}_{lm}\) are the fully normalized associated Legendre polynomials

Parameters:

tide_raising_body (str) – Name of body raising the tide.
love_number (float) – Constant real Love number to use for body undergoing deformation, at the spherical harmonic degree defined by ‘degree’ input.
degree (int) – Degree of the spherical harmonic gravity field, and associated Love number, that is to be considered.

Returns:

Instance of the BasicSolidBodyGravityFieldVariationSettings derived GravityFieldVariationSettings class

Return type:

BasicSolidBodyGravityFieldVariationSettings

Examples

In this example, we create gravity field variations of Earth for a tide raised by the Moon, with a single Love number \(k_{2}\) of 0.301, and add it to the list of gravity field variations

tide_raising_body = "Moon"
degree = 2
love_number = 0.301
gravity_field_variation_list = list()
gravity_field_variation_list.append( environment_setup.gravity_field_variation.solid_body_tide(
    tide_raising_body, love_number, degree )
body_settings.get( "Earth" ).gravity_field_variation_settings = gravity_field_variation_list

solid_body_tide_complex_k(tide_raising_body: str, love_number: complex, degree: int) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating solid body tides.

As solid_body_tide(), but with complex value for the Love number.

Parameters:

tide_raising_body (str) – Name of body raising the tide.
love_number (complex) – Constant real Love number to use for body undergoing deformation, at the spherical harmonic degree defined by ‘degree’ input.
degree (int) – Degree of the spherical harmonic gravity field, and associated Love number, that is to be considered.

Returns:

Instance of the BasicSolidBodyGravityFieldVariationSettings derived GravityFieldVariationSettings class

Return type:

BasicSolidBodyGravityFieldVariationSettings

solid_body_tide_degree_variable_k(tide_raising_body: str, love_number_per_degree: dict[int, float]) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating solid body tides.

Function for creating solid body tides, using a set of real, separate, Love numbers at any number of degrees (e.g. \(k_{2}\), \(k_{3}\), etc.). This output and mathematical model of this function is effectively identical to a list of outputs to solid_body_tide(), with differing degrees and associated Love numbers. This function evaluates Eq. (6.6) from the IERS Conventions 2010, with a set of real values \(k_{l}=k_{lm}\), at a set of values of \(l\) and a single tide-raising body \(j\).

Parameters:

tide_raising_body (str) – Name of body raising the tide.
love_number_per_degree (dict( int, float )) – Dictionary of Love numbers for each degree that is to be taken into account, with the key representing the degree \(l\) of the Love number, and value containing the Love number \(k_{l}\) itself

Returns:

Instance of the BasicSolidBodyGravityFieldVariationSettings derived GravityFieldVariationSettings class

Return type:

BasicSolidBodyGravityFieldVariationSettings

Examples

In this example, we create gravity field variations of Earth for a tide raised by the Moon, with a Love numbers \(k_{2}=0.301\), and \(k_{3}=0.09\), and add it to the list of gravity field variations

tide_raising_body = "Moon"
love_numbers = dict( )
love_numbers[ 2 ] = 0.301
love_numbers[ 3 ] = 0.09
gravity_field_variation_list = list()
gravity_field_variation_list.append( environment_setup.gravity_field_variation.solid_body_tide_degree_variable_k(
    tide_raising_body, love_numbers )
body_settings.get( "Earth" ).gravity_field_variation_settings = gravity_field_variation_list

solid_body_tide_degree_variable_complex_k(tide_raising_body: str, love_number_per_degree: dict[int, complex]) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating solid body tides.

As solid_body_tide_degree_variable_k(), but with complex values for the Love numbers.

Parameters:

tide_raising_body (str) – Name of body raising the tide.
love_number_per_degree (dict( int, complex )) – Dictionary of Love numbers for each degree that is to be taken into account, with the key representing the degree \(l\) of the Love number, and value containing the Love number \(k_{l}\) itself.

Returns:

Instance of the BasicSolidBodyGravityFieldVariationSettings derived GravityFieldVariationSettings class

Return type:

BasicSolidBodyGravityFieldVariationSettings

solid_body_tide_degree_order_variable_k(tide_raising_body: str, love_number_per_degree_and_order: dict[int, list[float]]) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating solid body tides.

Function for creating solid body tides, using a set of real, separate, Love numbers at any number of degrees and orders (e.g. \(k_{20}\), \(k_{21}\), \(k_{22}\), \(k_{30}\), etc.). This function evaluates Eq. (6.6) from the IERS Conventions 2010, with a set of real values \(k_{lm}\), at a set of values of \(l\) and a single tide-raising body \(j\).

The mathematical model of this function is effectively nearly equal to that of solid_body_tide() with the modification that \(k_{l}\rightarrow k_{lm}\).

Parameters:

tide_raising_body (str) – Name of body raising the tide.
love_number_per_degree_and_order (dict( int, list( float ) )) – Dictionary of Love numbers for each degree that is to be taken into account, with the key representing the degree \(l\) of the Love number, and value containing the list of Love numbers \(k_{lm}\) at this degree. Note that, for Love numbers at degree \(l\), the associated list can contain up to \(l+1\) entries, representing the Love numbers (in order) \(k_{l0}\), \(k_{l1}\)… \(k_{ll}\).

Returns:

Instance of the BasicSolidBodyGravityFieldVariationSettings derived GravityFieldVariationSettings class

Return type:

BasicSolidBodyGravityFieldVariationSettings

Examples

In this example, we create gravity field variations of the Moon, for a tide raised by Earth, with a Love numbers \(k_{20}=0.024615\), \(k_{21}=0.023915\) and \(k_{21}=0.024852\), and add it to the list of gravity field variations

tide_raising_body = "Earth"
love_numbers = dict( )
love_numbers[ 2 ] = list( )
love_numbers[ 2 ].append( 0.024615 )
love_numbers[ 2 ].append( 0 .023915 )
love_numbers[ 2 ].append( 0.024852 )
gravity_field_variation_list = list()
gravity_field_variation_list.append( environment_setup.gravity_field_variation.solid_body_tide_degree_order_variable_k(
    tide_raising_body, love_numbers )
body_settings.get( "Earth" ).gravity_field_variation_settings = gravity_field_variation_list

solid_body_tide_degree_order_variable_complex_k(tide_raising_body: str, love_number_per_degree_and_order: dict[int, list[complex]]) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating solid body tides.

As solid_body_tide_degree_order_variable_k(), but with complex values for the Love number.

Parameters:

tide_raising_body (str) – Name of body raising the tide.
love_number_per_degree (dict( int, list( complex ) )) – Dictionary of Love numbers for each degree that is to be taken into account, with the key representing the degree \(l\) of the Love number, and value containing the list of Love numbers \(k_{lm}\) at this degree. Note that, for Love numbers at degree \(l\), the associated list can contain up to \(l+1\) entries, representing the Love numbers (in order) \(k_{l0}\), \(k_{l1}\)…:math:k_{ll}.

Returns:

Instance of the BasicSolidBodyGravityFieldVariationSettings derived GravityFieldVariationSettings class

Return type:

BasicSolidBodyGravityFieldVariationSettings

solid_multi_body_tide_degree_order_variable_k(tide_raising_bodies: list[str], love_number_per_degree_and_order: dict[int, list[float]]) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating solid body tides raised by multiple bodies.

As solid_body_tide_degree_order_variable_k(), but with the same set of Love numbers used for tides raised by multiple bodies \(j\)

Parameters:

tide_raising_bodies (list[str]) – Names of bodies raising the tide.
love_number_per_degree_and_order (dict( int, list( float ) )) – Dictionary of Love numbers for each degree that is to be taken into account, with the key representing the degree \(l\) of the Love number, and value containing the list of Love numbers \(k_{lm}\) at this degree. Note that, for Love numbers at degree \(l\), the associated list can contain up to \(l+1\) entries, representing the Love numbers (in order) \(k_{l0}\), \(k_{l1}\)… \(k_{ll}\).

Returns:

Instance of the BasicSolidBodyGravityFieldVariationSettings derived GravityFieldVariationSettings class

Return type:

BasicSolidBodyGravityFieldVariationSettings

mode_coupled_solid_body_tide(deforming_bodies: list[str], love_numbers: dict[tuple[int, int], dict[tuple[int, int], float]]) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating solid body tides with coupling between different forcing degree and orders.

Function for creating solid body tides with coupling between different forcing degree and orders, similar to solid_body_tide_degree_order_variable_k(), but with multiple tide-raising bodies and the option to have forcing and response at different degrees and orders

\[\Delta \bar{C}_{l'm'}-i\Delta \bar{S}_{l'm'}=\sum_{j}\frac{1}{2l+1}k_{lm}^{l'm'}\frac{\mu_{j}}{\mu}\left(\frac{R}{r_{j}}\right)^{l+1}\bar{P}_{lm}(\sin\phi_{j})\left(\cos m\theta_{j}-i\sin m\theta_{j}\right)\]

The quantities \(l\) and \(m\) denote the degree and order of the forcing, while \(l'\) and \(m'\) denote the degree and order of the response

Parameters:

tide_raising_body (str) – Name of body raising the tide.
love_number_per_degree (dict[tuple[int, int], dict[tuple[int,int],float]]) – Double dictionary of Love numbers for each combination for forcing and response degree and order, and the value (float) the associated mode-coupled Love number \(k_{lm}^{l'm'}\). The first tuple is the forcing degree and order \(l,m\), the second tuple is the response degree and order \(l',m'\)

Returns:

Instance of a GravityFieldVariationSettings derived class containing required settings

Return type:

GravityFieldVariationSettings

periodic(cosine_coefficient_amplitudes_cosine_time: list[numpy.ndarray[numpy.float64[m, n]]], cosine_coefficient_amplitudes_sine_time: list[numpy.ndarray[numpy.float64[m, n]]], sine_coefficient_amplitudes_cosine_time: list[numpy.ndarray[numpy.float64[m, n]]], sine_coefficient_amplitudes_sine_time: list[numpy.ndarray[numpy.float64[m, n]]], angular_frequencies: list[float], reference_epoch: float, minimum_degree: int = 2, minimum_order: int = 0) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating time-periodic gravity field variations.

Function for creating gravity field variations that are a superposition of purely sinusoidal variations in the gravity field coefficients. The cosine and sine coefficient variations at degree and order \(l\) and \(m\) are computed from:

\[\begin{split}\Delta{\bar{C}}_{lm}=\sum_{i=1}^{N}\left(A_{i,\bar{C}_{lm}}\cos\left(f_{i}(t-t_{0})\right) + B_{i,\bar{C}_{lm}}\sin\left(f_{i}(t-t_{0})\right) \right)\\ \Delta{\bar{S}}_{lm}=\sum_{i=1}^{N}\left(A_{i,\bar{S}_{lm}}\cos\left(f_{i}(t-t_{0})\right) + B_{i,\bar{S}_{lm}}\sin\left(f_{i}(t-t_{0})\right) \right)\end{split}\]

The summation is over all \(N\) frequencies that are provided by the user. For each frequency, the user provides a block of coefficients \(A_{\bar{C}_{lm}}\), \(A_{i,\bar{S}_{lm}}\), \(B_{i,\bar{S}_{lm}}\) and \(B_{i,\bar{S}_{lm}}\). These blocks give the spherical harmonic coefficient variations at degree \(l_{\text{min}}\) until degree \(l_{\text{min}}+l_{\text{size}}\), and order \(m_{\text{min}}\) until degree \(m_{\text{min}}+m_{\text{size}}\). The \(l_{\text{min}}\) and \(m_{\text{min}}\) are defined by the minimum_degree and minimum_order inputs. The :math`l_{text{size}}` and :math`m_{text{size}}` are defined by the size of the matrices in the first four input lists to this function (starting with cosine_coefficient_amplitudes_cosine_time).

For instance, if minimum_degree is set to 2, and minimum_order to 0, and each matrix block for coefficient amplitudes provided is a 1x3 matrix, these amplitudes make of the variations in \(l,m=2,0\), \(l,m=2,1\) and \(l,m=2,2\) respectively.

Parameters:

cosine_coefficient_amplitudes_cosine_time (list[np.array]) – List of coefficient amplitude blocks \(A_{i,\bar{C}_{lm}}\), with each entry in the list corresponding to the frequency provided by the same entry in angular_frequencies. The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order.
cosine_coefficient_amplitudes_sine_time (list[np.array]) – List of coefficient amplitude blocks \(B_{i,\bar{C}_{lm}}\), with each entry in the list corresponding to the frequency provided by the same entry in angular_frequencies. The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order.
sine_coefficient_amplitudes_cosine_time (list[np.array]) – List of coefficient amplitude blocks \(A_{i,\bar{S}_{lm}}\), with each entry in the list corresponding to the frequency provided by the same entry in angular_frequencies. The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order. Note that if minimum_order is equal to 0, the first column of values in each matrix will be unused (since there is no \(S_{l0}\) coefficient).
sine_coefficient_amplitudes_sine_time (list[np.array]) – List of coefficient amplitude blocks \(B_{i,\bar{S}_{lm}}\), with each entry in the list corresponding to the frequency provided by the same entry in angular_frequencies. The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order. Note that if minimum_order is equal to 0, the first column of values in each matrix will be unused (since there is no \(S_{l0}\) coefficient).
angular_frequencies (list[float]) – List of angular frequencies (in rad/s) at which variations are to be added
reference_epoch (float) – Reference epoch \(t_{0}\) for the variations
minimum_degree (int) – Minimum degree \(l_{\text{min}}\) of gravity field variations
minimum_order (int) – Minimum order \(m_{\text{min}}\) of gravity field variations

Returns:

Instance of a GravityFieldVariationSettings derived class containing required settings

Return type:

GravityFieldVariationSettings

single_period_periodic(cosine_coefficient_amplitude_cosine_time: numpy.ndarray[numpy.float64[m, n]], cosine_coefficient_amplitude_sine_time: numpy.ndarray[numpy.float64[m, n]], sine_coefficient_amplitude_cosine_time: numpy.ndarray[numpy.float64[m, n]], sine_coefficient_amplitude_sine_time: numpy.ndarray[numpy.float64[m, n]], angular_frequency: float, reference_epoch: float, minimum_degree: int = 2, minimum_order: int = 0) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating time-periodic gravity field variations at a single variation period.

Function for creating time-periodic gravity field variations at a single variation period, same as \(~periodic\), but with a single frequency \(f\).

Parameters:

cosine_coefficient_amplitude_cosine_time (np.array) – Coefficient amplitude block \(A_{i,\bar{C}_{lm}}\). The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order.
cosine_coefficient_amplitude_sine_time (np.array) – Coefficient amplitude block \(B_{i,\bar{C}_{lm}}\). The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order.
sine_coefficient_amplitude_cosine_time (np.array) – Coefficient amplitude block \(A_{i,\bar{S}_{lm}}\). The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order. Note that if minimum_order is equal to 0, the first column of values in each matrix will be unused (since there is no \(S_{l0}\) coefficient).
sine_coefficient_amplitude_sine_time (np.array) – Coefficient amplitude block \(B_{i,\bar{S}_{lm}}\). The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order. Note that if minimum_order is equal to 0, the first column of values in each matrix will be unused (since there is no \(S_{l0}\) coefficient).
angular_frequency (list[float]) – Angular frequencies (in rad/s) at which variations are to be added
reference_epoch (float) – Reference epoch \(t_{0}\) for the variations
minimum_degree (int) – Minimum degree \(l_{\text{min}}\) of gravity field variations
minimum_order (int) – Minimum order \(m_{\text{min}}\) of gravity field variations

Returns:

Instance of a GravityFieldVariationSettings derived class containing required settings

Return type:

GravityFieldVariationSettings

polynomial(cosine_amplitudes_per_power: dict[int, numpy.ndarray[numpy.float64[m, n]]], sine_amplitudes_per_power: dict[int, numpy.ndarray[numpy.float64[m, n]]], reference_epoch: float, minimum_degree: int = 2, minimum_order: int = 0) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating time-polynomial gravity field variations.

Function for creating gravity field variations that are a superposition of purely polynomial variations in the gravity field coefficients. The cosine and sine coefficient variations at degree and order \(l\) and \(m\) are computed from:

\[\begin{split}\Delta{\bar{C}}_{lm}=\sum_{i=1}^{N}\left(K_{i,\bar{C}_{lm}} (t-t_{0})^{p_{i}} \right)\\ \Delta{\bar{S}}_{lm}=\sum_{i=1}^{N}\left(K_{i,\bar{S}_{lm}} (t-t_{0})^{p_{i}} \right)\end{split}\]

The summation is over all \(N\) polynomial exponents that are provided by the user. For each exponent, the user provides a block of coefficients \(K_{i,\bar{C}_{lm}}\), and \(K_{i,\bar{S}_{lm}}\). These blocks give the spherical harmonic coefficient variations at degree \(l_{\text{min}}\) until degree \(l_{\text{min}}+l_{\text{size}}\), and order \(m_{\text{min}}\) until degree \(m_{\text{min}}+m_{\text{size}}\). The \(l_{\text{min}}\) and \(m_{\text{min}}\) are defined by the minimum_degree and minimum_order inputs. The :math`l_{text{size}}` and :math`m_{text{size}}` are defined by the size of the matrices in the first two input lists to this function (starting with cosine_amplitudes_per_power).

Parameters:

cosine_amplitudes_per_power (dict[int, np.array]) – Dictionary of cosine coefficient amplitude blocks, with each key in the list corresponding to the polynomial power \(p_{i}\), and the dictionary value the corresponding \(K_{i,\bar{C}_{lm}}\). The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order.
sine_amplitudes_per_power (list[np.array]) – Dictionary of sine coefficient amplitude blocks, with each key in the list corresponding to the polynomial power \(p_{i}\), and the dictionary value the corresponding \(K_{i,\bar{S}_{lm}}\). The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order. Note that if minimum_order is equal to 0, the first column of values in each matrix will be unused (since there is no \(S_{l0}\) coefficient).
reference_epoch (float) – Reference epoch \(t_{0}\) for the variations
minimum_degree (int) – Minimum degree \(l_{\text{min}}\) of gravity field variations
minimum_order (int) – Minimum order \(m_{\text{min}}\) of gravity field variations

Returns:

Instance of a GravityFieldVariationSettings derived class containing required settings

Return type:

GravityFieldVariationSettings

single_power_polynomial(cosine_amplitudes: numpy.ndarray[numpy.float64[m, n]], sine_amplitudes: numpy.ndarray[numpy.float64[m, n]], polynomial_power: int, reference_epoch: float, minimum_degree: int = 2, minimum_order: int = 0) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating polynomial gravity field variations at a single variation period.

Function for creating polynomial gravity field variations at a single variation period, same as \(~polynomial\), but with a single polynmial power \(p\).

Parameters:

cosine_amplitudes_per_power (np.array) – Cosine coefficient amplitude block \(K_{\bar{C}_{lm}}\). The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order.
sine_amplitudes_per_power (list[np.array]) – Sine coefficient amplitude block \(K_{\bar{S}_{lm}}\). The first entry in each matrix block provides the coefficient variation amplitude at degree equal to minimum_degree and order equal to minimum_order. Note that if minimum_order is equal to 0, the first column of values in each matrix will be unused (since there is no \(S_{l0}\) coefficient).
polynomial_power (float) – Polynomial power \(p\) used in the computation
reference_epoch (float) – Reference epoch \(t_{0}\) for the variations
minimum_degree (int) – Minimum degree \(l_{\text{min}}\) of gravity field variations
minimum_order (int) – Minimum order \(m_{\text{min}}\) of gravity field variations

Returns:

Instance of a GravityFieldVariationSettings derived class containing required settings

Return type:

GravityFieldVariationSettings

tabulated(cosine_variations_table: dict[float, numpy.ndarray[numpy.float64[m, n]]], sine_variations_table: dict[float, numpy.ndarray[numpy.float64[m, n]]], minimum_degree: int, minimum_order: int, interpolation_settings: tudatpy.kernel.math.interpolators.InterpolatorSettings) → tudatpy.kernel.numerical_simulation.environment_setup.gravity_field_variation.GravityFieldVariationSettings¶

Function for creating gravity field variations from tabular variation values as a function of time.

Function for creating gravity field variations from tabular variation values as a function of time, which are interpolated to compute the instantaneous gravity field variation

The user provides a tables of blocks of coefficient variation at epochs \(t_{i}\) \(\Delta \bar{C}_{lm}(t_{i})\). These blocks give the spherical harmonic coefficient variations at degree \(l_{\text{min}}\) until degree \(l_{\text{min}}+l_{\text{size}}\), and order \(m_{\text{min}}\) until degree \(m_{\text{min}}+m_{\text{size}}\). The \(l_{\text{min}}\) and \(m_{\text{min}}\) are defined by the minimum_degree and minimum_order inputs. The :math`l_{text{size}}` and :math`m_{text{size}}` are defined by the size of the matrices in the tabulated inputs

Parameters:

cosine_variations_table (dict[float, np.array]) – Dictionary of cosine coefficient variations, with each key in list corresponding to epoch \(t_{i}\) and the value to the corresponding variation \(\Delta \bar{C}_{lm}(t_{i})\). The first entry in each matrix block provides the coefficient variation at degree equal to minimum_degree and order equal to minimum_order.
sine_amplitudes_per_power (dict[float, np.array]) – Dictionary of sine coefficient variations, with each key in list corresponding to epoch \(t_{i}\) and the value to the corresponding variation \(\Delta \bar{C}_{lm}(t_{i})\). The first entry in each matrix block provides the coefficient variation at degree equal to minimum_degree and order equal to minimum_order. Note that if minimum_order is equal to 0, the first column of values in each matrix will be unused (since there is no \(S_{l0}\) coefficient).
minimum_degree (int) – Minimum degree \(l_{\text{min}}\) of gravity field variations
minimum_order (int) – Minimum order \(m_{\text{min}}\) of gravity field variations
interpolation_settings (InterpolatorSettings) – Settings that define the type of interpolator that is to be used

Returns:

Instance of a GravityFieldVariationSettings derived class containing required settings

Return type:

GravityFieldVariationSettings

Enumerations¶

BodyDeformationTypes

Enumeration listing the different types of gravity and/or shape field variation models available in tudat.

class BodyDeformationTypes¶

Enumeration listing the different types of gravity and/or shape field variation models available in tudat. Note that for some types, only one of the two types of variations is available

Members:

basic_solid_body :

Basic tidal variation model, assuming a single constant Love number for the variation

iers_2010_tidal :

High-fidelity Earth tidal variation model based on IERS 2010 conventions

tabulated_deformation :

Variation model using interpolated tabular data for the variation model

periodic_variation :

Variation model using purely sinusoidal variations (as a function of time) for gravity field coefficients

polynomial_variation :

Variation model using polynomial functions of time for gravity field coefficients variations

ocean_tide :

Variation model due to ocean tides

pole_tide :

Variation model due to pole tides

property name¶

Classes¶

`GravityFieldVariationSettings`	Base class for providing settings for gravity field variations.
`BasicSolidBodyGravityFieldVariationSettings`	Class for providing settings for solid body tidal gravity field variations, derived from GravityFieldVariationSettings.

class GravityFieldVariationSettings¶: Base class for providing settings for gravity field variations.

class BasicSolidBodyGravityFieldVariationSettings¶: Class for providing settings for solid body tidal gravity field variations, derived from GravityFieldVariationSettings.

gravity_field_variation¶

Functions¶

Enumerations¶

Classes¶

`gravity_field_variation`¶