observation

This module contains a set of factory functions for setting up the observation models, for use in the tudat estimation framework

Functions

link_definition(link_ends)	Function to create a link definition object.
body_origin_link_end_id(body_name)	Function to create a link end identifier for the origin (typically center of mass) of a body.
body_reference_point_link_end_id(body_name, ...)	Function to create a link end identifier for a reference point on a body.
one_way_downlink_link_ends(transmitter, ...)	Function for defining one-way downlinks via LinkDefinition types.
one_way_uplink_link_ends(transmitters, receiver)	Function for defining one-way uplinks via LinkDefinition types.
light_time_convergence_settings(...)	Factory function for creating settings for a one-way range observable.
first_order_relativistic_light_time_correction(...)	Factory function for creating settings for first-order relativistic light-time corrections.
absolute_bias(bias_value)	Factory function for creating settings for an absolute observation bias.
relative_bias(bias_value)	Factory function for creating settings for a relative observation bias.
arcwise_absolute_bias(*args, **kwargs)	Overloaded function.
arcwise_absolute_bias(*args, **kwargs)	Overloaded function.
arcwise_relative_bias(*args, **kwargs)	Overloaded function.
arcwise_relative_bias(*args, **kwargs)	Overloaded function.
combined_bias(bias_list)	Factory function for creating settings for a combined observation bias.
one_way_range(link_ends, ...)	Factory function for creating settings for a one-way range observable.
n_way_range(link_ends, ...)	Factory function for creating settings for a n-way range observable.
n_way_range_from_one_way_links(...)	Factory function for creating settings for a n-way range observable.
two_way_range(link_ends, ...)	Factory function for creating settings for a two-way range observable.
two_way_range_from_one_way_links(...)	Factory function for creating settings for a two-way range observable.
angular_position(link_ends, ...)	Factory function for creating settings for an angular position observable.
relative_angular_position(link_ends, ...)	Factory function for creating settings for an angular position observable.
one_way_doppler_instantaneous(link_ends, ...)	Factory function for creating settings for a one-way instantaneous Doppler observable.
two_way_doppler_instantaneous_from_one_way_links(...)	Factory function for creating settings for a two-way instantaneous Doppler observable.
one_way_doppler_averaged(link_ends, ...)	Factory function for creating settings for a one-way averaged Doppler observable.
n_way_doppler_averaged(link_ends, ...)	Factory function for creating settings for an n-way averaged Doppler observable.
n_way_doppler_averaged_from_one_way_links(...)	Factory function for creating settings for an n-way averaged Doppler observable.
two_way_doppler_averaged(link_ends, ...)	Factory function for creating settings for an n-way averaged Doppler observable.
two_way_doppler_averaged_from_one_way_links(...)	Factory function for creating settings for an n-way averaged Doppler observable.
cartesian_position(link_ends, bias_settings)	Factory function for creating settings for a Cartesian position observable.
cartesian_velocity(link_ends, bias_settings)	Factory function for creating settings for a Cartesian velocity observable.
elevation_angle_viability(link_end_id, ...)	Factory function for defining single elevation angle viability setting.
elevation_angle_viability_list(link_end_ids, ...)	Factory function for defining list of elevation angle viability settings.
body_avoidance_viability(link_end_id, ...)	Factory function for defining body avoidance observation viability settings.
body_avoidance_viability_list(link_end_ids, ...)	Factory function for defining list of body avoidance viability settings.
body_occultation_viability(link_end_id, ...)	Factory function for defining body occultation viability settings.
body_occultation_viability_list(link_end_id, ...)	Factory function for defining body occultation viability settings.
doppler_ancilliary_settings([integration_time])	No documentation found.
two_way_range_ancilliary_settings([...])	Factory function for creating ancilliary settings for two-way range observable.
two_way_doppler_ancilliary_settings([...])	Factory function for creating ancilliary settings for two-way averaged Doppler observable.
n_way_range_ancilliary_settings([...])	Factory function for creating ancilliary settings for n-way range observable.
n_way_doppler_ancilliary_settings([...])	Factory function for creating ancilliary settings for n-way averaged Doppler observable.
tabulated_simulation_settings(...)	Factory function for creating settings object for observation simulation, using a predefined list of observation times.
tabulated_simulation_settings_list(...)	Factory function for creating a list of settings object for observation simulation, using a predefined list of observation times.
continuous_arc_simulation_settings(...)	Factory function for creating settings object for observation simulation, using observation times according to a requirement for a continuous tracking arc.
add_gaussian_noise_to_all(...)	Function for adding gaussian noise function to all existing observation simulation settings.
add_gaussian_noise_to_observable(...)	Function for adding gaussian noise function to existing observation simulation settings of a given observable type.
add_gaussian_noise_to_observable_for_link_ends(...)	No documentation found.
add_viability_check_to_all(...)	Function for including viability checks into existing observation simulation settings.
add_viability_check_to_observable_for_link_ends(...)	Function for including viability checks into existing observation simulation settings.

link_definition(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndId]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition

Function to create a link definition object.

Parameters:

link_ends (dict[LinkEndType,LinkEndId]) – Dictionary of link ends, with the key denoting the role in the observaton, and the associated value the identifier for the link end.

Returns:

The LinkDefinition object storing the link ends of the observation

Return type:

LinkDefinition

body_origin_link_end_id(body_name: str) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndId

Function to create a link end identifier for the origin (typically center of mass) of a body.

Function to create a link end identifier for the origin (typically center of mass) of a body. Using this option will simulate the origin of a body transmitter, receiving, etc. the observation. Although this is typically not physically realistic, it can be a useful approximation, in particular for simulation studies.

Parameters:

body_name (str) – Name of the body

Returns:

A LinkEndId object representing the center of mass of a body

Return type:

LinkEndId

body_reference_point_link_end_id(body_name: str, reference_point_id: str) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndId

Function to create a link end identifier for a reference point on a body.

Function to create a link end identifier for a reference point on a body, where the reference point is typically the identifier of a ground stations

Parameters:

• body_name (str) – Name of the body on which the reference point is located

• body_name – Name of the reference point on the body.

Returns:

A LinkEndId object representing a reference point on a body

Return type:

LinkEndId

one_way_downlink_link_ends(transmitter: tudat::observation_models::LinkEndId, receivers: List[tudat::observation_models::LinkEndId]) → List[Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, tudat::observation_models::LinkEndId]]

Function for defining one-way downlinks via LinkDefinition types.

Function for defining single or multiple one-way downlinks. Multiple downlinks share the same transmitters, but may each have a different receiver. For each downlink, the returned list will contain an additional LinkDefinition type.

Parameters:

• transmitter (Tuple[str, str]) – LinkEndId type (tuple of strings), where the first entrance identifies the body and the second entry the reference point of the single transmitter link end.

• receivers (List[ Tuple[str, str] ]) – List of LinkEndId types (tuple of strings), where for each tuple the first entrance identifies the body and the second entry the reference point of the receiver link end(s).

Returns:

List of one or more LinkDefinition types, each defining the geometry for one one-way downlink. A LinkDefinition type for a one one-way link is composed a dict with one receiver and one transmitter LinkEndType key, to each of which a LinkEndId type is mapped.

Return type:

List[ LinkDefinition ]

one_way_uplink_link_ends(transmitters: List[tudat::observation_models::LinkEndId], receiver: tudat::observation_models::LinkEndId) → List[Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, tudat::observation_models::LinkEndId]]

Function for defining one-way uplinks via LinkDefinition types.

Function for defining single or multiple one-way uplinks. Multiple uplinks share the same receiver, but may each have a different transmitter. For each uplink, the returned list will contain an additional LinkDefinition type.

Parameters:

• transmitters (List[ Tuple[str, str] ]) – List of LinkEndId types (tuple of strings), where for each tuple the first entrance identifies the body and the second entry the reference point of the transmitter link end(s).

• receiver (Tuple[str, str]) – LinkEndId type (tuple of strings), where the first entrance identifies the body and the second entry the reference point of the single receiver link end.

Returns:

List of one or more LinkDefinition types, each defining the geometry for one one-way uplink. A LinkDefinition type for a one one-way link is composed a dict with one receiver and one transmitter LinkEndType key, to each of which a LinkEndId type is mapped.

Return type:

List[ LinkDefinition ]

light_time_convergence_settings(iterate_corrections: bool = False, maximum_number_of_iterations: int = 50, absolute_tolerance: float = nan, failure_handling: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeFailureHandling = <LightTimeFailureHandling.accept_without_warning: 0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria

Factory function for creating settings for a one-way range observable.

Factory function for creating observation model settings of one-way range type observables, for a single link definition. The associated observation model creates a single-valued observable \(h_{_{\text{1-range}}}\) as follows (in the unbiased case):

\[h_{_{\text{1-range}}}(t_{R},t_{T})=|\mathbf{r}_{R}(t_{R})-\mathbf{r}_{T}(t_{T})| + \Delta s\]

where \(\mathbf{r}_{R}\), \(\mathbf{r}_{T}\), \(t_{R}\) and \(t_{T}\) denote the position function of receiver and transmitter, and evaluation time of receiver and transmitter. The term \(\Delta s\) denotes light-time corrections due to e.g relativistic, atmospheric effects (as defined by the light_time_correction_settings input). The transmission and reception time are related to the light-time \(T=t_{R}-t_{T}\), which is in turn related to the one-way range as \(T=h/c\) As a result, the calculation of the one-way range (and light-time) requires the iterative solution of the equation:

\[ \begin{align}\begin{aligned}t_{R}-t_{T}=c\left(|\mathbf{r}_{R}(t_{R})-\mathbf{r}(t_{R})| + \Delta s\right)\\The method for the iterative solution is described in the :func:`light_time_convergence_settings` entry\end{aligned}\end{align} \]

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver LinkEndType entries to be defined.

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is None (unbiased observation)

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings class defining the settings for the one-way observable.

Return type:

ObservationSettings

first_order_relativistic_light_time_correction(perturbing_bodies: List[str]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeCorrectionSettings

Factory function for creating settings for first-order relativistic light-time corrections.

Factory function for creating settings for first-order relativistic light-time corrections: the correction to the light time of a (set of) stationary point masses, computed up to c−2 according to general relativity as formulated by e.g. Moyer (2000). One ambiguity in the model is the time at which the states of the perturbing bodies are evaluated. We distinguish two cases:

• In the case where the perturbing body contains a link end of the observation (for instance perturbation due to Earth gravity field, with one of the link ends being an Earth-based station), the time at which the Earth’s state is evaluated equals the transmission time if Earth acts as transmitter, and reception time if Earth acts as receiver.

• In other cases, where the perturbing body is not involved in the link ends, its state is evaluated at the midpoint time between transmitter and receiver.

Parameters:

perturbing_bodies (str) – A list containing the names of the bodies due to which the light-time correction is to be taken into account.

Returns:

Instance of the LightTimeCorrectionSettings derived FirstOrderRelativisticLightTimeCorrectionSettings class, defining the settings for the light-time corrections

Return type:

FirstOrderRelativisticLightTimeCorrectionSettings

absolute_bias(bias_value: numpy.ndarray[numpy.float64[m, 1]]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for an absolute observation bias.

Factory function for creating settings for an absolute observation bias. When calculating the observable value, applying this setting will take the physically ideal observation \(h\), and modify it to obtain the biased observation \(\tilde{h}\) as follows:

\[\tilde{h}=h+K\]

where \(K\) is the bias_value. For an observable with size greater than 1, \(K\) is a vector and the addition is component-wise.

Parameters:

bias_value (numpy.ndarray) – A vector containing the bias that is to be applied to the observable. This vector should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

Returns:

Instance of the ObservationBiasSettings derived ConstantObservationBiasSettings class, defining the settings for a constant, absolute observation bias.

Return type:

ConstantObservationBiasSettings

relative_bias(bias_value: numpy.ndarray[numpy.float64[m, 1]]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for a relative observation bias.

Factory function for creating settings for a relative observation bias. When calculating the observable value, applying this setting will take the physically ideal observation \(h\), and modify it to obtain the biased observation \(\tilde{h}\) as follows:

\[\tilde{h}=h(1+K)\]

where \(K\) is the`bias_value`. For an observable with size greater than 1, \(K\) is a vector and the multiplication is component-wise.

Parameters:

bias_value (numpy.ndarray) – A vector containing the bias that is to be applied to the observable. This vector should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

Returns:

Instance of the ObservationBiasSettings derived ConstantObservationBiasSettings class, defining the settings for a constant, relative observation bias.

Return type:

ConstantObservationBiasSettings

arcwise_absolute_bias(*args, **kwargs)

Overloaded function.

1. arcwise_absolute_bias(arc_start_times: List[float], bias_values: List[numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for arc-wise absolute observation biases.

Factory function for creating settings for arc-wise absolute observation biases. This bias setting differs from the absolute_bias setting only through the option of setting the bias_value \(K\) to a different values for each arc.

Parameters:

• arc_start_times (List[ float ]) – List containing starting times for each arc.

• bias_values (List[ numpy.ndarray ]) – List of arc-wise bias vectors that are to be applied to the given observable. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

• reference_link_end_type (LinkEndType) – Defines the link end (via the LinkEndType) which is used as a reference for observation times.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

2. arcwise_absolute_bias(bias_values_per_start_time: Dict[float, numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for arc-wise absolute observation biases.

Factory function for creating settings for arc-wise absolute observation biases. This bias setting differs from the absolute_bias setting only through the option of setting the bias_value \(K\) to a different values for each arc.

Parameters:

• bias_values_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the bias value vectors for each arc are directly mapped to the starting times of the respective arc. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

• reference_link_end_type (LinkEndType) – Defines the link end (via the LinkEndType) which is used as a reference for observation times.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

arcwise_absolute_bias(*args, **kwargs)

Overloaded function.

1. arcwise_absolute_bias(arc_start_times: List[float], bias_values: List[numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for arc-wise absolute observation biases.

Factory function for creating settings for arc-wise absolute observation biases. This bias setting differs from the absolute_bias setting only through the option of setting the bias_value \(K\) to a different values for each arc.

Parameters:

• arc_start_times (List[ float ]) – List containing starting times for each arc.

• bias_values (List[ numpy.ndarray ]) – List of arc-wise bias vectors that are to be applied to the given observable. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

• reference_link_end_type (LinkEndType) – Defines the link end (via the LinkEndType) which is used as a reference for observation times.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

2. arcwise_absolute_bias(bias_values_per_start_time: Dict[float, numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for arc-wise absolute observation biases.

Factory function for creating settings for arc-wise absolute observation biases. This bias setting differs from the absolute_bias setting only through the option of setting the bias_value \(K\) to a different values for each arc.

Parameters:

• bias_values_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the bias value vectors for each arc are directly mapped to the starting times of the respective arc. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

• reference_link_end_type (LinkEndType) – Defines the link end (via the LinkEndType) which is used as a reference for observation times.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

arcwise_relative_bias(*args, **kwargs)

Overloaded function.

1. arcwise_relative_bias(arc_start_times: List[float], bias_values: List[numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for arc-wise relative observation biases.

Factory function for creating settings for arc-wise relative observation biases. This bias setting differs from the relative_bias setting only through the option of setting the bias_value \(K\) to a different values for each arc.

Parameters:

• arc_start_times (List[ float ]) – List containing starting times for each arc.

• bias_values (List[ numpy.ndarray ]) – List of arc-wise bias vectors that are to be applied to the given observable. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

• reference_link_end_type (LinkEndType) – Defines the link end (via the LinkEndType) which is used as a reference for observation times.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

2. arcwise_relative_bias(bias_values_per_start_time: Dict[float, numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for arc-wise relative observation biases.

Factory function for creating settings for arc-wise relative observation biases. This bias setting differs from the relative_bias setting only through the option of setting the bias_value \(K\) to a different values for each arc.

Parameters:

• bias_values_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the bias value vectors for each arc are directly mapped to the starting times of the respective arc. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

• reference_link_end_type (LinkEndType) – Defines the link end (via the LinkEndType) which is used as a reference for observation times.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

arcwise_relative_bias(*args, **kwargs)

Overloaded function.

1. arcwise_relative_bias(arc_start_times: List[float], bias_values: List[numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for arc-wise relative observation biases.

Factory function for creating settings for arc-wise relative observation biases. This bias setting differs from the relative_bias setting only through the option of setting the bias_value \(K\) to a different values for each arc.

Parameters:

• arc_start_times (List[ float ]) – List containing starting times for each arc.

• bias_values (List[ numpy.ndarray ]) – List of arc-wise bias vectors that are to be applied to the given observable. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

• reference_link_end_type (LinkEndType) – Defines the link end (via the LinkEndType) which is used as a reference for observation times.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

2. arcwise_relative_bias(bias_values_per_start_time: Dict[float, numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for arc-wise relative observation biases.

Factory function for creating settings for arc-wise relative observation biases. This bias setting differs from the relative_bias setting only through the option of setting the bias_value \(K\) to a different values for each arc.

Parameters:

• bias_values_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the bias value vectors for each arc are directly mapped to the starting times of the respective arc. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)

• reference_link_end_type (LinkEndType) – Defines the link end (via the LinkEndType) which is used as a reference for observation times.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

combined_bias(bias_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Factory function for creating settings for a combined observation bias.

Factory function for creating settings for a combined observation bias, calculating by combining any number of bias types. Each contribution of the combined bias is computed from the unbiased observable, so when applying both a relative and absolute bias, we get:

\[\tilde{h}=h+K_{a}+hK_{r}\]

And, crucially:

\[\tilde{h}\neq (h+K_{a})(1+K_{r})\]

where \(K_{r}\) and \(K_{a}\) is the relative and absolute bias, respectively.

Parameters:

bias_list (List[ class:ObservationBiasSettings ]) – A list containing the bias the bias settings that are to be applied to the observable.

Returns:

Instance of the ObservationBiasSettings derived MultipleObservationBiasSettings class, combining the settings for multiple observation biases.

Return type:

MultipleObservationBiasSettings

one_way_range(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6f69d68f0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a one-way range observable.

Factory function for creating observation model settings of one-way range type observables, for a single link definition. The associated observation model creates a single-valued observable \(h_{_{\text{1-range}}}\) as follows (in the unbiased case):

\[h_{_{\text{1-range}}}(t_{R},t_{T})=|\mathbf{r}_{R}(t_{R})-\mathbf{r}_{T}(t_{T})| + \Delta s\]

where \(\mathbf{r}_{R}\), \(\mathbf{r}_{T}\), \(t_{R}\) and \(t_{T}\) denote the position function of receiver and transmitter, and evaluation time of receiver and transmitter. The term \(\Delta s\) denotes light-time corrections due to e.g relativistic, atmospheric effects (as defined by the light_time_correction_settings input). The transmission and reception time are related to the light-time \(T=t_{R}-t_{T}\), which is in turn related to the one-way range as \(T=h/c\) As a result, the calculation of the one-way range (and light-time) requires the iterative solution of the equation:

\[ \begin{align}\begin{aligned}t_{R}-t_{T}=c\left(|\mathbf{r}_{R}(t_{R})-\mathbf{r}(t_{R})| + \Delta s\right)\\The method for the iterative solution is described in the :func:`light_time_convergence_settings` entry\end{aligned}\end{align} \]

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver LinkEndType entries to be defined.

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is None (unbiased observation)

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings class defining the settings for the one-way observable.

Return type:

ObservationSettings

n_way_range(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6f68c9270>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a n-way range observable.

Factory function for creating observation model settings of n-way range type observables, for a single link definition. The associated observation model creates a single-valued observable \(h_{_{\text{N-range}}}\) by combining together a series \(n\) one-way range observations (see one_way_range()). By default, the reception time of the \(i^{th}\) one-way range is set as the transmission time of the \((i+1)^{th}\) one-way range. A retransmission delay may be defined by ancilliary settings (see TODO) when creating observation simulation setings.

For this factory function, the settings for each constituent one-way range (with the exception of the link end identifiers) are equal.

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver LinkEndType entries to be defined, as well as a retransmitter1, retransmitter2, …. (with the number of retransmitters to be defined by the user).

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used for each constituent one-way range. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation). Note that only one bias setting is applied to the n-way observable.

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings derived NWayRangeObservationSettings class.

Return type:

NWayRangeObservationSettings

n_way_range_from_one_way_links(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a n-way range observable.

Factory function for creating observation model settings of n-way range type observables, for a single link definition. The implementation is the same as n_way_range(), with the difference that the constituent one-way ranges may have different settings.s

Parameters:

• one_way_range_settings (List[ ObservationModelSettings ]) – List of observation model settings for each of the \(n\) constituent one-way ranges of the n-way range observable. The LinkDefinition of this n-way range observable is created from this list, with the transmitter and retransmitter1 defined by the transmitter and receiver of the first entry in this list. The retransmitter``(n-1) and ``receiver are defined by the transmitter and receiver of the :math:`n`^{th} entry of this list.

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation). Note that only one bias setting is applied to the n-way observable.

Returns:

Instance of the ObservationModelSettings derived NWayRangeObservationSettings class.

Return type:

NWayRangeObservationSettings

two_way_range(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6f68c9130>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a two-way range observable.

Same as n_way_range(), with \(n=2\). This function is provided for convenience.

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter, retransmitter and receiver LinkEndType entries to be defined

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used for each constituent one-way range. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation). Note that only one bias setting is applied to the n-way observable.

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings derived NWayRangeObservationSettings class.

Return type:

NWayRangeObservationSettings

two_way_range_from_one_way_links(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a two-way range observable.

Same as n_way_range_from_one_way_links(), with \(n=2\). This function is provided for convenience.

Parameters:

• one_way_range_settings (List[ ObservationModelSettings ]) – List of observation model settings of size two, with the first entry the one-way range settings for the uplink, and the second entry the one-way range settings for the downlink. The LinkDefinition of this two-way range observable is created from this list, with the transmitter and retransmitter1 defined by the transmitter and receiver of the first entry in this list. The retransmitter and receiver are defined by the transmitter and receiver of the second entry of this list.

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation). Note that only one bias setting is applied to the n-way observable.

Returns:

Instance of the ObservationModelSettings derived NWayRangeObservationSettings class.

Return type:

NWayRangeObservationSettings

angular_position(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6f69d5770>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for an angular position observable.

Factory function for creating observation model settings of angular position type observables (as right ascension \(\alpha\) and declination \(\delta\)), for a single link definition. The associated observation model creates an observable \(\mathbf{h}_{_{\text{ang.pos.}}}\) of type two as follows (in the unbiased case):

\[\begin{split}\Delta\mathbf{r}=\mathbf{r}_{R}(t_{R})-\mathbf{r}_{T}(t_{T})\\ \tan\alpha=\frac{\Delta r_{y}}{\Delta r_{x}}\\ \delta=\frac{\Delta r_{z}}{\sqrt{\Delta r_{x}^{2}+\Delta r_{y}^{2}}}\\ \mathbf{h}_{_{\text{ang.pos.}}} = [\alpha;\delta]\end{split}\]

The relative position vector \(\Delta\mathbf{r}\) is computed identically as described for the one_way_range() The angular position observable can be used for optical astrometry, VLBI, etc. Due to the definition of this observable, the xy-plane is defined by the global frame orientation of the environment.

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver LinkEndType entries to be defined.

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings class defining the settings for the angular position observable.

Return type:

ObservationSettings

relative_angular_position(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6ee09b9f0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for an angular position observable.

Factory function for creating observation model settings of angular position type observables (as right ascension \(\alpha\) and declination \(\delta\)), for a single link definition. The associated observation model creates an observable \(\mathbf{h}_{_{\text{ang.pos.}}}\) of type two as follows (in the unbiased case):

\[\begin{split}\Delta\mathbf{r}=\mathbf{r}_{R}(t_{R})-\mathbf{r}_{T}(t_{T})\\ \tan\alpha=\frac{\Delta r_{y}}{\Delta r_{x}}\\ \delta=\frac{\Delta r_{z}}{\sqrt{\Delta r_{x}^{2}+\Delta r_{y}^{2}}}\\ \mathbf{h}_{_{\text{ang.pos.}}} = [\alpha;\delta]\end{split}\]

The relative position vector \(\Delta\mathbf{r}\) is computed identically as described for the one_way_range() The angular position observable can be used for optical astrometry, VLBI, etc. Due to the definition of this observable, the xy-plane is defined by the global frame orientation of the environment.

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver LinkEndType entries to be defined.

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings class defining the settings for the angular position observable.

Return type:

ObservationSettings

one_way_doppler_instantaneous(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, transmitter_proper_time_rate_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.DopplerProperTimeRateSettings = None, receiver_proper_time_rate_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.DopplerProperTimeRateSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6ec75e870>, normalized_with_speed_of_light: bool = False) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a one-way instantaneous Doppler observable.

Factory function for creating settings for a one-way instantaneous Doppler observable for a single link definition. The associated observation model creates a single-valued observable \(h_{_{\text{1-Dopp.}}}\) as follows (in the unbiased case):

\[h_{_{\text{1-Dopp.}}}=c\left(\frac{d\tau_{T}}{dt_{T}}\frac{t_{T}}{dt_{R}}\frac{dt_{R}}{d\tau_{R}}-1\right)\]

where \(t\) and \(\tau\) denote coordinate and proper time of the transmitter T and receiver R, respectively. The receiver and transmitter position and coordinate time are computed identically as described for the one_way_range(). The detailed mathematical implementation are described on TODO.

This observable represents the ‘instantaneous (non-integrated)’ Doppler observable, as obtained from open-loop observations. It should not be used for the modelling of the typical closed-loop observations used in deep space tracking (for which the one_way_doppler_averaged() should be used)

The coordinate time derivative \(\frac{t_{A}}{dt_{B}}\) is always computed when generating this observable. Settings for the proper time rates \(\frac{d\tau}{dt}\) can be specified by the user through the transmitter_proper_time_rate_settings and receiver_proper_time_rate_settings inputs. Whene these are left empty, the proper time rates are omitted (set to 1.0).

The observable may be non-dimensionalized by the speed of light \(c\), which results in the observable being equal to thee received and transmitted signal frequencies \(f_{R}/f_{T}-1\).

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the transmitter and receiver LinkEndType entries to be defined.

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

• transmitter_proper_time_rate_settings (DopplerProperTimeRateSettings, default = None) – Settings for computing the transmitter proper time rate \(\frac{d\tau}{dt}\), default is none (\(\frac{d\tau}{dt}=1\))

• receiver_proper_time_rate_settings (DopplerProperTimeRateSettings, default = None) – Settings for computing the receiver proper time rate \(\frac{d\tau}{dt}\), default is none (\(\frac{d\tau}{dt}=1\))

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

• normalized_with_speed_of_light (bool, default = false) – Option to non-dimensionalize the observable with speed of light \(c\)

Returns:

Instance of the ObservationModelSettings derived OneWayDopplerObservationSettings class defining the settings for the one-way open doppler observable observable.

Return type:

OneWayDopplerObservationSettings

two_way_doppler_instantaneous_from_one_way_links(uplink_doppler_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.OneWayDopplerObservationSettings, downlink_doppler_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.OneWayDopplerObservationSettings, bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a two-way instantaneous Doppler observable.

Factory function for creating settings for a two-way instantaneous Doppler observable for a single link definition. The implementation is the same as two_way_doppler_instantaneous(), with the difference that the constituent one-way ranges may have different settings.

The observable may be non-dimensionalized by the speed of light \(c\) (in the constituent one-way Doppler observable settings), which results in the observable being equal to the received and transmitted signal frequencies \(f_{R}/f_{T}-1\).

Parameters:

• uplink_doppler_settings (OneWayDopplerObservationSettings) – Settings for uplink leg of one-way observable, created using one_way_open_loop_doppler()

• downlink_doppler_settings (OneWayDopplerObservationSettings) – Settings for downlink leg of one-way observable, created using one_way_open_loop_doppler()

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the full observation, default is none (unbiased observation). Note that, even if no bias is applied to the two-way observable, the constituent one-way observables may still be biased.

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings derived TwoWayDopplerObservationSettings class defining the settings for the two-way open doppler observable.

Return type:

TwoWayDopplerObservationSettings

one_way_doppler_averaged(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6ec70fcf0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a one-way averaged Doppler observable.

Factory function for creating observation model settings for one-way averaged Doppler observables, for a single link definition. The associated observation model creates a single-valued observable \(h_{_{\text{1-\bar{Dopp}}}}\) as follows (in the unbiased case):

\[\begin{split}h_{_{\text{1-\bar{Dopp}}}}&=c\int_{t-\Delta t}^{t+\Delta t}\frac{t_{T}}{dt_{R}}d\bar{t}\\ &=\frac{h_{_{\text{1-range}}}(t_{R}=t+\Delta t,t_{T})-h_{_{\text{1-range}}}(t_{R}=t,t_{T})}{\Delta t}\end{split}\]

where, in the latter formulation (which is the one that is implemented), the observable is referenced to the receiver time. This averaged Doppler observable is computed as the difference of two one-way range observables (see one_way_range()), with the reference time shifted by \(\Delta t\). As such, it is sensitive to numerical errors for small \(\Delta t\)

The integration time \(\Delta t\) is defined in the ancilliary settings when simulating the observations (with 60 s as default).

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the transmitter and receiver LinkEndType entries to be defined.

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings derived OneWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.

Return type:

ObservationSettings

n_way_doppler_averaged(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6f69d5f70>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for an n-way averaged Doppler observable.

Factory function for creating observation model settings for n-way averaged Doppler observables, for a single link definition. The implemenation is analogous to the one_way_doppler_averaged() observable. But, in the present case the observable is computed from the difference of two n-way range observables, with the reference time shifted by \(\Delta t\).

The integration time \(\Delta t\) is defined in the ancilliary settings when simulating the observations (with 60 s as default).

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver LinkEndType entries to be defined, as well as a retransmitter1, retransmitter2, …. (with the number of retransmitters to be defined by the user).

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings derived NWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.

Return type:

ObservationSettings

n_way_doppler_averaged_from_one_way_links(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for an n-way averaged Doppler observable.

Factory function for creating observation model settings for n-way averaged Doppler observables, for a single link definition. The implementation is the same as n_way_doppler_averaged(), with the difference that the constituent one-way range observables may have different settings.

Parameters:

• one_way_range_settings (List[ ObservationModelSettings ]) – List of observation model settings for each of the \(n\) constituent one-way ranges of the n-way averaged range rate observable. The LinkDefinition of this n-way range observable is created from this list, with the transmitter and retransmitter1 defined by the transmitter and receiver of the first entry in this list. The retransmitter``(n-1) and ``receiver are defined by the transmitter and receiver of the :math:`n`^{th} entry of this list.

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

Returns:

Instance of the ObservationModelSettings derived NWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.

Return type:

ObservationSettings

two_way_doppler_averaged(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7fe6f68c9470>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for an n-way averaged Doppler observable.

Factory function for creating observation model settings for n-way averaged Doppler observables, for a single link definition. The implemenation is analogous to the one_way_doppler_averaged() observable. But, in the present case the observable is computed from the difference of two n-way range observables, with the reference time shifted by \(\Delta t\).

The integration time \(\Delta t\) is defined in the ancilliary settings when simulating the observations (with 60 s as default).

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver LinkEndType entries to be defined, as well as a retransmitter1, retransmitter2, …. (with the number of retransmitters to be defined by the user).

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings derived NWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.

Return type:

ObservationSettings

two_way_doppler_averaged_from_one_way_links(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for an n-way averaged Doppler observable.

Factory function for creating observation model settings for n-way averaged Doppler observables, for a single link definition. The implemenation is analogous to the one_way_doppler_averaged() observable. But, in the present case the observable is computed from the difference of two n-way range observables, with the reference time shifted by \(\Delta t\).

The integration time \(\Delta t\) is defined in the ancilliary settings when simulating the observations (with 60 s as default).

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver LinkEndType entries to be defined, as well as a retransmitter1, retransmitter2, …. (with the number of retransmitters to be defined by the user).

• light_time_correction_settings (List[ LightTimeCorrectionSettings ], default = list()) – List of corrections for the light-time that are to be used. Default is none, which will result in the signal being modelled as moving in a straight line with the speed of light

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

• light_time_convergence_settings (LightTimeConvergenceCriteria, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the light-time (default settings defined in light_time_convergence_settings())

Returns:

Instance of the ObservationModelSettings derived NWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.

Return type:

ObservationSettings

cartesian_position(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a Cartesian position observable.

Factory function for creating observation model settings of Cartesian position type observables. Note that this observable is typically not realized in reality, but can be very useful for verification or analysis purposes. This observable provides the inertial (w.r.t. global frame origin) Cartesian position of the observed_body defined by the link_ends input. The observable has size 3, and contains the \(x\), \(y\) and \(z\) position

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body` LinkEndType entries to be defined.

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

Returns:

Instance of the ObservationModelSettings class defining the settings for the cartesian position observable.

Return type:

ObservationSettings

cartesian_velocity(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for a Cartesian velocity observable.

Factory function for creating observation model settings of Cartesian position type observables. Note that this observable is typically not realized in reality, but can be very useful for verification or analysis purposes. This observable provides the inertial (w.r.t. global frame origin) Cartesian velocity of the observed_body defined by the link_ends input. The observable has size 3, and contains the \(x\), \(y\) and \(z\) velocity

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body` LinkEndType entries to be defined.

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

Returns:

Instance of the ObservationModelSettings class defining the settings for the cartesian velocity observable.

Return type:

ObservationSettings

313_euler_angles(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Factory function for creating settings for observable containing the body orientation as Euler angles.

Factory function for creating observation model settings of Euler angle type observables. This observable can be used for e.g. body attitude observations, but can also be very useful as ‘synthetic’ observable for verification or analysis purposes. This observable provides the rotation from inertial (defined by the global frame orientation) to body-fixed orientation of the body specified by the observed_body in the link_ends input. The observable has size 3, and contains the 3-1-3 (e.g. z-x-z) Euler angles

Parameters:

• link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body` LinkEndType entries to be defined.

• bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

Returns:

Instance of the ObservationModelSettings class defining the settings for the Euler angle observable.

Return type:

ObservationSettings

elevation_angle_viability(link_end_id: Tuple[str, str], elevation_angle: float) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings

Factory function for defining single elevation angle viability setting.

Factory function for defining elevation angle viability settings for single link end. When simulating observations, this setting ensures that any applicable observations, for which the local elevation angle at link end is less than some limit value, will be omitted.

Parameters:

• link_end_id (Tuple[str,str]) – Link end (as defined by body/reference point pair, see TODO), for which the elevation angle viability setting is to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”].

• elevation_angle (float) – Limit elevation angle, below which no observations are produced when using the simulate_observations() function. Note: this value must be in radians.

Returns:

Instance of the ObservationViabilitySettings class, defining the settings for observation viability

Return type:

ObservationViabilitySettings

elevation_angle_viability_list(link_end_ids: List[Tuple[str, str]], elevation_angle: float) → List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings]

Factory function for defining list of elevation angle viability settings.

Factory function for defining elevation angle viability settings for multiple link ends. Each entry in the returned list contains the observation viability settings for one link end. When simulating observations, these settings ensure that any applicable observations, for which the local elevation angle at a link end is less than some limit value, will be omitted.

Parameters:

• link_end_ids (List[ Tuple[str,str] ]) – List of individual link ends (as defined by body/reference point pair, see TODO), for which the elevation angle viability setting is to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”]. For each link end included in this list, it will be checked if a signal received by and/or transmitted (or reflected) by this link end violates the minimum elevation angle constraint.

• elevation_angle (float) – Limit elevation angle, below which no observations are produced when using the simulate_observations() function. Note: this value must be in radians.

Returns:

List of ObservationViabilitySettings objects, each defining the settings for observation viability of one link end.

Return type:

ObservationViabilitySettings

body_avoidance_viability(link_end_id: Tuple[str, str], body_to_avoid: str, avoidance_angle: float) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings

Factory function for defining body avoidance observation viability settings.

Factory function for defining body avoidance observation viability settings for single link ends. When simulating observations, this settings ensures that any applicable observations, for which the signal path passes ‘too close’ to a body, will be omitted. The definition of ‘too close’ is computed as the angle between:

• The line-of-sight vector from a link end to a given third body

• The line-of-sight between two link ends

This constraint is typically used to prevent the Sun from being too close to the field-of-view of the telescope(s), as defined by a so-called ‘SPE’ (Sun-Probe-Earth) angle constraint. The present viability setting generalizes this constraint.

Parameters:

• link_end_id (Tuple[str,str]) – Link end (as defined by body/reference point pair, see TODO), for which the viability settings are to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”] is entry in this list. For each link end included in this list, it will be checked if a signal received by and/or transmitted (or reflected) by this link end passes too close to the specified body.

• body_to_avoid (str) – Name of the body which the signal path should not pass ‘too close’ to.

• avoidance_angle (float) – Limit angle (generalization of SPE angle), below which no observations are produced when using the simulate_observations() function. Note: this value must be in radians.

Returns:

Instance of the ObservationViabilitySettings, defining the settings for observation viability.

Return type:

ObservationViabilitySettings

body_avoidance_viability_list(link_end_ids: List[Tuple[str, str]], body_to_avoid: str, avoidance_angle: float) → List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings]

Factory function for defining list of body avoidance viability settings.

Factory function for defining body avoidance viability settings for multiple link ends. Each entry in the returned list contains the observation viability settings for one link end. When simulating observations, these settings ensure that any applicable observations, for which the signal path passes ‘too close’ to a body, will be omitted. The definition of ‘too close’ is computed as the angle between:

• The line-of-sight vector from a link end to a given third body

• The line-of-sight between two link ends

This constraint is typically used to prevent the Sun from being too close to the field-of-view of the telescope(s), as defined by a so-called ‘SPE’ (Sun-Probe-Earth) angle constraint. The present viability setting generalizes this constraint.

Parameters:

• link_end_ids (List[ Tuple[str,str] ]) – List of individual link ends (as defined by body/reference point pair, see TODO), for which the elevation angle viability setting is to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”].

• body_to_avoid (str) – Name of the body which the signal path should not pass ‘too close’ to.

• avoidance_angle (float) – Limit angle (generalization of SPE angle), below which no observations are produced when using the simulate_observations() function. Note: this value must be in radians.

Returns:

List of ObservationViabilitySettings objects, each defining the settings for observation viability of one link end.

Return type:

ObservationViabilitySettings

body_occultation_viability(link_end_id: Tuple[str, str], occulting_body: str) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings

Factory function for defining body occultation viability settings.

Factory function for defining body occultation viability settings for single link ends. When simulating observations, this setting ensures that any applicable observations, for which the signal path is occulted by a given body, will be omitted. The occultation is computed using the shape model of the specified body.

Parameters:

• link_end_id (Tuple[str,str]) – Link end (as defined by body/reference point pair, see TODO), for which the viability settings are to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”] is entry in this list.

• body_to_avoid (str) – Name of the body which the signal path should not be occulted by.

Returns:

Instance of the ObservationViabilitySettings, defining the settings for observation viability.

Return type:

ObservationViabilitySettings

body_occultation_viability_list(link_end_id: Tuple[str, str], occulting_body: str) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings

Factory function for defining body occultation viability settings.

Factory function for defining body occultation viability settings for multiple link ends. Each entry in the returned list contains the observation viability settings for one link end. When simulating observations, these settings ensure that any applicable observations, for which the signal path is occulted by a given body, will be omitted. The occultation is computed using the shape model of the specified body.

Parameters:

• link_end_ids (List[ Tuple[str,str] ]) – List of individual link ends (as defined by body/reference point pair, see TODO), for which the viability settings are to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”] is entry in this list. For each link end included in this list, it will be checked if a signal received by and/or transmitted (or reflected) by this link end is occulted by the specified body.

• body_to_avoid (str) – Name of the body which the signal path should not be occulted by.

Returns:

List of ObservationViabilitySettings objects, each defining the settings for observation viability of one link end.

Return type:

ObservationViabilitySettings

doppler_ancilliary_settings(integration_time: float = 60.0) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings

No documentation found.

two_way_range_ancilliary_settings(retransmission_delay: float = 0.0) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings

Factory function for creating ancilliary settings for two-way range observable.

Factory function for creating ancilliary settings for a two-way range observable. Specifically, this function can be used to create settings for the retransmission delay of the observable. NOTE: this function is provided for convenience, and is equivalent to calling n_way_range_ancilliary_settings() with a single retransmission delay.

Parameters:

retransmission_delay (float, default = 0.0) – Retransmission delay that is to be applied to the simulation of the two-way observable

Returns:

Instance of the ObservationAncilliarySimulationSettings with the required settings.

Return type:

ObservationAncilliarySimulationSettings

two_way_doppler_ancilliary_settings(integration_time: float = 60.0, retransmission_delay: float = 0.0) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings

Factory function for creating ancilliary settings for two-way averaged Doppler observable.

Factory function for creating ancilliary settings for a two-way range observable. Specifically, this function can be used to create settings for the retransmission delay of the observable. NOTE: this function is provided for convenience, and is equivalent to calling n_way_doppler_ancilliary_settings() with a single retransmission delay.

Parameters:

• integration_time (float, default = 60.0) – Integration time that is to be used for the averaged Doppler observable

• retransmission_delay (float, default = 0.0) – Retransmission delay that is to be applied to the simulation of the two-way observable

Returns:

Instance of the ObservationAncilliarySimulationSettings with the required settings.

Return type:

ObservationAncilliarySimulationSettings

n_way_range_ancilliary_settings(retransmission_delays: List[float] = []) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings

Factory function for creating ancilliary settings for n-way range observable.

Factory function for creating ancilliary settings for a n-way range observable. Specifically, this function can be used to create settings for the retransmission delays of the observable, for each of the retransmitters.

Parameters:

retransmission_delays (list[ float ], default = None) – Retransmission delays that are to be applied to the simulation of the n-way observable. If kept empty, this results in 0 retransmission delay at each retransmitter. If defined, this list must be the same length as the number of retransmitters, and the \(i^{th}\) entry contains the retransmission delay of the \(i^{th}\) retrasmitter

Returns:

Instance of the ObservationAncilliarySimulationSettings with the required settings.

Return type:

ObservationAncilliarySimulationSettings

n_way_doppler_ancilliary_settings(integration_time: float = 60.0, retransmission_delays: List[float] = []) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings

Factory function for creating ancilliary settings for n-way averaged Doppler observable.

Factory function for creating ancilliary settings for a n-way averaged Doppler observable. Specifically, this function can be used to create settings for the integration time of the observable, and the retransmission delays for each of the retransmitters.

Parameters:

• integration_time (float, default = 60.0) – Integration time that is to be used for the averaged Doppler observable

• retransmission_delays (list[ float ], default = None) – Retransmission delays that are to be applied to the simulation of the n-way observable. If kept empty, this results in 0 retransmission delay at each retransmitter. If defined, this list must be the same length as the number of retransmitters, and the \(i^{th}\) entry contains the retransmission delay of the \(i^{th}\) retrasmitter

Returns:

Instance of the ObservationAncilliarySimulationSettings with the required settings.

Return type:

ObservationAncilliarySimulationSettings

tabulated_simulation_settings(observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, simulation_times: List[float], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType = <LinkEndType.receiver: 5>, viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings] = [], noise_function: Callable[[float], numpy.ndarray[numpy.float64[m, 1]]] = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings

Factory function for creating settings object for observation simulation, using a predefined list of observation times.

Factory function for creating single simulation settings object, using a predefined list of observation times. The list of resulting observations may be reduced compared to the simulation_times provided here, as only observations that meet the viability settings are retained during observation simulation (these may be provide directly here through the viability_settings input, or added later to the resulting settings object).

Parameters:

• observable_type (ObservableType) – Observable type of which observations are to be simulated.

• link_ends (LinkDefinition) – Link ends for which observations are to be simulated.

• simulation_times (List[float]) – List of times at which to perform the observation simulation.

• reference_link_end_type (LinkEndType, default = LinkEndType.receiver) – Defines the link end (via the LinkEndType) which is used as a reference time for the observation.

• viability_settings (List[ ObservationViabilitySettings ], default = [ ]) – Settings for the creation of the viability criteria calculators, which conduct viability checks on the simulated observations.

• noise_function (Callable[ [float], numpy.ndarray[numpy.float64[m, 1]] ], default = None) – Function providing the observation noise factors as a function of observation time.

Returns:

Instance of the ObservationSimulationSettings derived TabulatedObservationSimulationSettings class.

Return type:

TabulatedObservationSimulationSettings

tabulated_simulation_settings_list(link_ends_per_observable: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition]], simulation_times: List[float], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType = <LinkEndType.receiver: 5>, viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings] = []) → List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings]

Factory function for creating a list of settings object for observation simulation, using a predefined list of observation times.

Factory function for creating multiple tabulated observation simulation settings objects in a list. This function is equivalent to calling the tabulated_simulation_settings() repeatly, with the different observables and link definition provided here through link_ends_per_observable. During a single call to this function, one simulation settings object is created for each combination of observable type and link geometry given by the link_ends_per_observable parameter.

Parameters:

• link_ends_per_observable (Dict[ObservableType, List[LinkDefinition]]]) – Link geometry per observable type of which observations are to be simulated.

• simulation_times (List[ float ]) – List of times at which to perform the observation simulation.

• reference_link_end_type (LinkEndType, default = LinkEndType.receiver) – Defines the link end (via the LinkEndType) which is used as a reference for observation times. The single link end specified here will be considered as the reference link end for all simulation settings object created in the function call.

• viability_settings (List[ ObservationViabilitySettings ], default = [ ]) – Settings for the creation of the viability criteria calculators, which conduct viability checks on the simulated observations. The single settings list given here will be considered as potential viability settings for all simulation settings object created in the function call.

Returns:

List of ObservationSimulationSettings derived TabulatedObservationSimulationSettings objects.

Return type:

List[ TabulatedObservationSimulationSettings ]

continuous_arc_simulation_settings(observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, start_time: float, end_time: float, interval_between_observations: float, arc_limiting_constraints: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings, minimum_arc_duration: float, maximum_arc_duration: float, minimum_time_between_arcs: float, reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType = <LinkEndType.receiver: 5>, additional_viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings] = [], noise_function: Callable[[float], numpy.ndarray[numpy.float64[m, 1]]] = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings

Factory function for creating settings object for observation simulation, using observation times according to a requirement for a continuous tracking arc.

Factory function for creating settings object for observation simulation. Unlike the tabulated_simulation_settings() function, the resulting settings do not define the observation times explicitly. Instead, this settings object determines the observation times adaptively during the simulation of the observation, with the requirement that observations should be simulated over a set of contiguous arcs (if possible). The exact algorithm meets the following conditions:

• Observations are only simulated within the time span of start_time and end_time

• A contiguous tracking arc has simulated observations separated by interval_between_observations

• Starting from start_time, an observation is simulated each interval_between_observations. Once an observation is unviable, as defined by the arc_limiting_constraints input, it is checked whether the arc up until that point is longer in duration than minimum_arc_duration. If it is, the arc is added to the simulated observations. If not, the arc is discarded. In either case, a new arc is started once a viable is observation is encountered

• If the current arc reaching a duration greater than maximum_arc_duration, the arc is added to the existing observations, and a new arc is started

• If defined (e.g. if not NaN), the current observation time is incremented by minimum_time_between_arcs when an arc has been added to the observations.

Nominally, this algorithm ensures that any arc of observations has a minimum and maximum duration. In addition, it ensures that (if desired) there is a minimum time interval between two tracking arcs. This behaviour can be modified by adding additional_viability_settings, which are not used when computing the tracking arcs, but which are instead only used to reduce the set of simulated observations afterwards.

Parameters:

• observable_type (ObservableType) – Observable type of which observations are to be simulated.

• link_ends (LinkDefinition) – Link ends for which observations are to be simulated.

• start_time (float) – First time at which an observation is to be simulated (and checked for viability).

• end_time (float) – Maximum time at which an observation is to be simulated (and checked for viability).

• interval_between_observations (float) – Cadence (in seconds) of subsequent observations in an arc

• arc_limiting_constraints (List[ ObservationViabilitySettings ], default = [ ]) – List of settings for the creation of the viability criteria calculators, which are used to check if an observation is viable, and define whether an arc should be terminated.

• minimum_arc_duration (float) – Minimum permissible time for a tracking arc

• maximum_arc_duration (float) – Maximum permissible time for a tracking arc

• minimum_time_between_arc (float, default = NaN) – Minimum time between two tracking arcs. If NaN, this is effectively set to the interval_between_observations

• additional_viability_settings (List[ ObservationViabilitySettings ], default = [ ]) – Settings for the creation of the viability criteria calculators, which conduct viability checks on the simulated observations. These settings are not used to determine whether an arc is to be terminated, but are instead applied after the arcs have been computed.

• noise_function (Callable[ [float], numpy.ndarray[numpy.float64[m, 1]] ], default = None) – Function providing the observation noise factors as a function of observation time.

Returns:

Instance of the ObservationSimulationSettings derived TabulatedObservationSimulationSettings class.

Return type:

TabulatedObservationSimulationSettings

add_gaussian_noise_to_all(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], noise_amplitude: float) → None

Function for adding gaussian noise function to all existing observation simulation settings.

Function for including simple time-independent and time-uncorrelated Gaussian noise function to the simulation settings of one or more observable(s). The noise settings are added to all ObservationSimulationSettings object(s) in the observation_simulation_settings list.

Note: the ObservationSimulationSettings objects are modified in-place by this function, and thus the function does not return anything.

Parameters:

• observation_simulation_settings (List[ ObservationSimulationSettings ]) – Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

• noise_amplitude (float) – Standard deviation defining the un-biased Gaussian distribution for the noise.

Returns:

The ObservationSimulationSettings object(s) are changed in-place.

Return type:

None

add_gaussian_noise_to_observable(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], noise_amplitude: float, observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType) → None

Function for adding gaussian noise function to existing observation simulation settings of a given observable type.

As add_gaussian_noise_to_all(), except that the function only adds noise to entries of the observation_simulation_settings list that matches the specified observable_type.

Parameters:

• observation_simulation_settings (List[ ObservationSimulationSettings ]) – Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

• noise_amplitude (float) – Standard deviation defining the un-biased Gaussian distribution for the noise.

• observable_type (ObservableType) – Identifies the observable type in the observation simulation settings to which the noise is to be added.

Returns:

The ObservationSimulationSettings object(s) are changed in-place.

Return type:

None

add_gaussian_noise_to_observable_for_link_ends(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], noise_amplitude: float, observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, link_definition: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition) → None

No documentation found.

add_viability_check_to_all(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings]) → None

Function for including viability checks into existing observation simulation settings.

Function for adding viability checks to the observation simulation settings, such that only observations meeting certain conditions are retained. The noise settings are added to all ObservationSimulationSettings object(s) in the observation_simulation_settings list. Note: the ObservationSimulationSettings objects are modified in-place by this function, and thus the function does not return anything.

Parameters:

• observation_simulation_settings (List[ ObservationSimulationSettings ]) – Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

• viability_settings (List[ ObservationViabilitySettings ]) – List of one or more ObservationViabilitySettings objects, defining the viability checks to be included.

Returns:

The ObservationSimulationSettings object(s) are changed in-place.

Return type:

None

add_viability_check_to_observable_for_link_ends(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings], observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition) → None

Function for including viability checks into existing observation simulation settings.

As add_viability_check_to_all(), except that the function only adds noise to entries of the observation_simulation_settings list that matches the specified observable_type and link_definition.

Parameters:

• observation_simulation_settings (List[ ObservationSimulationSettings ]) – Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

• viability_settings (List[ ObservationViabilitySettings ]) – List of one or more ObservationViabilitySettings objects, defining the viability checks to be included.

• observable_type (ObservableType) – Identifies the observable type in the observation simulation settings for which the viability checks are to be considered.

• link_definition (LinkDefinition) – Identifies the link definition in the observation simulation settings for which the viability checks are to be considered.

Returns:

The :class

Return type:

None

Enumerations

LinkEndType	Enumeration of available link end types.
ObservableType	Enumeration of available observable types.
ObservationViabilityType	Enumeration of observation viability criterion types.
LightTimeFailureHandling	Enumeration of behaviour when failing to converge light-time with required settings.

class LinkEndType

Enumeration of available link end types.

Members:

unidentified_link_end

transmitter

reflector1

retransmitter

reflector2

reflector3

reflector4

receiver

observed_body

property name

class ObservableType

Enumeration of available observable types.

Members:

one_way_range_type

n_way_range_type

angular_position_type

relative_angular_position_type

position_observable_type

velocity_observable_type

one_way_instantaneous_doppler_type

one_way_averaged_doppler_type

two_way_instantaneous_doppler_type

n_way_averaged_doppler_type

euler_angle_313_observable_type

property name

class ObservationViabilityType

Enumeration of observation viability criterion types.

Members:

minimum_elevation_angle

body_avoidance_angle

body_occultation

property name

class LightTimeFailureHandling

Enumeration of behaviour when failing to converge light-time with required settings.

Members:

accept_without_warning

print_warning_and_accept

throw_exception

property name

Classes

LinkEndId	Object serving as identifier of a specific link end.
LinkDefinition	Object storing the link ends involved in a given observation.
DopplerProperTimeRateSettings	Base class to defining proper time rate settings.
ObservationSettings	Base class for defining observation settings.
OneWayDopplerObservationSettings	Class for defining the settings of one-way instantaneous Doppler observation models.
LightTimeCorrectionSettings	Base class to defining light time correction settings.
ObservationBiasSettings	Base class to defining observation bias settings.
ObservationSimulationSettings	Base class for defining settings for simulating observations.
TabulatedObservationSimulationSettings	Class for defining settings for simulating observations at a predefined set of times.
ObservationViabilitySettings	Enumeration of observation viability criterion types.
ObservationDependentVariableSettings	Base class for setting observation dependent variables.
ObservationAncilliarySimulationSettings	Class for holding ancilliary settings for observation simulation.

class LinkEndId

Object serving as identifier of a specific link end.

property body_name

No documentation found.

property reference_point

No documentation found.

class LinkDefinition

Object storing the link ends involved in a given observation.

class DopplerProperTimeRateSettings

Base class to defining proper time rate settings.

Functional (base) class for settings of proper time rate (at a single link end) for instantaneous Doppler observation model settings. Specific proper time rate settings must be defined using an object derived from this class. The derived classes are made accessible via dedicated factory functions.

class ObservationSettings

Base class for defining observation settings.

Functional (base) class for settings of observation models. Observation model settings define at least the type and geometry of a given observation. They can furthermore set observation biases and/or light-time corrections. Simple observation models settings that are fully characterised by these elements can be managed by this base class, which can be instantiated through dedicated factory functions, such as one_way_range(), cartesian_position(), angular_position(), etc. Model settings for specific observation models that require additional information such as integration time, retransmission time, etc. must be defined using an object derived from this class. The derived classes are made accessible through further factory functions.

class OneWayDopplerObservationSettings

Class for defining the settings of one-way instantaneous Doppler observation models.

ObservationSettings derived class for one-way instantaneous Doppler observation model settings. Settings object can account for additional observation model aspects such as light time corrections and proper time rate settings. Instances of this class can be created via the one_way_doppler_instantaneous() factory function.

class LightTimeCorrectionSettings

Base class to defining light time correction settings.

Functional (base) class for settings of light time corrections. This class is not used for calculations of corrections, but is used for the purpose of defining the light time correction properties. Specific light time correction settings must be defined using an object derived from this class. The derived classes are made accessible via dedicated factory functions, such as e.g. first_order_relativistic_light_time_correction()

class ObservationBiasSettings

Base class to defining observation bias settings.

Functional (base) class for settings of observation bias. Specific observation bias settings must be defined using an object derived from this class. The derived classes are made accessible via dedicated factory functions.

class ObservationSimulationSettings

Base class for defining settings for simulating observations.

Base class for defining settings for simulating observations. This simulation settings object defines observation times, noise and viability criteria, etc. at which observations are to be simulated. Therefore, one simulation settings object of this type can only refer to one combination of observable type and link geometry (LinkDefinition). The user does not interact with this class directly, but defines specific observation simulation settings using an object derived from this class (created through the associated factory function).

property noise_function

No documentation found.

property viability_settings_list

No documentation found.

class TabulatedObservationSimulationSettings

Class for defining settings for simulating observations at a predefined set of times.

ObservationSimulationSettings derived class for defining settings for simulating observations at a predefined set of times This type defines predefined time epochs at which applicable observations are to be simulated, stored in a rigid, “tabulated” form. Some observation times may be discarded due to the use of viability settings. Instances of this class are typicall created via the tabulated_simulation_settings() and tabulated_simulation_settings_list() factory functions.

class ObservationViabilitySettings

Enumeration of observation viability criterion types.

class ObservationDependentVariableSettings

Base class for setting observation dependent variables.

Functional (base) class for setting observation dependent variables as part of the observation output. Note: The associated functionality is not yet mature enough for the end user. Class is exposed for development purposes only.

class ObservationAncilliarySimulationSettings

Class for holding ancilliary settings for observation simulation.

get_float_list_settings(self: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings, setting_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationVariable, throw_exception: bool = True) → List[float]

Parameters:

• setting_type (ObservationAncilliarySimulationVariable) – Type of the setting for which the value is to be returned

• throw_exception (bool, default = false) – Boolean defining whether to throw an exception if the requested setting does not exist, or does not exist as list of floating point values.

Returns:

Value of the requested ancilliary variable (or empty list if it does not exist)

Return type:

list[ float ]

get_float_settings(self: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings, setting_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationVariable, throw_exception: bool = True) → float

Parameters:

• setting_type (ObservationAncilliarySimulationVariable) – Type of the setting for which the value is to be returned

• throw_exception (bool, default = false) – Boolean defining whether to throw an exception if the requested setting does not exist, or does not exist as a floating point value.

Returns:

Value of the requested ancilliary variable (or NaN if it does not exist)

Return type:

float