parameters_setup¶
This module contains a set of factory functions for setting up the observation models, for use in the tudat estimation framework
This module and its constituents are in many cases documented under the assumption that its functionalities are used in the context of an estimation problem. However, since estimatable parameter settings are firstly used to set up variational equations of the dynamical / observation model w.r.t. the estimatable parameters, the functionality of this module can be relevant in any context in which variational equations are required.
Functions¶
|
Function for creating a consolidated parameter from the given estimatable parameter settings. |
|
Function for creating parameter settings for initial state parameters. |
Function for creating parameter settings for constant drag coefficients. |
|
|
Function for creating parameter settings for arc-wise constant drag coefficients. |
|
Function for creating parameter settings for aerodynamic drag scaling factor |
|
Function for creating parameter settings for aerodynamic side force scaling factor |
|
Function for creating parameter settings for aerodynamic lift force scaling factor |
Function for creating parameter settings for radiation pressure coefficients. |
|
Creates settings for estimating the three constants of a three-coefficient radiation-pressure acceleration. |
|
|
Function for creating parameter settings for arc-wise radiation pressure coefficients. |
Function for creating parameter settings for a radiation pressure acceleration scaling factor in target direction. |
|
|
Function for creating parameter settings for a radiation pressure acceleration scaling factor perpendicular to target direction. |
|
Function for creating parameter settings for the specular reflectivity of a panel group. |
|
Function for creating parameter settings for the diffuse reflectivity of a panel group. |
|
Function for creating parameter settings for the energy accommodation coefficient of a panel group. |
|
Function for creating parameter settings for the normal accommodation coefficient of a panel group. |
|
Function for creating parameter settings for the tangential accommodation coefficient of a panel group. |
|
Function for creating parameter settings for the normal velocity at wall ratio of a panel group. |
|
Function for creating parameter settings for empirical acceleration magnitudes. |
|
Function for creating parameter settings for arc-wise empirical acceleration magnitudes. |
|
Function for creating parameter settings for constant empirical acceleration terms. |
|
Function for creating parameter settings for empirical acceleration magnitudes for all components. |
Function for creating parameter settings for arc-wise constant empirical acceleration terms. |
|
|
Function for creating parameter settings for quasi-impulsive shots. |
|
Function for creating parameter settings for a massive body's gravitational parameter. |
|
Function for creating parameter settings for the cosine coefficients of body's spherical harmonics gravitational model. |
|
Function for creating parameter settings for the sine coefficients of body's spherical harmonics gravitational model. |
Function for creating parameter settings for the cosine coefficients of body's spherical harmonics gravitational model. |
|
Function for creating parameter settings for the sine coefficients of body's spherical harmonics gravitational model. |
|
|
Function for creating parameter settings for Yarkovsky parameter. |
|
Function for creating parameter settings for a body's constant rotation rate. |
|
Function for creating parameter settings for a body's rotation pole position. |
|
Function for creating parameter settings for a body's \(k_{l}\) Love number. |
|
Function for creating parameter settings for a body's \(k_{lm}\) Love numbers. |
|
Function for creating parameter settings for a body's mode-coupled \(k_{lm}^{l'm'}\) Love numbers. |
Function for creating parameter settings for a body's polynomial gravity field amplitudes. |
|
Function for creating parameter settings for a body's polynomial gravity field variation amplitudes |
|
Function for creating parameter settings for a body's polynomial gravity field amplitudes at a single power. |
|
Function for creating parameter settings for a body's polynomial gravity field amplitudes at a single power. |
|
|
Overloaded function. |
|
Overloaded function. |
|
Function for creating parameter settings for a body's mean moment of inertia. |
|
Function for creating parameter settings for a body's periodic spin variations. |
|
Function for creating parameter settings for a body's polar motion amplitudes. |
|
Configure estimation of the scaled longitude libration amplitude of |
|
Function for creating parameter settings for a body's core factor. |
|
Function for creating parameter settings for a body's free core nutation rate. |
|
Create one estimatable bias shared by all observation links matching a selector. |
|
Function for creating parameter settings for an absolute observation bias. |
|
Function for creating parameter settings for an relative observation bias. |
|
Function for creating parameter settings for arc-wise absolute observation bias. |
|
Function for creating parameter settings for arc-wise absolute observation bias. |
|
Function for creating parameter settings for ground station position bias. |
|
Configure estimation of the body-fixed Cartesian position of |
Function for creating parameter settings for post-newtonian gamma parameter. |
|
Function for creating parameter settings for post-newtonian beta parameter. |
|
Configure estimation of polynomial clock correction coefficients shared across clock arcs. |
|
Configure estimation of separate polynomial clock corrections on selected arcs. |
|
|
Configure estimation of an observation bias growing linearly with elapsed time from |
Configure estimation of a separate linear observation-bias drift on each time arc. |
|
|
Configure estimation of a constant time-tag bias for |
|
Configure estimation of a separate time-tag bias on each arc for |
|
Configure a custom estimatable parameter vector identified by |
Configure a user-supplied acceleration partial for the specified accelerating body, source body and acceleration type. |
|
|
Configure numerical acceleration partials using the component-wise |
|
Function for creating parameter settings for arc-wise aerodynamic drag scaling factor |
Environment model parameter associated with the exponential atmosphere model of given body. |
|
Environment model parameter associated with the exponential atmosphere model of given body. |
|
|
Function for creating parameter settings for arc-wise aerodynamic lift force scaling factor |
|
Function for creating parameter settings for arc-wise aerodynamic side force scaling factor |
|
Function for creating parameter settings for a scaling factor for a body's area to mass ratio(s) |
|
Environment model parameter associated with the exponential atmosphere model of given body. |
|
Environment model parameter associated with the exponential atmosphere model of given body. |
Function for creating parameter settings for a scaling factor for a single acceleration acting on a body |
|
Function for creating parameter settings for a body's longitudinal libration amplitudes in an IAU rotation model |
|
|
Function for creating parameter settings for a body's nominal pole position in an IAU rotation model |
|
Function for creating parameter settings for a body's pole libration amplitudes in an IAU rotation model |
Function for creating parameter settings for a body's pole precession rate in an IAU rotation model |
|
|
Force model parameter associated with the RTG radiation acceleration. |
|
Force model parameter associated with the RTG radiation acceleration. |
- create_parameter_set(parameter_settings: list[tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings], bodies: tudatpy.kernel.dynamics.environment.SystemOfBodies, propagator_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagatorSettings = None, consider_parameters_names: list[tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings] = [], print_parameter_order_warning: bool = True) tudatpy.kernel.dynamics.parameters.EstimatableParameterSet¶
Function for creating a consolidated parameter from the given estimatable parameter settings.
Function for creating a consolidated parameter from the given estimatable parameter settings. The function checks for consistency between the parameter settings and the models contained in the simulation setup (given by the bodies & and propagator_settings parameters).
- Parameters:
parameter_settings (list[
EstimatableParameterSettings]) – List of objects that define the settings for the parameters that are to be created. Each entry in this list is typically created by a call to a function in the parameters_setup module.bodies (
SystemOfBodies) – Object consolidating all bodies and environment models, including ground station models, that constitute the physical environment.propagator_settings (
PropagatorSettings) – Object containing the consolidated propagation settings of the simulation.consider_parameters_names (list[
EstimatableParameterSettings] = []) – List of objects that define the settings for the considered parameters that are to be created. Each entry in this list is typically created by a call to a function in the parameters_setup module.print_parameter_order_warning (bool = True) – Flag to determine whether a warning is printed to the console if there are both scalar and vector parameters found.
- Returns:
Instance of
EstimatableParameterSetclass, consolidating all estimatable parameters and simulation models.- Return type:
Examples
# Create bodies bodies = ... # Define parameters settings parameter_settings = ... # Create the parameters that will be estimated parameters_to_estimate = dynamics.parameters_setup.create_parameter_set(parameter_settings, bodies)
This code snippet closely follows what is done in: Full Estimation Example.
- initial_states(propagator_settings: tudatpy.kernel.dynamics.propagation_setup.propagator.PropagatorSettings, bodies: tudatpy.kernel.dynamics.environment.SystemOfBodies, arc_initial_times: list[float] = []) list[tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings]¶
Function for creating parameter settings for initial state parameters.
Function for creating a parameter settings object for initial state parameters. The function uses the propagator settings to determine which type of initial state parameter (single/multi/hybrid-arc; translational/rotational/… dynamics) is to be estimated, e.g. if a single-arc translational state propagator is defined, the function will automatically create the parameters for the associated initial state parameter
Note
This function return lists of parameter settings objects. This means that the return of this function cannot simply be added to the parameter settings objects of single parameters in a list creation statement. Instead, list concatenation is recommended. Please see the following example:
# define single estimatable parameters single_parameter_1 = ... single_parameter_2 = ... ... # bad: list creation statement --> will result in nested list, undesired! list_of_all_parameters = [dynamics.parameters_setup.initial_states(...), single_parameter_1, single_parameter_2, ...] # better: list concatenation --> will result in simple list, desired! list_of_all_parameters = dynamics.parameters_setup.initial_states(...) + [single_parameter_1, single_parameter_2, ...]
- Parameters:
propagator_settings (
PropagatorSettings) – Object containing the consolidated propagation settings of the simulation in the context of which the given model parameters are to be estimated.bodies (
SystemOfBodies) – Object consolidating all bodies and environment models that constitute the physical environment.arc_initial_times (List[ float ] = []) – Initial times of arcs, only required if arc-wise propagation settings are passed via the propagator_settings object.
- Returns:
List of
EstimatableParameterSettingsobjects, one per component of each initial state in the simulation.- Return type:
List[
EstimatableParameterSettings]
- constant_drag_coefficient(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for constant drag coefficients.
Function for creating parameter settings object for a constant drag coefficient parameter \(C_{D}\) (see
aerodynamic()). Using the constant drag coefficient as an estimatable parameter requires:A
constant()aerodynamic interface (withnegative_aerodynamic_frame_coefficients()as input toforce_coefficients_frame) to be defined for the body specified by thebodyparameterThe body specified by the
bodyparameter to undergoaerodynamic()acceleration
The estimated parameter modifies the
aerodynamic()- Parameters:
body (str) – Name of the body, with whose drag acceleration model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s constant drag coefficient.- Return type:
- arcwise_constant_drag_coefficient(body: str, arc_initial_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise constant drag coefficients.
Function for creating parameter settings object for arc-wise constant drag coefficients \(C_{D}\) (arc-wise version of
constant_drag_coefficient()). Using the arc-wise constant drag coefficient as an estimatable parameter requires:A
constant()aerodynamic interface to be defined for the body specified by thebodyparameterThe body specified by the
bodyparameter to undergoaerodynamic()acceleration
When using this parameter, whenever \(C_{D}\) is required at a time \(t\), the index \(i\) in the
arc_initial_timesordered list is found for which \(t_{i}\le t<t_{i+1}\) (or, if \(t\) is larger than the largest value in the list, \(i\) is set to be last index of the list), and the parameter entry representing \(C_{D,i}\) will be used.Note
This parameter may be estimated for a single-arc propagation, or a multi-arc propagation. In the latter case, the arcs selected for the estimation of the drag coefficient may, but need not, correspond to the arcs used for a multi-arc propagation.
- Parameters:
- Returns:
Instance of
EstimatableParameterSettingsderivedArcWiseDragCoefficientEstimatableParameterSettingsclass for arc-wise treatment of the specified body’s constant drag coefficient.- Return type:
- drag_component_scaling(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for aerodynamic drag scaling factor
Function for creating parameter settings object for a scaling factor \(K\) (initialized to 1.0) for the aerodynamic force along the drag direction (effectively scaling the drag coefficient \(C_{D}\) (see
aerodynamic())Using the arc-wise constant drag coefficient as an estimatable parameter requires:
The body specified by the
bodyparameter to undergoaerodynamic()acceleration
Note that, unlike the
constant_drag_coefficient()parameter, this parameter does not modify the drag coefficient itself, but works regardless of the type of aerodynamic coefficients (in any frame, and with any dependencies). Using this parameter, the aerodynamic force along the drag direction is scaled (multiplied) by the factor \(K\) during each function evaluation.- Parameters:
body (str) – Name of the body, with whose aerodynamic acceleration model the estimatable parameter is associated.
- Returns:
Instance of
EstimatableParameterSettingsclass that define the settings.- Return type:
- side_component_scaling(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for aerodynamic side force scaling factor
As
drag_component_scaling(), but scales the force along the \(C_{S}\) direction rather than the \(C_{D}\) direction- Parameters:
body (str) – Name of the body, with whose aerodynamic acceleration model the estimatable parameter is associated.
- Returns:
Instance of
EstimatableParameterSettingsclass that define the settings.- Return type:
- lift_component_scaling(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for aerodynamic lift force scaling factor
As
drag_component_scaling(), but scales the force along the \(C_{L}\) direction rather than the \(C_{D}\) direction- Parameters:
body (str) – Name of the body, with whose aerodynamic acceleration model the estimatable parameter is associated.
- Returns:
Instance of
EstimatableParameterSettingsclass that define the settings.- Return type:
- radiation_pressure_coefficient(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for radiation pressure coefficients.
Function for creating parameter settings object for a radiation pressure coefficient \(C_{r}\). Using the radiation pressure coefficient as an estimatable parameter requires:
A
cannonball_radiation_target()radiation pressure target model to be defined for the body specified by thebodyparameterThe body specified by the
bodyparameter to undergoradiation_pressure()acceleration (which, if the body has multiple target model defined, has thetarget_typeinput set tocannonball_target)
- Parameters:
body (str) – Name of the body, with whose radiation pressure acceleration model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s radiation pressure coefficient.- Return type:
- three_coefficient_radiation_pressure_coefficients(body: str, radiation_source: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Creates settings for estimating the three constants of a three-coefficient radiation-pressure acceleration.
The resulting single vector parameter has size three and contains \((A_1,A_2,A_3)\) in square metres. It is linked to every matching acceleration created with
three_coefficient_radiation_pressure()fromradiation_sourceacting onbodyin the supplied propagator settings.- Parameters:
- Returns:
Settings for the size-three coefficient parameter.
- Return type:
- arcwise_radiation_pressure_coefficient(body: str, arc_initial_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise radiation pressure coefficients.
Function for creating parameter settings object for arc-wise radiation pressure coefficients \(C_{r}\) (arc-wise version of
radiation_pressure_coefficient()). Using the radiation pressure coefficient as an estimatable parameter requires:A
cannonball_radiation_target()radiation pressure target model to be defined for the body specified by thebodyparameterThe body specified by the
bodyparameter to undergoradiation_pressure()acceleration (which, if the body has multiple target model defined, has thetarget_typeinput set tocannonball_target())
When using this parameter, whenever \(C_{r}\) is required at a time \(t\), the index math:i in the
arc_initial_timesordered list is found for which \(t_{i}\le t<t_{i+1}\) (or, if \(t\) is larger than the largest value in the list, \(i\) is set to be last index of the list), and the parameter entry representing \(C_{r,i}\) will be used.Note
This parameter may be estimated for a single-arc propagation, or a multi-arc propagation. In the latter case, the arcs selected for the estimation of the radiation pressure coefficient may, but need not, correspond to the arcs used for a multi-arc propagation.
- Parameters:
- Returns:
Instance of
EstimatableParameterSettingsderivedArcWiseRadiationPressureCoefficientEstimatableParameterSettingsclass for arc-wise treatment of the specified body’s radiation pressure coefficient.- Return type:
- radiation_pressure_target_direction_scaling(target_body: str, source_body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a radiation pressure acceleration scaling factor in target direction.
Function for creating parameter settings for scaling the radiation pressure acceleration component in the direction from the body undergoing the acceleration to the source model. When using this parameter, the radiation pressure \(\mathbf{a}\) is decomposed into a component \(\mathbf{a}_{\parallel}\) and \(\mathbf{a}_{\perp}, such that :math:\)mathbf{a}=mathbf{a}_{parallel}+mathbf{a}_{perp}`, where the parallel direction is computed as the component parallel with the vector from the center of mass of the source direction to the center of mass of the target direction. The radiation pressure model has parameters \(c_{\parallel}\) and \(c_{\perp}\) (nominally set to unity) that modify the acceleration as:
\[\mathbf{a}=c_{\parallel}\mathbf{a}_{\parallel}+c_{\perp}\mathbf{a}_{\perp}\]The present function creates settings for a parameter defining \(c_{\parallel}\)
Using this parameter requires:
The body specified by the
target_bodyparameter to undergoradiation_pressure()acceleration exerted bysource_body
- Parameters:
- Returns:
Instance of
EstimatableParameterSettingsclass defining parallel radiation pressure scaling- Return type:
- radiation_pressure_target_perpendicular_direction_scaling(target_body: str, source_body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a radiation pressure acceleration scaling factor perpendicular to target direction.
Function for creating parameter settings for scaling the radiation pressure acceleration component perpendicular to the direction from the body undergoing the acceleration to the source model. The present function creates settings for a parameter defining \(c_{\perp}\), see
radiation_pressure_target_direction_scaling()Using this parameter requires:
The body specified by the
target_bodyparameter to undergoradiation_pressure()acceleration exerted bysource_body
- Parameters:
- Returns:
Instance of
EstimatableParameterSettingsclass defining parallel radiation pressure scaling- Return type:
- specular_reflectivity(body: str, panel_group_id: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the specular reflectivity of a panel group.
- Parameters:
- Returns:
Instance of
EstimatableParameterSettingsfor specular reflectivity estimation.- Return type:
- diffuse_reflectivity(body: str, panel_group_id: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the diffuse reflectivity of a panel group.
- Parameters:
- Returns:
Instance of
EstimatableParameterSettingsfor diffuse reflectivity estimation.- Return type:
- energy_accommodation_coefficient(body: str, panel_group_id: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the energy accommodation coefficient of a panel group.
The panels selected by
panel_group_idshare one scalar estimated value. If their initial values differ, construction of the estimatable parameter replaces them by their arithmetic mean. This parameter affects the Sentman and Cook gas-surface interaction models. Its aerodynamic-coefficient partial is zero for the Storch, Newton, and constant-coefficient models.- Parameters:
- Returns:
Settings for energy accommodation coefficient estimation.
- Return type:
- normal_accommodation_coefficient(body: str, panel_group_id: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the normal accommodation coefficient of a panel group.
The panels selected by
panel_group_idshare one scalar estimated value. If their initial values differ, construction of the estimatable parameter replaces them by their arithmetic mean. This parameter affects the Storch gas-surface interaction model. Its aerodynamic-coefficient partial is zero for the Sentman, Cook, Newton, and constant-coefficient models.- Parameters:
- Returns:
Settings for normal accommodation coefficient estimation.
- Return type:
- tangential_accommodation_coefficient(body: str, panel_group_id: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the tangential accommodation coefficient of a panel group.
The panels selected by
panel_group_idshare one scalar estimated value. If their initial values differ, construction of the estimatable parameter replaces them by their arithmetic mean. This parameter affects the Storch gas-surface interaction model. Its aerodynamic-coefficient partial is zero for the Sentman, Cook, Newton, and constant-coefficient models.- Parameters:
- Returns:
Settings for tangential accommodation coefficient estimation.
- Return type:
- normal_velocity_at_wall_ratio(body: str, panel_group_id: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the normal velocity at wall ratio of a panel group.
The panels selected by
panel_group_idshare one scalar estimated value. If their initial values differ, construction of the estimatable parameter replaces them by their arithmetic mean. This parameter affects the Storch gas-surface interaction model. Its aerodynamic-coefficient partial is zero for the Sentman, Cook, Newton, and constant-coefficient models.- Parameters:
- Returns:
Settings for normal velocity at wall ratio estimation.
- Return type:
- empirical_accelerations(body: str, centralBody: str, acceleration_components: dict[tudatpy.kernel.dynamics.parameters_setup.EmpiricalAccelerationComponents, list[tudatpy.kernel.dynamics.parameters_setup.EmpiricalAccelerationFunctionalShapes]]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for empirical acceleration magnitudes.
Function for creating parameter settings object for empirical acceleration magnitudes. Using the empirical acceleration terms as estimatable parameters requires:
The body specified by the
bodyparameter to undergoempirical()acceleration, which include constant (in RSW frame) terms
Any subset of the directions and functional shapes can be estimated. The values in the parameter vector are ordered first by functional shape (constant, sine, cosine) and then by component (radial, normal, cross-track) For instance, if all nine coefficients are estimated, they will be ordered as \(\mathbf{a}_{R,\text{const.}},\mathbf{a}_{R,\text{sine}},\mathbf{a}_{R,\text{cosine}},\mathbf{a}_{S,\text{const.}},\mathbf{a}_{S,\text{sine}},\mathbf{a}_{S,\text{cosine}},\mathbf{a}_{W,\text{const.}},\mathbf{a}_{W,\text{sine}},\mathbf{a}_{W,\text{cosine}}\) Any non-estimated components will be left to the values at which they were initialized.
- Parameters:
body (str) – Name of the body, with whose empirical acceleration model the estimatable parameter is associated.
centralBody (str) – Name of the central body of the empirical acceleration model (of which the gravitational parameter is extracted to compute the true anomaly, and w.r.t. which the RSW directions are determined). This body is the same as the body considered to be ‘exerting’ the empirical acceleration
acceleration_components (dict[ EmpiricalAccelerationComponents, list[ EmpiricalAccelerationFunctionalShapes] ]) – Dictionary of components of the empirical acceleration which are to be estimated. There are two ‘degrees of freedom’ in these components: the direction of the acceleration (e.g. R, S or W direction) and the temporal signature (constant, sine of true anomaly or cosine of true anomaly). With this input, any subset may be selected. This parameter is a dictionary, with the key denoting the direction of the acceleration, and the value a list of the temporal signatures to estimate for this empirical acceleration direction.
- Returns:
Instance of
EstimatableParameterSettingsderivedEmpiricalAccelerationEstimatableParameterSettingsclass for the specified body’s empirical acceleration terms.- Return type:
- arcwise_empirical_accelerations(body: str, centralBody: str, acceleration_components: dict[tudatpy.kernel.dynamics.parameters_setup.EmpiricalAccelerationComponents, list[tudatpy.kernel.dynamics.parameters_setup.EmpiricalAccelerationFunctionalShapes]], arc_start_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise empirical acceleration magnitudes.
Function for creating parameter settings object for arc-wise empirical acceleration magnitudes (arc-wise version of
empirical_accelerations()). Using the empirical acceleration terms as estimatable parameters requires:The body specified by the
bodyparameter to undergoempirical()acceleration, which include constant (in RSW frame) terms
When using this parameter, whenever an empirical acceleration is required at a time \(t\), the index math:i in the
arc_initial_timesordered list is found for which \(t_{i}\le t<t_{i+1}\) (or, if \(t\) is larger than the largest value in the list, \(i\) is set to be last index of the list), and the parameter values representing empirical acceleration components in arc \(i\) will be used.Note
This parameter may be estimated for a single-arc propagation, or a multi-arc propagation. In the latter case, the arcs selected for the estimation of the radiation pressure coefficient may, but need not, correspond to the arcs used for a multi-arc propagation.
- Parameters:
body (str) – Name of the body, with whose empirical acceleration model the estimatable parameter is associated.
centralBody (str) – Name of the central body of the empirical acceleration model (of which the gravitational parameter is extracted to compute the true anomaly, and w.r.t. which the RSW directions are determined). This body is the same as the body considered to be ‘exerting’ the empirical acceleration
acceleration_components (Dict[ EmpiricalAccelerationComponents, List[ EmpiricalAccelerationFunctionalShapes] ]) – Dictionary of components of the empirical acceleration which are to be estimated. There are two ‘degrees of freedom’ in these components: the direction of the acceleration (e.g. R, S or W direction) and the temporal signature (constant, sine of true anomaly or cosine of true anomaly). With this input, any subset may be selected. This parameter is a dictionary, with the key denoting the direction of the acceleration, and the value a list of the temporal signatures to estimate for this empirical acceleration direction.
arc_initial_times (List[ float ]) – List of times at which the arcs over which the empirical accelerations are to be estimated will start.
- Returns:
Instance of
EstimatableParameterSettingsderivedEmpiricalAccelerationEstimatableParameterSettingsclass for the specified body’s arc-wise empirical acceleration terms.- Return type:
- constant_empirical_acceleration_terms(body: str, centralBody: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for constant empirical acceleration terms.
As
empirical_accelerations(), but only using the constant R, S and W components (no sine or cosine term estimation). This function is added as a function of convenience- Parameters:
body (str) – Name of the body, with whose empirical acceleration model the estimatable parameter is associated.
centralBody (str) – Name of the central body of the empirical acceleration model (of which the gravitational parameter is extracted to compute the true anomaly, and w.r.t. which the RSW directions are determined). This body is the same as the body considered to be ‘exerting’ the empirical acceleration
- Returns:
Instance of
EstimatableParameterSettingsderivedEmpiricalAccelerationEstimatableParameterSettingsclass for the specified body’s empirical acceleration terms.- Return type:
- full_empirical_acceleration_terms(body: str, centralBody: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for empirical acceleration magnitudes for all components.
As
empirical_accelerations(), but using selecting all nine components. This function is added as a function of convenience- Parameters:
body (str) – Name of the body, with whose empirical acceleration model the estimatable parameter is associated.
centralBody (str) – Name of the central body of the empirical acceleration model (of which the gravitational parameter is extracted to compute the true anomaly, and w.r.t. which the RSW directions are determined). This body is the same as the body considered to be ‘exerting’ the empirical acceleration
- Returns:
Instance of
EstimatableParameterSettingsderivedEmpiricalAccelerationEstimatableParameterSettingsclass for the specified body’s empirical acceleration terms.- Return type:
- arcwise_constant_empirical_acceleration_terms(body: str, centralBody: str, arc_start_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise constant empirical acceleration terms.
As
arcwise_empirical_accelerations(), but only using the constant R, S and W components (no sine or cosine term estimation). This function is added as a function of convenience- Parameters:
body (str) – Name of the body, with whose empirical acceleration model the estimatable parameter is associated.
centralBody (str) – Name of the central body of the empirical acceleration model (of which the gravitational parameter is extracted to compute the true anomaly, and w.r.t. which the RSW directions are determined). This body is the same as the body considered to be ‘exerting’ the empirical acceleration
arc_initial_times (List[ float ]) – List of times at which the arcs over which the empirical accelerations are to be estimated will start.
- Returns:
Instance of
EstimatableParameterSettingsderivedEmpiricalAccelerationEstimatableParameterSettingsclass for the specified body’s arc-wise constant empirical acceleration terms.- Return type:
- quasi_impulsive_shots(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for quasi-impulsive shots.
Function for creating parameter settings object for so-called ‘quasi-impulsive shots’, such as desaturation maneuvers. With this parameter, the total \(\Delta \mathbf{V}\) vector of a set of such maneuvers can be estimated (see
quasi_impulsive_shots_acceleration()for mathematical details). Using the quasi-impulsive shots as an estimatable parameter requires:The body specified by the
bodyparameter to undergoquasi_impulsive_shots_acceleration()acceleration
Note
this parameter considers all shots/maneuvers used in the above acceleration model, and estimates the value of the ‘delta_v_values’ input of this acceleration.
- Parameters:
body (str) – Name of the body, with which the quasi-impulsive shot estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s quasi-impulsive shots- Return type:
- gravitational_parameter(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a massive body’s gravitational parameter.
Function for creating parameter settings object for the gravitational parameter of massive bodies. Using the gravitational parameter as estimatable parameter requires:
The body specified by the
bodyparameter to be endowed with a gravity field (see gravity_field module for options)Any dynamical or observational model to depend on the gravitational parameter of the body specified by the
bodyparameter
- Parameters:
body (str) – Name of the body, with whose gravitational model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s gravitational parameter.- Return type:
- spherical_harmonics_c_coefficients(body: str, minimum_degree: int, minimum_order: int, maximum_degree: int, maximum_order: int) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the cosine coefficients of body’s spherical harmonics gravitational model.
Function for creating parameter settings object for the spherical harmonics cosine-coefficients (\(\bar{C}_{lm}\)) of a body with a spherical harmonic gravity field. Using this function, a ‘full’ set of spherical harmonic coefficients between an minimum/maximum degree/order are estimated. For instance, for minimum degree/order of 2/0, and maximum degree/order 4/4, all spherical harmonic cosine coefficients of degrees 2, 3 and 4 are estimated. If the maximum degree/order is set to 4/2, only coefficients with an order of 0, 1 and 2 are included. The entries in the parameter are sorted first by degree, and then by order (both ascending, i.e., \(\bar{C}_{20}, \bar{C}_{21}, \bar{C}_{22}, \bar{C}_{30}, \bar{C}_{31}, ...\)). Using the spherical harmonics cosine coefficients as estimatable parameter requires:
A
spherical_harmonic()(or derived) gravity model to be defined for the body specified by thebodyparameterAny dynamical or observational model to depend on the estimated cosine coefficients of the body specified by the
bodyparameter. Typically, this dependency will be aspherical_harmonic_gravity()acceleration
- Parameters:
body (str) – Name of the body, with whose gravitational model the estimatable parameters are associated.
minimum_degree (int) – Minimum degree of c-coefficients to be included.
minimum_order (int) – Minimum order of c-coefficients to be included.
maximum_degree (int) – Maximum degree of c-coefficients to be included.
maximum_order (int) – Maximum order of c-coefficients to be included.
- Returns:
Instance of
EstimatableParameterSettingsderivedSphericalHarmonicEstimatableParameterSettingsclass for the applicable spherical harmonics c-coefficients of the specified body’s gravitational model.- Return type:
- spherical_harmonics_s_coefficients(body: str, minimum_degree: int, minimum_order: int, maximum_degree: int, maximum_order: int) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the sine coefficients of body’s spherical harmonics gravitational model.
Function for creating parameter settings object for the spherical harmonics sine-coefficients (\(\bar{S}_{lm}\)) of a body with a spherical harmonic gravity field. Using this function, a ‘full’ set of spherical harmonic coefficients between an minimum/maximum degree/order are estimated. For instance, for minimum degree/order of 2/1 (there is no order 0 sine coefficient), and maximum degree/order 4/4, all spherical harmonic sine coefficients of degrees 2, 3 and 4 are estimated. If the maximum degree/order is set to 4/2, only coefficients with an order of 1 and 2 are included. The entries in the parameter are sorted first by degree, and then by order (both ascending, i.e., \(\bar{S}_{21}, \bar{S}_{22}, \bar{S}_{31}, ...\)). Using the spherical harmonics cosine coefficients as estimatable parameter requires:
A
spherical_harmonic()(or derived) gravity model to be defined for the body specified by thebodyparameterAny dynamical or observational model to depend on the estimated cosine coefficients of the body specified by the
bodyparameter. Typically, this dependency will be aspherical_harmonic_gravity()acceleration
- Parameters:
body (str) – Name of the body, with whose gravitational model the estimatable parameters are associated.
minimum_degree (int) – Minimum degree of s-coefficients to be included.
minimum_order (int) – Minimum order of s-coefficients to be included.
maximum_degree (int) – Maximum degree of s-coefficients to be included.
maximum_order (int) – Maximum order of s-coefficients to be included.
- Returns:
Instance of
EstimatableParameterSettingsderivedSphericalHarmonicEstimatableParameterSettingsclass for the applicable spherical harmonics s-coefficients of the specified body’s gravitational model.- Return type:
- spherical_harmonics_c_coefficients_block(body: str, block_indices: list[tuple[int, int]]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the cosine coefficients of body’s spherical harmonics gravitational model.
As
spherical_harmonics_c_coefficients, but with a manually defined set of coefficients.- Parameters:
body (str) – Name of the body, with whose gravitational model the estimatable parameters are associated.
block_indices (List[ tuple[int, int] ]) – List of block indices. The length of this list can be arbitrary, as long as the pairs are unique. For each pair, the first value is the degree and the second the order of the coefficient to be included.
- Returns:
Instance of
EstimatableParameterSettingsderivedSphericalHarmonicEstimatableParameterSettingsclass for the applicable spherical harmonics c-coefficients of the specified body’s gravitational model.- Return type:
- spherical_harmonics_s_coefficients_block(body: str, block_indices: list[tuple[int, int]]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for the sine coefficients of body’s spherical harmonics gravitational model.
As
spherical_harmonics_s_coefficients, but with a manually defined set of coefficients.- Parameters:
body (str) – Name of the body, with whose gravitational model the estimatable parameters are associated.
block_indices (List[ tuple[int, int] ]) – List of block indices. The length of this list can be arbitrary, as long as the pairs are unique. For each pair, the first value is the degree and the second the order of the coefficient to be included.
- Returns:
Instance of
EstimatableParameterSettingsderivedSphericalHarmonicEstimatableParameterSettingsclass for the applicable spherical harmonics s-coefficients of the specified body’s gravitational model.- Return type:
- yarkovsky_parameter(body_name: str, central_body_name: str = 'Sun') tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for Yarkovsky parameter.
Function for creating parameter settings for Yarkovsky acceleration parameter \(A_{2}\) (see
yarkovsky()).The body specified by the
bodyparameter to undergoyarkovsky()acceleration withcentral_body_nameas body exerting the acceleration
- Parameters:
body (str) – Name of the body, with whose radiation pressure acceleration model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s radiation pressure coefficient.- Return type:
- constant_rotation_rate(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s constant rotation rate.
Function for creating parameter settings object for a body’s constant rotation rate parameter. Using the constant rotation rate as estimatable parameter requires:
A
simple()orsimple_from_spice()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s constant spin rate.- Return type:
- rotation_pole_position(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s rotation pole position.
Function for creating parameter settings object for a body’s rotation pole position, parameterized by the constant pole rotation angles (\(\alpha\) and \(\delta\)). Using the rotation pole position as estimatable parameter requires:
A
simple()orsimple_from_spice()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s rotation pole position.- Return type:
- order_invariant_k_love_number(deformed_body: str, degree: int, deforming_bodies: list[str], use_complex_love_number: bool = 0) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s \(k_{l}\) Love number.
Function for creating parameter settings for a body’s \(k_{l}\) Love number. When using this function, we assume (for the case of degree 2 Love number) that \(k_{20}=k_{21}=k_{22}\). The estimation of the Love number can be limited to a subset of the bodies that raise a tide on the body undergoing tidal deformation.
Using the \(k_{l}\) Love number as estimatable parameter requires:
A
solid_body_tide()gravity field variation model in thedeformed_body(or one the more complex ones such assolid_body_tide_degree_order_variable_k()). The parameter settings have to match the specifics of the variation model. For instance, ifuse_complex_love_numberis set to true, the gravity field variation has to have been created using a complex Love numberAny dynamical model to depend on the gravity field of the body specified by the
deformed_bodyparameter
- Parameters:
deformed_body (str) – Name of the body that is undergoing tidal deformation
degree (int) – Degree \(l\) of the Love number \(k_{l}\) that is to be estimated
deforming_bodies (list[str]) – List of bodies that raise a tide on
deformed_bodyfor which the single Love number defined by this setting is to be used. The bodies may belong to one or more separatesolid_body_tidevariation models. If the list is left empty, all compatible basic solid-body tide-raising bodies/models ofdeformed_bodywill be used. By using this parameter, the value of \(k_{l}\) will be identical for the tides raised by each body in this list once parameter values are reset, even if they were different upon environment initializationuse_complex_love_number (bool) – Boolean defining whether the estimated Love number is real or imaginary
- Returns:
Object for the specified body’s Love number \(k_{l}\) for the tides raised by the specified bodies
- Return type:
- order_varying_k_love_number(deformed_body: str, degree: int, orders: list[int], deforming_bodies: list[str], use_complex_love_number: bool) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s \(k_{lm}\) Love numbers.
Function for creating parameter settings for a body’s \(k_{lm}\) Love numbers. When using this function, we assume (for the case of degree 2 Love number) that \(k_{20}\neq k_{21}\neq k_{22}\). The estimation of the Love numbers can be limited to a subset of the bodies that raise a tide on the body undergoing tidal deformation.
Using the \(k_{lm}\) Love number as estimatable parameter requires:
A
solid_body_tide_degree_order_variable_k()gravity field variation model in thedeformed_body(orsolid_body_tide_degree_order_variable_complex_k()ifuse_complex_love_numberis set to true)Any dynamical model to depend on the gravity field of the body specified by the
deformed_bodyparameter
- Parameters:
deformed_body (str) – Name of the body that is undergoing tidal deformation
degree (int) – Degree \(l\) of the Love numbers \(k_{lm}\) that are to be estimated
orders (list[int]) – Orders \(m\) of the Love numbers \(k_{lm}\) that are to be estimated
deforming_bodies (list[str]) – List of bodies that raise a tide on
deformed_bodyfor which the Love numbers defined by this setting is to be used. If the list is left empty, all tide-raising bodies will be used. By using this parameter, the values of \(k_{lm}\) will be identical for the tides raised by each body in this list once parameter values are reset, even if they were different upon environment initializationuse_complex_love_number (bool) – Boolean defining whether the estimated Love number is real or imaginary
- Returns:
Object for the specified body’s Love numbers \(k_{lm}\) for the tides raised by the specified bodies
- Return type:
- mode_coupled_k_love_numbers(deformed_body: str, love_number_indices: dict[tuple[int, int], list[tuple[int, int]]], deforming_bodies: list[str]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s mode-coupled \(k_{lm}^{l'm'}\) Love numbers.
Function for creating parameter settings for a body’s \(k_{lm}^{l'm'}\) Love numbers (see
mode_coupled_solid_body_tide model()details). The estimation of the Love numbers can be limited to a subset of the bodies that raise a (mode-coupled) tide on the body undergoing tidal deformation.Using the \(k_{lm}\) Love number as estimatable parameter requires:
A
mode_coupled_solid_body_tide()gravity field variation model in thedeformed_body.Any dynamical model to depend on the gravity field of the body specified by the
deformed_bodyparameter
- Parameters:
deformed_body (str) – Name of the body that is undergoing tidal deformation
love_number_indices (dict[tuple[int, int], list[tuple[int, int]]]) – Dictionary of Love number indices for each combination for forcing and response degree and order. The first tuple (key) is the forcing degree and order \(l,m\), the list of tuples (key) is the list of associated response degrees and orders \(l',m'\) for which the Love numbers are to be estimated (see
mode_coupled_solid_body_tide()for mathematical definition))deforming_bodies (list[str]) – List of bodies that raise a tide on
deformed_bodyfor which the Love numbers defined by this setting is to be used. If the list is left empty, all tide-raising bodies will be used. By using this parameter, the values of \(k_{lm}\) will be identical for the tides raised by each body in this list once parameter values are reset, even if they were different upon environment initialization
- Returns:
Object for the specified body’s mode-coupled Love numbers \(k_{lm}^{l'm'}\) for the tides raised by the specified bodies
- Return type:
- polynomial_gravity_field_variation_amplitudes(body_name: str, cosine_indices_per_power: dict[int, list[tuple[int, int]]], sine_indices_per_power: dict[int, list[tuple[int, int]]]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s polynomial gravity field amplitudes.
Function for creating parameter settings for a body’s polynomial gravity field amplitudes \(K_{i,\bar{C}_{lm}}\) and \(K_{i,\bar{S}_{lm}}\), as defined in
polynomial().Using this settings as estimatable parameter requires:
A
polynomial()(orsingle_power_polynomial()) gravity field variation model in thebody_name.Any dynamical model to depend on the gravity field of the body specified by the
deformed_bodyparameter
When using this parameter, a subset of all the variation amplitudes defined in the gravity field variation model can be estimated. These are defined in the
cosine_indices_per_powerandsine_indices_per_powerinputs- Parameters:
body_name (str) – Name of the body that is undergoing gravity field variation
cosine_indices_per_power (dict[int, list[tuple[int, int]]]) – Dictionary of powers \(i\) (as keys) with list of combinations of degrees \(l\) and orders \(m\) for which to estimate \(K_{i,\bar{C}_{lm}}\) as values (see
polynomial()for mathematical definition)sine_indices_per_power (dict[int, list[tuple[int, int]]]) – Dictionary of powers \(i\) (as keys) with list of combinations of degrees \(l\) and orders \(m\) for which to estimate \(K_{i,\bar{S}_{lm}}\) as values (see
polynomial()for mathematical definition)
- Returns:
Object for the specified body’s polynomial gravity field variations
- Return type:
- periodic_gravity_field_variation_amplitudes(body_name: str, cosine_indices_per_period: dict[int, list[tuple[int, int]]], sine_indices_per_period: dict[int, list[tuple[int, int]]]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s polynomial gravity field variation amplitudes
Function for creating parameter settings for a body’s polynomial gravity field variation amplitudes \(A_{i,\bar{C}_{lm}}\), \(B_{i,\bar{C}_{lm}}\), \(A_{i,\bar{S}_{lm}}\) and \(B_{i,\bar{S}_{lm}}\) as defined in
single_period_periodic().Using this settings as estimatable parameter requires:
A
periodic()(orsingle_period_periodic()) gravity field variation model in thebody_name.Any dynamical model to depend on the gravity field of the body specified by the
deformed_bodyparameter
When using this parameter, a subset of all the variation amplitudes defined in the gravity field variation model can be estimated. These are defined in the
cosine_indices_per_periodandsine_indices_per_periodinputs- Parameters:
body_name (str) – Name of the body that is undergoing gravity field variation
cosine_indices_per_period (dict[int, list[tuple[int, int]]]) – Dictionary of frequency index \(i\) (as keys; corresponding to frequency \(f_{i}\)) with list of combinations of degrees \(l\) and orders \(m\) for which to estimate \(A_{i,\bar{C}_{lm}}\) and \(B_{i,\bar{C}_{lm}}\) as values (see
periodic()for mathematical definition)sine_indices_per_period (dict[int, list[tuple[int, int]]]) – Dictionary of frequency index \(i\) (as keys; corresponding to frequency \(f_{i}\)) with list of combinations of degrees \(l\) and orders \(m\) for which to estimate \(A_{i,\bar{S}_{lm}}\) and \(B_{i,\bar{S}_{lm}}\) as values (see
periodic()for mathematical definition)
- Returns:
Object for the specified body’s periodic gravity field variations
- Return type:
- monomial_gravity_field_variation_amplitudes(body_name: str, power: int, cosine_indices: list[tuple[int, int]], sine_indices: list[tuple[int, int]]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s polynomial gravity field amplitudes at a single power.
Identical to
polynomial(), but for only a single power.- Parameters:
body_name (str) – Name of the body that is undergoing gravity field variation
power (int) – Power \(i\) for which to estimate polynomial gravity field variations
cosine_indices (list[tuple[int, int]]) – List of combinations of degrees \(l\) and orders \(m\) for which to estimate \(K_{i,\bar{C}_{lm}}\) (see
polynomial()for mathematical definition)sine_indices (list[tuple[int, int]]) – List of combinations of degrees \(l\) and orders \(m\) for which to estimate \(K_{i,\bar{S}_{lm}}\) (see
polynomial()for mathematical definition)
- Returns:
Object for the specified body’s polynomial gravity field variations
- Return type:
- monomial_full_block_gravity_field_variation_amplitudes(body_name: str, power: int, minimum_degree: int, minimum_order: int, maximum_degree: int, maximum_order: int) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s polynomial gravity field amplitudes at a single power.
Identical to
polynomial(), but for only a single power, and a full block of spherical harmonic coefficient degrees \(l\) and orders :math`m` For each degree \(l_{\text{min}}\le l \le l_{\text{max}}\), variations are estimated for all orders \(m_{\text{min}}\le m \le \left( \text{min}(m_{\text{max}},l) \right)\)- Parameters:
body_name (str) – Name of the body that is undergoing gravity field variation
power (int) – Power \(i\) for which to estimate polynomial gravity field variations
minimum_degree (int) – Minimum degree \(l_{\text{min}}\) for which \(K_{i,\bar{C}_{lm}}\) and \(K_{i,\bar{S}_{lm}}\) are to be estimated (see
polynomial()for mathematical definition)minimum_order (int) – Minimum order \(m_{\text{min}}\) for which \(K_{i,\bar{C}_{lm}}\) and \(K_{i,\bar{S}_{lm}}\) are to be estimated (see
polynomial()for mathematical definition)maximum_degree (int) – Maximum degree \(l_{\text{max}}\) for which \(K_{i,\bar{C}_{lm}}\) and \(K_{i,\bar{S}_{lm}}\) are to be estimated (see
polynomial()for mathematical definition)maximum_order (int) – Maximum degree \(m_{\text{max}}\) for which \(K_{i,\bar{C}_{lm}}\) and \(K_{i,\bar{S}_{lm}}\) are to be estimated (see
polynomial()for mathematical definition)
- Returns:
Object for the specified body’s polynomial gravity field variations
- Return type:
- direct_tidal_dissipation_time_lag(*args, **kwargs)¶
Overloaded function.
Overload 1:
direct_tidal_dissipation_time_lag(body: str, deforming_body: str) -> tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettingsConfigure estimation of the direct tidal dissipation time lag of
body, in seconds.deforming_bodyis the name, or list of names, of bodies raising the tides associated with the estimated lag.- Parameters:
- Returns:
Settings for the requested estimatable parameter.
- Return type:
Overload 2:
direct_tidal_dissipation_time_lag(body: str, deforming_body: list[str]) -> tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettingsConfigure estimation of the direct tidal dissipation time lag of
body, in seconds.deforming_bodyis the name, or list of names, of bodies raising the tides associated with the estimated lag.- Parameters:
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- inverse_tidal_quality_factor(*args, **kwargs)¶
Overloaded function.
Overload 1:
inverse_tidal_quality_factor(body: str, deforming_body: str) -> tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettingsConfigure estimation of the dimensionless inverse tidal quality factor of
body.deforming_bodyis the name, or list of names, of bodies raising the associated tides.- Parameters:
- Returns:
Settings for the requested estimatable parameter.
- Return type:
Overload 2:
inverse_tidal_quality_factor(body: str, deforming_body: list[str]) -> tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettingsConfigure estimation of the dimensionless inverse tidal quality factor of
body.deforming_bodyis the name, or list of names, of bodies raising the associated tides.- Parameters:
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- mean_moment_of_inertia(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s mean moment of inertia.
Function for creating parameter settings object for a body’s mean moment of inertia. In most cases, the mean moment of inertia will not influence the dynamics/observation directly and sensitivity to this parameter will not be included. The dynamics/observation will be sensitive to this parameter if the rotational dynamics of a relevant body is estimated. Using the mean moment of inertia as estimatable parameter requires:
The estimation of an initial rotational state of the body specified by the
bodyparameter
- Parameters:
body (str) – Name of the body, with whose body model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s mean moment of inertia.- Return type:
- periodic_spin_variations(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s periodic spin variations.
Function for creating parameter settings object for a body’s periodic spin variation parameters. Using the mean moment of inertia as estimatable parameter requires:
A
mars_high_accuracy()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s periodic spin variations.- Return type:
- polar_motion_amplitudes(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s polar motion amplitudes.
Function for creating parameter settings object for a body’s polar motion amplitudes. Using the polar motion amplitudes as estimatable parameter requires
A
mars_high_accuracy()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s polar motion amplitudes.- Return type:
- scaled_longitude_libration_amplitude(body_name: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure estimation of the scaled longitude libration amplitude of
body_name.- Parameters:
body_name (str) – Name of the body in the system of bodies.
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- core_factor(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s core factor.
Function for creating parameter settings object for a body’s core factor. Using the core factor as estimatable parameter requires
A
mars_high_accuracy()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s core factor.- Return type:
- free_core_nutation_rate(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s free core nutation rate.
Function for creating parameter settings object for a body’s free core nutation rate. Using the free core nutation rate as estimatable parameter requires
A
mars_high_accuracy()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s free core nutation rate.- Return type:
Create one estimatable bias shared by all observation links matching a selector.
Each selected observation model must already contain exactly one bias of the requested type, optionally within a combined bias. Initial values must agree unless the shared parameter value is explicitly set before its first binding. This assignment initializes the first set of models only. Reusing the parameter set for another estimator takes initial values from the new model settings; updates made while bound, including estimation updates, do not override them. A bias component can be owned by only one estimated parameter: overlapping ordinary or shared bias parameters are rejected. The matching body and reference-point name are both compared exactly.
- Parameters:
bias_type (tudatpy.estimation.observable_models_setup.biases.ObservationBiasTypes) – Supports constant_absolute_bias, constant_relative_bias, arc_wise_constant_absolute_bias, constant_time_bias, and arc_wise_time_bias. Relative biases are component-wise fractions.
observable_type (ObservableType) – Observable whose biases are shared.
link_end_type (LinkEndType) – Role of the shared link end, e.g. receiver.
link_end_id (LinkEndId) – Body and reference point of the shared link end.
arc_start_times (list[float], optional) – Required for arc-wise biases; finite, strictly increasing start times. Every matching model must use these same arcs.
time_link_end (LinkEndType, optional) – Event time used to select the active arc, defaulting to link_end_type. Reception and transmission times differ by the light travel time. For time biases, this is also the event whose time is shifted, and every matching model must use the same link end. Omit for other constant biases.
- Returns:
One vector parameter of observable size, or observable size times the number of arcs. Values are ordered by arc, then by observable component. Time biases have a single value (in seconds) per arc, independent of the observable size.
- Return type:
- absolute_observation_bias(link_ends: tudatpy.kernel.estimation.observable_models_setup.links.LinkDefinition, observable_type: tudatpy.kernel.estimation.observable_models_setup.model_settings.ObservableType) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for an absolute observation bias.
Function for creating parameter settings object for an observation’s absolute bias parameter. Using the absolute observation bias as estimatable parameter requires:
The observation model (corresponding to the link_ends and observable_type) to include an absolute bias (
absolute_bias())
- Parameters:
link_ends (
LinkDefinition) – Set of link ends that define the geometry of the biased observations.observable_type (ObservableType) – Observable type of the biased observations.
- Returns:
Instance of the
EstimatableParameterSettingsderivedConstantObservationBiasEstimatableParameterSettingsfor the specified observation’s arc-wise absolute bias.- Return type:
- relative_observation_bias(link_ends: tudatpy.kernel.estimation.observable_models_setup.links.LinkDefinition, observable_type: tudatpy.kernel.estimation.observable_models_setup.model_settings.ObservableType) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for an relative observation bias.
Function for creating parameter settings object for an observation’s relative bias parameter. Using the relative observation bias as estimatable parameter requires
The observation model (corresponding to the link_ends and observable_type) to include a relative bias (
relative_bias())
- Parameters:
link_ends (
LinkDefinition) – Set of link ends that define the geometry of the biased observations.observable_type (ObservableType) – Observable type of the biased observations.
- Returns:
Instance of the
EstimatableParameterSettingsderivedConstantObservationBiasEstimatableParameterSettingsfor the specified observation’s arc-wise relative bias.- Return type:
- arcwise_absolute_observation_bias(link_ends: tudatpy.kernel.estimation.observable_models_setup.links.LinkDefinition, observable_type: tudatpy.kernel.estimation.observable_models_setup.model_settings.ObservableType, arc_start_times: list[float], time_link_end: tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise absolute observation bias.
Function for creating parameter settings object for the arc-wise treatment of an observation’s absolute bias parameter. Using the arc-wise absolute observation bias as estimatable parameter requires
The observation model (corresponding to the link_ends and observable_type) to include an arc-wise absolute bias (
arcwise_absolute_bias())
- Parameters:
link_ends (
LinkDefinition) – Set of link ends that define the geometry of the biased observations.observable_type (ObservableType) – Observable type of the biased observations.
arc_start_times (List[ float ]) – List of times at which the arcs over which the bias is to be estimated will start.
time_link_end (LinkEndType) – The link end type (transmitter, receiver, etc.) at which the arc_start_times is evaluated.
- Returns:
Instance of the
EstimatableParameterSettingsderivedArcWiseConstantObservationBiasEstimatableParameterSettingsfor the specified observation’s arc-wise absolute bias.- Return type:
- arcwise_relative_observation_bias(link_ends: tudatpy.kernel.estimation.observable_models_setup.links.LinkDefinition, observable_type: tudatpy.kernel.estimation.observable_models_setup.model_settings.ObservableType, arc_start_times: list[float], time_link_end: tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise absolute observation bias.
Function for creating parameter settings object for the arc-wise treatment of an observation’s relative bias parameter. Using the arc-wise relative observation bias as estimatable parameter requires
The observation model (corresponding to the link_ends and observable_type) to include an arc-wise relative bias (
arcwise_relative_bias())
Note
This parameter may be estimated for a single-arc propagation, or a multi-arc propagation. In the latter case, the arcs selected for the estimation of the bias may, but need not, correspond to the arcs used for a multi-arc propagation.
- Parameters:
link_ends (
LinkDefinition) – Set of link ends that define the geometry of the biased observations.observable_type (ObservableType) – Observable type of the biased observations.
arc_start_times (List[ float ]) – List of times at which the arcs over which the bias is to be estimated will start.
time_link_end (LinkEndType) – The link end type (transmitter, receiver, etc.) at which the arc_start_times is evaluated.
- Returns:
Instance of the
EstimatableParameterSettingsderivedArcWiseConstantObservationBiasEstimatableParameterSettingsfor the specified observation’s arc-wise relative bias.- Return type:
- ground_station_position(body: str, ground_station_name: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for ground station position bias.
Function for creating parameter settings object for a ground station’s body-fixed Cartesian position. Using the ground station position bias as estimatable parameter requires:
At least one observation model to rely on the specified ground station
- Parameters:
- Returns:
EstimatableParameterSettingsobject for the specified ground station’s position bias.- Return type:
- reference_point_position(body: str, reference_point_name: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure estimation of the body-fixed Cartesian position of
reference_point_nameonbody, in metres.- Parameters:
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- ppn_parameter_gamma() tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for post-newtonian gamma parameter.
Function for creating parameter settings object for a global PPN \(\gamma\) parameter. Using the post-newtonian gamma parameter as estimatable parameter requires at least one of the following:
An acceleration model depending on this parameter, such as
relativistic_correction()An observation model with a light-time correction depending on this parameter, such as
first_order_relativistic_light_time_correction()
- Returns:
EstimatableParameterSettingsobject for a global post-newtonian \(\gamma\) parameter.- Return type:
- ppn_parameter_beta() tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for post-newtonian beta parameter.
Function for creating parameter settings object for a global PPN \(\beta\) parameter. Using the post-newtonian gamma parameter as estimatable parameter requires at least one of the following:
An acceleration model depending on this parameter, such as
relativistic_correction()An observation model with a light-time correction depending on this parameter (none yet implemented)
- Returns:
EstimatableParameterSettingsobject for a global post-newtonian \(\beta\) parameter.- Return type:
- global_polynomial_clock_corrections(associated_body: str, associated_station: str, correction_powers: list[int]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure estimation of polynomial clock correction coefficients shared across clock arcs.
associated_bodyandassociated_stationidentify the clock;correction_powerslists the polynomial powers whose coefficients are estimated.- Parameters:
associated_body (str) – Name of the body whose clock parameters are estimated.
associated_station (str) – Identifier of the ground station whose clock is estimated; an empty string selects the body’s clock.
correction_powers (list[int]) – Polynomial powers whose clock-correction coefficients are estimated.
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- arc_wise_polynomial_clock_corrections(associated_body: str, associated_station: str, correction_powers: list[int], arc_indices: list[int]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure estimation of separate polynomial clock corrections on selected arcs.
associated_bodyandassociated_stationidentify the clock,correction_powersselects polynomial terms andarc_indicesselects clock arcs.- Parameters:
associated_body (str) – Name of the body whose clock parameters are estimated.
associated_station (str) – Identifier of the ground station whose clock is estimated; an empty string selects the body’s clock.
correction_powers (list[int]) – Polynomial powers whose clock-correction coefficients are estimated.
arc_indices (list[int]) – Indices of the clock arcs whose correction coefficients are estimated.
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- time_drift_observation_bias(link_ends: dict[tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType, tudatpy.kernel.estimation.observable_models_setup.links.LinkEndId], observable_type: tudatpy.kernel.estimation.observable_models_setup.model_settings.ObservableType, ref_epoch: float, time_link_end: tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure estimation of an observation bias growing linearly with elapsed time from
ref_epoch.link_endsandobservable_typeidentify the observations.time_link_endspecifies the link end at which times are evaluated;ref_epochis in seconds since J2000.- Parameters:
link_ends (dict[LinkEndType, LinkEndId]) – Definition of the bodies and reference points participating in the observation link.
observable_type (ObservableType) – Type of observable to which the settings or measurements apply.
ref_epoch (float) – Reference epoch for the linear bias drift, in seconds since J2000.
time_link_end (LinkEndType) – Link end whose time is used when evaluating the bias drift.
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- arcwise_time_drift_observation_bias(link_ends: dict[tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType, tudatpy.kernel.estimation.observable_models_setup.links.LinkEndId], observable_type: tudatpy.kernel.estimation.observable_models_setup.model_settings.ObservableType, arc_start_times: list[float], ref_epochs: list[float], time_link_end: tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure estimation of a separate linear observation-bias drift on each time arc.
link_endsandobservable_typeidentify the observations.arc_start_timesandref_epochsgive arc boundaries and drift reference epochs in seconds since J2000;time_link_enddefines their time reference.- Parameters:
link_ends (dict[LinkEndType, LinkEndId]) – Definition of the bodies and reference points participating in the observation link.
observable_type (ObservableType) – Type of observable to which the settings or measurements apply.
arc_start_times (list[float]) – Start epochs of the bias arcs, in seconds since J2000.
ref_epochs (list[float]) – Reference epoch for the linear bias drift in each arc, in seconds since J2000.
time_link_end (LinkEndType) – Link end whose time is used when evaluating the bias drift.
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- constant_time_bias(link_ends: dict[tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType, tudatpy.kernel.estimation.observable_models_setup.links.LinkEndId], observable_type: tudatpy.kernel.estimation.observable_models_setup.model_settings.ObservableType, reference_link_end: tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure estimation of a constant time-tag bias for
link_endsandobservable_type.reference_link_endidentifies the link end whose observation time tags are shifted.- Parameters:
link_ends (dict[LinkEndType, LinkEndId]) – Definition of the bodies and reference points participating in the observation link.
observable_type (ObservableType) – Type of observable to which the settings or measurements apply.
reference_link_end (LinkEndType) – Link end at which the observation epochs are defined.
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- arcwise_time_bias(link_ends: dict[tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType, tudatpy.kernel.estimation.observable_models_setup.links.LinkEndId], observable_type: tudatpy.kernel.estimation.observable_models_setup.model_settings.ObservableType, arc_start_times: list[float], reference_link_end: tudatpy.kernel.estimation.observable_models_setup.links.LinkEndType) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure estimation of a separate time-tag bias on each arc for
link_endsandobservable_type.arc_start_timesgives arc boundaries in seconds since J2000, referenced toreference_link_end.- Parameters:
link_ends (dict[LinkEndType, LinkEndId]) – Definition of the bodies and reference points participating in the observation link.
observable_type (ObservableType) – Type of observable to which the settings or measurements apply.
arc_start_times (list[float]) – Start epochs of the bias arcs, in seconds since J2000.
reference_link_end (LinkEndType) – Link end at which the observation epochs are defined.
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- custom_parameter(custom_id: str, parameter_size: int, get_parameter_function: Callable[[], numpy.ndarray[numpy.float64[m, 1]]], set_parameter_function: Callable[[numpy.ndarray[numpy.float64[m, 1]]], None]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Configure a custom estimatable parameter vector identified by
custom_id.parameter_sizeis the vector length.get_parameter_functionreturns its current values andset_parameter_functionassigns a supplied vector.- Parameters:
custom_id (str) – Identifier of the user-defined estimatable parameter.
parameter_size (int) – Number of scalar entries in the parameter vector.
get_parameter_function (Callable[[], numpy.ndarray[numpy.float64[m, 1]]]) – Function without arguments returning the current parameter vector.
set_parameter_function (Callable[[numpy.ndarray[numpy.float64[m, 1]]], None]) – Function that applies the supplied parameter vector to the environment.
- Returns:
Settings for the requested estimatable parameter.
- Return type:
- custom_analytical_partial(analytical_partial_function: Callable[[float, numpy.ndarray[numpy.float64[3, 1]]], numpy.ndarray[numpy.float64[m, n]]], body_undergoing_acceleration: str, body_exerting_acceleration: str, acceleration_type: tudatpy.kernel.dynamics.propagation_setup.acceleration.AvailableAcceleration) tudatpy.kernel.dynamics.parameters_setup.CustomAccelerationPartialSettings¶
Configure a user-supplied acceleration partial for the specified accelerating body, source body and acceleration type.
analytical_partial_functionreceives the epoch in seconds since J2000 and the current three-component acceleration, and returns the acceleration derivative matrix.- Parameters:
analytical_partial_function (Callable[[float, numpy.ndarray[numpy.float64[3, 1]]], numpy.ndarray[numpy.float64[m, n]]]) – Function of time returning the analytical acceleration partial with respect to the parameter.
body_undergoing_acceleration (str) – Name of the body undergoing the acceleration.
body_exerting_acceleration (str) – Name of the body exerting the acceleration.
acceleration_type (AvailableAcceleration) – Type of acceleration to which the settings apply.
- Returns:
Settings defining how to compute the acceleration partial with respect to the parameter.
- Return type:
- custom_numerical_partial(parameter_perturbation: numpy.ndarray[numpy.float64[m, 1]], body_undergoing_acceleration: str, body_exerting_acceleration: str, acceleration_type: tudatpy.kernel.dynamics.propagation_setup.acceleration.AvailableAcceleration, environment_updates: dict[tudatpy.kernel.dynamics.parameters_setup.EnvironmentModelsToUpdate, list[str]] = {}) tudatpy.kernel.dynamics.parameters_setup.CustomAccelerationPartialSettings¶
Configure numerical acceleration partials using the component-wise
parameter_perturbationvector.body_undergoing_acceleration,body_exerting_accelerationandacceleration_typeidentify the model.environment_updatesmaps environment model types to bodies to refresh after a perturbation.- Parameters:
parameter_perturbation (numpy.ndarray[numpy.float64[m, 1]]) – Perturbation magnitude used to compute the numerical partial derivative.
body_undergoing_acceleration (str) – Name of the body undergoing the acceleration.
body_exerting_acceleration (str) – Name of the body exerting the acceleration.
acceleration_type (AvailableAcceleration) – Type of acceleration to which the settings apply.
environment_updates (dict[EnvironmentModelsToUpdate, list[str]], default = {}) – Environment models to refresh for each perturbed parameter value, with the corresponding body names.
- Returns:
Settings defining how to compute the acceleration partial with respect to the parameter.
- Return type:
- arcwise_drag_component_scaling(body: str, arc_initial_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise aerodynamic drag scaling factor
Function for creating parameter settings object for an arcwise scaling factor \(K\) (initialized to 1.0) for the aerodynamic force along the drag direction (effectively scaling the drag coefficient \(C_{D}\) (see
aerodynamic())Using the arc-wise drag component scaling as an estimatable parameter requires:
The body specified by the
bodyparameter to undergoaerodynamic()acceleration
Note that, unlike the
constant_drag_coefficient()parameter, this parameter does not modify the drag coefficient itself, but works regardless of the type of aerodynamic coefficients (in any frame, and with any dependencies). Using this parameter, the aerodynamic force along the drag direction is scaled (multiplied) by the factor \(K\) during each function evaluation.- Parameters:
- Returns:
Settings for the arc-wise acceleration scaling parameter.
- Return type:
ArcWiseAerodynamicScalingCoefficientEstimatableParameterSettings
- arcwise_exponential_atmosphere_base_density(body_name: str, arc_start_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Environment model parameter associated with the exponential atmosphere model of given body. This parameter allows for arc-wise estimation of the base density in an exponential atmosphere model of the given body.
- arcwise_exponential_atmosphere_scale_height(body_name: str, arc_start_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Environment model parameter associated with the exponential atmosphere model of given body. This parameter allows for arc-wise estimation of the scale height in an exponential atmosphere model of the given body.
- arcwise_lift_component_scaling(body: str, arc_initial_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise aerodynamic lift force scaling factor
As
arcwise_drag_component_scaling(), but scales the force along the \(C_{L}\) direction rather than the \(C_{D}\) direction- Parameters:
- Returns:
Settings for the arc-wise acceleration scaling parameter.
- Return type:
ArcWiseAerodynamicScalingCoefficientEstimatableParameterSettings
- arcwise_side_component_scaling(body: str, arc_initial_times: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for arc-wise aerodynamic side force scaling factor
As
arcwise_drag_component_scaling(), but scales the force along the \(C_{S}\) direction rather than the \(C_{D}\) direction- Parameters:
- Returns:
Settings for the arc-wise acceleration scaling parameter.
- Return type:
ArcWiseAerodynamicScalingCoefficientEstimatableParameterSettings
- area_to_mass_ratio_scaling_parameter(body_name: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a scaling factor for a body’s area to mass ratio(s)
Using these parameter settings, a scaling factor for the all acceleration models that contain an area-to-mass scaling factor \(A/m\), specifically radiation pressure or aerodynamics. Upon initialization, the value of this parameter \(p\) is equal to 1. When using it, it effectively scales the acceleration formulation such that \(A/m\rightarrow p(A/m)\). Estimating an area-to-mass ratio is typical in, for instance, orbit estimation of near-Earth space debris.
However, since the mass of a body is not (necessarily) a constant, and the reference area of a body is not (necessarily) related to a physical surface area, so we have opted to implement an \(A/m\) scaling factor as parameter instead. This scaling factor applies to both aerodynamics and radiation pressure, regardless of whether their reference areas are identical. It is also by definition comaptible with an object of varying mass.
Using this settings as estimatable parameter requires:
The acceleration models of body
body_nameto include one or more accelerations that contains an area to mass ratio \(A/m\) in its formulation, eitheraerodynamic()orradiation_pressure(). Each such acceleration will be scaled (multiplied) by the value of the parameter during the propagation
- Parameters:
body_undergoing_acceleration (str) – Name of the body for which the area-to-mass scaling factor is applied
- Returns:
Instance of the
EstimatableParameterSettingsclass for the specified scaling factor- Return type:
- exponential_atmosphere_base_density(body_name: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Environment model parameter associated with the exponential atmosphere model of given body. This parameter allows for estimation of the base density in an exponential atmosphere model of the given body.
- exponential_atmosphere_scale_height(body_name: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Environment model parameter associated with the exponential atmosphere model of given body. This parameter allows for estimation of the scale height in an exponential atmosphere model of the given body.
- full_acceleration_scaling_parameter(body_name_undergoing_acceleration: str, body_name_exerting_acceleration: str, acceleration_type: tudatpy.kernel.dynamics.propagation_setup.acceleration.AvailableAcceleration) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a scaling factor for a single acceleration acting on a body
Using these parameter settings, a scaling factor \(p\) is applied to a single acceleration \(\mathbf{a}\), increasing or decreasing it according to the value of the parameter \(p\) as \(\mathbf{a}\rightarrow p\mathbf{a}\). This parameter is typically used in an estimation to absorb a (constant scaling) mismodelling in a single acceleration. The value of \(p\) is initialized to 1 upon parameter creation
Using this settings as estimatable parameter requires:
The body
body_undergoing_accelerationundergoing an acceleration of exerted bybody_exerting_accelerationof typeacceleration_type
- Parameters:
body_undergoing_acceleration (str) – Name of the body undergoing the acceleration
body_exerting_acceleration (str) – Name of the body exerting the acceleration
acceleration_type (AvailableAcceleration) – Type of exerted acceleration
- Returns:
Instance of the
EstimatableParameterSettingsclass for the specified scaling factor- Return type:
- iau_rotation_model_longitudinal_librations(body: str, libration_angular_frequencies: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s longitudinal libration amplitudes in an IAU rotation model
Function for creating parameter settings for a body’s longitudinal libration amplitudes in an IAU rotation model Using this requires:
A
iau_rotation_model()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
This parameter estimates a list of \(W_{i}\) variables of the
iau_rotation_model()rotation model. The values of \(i\) for which \(W_{i}\) is estimated is defined by thelibration_angular_frequenciesinput, which defines the corresponding \(\omega_{W_i}\) values for which the librations are to be estimated. Note that the parameters are ordered as in thelibration_angular_frequenciesvector.- Parameters:
- Returns:
EstimatableParameterSettingsobject for the specified body’s property- Return type:
- iau_rotation_model_pole(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s nominal pole position in an IAU rotation model
Function for creating parameter settings for a body’s nominal pole position in an IAU rotation model Using this requires:
A
iau_rotation_model()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
This parameter estimates the \([\alpha_{0},\delta_{0}]\) variables of the
iau_rotation_model()rotation model- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s property- Return type:
- iau_rotation_model_pole_librations(body: str, libration_angular_frequencies: list[float]) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s pole libration amplitudes in an IAU rotation model
Function for creating parameter settings for a body’s pole libration amplitudes in an IAU rotation model Using this requires:
A
iau_rotation_model()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
This parameter estimates the libration amplitude \(\alpha_{i}\) and \(\delta_{i}\) variables of the
iau_rotation_model()rotation model. The values of \(i\) for which the amplitudes is estimated is defined by thelibration_angular_frequenciesinput, which defines the corresponding \(\omega_{alpha_i}\) (\(=\omega_{\delta_i}\)) values for which the amplitudes are to be estimated. Note that the parameters are ordered [\(\alpha_{i}\), \(\delta_{i}\), \(\alpha_{i+1}\), \(\alpha_{i+1}\), …], where the index \(i\) follows the order of the frequency terms provided in thelibration_angular_frequenciesinput argument.- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
libration_angular_frequencies (List[ float ]) – List of angular frequencies (\(\omega_{alpha_i}\) (\(=\omega_{\delta_i}\))) at which pole libration amplitudes (\(\alpha_{i}\), \(\delta_{i}\)) are to be included in estimatable parameter.
- Returns:
EstimatableParameterSettingsobject for the specified body’s property- Return type:
- iau_rotation_model_pole_rate(body: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Function for creating parameter settings for a body’s pole precession rate in an IAU rotation model
Function for creating parameter settings for a body’s pole precession rate in an IAU rotation model Using this requires:
A
iau_rotation_model()rotation model specified by thebodyparameterAny dynamical or observational model to depend on the rotation model of the body specified by the
bodyparameter
This parameter estimates the \([\dot{\alpha},\dot{\delta}]\) variables of the
iau_rotation_model()rotation model- Parameters:
body (str) – Name of the body, with whose rotation model the estimatable parameter is associated.
- Returns:
EstimatableParameterSettingsobject for the specified body’s property- Return type:
- rtg_force_vector(body_name: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Force model parameter associated with the RTG radiation acceleration. This parameter allows for estimation of RTG force direction (in body-fixed frame) and magnitude at the acceleration model reference epoch.
- rtg_force_vector_magnitude(body_name: str) tudatpy.kernel.dynamics.parameters_setup.EstimatableParameterSettings¶
Force model parameter associated with the RTG radiation acceleration. This parameter allows for estimation of RTG force magnitude at the acceleration model reference epoch.
Enumerations¶
Enumeration of model parameters that are available for estimation. |
|
Enumeration of radial, along-track and cross-track empirical acceleration components. |
|
Enumeration of constant, sine and cosine time dependence of an empirical acceleration component. |
- class EstimatableParameterTypes¶
Bases:
pybind11_objectEnumeration of model parameters that are available for estimation. In order to establish a parameter estimation settings for a parameter of a certain type, use the function dedicated to this parameter type. Note that not all of the listed types might be accessible via functions in the python interface yet.
Members:
arc_wise_initial_body_state_type : Estimatable parameter for arc-wise initial body state.
initial_body_state_type : Estimatable parameter for initial body state.
initial_rotational_body_state_type : Estimatable parameter for initial rotational body state.
gravitational_parameter_type : Estimatable parameter for gravitational parameter.
constant_drag_coefficient_type : Estimatable parameter for constant drag coefficient.
radiation_pressure_coefficient_type : Estimatable parameter for radiation pressure coefficient.
three_coefficient_radiation_pressure_coefficients_type : Estimatable parameter for three coefficient radiation pressure coefficients.
arc_wise_radiation_pressure_coefficient_type : Estimatable parameter for arc-wise radiation pressure coefficient.
spherical_harmonics_cosine_coefficient_block_type : Estimatable parameter for spherical harmonics cosine coefficient block.
spherical_harmonics_sine_coefficient_block_type : Estimatable parameter for spherical harmonics sine coefficient block.
constant_rotation_rate_type : Estimatable parameter for constant rotation rate.
rotation_pole_position_type : Estimatable parameter for rotation pole position.
constant_additive_observation_bias_type : Estimatable parameter for constant additive observation bias.
shared_observation_bias_type : Estimatable parameter for shared observation bias.
arcwise_constant_additive_observation_bias_type : Estimatable parameter for arc-wise constant additive observation bias.
constant_relative_observation_bias_type : Estimatable parameter for constant relative observation bias.
arcwise_constant_relative_observation_bias_type : Estimatable parameter for arc-wise constant relative observation bias.
ppn_parameter_gamma_type : Estimatable parameter for PPN parameter gamma.
ppn_parameter_beta_type : Estimatable parameter for PPN parameter beta.
ground_station_position_type : Estimatable parameter for ground station position.
equivalence_principle_lpi_violation_parameter_type : Estimatable parameter for equivalence principle lpi violation parameter.
empirical_acceleration_coefficients_type : Estimatable parameter for empirical acceleration coefficients.
arc_wise_empirical_acceleration_coefficients_type : Estimatable parameter for arc-wise empirical acceleration coefficients.
full_degree_tidal_love_number_type : Estimatable parameter for full degree tidal love number.
single_degree_variable_tidal_love_number_type : Estimatable parameter for single degree variable tidal love number.
direct_dissipation_tidal_time_lag_type : Estimatable parameter for direct dissipation tidal time lag.
mean_moment_of_inertia_type : Estimatable parameter for mean moment of inertia.
arc_wise_constant_drag_coefficient_type : Estimatable parameter for arc-wise constant drag coefficient.
periodic_spin_variation_type : Estimatable parameter for periodic spin variation.
polar_motion_amplitude_type : Estimatable parameter for polar motion amplitude.
core_factor_type : Estimatable parameter for core factor.
free_core_nutation_rate_type : Estimatable parameter for free core nutation rate.
desaturation_delta_v_values_type : Estimatable parameter for desaturation delta v values.
constant_time_drift_observation_bias_type : Estimatable parameter for constant time drift observation bias.
arc_wise_time_drift_observation_bias_type : Estimatable parameter for arc-wise time drift observation bias.
global_polynomial_clock_corrections_type : Estimatable parameter for global polynomial clock corrections.
arc_wise_polynomial_clock_corrections_type : Estimatable parameter for arc-wise polynomial clock corrections.
inverse_tidal_quality_factor_type : Estimatable parameter for inverse tidal quality factor.
radiation_pressure_target_perpendicular_direction_scaling_factor_type : Estimatable parameter for radiation pressure target perpendicular direction scaling factor.
radiation_pressure_target_direction_scaling_factor_type : Estimatable parameter for radiation pressure target direction scaling factor.
drag_component_scaling_factor_type : Estimatable parameter for drag component scaling factor.
side_component_scaling_factor_type : Estimatable parameter for side component scaling factor.
lift_component_scaling_factor_type : Estimatable parameter for lift component scaling factor.
arc_wise_drag_component_scaling_factor_type : Estimatable parameter for arc-wise drag component scaling factor.
arc_wise_side_component_scaling_factor_type : Estimatable parameter for arc-wise side component scaling factor.
arc_wise_lift_component_scaling_factor_type : Estimatable parameter for arc-wise lift component scaling factor.
rtg_force_vector_type : Estimatable parameter for RTG force vector.
area_to_mass_scaling_factor_type : Estimatable parameter for area-to-mass scaling factor.
rtg_force_vector_magnitude_type : Estimatable parameter for RTG force vector magnitude.
exponential_atmosphere_base_density_type : Estimatable parameter for exponential atmosphere base density.
exponential_atmosphere_scale_height_type : Estimatable parameter for exponential atmosphere scale height.
arc_wise_exponential_atmosphere_base_density_type : Estimatable parameter for arc-wise exponential atmosphere base density.
arc_wise_exponential_atmosphere_scale_height_type : Estimatable parameter for arc-wise exponential atmosphere scale height.
specular_reflectivity_type : Estimatable parameter for specular reflectivity.
diffuse_reflectivity_type : Estimatable parameter for diffuse reflectivity.
energy_accommodation_coefficient_type : Estimatable parameter for energy accommodation coefficient.
normal_accommodation_coefficient_type : Estimatable parameter for normal accommodation coefficient.
tangential_accommodation_coefficient_type : Estimatable parameter for tangential accommodation coefficient.
normal_velocity_at_wall_ratio_type : Estimatable parameter for normal velocity at wall ratio.
- EstimatableParameterTypes.name -> str
read-only
- class EmpiricalAccelerationComponents¶
Bases:
pybind11_objectEnumeration of radial, along-track and cross-track empirical acceleration components.
Members:
radial_empirical_acceleration_component : Radial empirical acceleration component in the local orbital frame.
along_track_empirical_acceleration_component : Along track empirical acceleration component in the local orbital frame.
across_track_empirical_acceleration_component : Across track empirical acceleration component in the local orbital frame.
- EmpiricalAccelerationComponents.name -> str
read-only
- class EmpiricalAccelerationFunctionalShapes¶
Bases:
pybind11_objectEnumeration of constant, sine and cosine time dependence of an empirical acceleration component.
Members:
constant_empirical : Constant empirical time dependence of an empirical acceleration.
sine_empirical : Sine empirical time dependence of an empirical acceleration.
cosine_empirical : Cosine empirical time dependence of an empirical acceleration.
- EmpiricalAccelerationFunctionalShapes.name -> str
read-only
Classes¶
Base class to defining settings of parameter to be estimated. |
|
Settings returned by |
- class EstimatableParameterSettings¶
Bases:
pybind11_objectBase class to defining settings of parameter to be estimated.
Functional (base) class for settings of model parameter to be estimated. Settings of simple parameters types are managed via this class, more complex parameter types are handled by specialised derivatives of this class. Instances of either base or derived class can be created via dedicated functions.
- property custom_partial_settings¶
Custom acceleration partial settings associated with this estimatable parameter.
- property parameter_identifier¶
Type and associated body of the parameter.
The identifier contains the type of the parameter, defined by the
EstimatableParameterTypesenumeration, the body and (if applicable) the reference point to which the parameter is associated. The identifier is represented by a tuple of the form(parameter_type, (body_name, reference_point_name)).- Type:
tuple[
EstimatableParameterTypes, tuple[str, str] ]
- class CustomAccelerationPartialSettings¶
Bases:
pybind11_objectSettings returned by
custom_analytical_partial(),custom_numerical_partial().