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 single or multiple one-way uplinks via LinkDefinition types.

light_time_convergence_settings(...)

Function for creating convergence settings for solving the light-time equation.

first_order_relativistic_light_time_correction(...)

Function for creating settings for first-order relativistic light-time corrections.

absolute_bias(bias_value)

Function for creating settings for an absolute observation bias.

relative_bias(bias_value)

Function for creating settings for a relative observation bias.

arcwise_absolute_bias(arc_start_times, ...)

Function for creating settings for arc-wise absolute observation biases.

arcwise_absolute_bias_per_time(...)

Function for creating settings for arc-wise absolute observation biases.

arcwise_relative_bias(arc_start_times, ...)

Function for creating settings for arc-wise relative observation biases.

arcwise_absolute_bias_per_time(...)

Function for creating settings for arc-wise absolute observation biases.

time_drift_bias(bias_value, time_link_end, ...)

Function for creating settings for a time-drift bias.

arc_wise_time_drift_bias(bias_value, ...)

Function for creating settings for arc-wise time-drift biases.

arc_wise_time_drift_bias_per_time(...)

Function for creating settings for arc-wise time-drift biases.

combined_bias(bias_list)

Function for creating settings for a combined observation bias.

one_way_range(link_ends, ...)

Function for creating settings for a one-way range observable.

n_way_range(link_ends, ...)

Function for creating settings for a n-way range observable.

n_way_range_from_one_way_links(...)

Function for creating settings for a n-way range observable.

two_way_range(link_ends, ...)

Function for creating settings for a two-way range observable.

two_way_range_from_one_way_links(...)

Function for creating settings for a two-way range observable.

angular_position(link_ends, ...)

Function for creating settings for an angular position observable.

relative_angular_position(link_ends, ...)

Function for creating settings for a relative angular position observable.

one_way_doppler_instantaneous(link_ends, ...)

Function for creating settings for a one-way instantaneous Doppler observable.

two_way_doppler_instantaneous_from_one_way_links(...)

Function for creating settings for a two-way instantaneous Doppler observable.

one_way_doppler_averaged(link_ends, ...)

Function for creating settings for a one-way averaged Doppler observable.

n_way_doppler_averaged(link_ends, ...)

Function for creating settings for an n-way averaged Doppler observable.

n_way_doppler_averaged_from_one_way_links(...)

Function for creating settings for an n-way averaged Doppler observable.

two_way_doppler_averaged(link_ends, ...)

Function for creating settings for an n-way averaged Doppler observable.

two_way_doppler_averaged_from_one_way_links(...)

Function for creating settings for an n-way averaged Doppler observable.

cartesian_position(link_ends, bias_settings)

Function for creating settings for a Cartesian position observable.

relative_cartesian_position(link_ends, ...)

Function for creating settings for a relative Cartesian position observable.

cartesian_velocity(link_ends, bias_settings)

Function for creating settings for a Cartesian velocity observable.

euler_angles_313(link_ends, bias_settings)

No documentation found.

elevation_angle_viability(link_end_id, ...)

Function for defining single elevation angle viability setting.

elevation_angle_viability_list(link_end_ids, ...)

Function for defining list of elevation angle viability settings.

body_avoidance_viability(link_end_id, ...)

Function for defining body avoidance observation viability settings.

body_avoidance_viability_list(link_end_ids, ...)

Function for defining list of body avoidance viability settings.

body_occultation_viability(link_end_id, ...)

Function for defining body occultation viability settings.

body_occultation_viability_list(link_end_id, ...)

Function for defining body occultation viability settings.

doppler_ancilliary_settings([integration_time])

Function for creating ancilliary settings for averaged Doppler observable.

two_way_range_ancilliary_settings([...])

Function for creating ancilliary settings for two-way range observable.

two_way_doppler_ancilliary_settings([...])

Function for creating ancilliary settings for two-way averaged Doppler observable.

n_way_range_ancilliary_settings(...)

Function for creating ancilliary settings for n-way range observable.

n_way_doppler_ancilliary_settings(...)

Function for creating ancilliary settings for n-way averaged Doppler observable.

tabulated_simulation_settings(...)

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

tabulated_simulation_settings_list(...)

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

get_default_reference_link_end(observabl_type)

Function for automatically retrieving the reference link end associated with a given observable type.

continuous_arc_simulation_settings(...)

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

continuous_arc_simulation_settings_list(...)

Function for creating a list of 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(...)

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

add_viability_check_to_all(...)

Function for including viability checks into existing observation simulation settings.

add_viability_check_to_observable(...)

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.

add_dependent_variables_to_all(...)

Function for including dependent variables into all existing observation simulation settings.

add_dependent_variables_to_observable(...)

Function for including dependent variables into selected existing observation simulation settings.

add_noise_function_to_all(...)

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

add_noise_function_to_observable(...)

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

add_noise_function_to_observable_for_link_ends(...)

Function for adding a custom noise function to existing observation simulation settings of a given observable type and link definition.

link_ends_delays

Enumeration of observation ancillary variable types.

Function to create a link definition object.

Function to create a link definition object. It returns the LinkDefinition object storing the link ends of the observation.

Parameters:

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

Returns:

The LinkDefinition object storing the link ends of the observation

Return type:

LinkDefinition

Examples

# Code Snippet to showcase the use of the link_definition function to return a LinkDefinition object
from tudatpy.numerical_simulation.estimation_setup import observation

# Create link_ends. These are the input parameters of the link_definition function
link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# Show that, using observation.link_definition, a LinkDefinition object is returned
print(observation.link_definition(link_ends))

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

Examples

# Code Snippet to showcase the use of the body_origin_link_end_id
from tudatpy.numerical_simulation.estimation_setup import observation

# Input of body_origin_link_end_id are strings (name of bodies, or satellites, or ground stations, etc...)
receiver = "Earth"
transmitter = "Delfi-C3"

# Call and print observation.body_origin_link_end_id with the proper inputs (receiver, transmitter)
# a LinkEndId object is returned for both receiver and transmitter
print(observation.body_origin_link_end_id(receiver))
print(observation.body_origin_link_end_id(transmitter))

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: LinkEndId, str

  • reference_point_id (str) – Identifier of a specific link end: LinkEndId, str

Returns:

A LinkEndId object representing a reference point on a body

Return type:

LinkEndId

Examples

# Code Snippet to showcase the use of the body_reference_point_link_end_id
from tudatpy.numerical_simulation.estimation_setup import observation

# Input of body_reference_point_link_end_id are strings (name of bodies, or satellites, or ground stations, etc...)
receiver = "Earth"
reference_point = "CoolTrackingStation"

# Call and print observation.body_reference_point_link_end_id with the proper inputs (receiver, reference_point)
# a LinkEndId object is returned
print(observation.body_reference_point_link_end_id(receiver, reference_point))

Function for defining one-way downlinks via LinkDefinition types.

Function for defining single or multiple one-way downlinks via LinkDefinition types. 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]) – List of LinkEndId types (tuple of strings), where, for each tuple, the first entry identifies the body and the second entry reference point of the single transmitter link end(s).

  • 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 ]

Examples

# Code Snippet to showcase the use of the one_way_downlink_link_ends function to return a LinkDefinition object

from tudatpy.kernel.numerical_simulation.estimation_setup import observation

# Create a dictionary of LinkEndId objects
link_ends = {
    observation.receiver: observation.body_origin_link_end_id("Earth"),
    observation.transmitter: observation.body_origin_link_end_id("Delfi-C3")
}

# Print individual LinkEndId objects
print("Transmitter:", link_ends[observation.transmitter])
print("Receiver:", link_ends[observation.receiver])

# Call one_way_downlink_link_ends with properly formatted arguments
# Note: The function expects a transmitter and a list of receivers
link_definition = observation.one_way_downlink_link_ends(
    link_ends[observation.transmitter],
    [link_ends[observation.receiver]]  # Receivers must be in a list
)

# Verify that the one_way_downlink_link_ends function returns a LinkDefinition object
print(link_definition)

Function for defining single or multiple one-way uplinks via LinkDefinition types.

Function for defining single or multiple one-way uplinks via LinkDefinition types. 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 entry identifies the body and the second entry the reference point of the transmitter link end(s).

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

Returns:

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

Return type:

List[ LinkDefinition ]

Examples

# Code Snippet to showcase the use of the one_way_uplink_link_ends function to return a LinkDefinition object
from tudatpy.kernel.numerical_simulation.estimation_setup import observation

# Create a dictionary of LinkEndId objects
link_ends = {
    observation.receiver: observation.body_origin_link_end_id("Earth"),
    observation.transmitter: observation.body_origin_link_end_id("Delfi-C3")
}

# Print individual LinkEndId objects
print("Transmitter:", link_ends[observation.transmitter])
print("Receiver:", link_ends[observation.receiver])

# Call one_way_uplink_link_ends with properly formatted arguments
# Note: The function expects a transmitter and a list of receivers
link_definition = observation.one_way_uplink_link_ends(
    [link_ends[observation.transmitter]], # Transmitters must be in a list
    link_ends[observation.receiver]
)

# Verify that the one_way_uplink_link_ends function returns a LinkDefinition object
print(link_definition)
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

Function for creating convergence settings for solving the light-time equation.

Function for creating convergence settings for solving the light-time equation. Computing the light time \(s=t_{R}-t_{T}\) between two receiver \(R\) and transmitter \(T\) requires the iterative solution of the following equation:

\[t_{R} - t_{T} = c\left(|\mathbf{r}_{R}(t_{R}) - \mathbf{r}_{T}(t_{T})| + \Delta s(t_{R}, t_{T}, \mathbf{r}_{R}(t_{R}), \mathbf{r}_{T}(t_{T}))\right)\]

where either the reception time \(t_{R}\) or the transmission time \(t_{T}\) is kept fixed (reference link end time). The term \(\Delta s\) contains any deviations in the light-time from straight-line propagation at speed of light (relativistic corrections, media corrections, etc.). The algorithm starts at \(t_{R}=t_{T}\), and uses this to evaluate the right-hand side of the above equation. This leads to a new value of \(t_{R}\) or \(t_{T}\) (depending on which is kept fixed) and the right-hand side is re-evaluated in a new iteration. The input to this function defines the settings for when the iteration will terminate.

Parameters:

  • iterate_corrections (bool, default = False) – Boolean denoting whether the terms \(\Delta s\) are recomputed at each iteration or not. If false, the corrections are calculated only on the first iteration. Afterwards, the value is kept fixed until convergence. Once preliminarily converged, the algorithm recomputes \(\Delta s\), and continues the iteration (until proper convergence) while now recomputing \(\Delta s\) each iteration. Setting this input to false is typically safe, and is computationally more efficient.

  • maximum_number_of_iterations (int, default = 50) – Maximum number of iterations taken by the algorithm. If this number of iterations is reached without convergence (as defined by absolute_tolerance input), the behaviour of the algorithm is defined by the failure_handling input.

  • absolute_tolerance (float, default = nan) – Difference in \(t_{R}-t_{T}\) between two consecutive iterations below which the algorithm is considered to be converged. Default value is nan, which means the default value is taken. The default value depends on the time representation used (1 ps for float; 1 fs for Time class)

  • failure_handling (LightTimeFailureHandling, default = accept_without_warning) – Input defines behaviour when failing to converge within the required number of iterations. NOTE: the default value should be overridden for high-accuracy applications

Returns:

Instance of the LightTimeConvergenceCriteria with the required settings.

Return type:

LightTimeConvergenceCriteria

Examples

# Code Snippet to showcase the use of the light_time_convergence_settings function
from tudatpy.numerical_simulation.estimation_setup import observation

# The light_time_convergence_settings function can be used with default inputs as just:
light_time_convergence_settings = observation.light_time_convergence_settings()
# A LightTimeConvergenceCriteria object is returned
print(light_time_convergence_settings)

# Users can also specify the following input arguments:
# iterate_corrections, maximum_number_of_iterations, absolute_tolerance, failure_handling.
# Let's set the failure_handling argument to LightTimeFailureHandling.print_warning_and_accept (default was LightTimeFailureHandling.accept_without_warning)
light_time_convergence_settings = observation.light_time_convergence_settings(
    failure_handling = observation.LightTimeFailureHandling.print_warning_and_accept
)
# Again, a LightTimeConvergenceCriteria object is returned
print(light_time_convergence_settings)
first_order_relativistic_light_time_correction(perturbing_bodies: list[str]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeCorrectionSettings

Function for creating settings for first-order relativistic light-time corrections.

Function for creating settings for first-order relativistic light-time corrections: These corrections account for the delay in light travel time caused by stationary point masses, calculated up to \(c^{-2}\) according to general relativity (e.g., Moyer, 2000). A key consideration in the model is the time at which the states of the perturbing bodies are evaluated. This depends on their involvement in the observation link ends:

    1. Perturbing Body as a Link End: If the perturbing body (e.g., Earth) is directly involved in the observation (e.g., as the location of a transmitter or receiver):

    • The body’s state is evaluated at the transmission time if it acts as the transmitter.

    • The body’s state is evaluated at the reception time if it acts as the receiver.

    1. Perturbing Body Not as a Link End: If the perturbing body is not part of the observation link ends, its state is evaluated at the midpoint time between the transmission and reception events.

Parameters:

perturbing_bodies (List[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 configured to include first-order relativistic light-time corrections.

Return type:

LightTimeCorrectionSettings

Examples

# Code Snippet to showcase the use of the first_order_relativistic_light_time_correction function
from tudatpy.numerical_simulation.estimation_setup import observation

# Create Link Ends dictionary
link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# Create a Link Definition Object from link_ends dictionary
Link_Definition_Object = observation.LinkDefinition(link_ends)

# The function first_order_relativistic_light_time_correction() requires a list of strings (perturbing body/bodies) as input
perturbing_body = ['Earth']
doppler_observation_settings = observation.first_order_relativistic_light_time_correction(perturbing_body)

# Show that it returns a LightTimeCorrectionSettings object.
print(doppler_observation_settings)
absolute_bias(bias_value: numpy.ndarray[numpy.float64[m, 1]]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Function for creating settings for an absolute observation bias.

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 defining the settings for a constant, absolute observation bias.

Return type:

ConstantObservationBiasSettings

Examples

# Code Snippet to showcase the use of the absolute_bias function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function absolute_bias() requires a numpy.array of bias values in input
bias_array = np.array([1e-2])
absolute_bias_settings = observation.absolute_bias(bias_array)

# Show that it returns an ObservationBiasSettings object.
print(absolute_bias_settings)
relative_bias(bias_value: numpy.ndarray[numpy.float64[m, 1]]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Function for creating settings for a relative observation bias.

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 class, defining the settings for a constant, relative observation bias.

Return type:

ConstantObservationBiasSettings

Examples

# Code Snippet to showcase the use of the relative_bias function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function relative_bias() requires a numpy.array of bias values in input
bias_array = np.array([1e-2])
relative_bias_settings_settings = observation.relative_bias(bias_array)

# Show that it returns an ObservationBiasSettings object.
print(relative_bias_settings_settings)
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

Function for creating settings for arc-wise absolute observation biases.

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

Examples

# Code Snippet to showcase the use of the arcwise_absolute_bias function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function arcwise_absolute_bias() requires:
# 1) an arc_start_times list ,2) a numpy.array of bias values in input, 3) reference_link_end_type
# Let's simulate two arcs
arc_start_times = [0, 60] # define start time in seconds
arcwise_bias_array = [np.array([1e-2]), np.array([2e-2])] # set arc bias
reference_link_end_type = observation.receiver # set bias at receiving link end
arcwise_absolute_bias_settings = observation.arcwise_absolute_bias(arc_start_times, arcwise_bias_array, observation.receiver)

# Show that it returns an ObservationBiasSettings object.
print(arcwise_absolute_bias_settings)
arcwise_absolute_bias_per_time(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

Function for creating settings for arc-wise absolute observation biases.

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

Examples

# Code Snippet to showcase the use of the arcwise_absolute_bias function from tudatpy.numerical_simulation.estimation_setup import observation import numpy as np

# The function arcwise_absolute_bias_settings_per_time() requires: # 1) a dictionary with times as keys and bias values as values ,2) a reference_link_end_type # Let’s simulate two arcs bias_value_per_start_time = dict() bias_value_per_start_time[0] = np.array([1e-2]) bias_value_per_start_time[60] = np.array([2e-2]) reference_link_end_type = observation.receiver # set bias at receiving link end

arcwise_absolute_bias_settings_per_time = observation.arcwise_absolute_bias_per_time(bias_value_per_start_time, reference_link_end_type)

# Show that it returns an ObservationBiasSettings object. print(arcwise_absolute_bias_settings_per_time)

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

Function for creating settings for arc-wise relative observation biases.

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

Examples

# Code Snippet to showcase the use of the arcwise_relative_bias function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function arcwise_relative_bias() requires:
# 1) an arc_start_times list ,2) a numpy.array of bias values in input, 3) reference_link_end_type
# Let's simulate two arcs
arc_start_times = [0, 60] # define start time in seconds
arcwise_bias_array = [np.array([1e-2]), np.array([2e-2])] # set arc bias
reference_link_end_type = observation.receiver # set bias at receiving link end
arcwise_relative_bias_settings = observation.arcwise_relative_bias(arc_start_times, arcwise_bias_array, reference_link_end_type)

# Show that it returns an ObservationBiasSettings object.
print(arcwise_relative_bias_settings)
arcwise_relative_bias_per_time(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

Function for creating settings for arc-wise relative observation biases.

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

Examples

# Code Snippet to showcase the use of the arcwise_relative_bias function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function arcwise_relative_bias_per_time() requires:
# 1) a dictionary with times as keys and bias values as values ,2) a reference_link_end_type
# Let's simulate two arcs
bias_value_per_start_time = dict()
bias_value_per_start_time[0] = np.array([1e-2])
bias_value_per_start_time[60] = np.array([2e-2])
reference_link_end_type = observation.receiver # set bias at receiving link end

arcwise_relative_bias_settings_per_time = observation.arcwise_relative_bias_per_time(bias_value_per_start_time, reference_link_end_type)

# Show that it returns an ObservationBiasSettings object.
print(arcwise_relative_bias_settings_per_time)
time_drift_bias(bias_value: numpy.ndarray[numpy.float64[m, 1]], time_link_end: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, ref_epoch: float) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Function for creating settings for a time-drift bias.

Function for creating settings for a time-drift bias. This bias setting generates the configuration for applying a constant time-drift bias to an observation model.

Parameters:

  • bias_value (numpy.ndarray) – Constant time drift bias that is to be considered for the observation time. This vector should be the same size as the observable to which it is assigned (e.g. size 1 for a range observable, size 2 for angular position, etc.)

  • time_link_end (LinkEndType) – Defines the link end (via the LinkEndType) which is used the current time.

  • ref_epoch (float) – Defines the reference epoch at which the effect of the time drift is initialised.

Returns:

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

Return type:

constantTimeDriftBias

Examples

# Code Snippet to showcase the use of the time_drift_bias function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function time_drift_bias() requires a numpy.array of bias value, time_link_end and ref_epoch as inputs
bias_array = np.array([1e-2])
time_link_end = observation.receiver
ref_epoch = 0
time_drift_bias_settings = observation.time_drift_bias(bias_array, time_link_end, ref_epoch)

# Show that it returns an ObservationBiasSettings object.
print(time_drift_bias_settings)
arc_wise_time_drift_bias(bias_value: list[numpy.ndarray[numpy.float64[m, 1]]], arc_start_times: list[float], time_link_end: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, ref_epochs: list[float]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Function for creating settings for arc-wise time-drift biases.

Function for creating settings for arc-wise time-drift biases. This bias setting differs from the time_drift_bias setting only through the option of setting the bias_value (time drift bias) to a different values for each arc.

Parameters:

  • bias_value (numpy.ndarray) – Constant time drift bias that is to be considered for the observation time. This vector should be the same size as the observable to which it is assigned (e.g. size 1 for a range observable, size 2 for angular position, etc.)

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

  • time_link_end (LinkEndType) – Defines the link end (via the LinkEndType) which is used the current time.

  • ref_epochs (List[ float ]) – List containing the arc-wise reference epochs at which the effect of the arc-wise time drift is initialised.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

Examples

# Code Snippet to showcase the use of the arcwise_time_drift_bias function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function arcwise_time_drift_bias() requires:
# 1) an arc_start_times list ,2) a numpy.array of bias values in input, 3) reference_link_end_type, 4) list of reference epochs
# Let's simulate two arcs
arc_start_times = [0, 60] # define start time in seconds
arcwise_bias_array = [np.array([1e-2]), np.array([2e-2])] # set arc bias
reference_link_end_type = observation.receiver # set bias at receiving link end
ref_epochs = [0,60]
arcwise_time_drift_bias_settings = observation.arc_wise_time_drift_bias(arcwise_bias_array, arc_start_times, observation.receiver, ref_epochs)

# Show that it returns an ObservationBiasSettings object.
print(arcwise_time_drift_bias_settings)
arc_wise_time_drift_bias_per_time(bias_value_per_start_time: dict[float, numpy.ndarray[numpy.float64[m, 1]]], time_link_end: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, ref_epochs: list[float]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Function for creating settings for arc-wise time-drift biases.

Function for creating settings for arc-wise time-drift biases. This bias setting differs from the time_drift_bias setting only through the option of setting the bias_value (time drift bias) to a different values for each arc.

Parameters:

  • bias_value_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the time 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.)

  • time_link_end (LinkEndType) – Defines the link end (via the LinkEndType) which is used the current time.

  • ref_epochs (List[ float ]) – List containing the arc-wise reference epochs at which the effect of the arc-wise time drift is initialised.

Returns:

Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

Return type:

ArcWiseConstantObservationBiasSettings

Examples

# Code Snippet to showcase the use of the arcwise_time_drift_bias_per_time function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function arcwise_time_drift_bias_per_time() requires:
# 1) an arc_start_times list ,2)  a dictionary with times as keys and bias values as values, 2) a reference_link_end_type, 3) reference_link_end_type, 4) list of reference epochs
# Let's simulate two arcs
bias_value_per_start_time = dict()
bias_value_per_start_time[0] = np.array([1e-2])
bias_value_per_start_time[60] = np.array([2e-2])
reference_link_end_type = observation.receiver # set bias at receiving link end
ref_epochs = [0,60]
arcwise_time_drift_bias_settings = observation.arc_wise_time_drift_bias(bias_value_per_start_time, reference_link_end_type, ref_epochs)

# Show that it returns an ObservationBiasSettings object.
print(arcwise_time_drift_bias_settings)
combined_bias(bias_list: list[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings]) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

Function for creating settings for a combined observation bias.

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[ObservationBiasSettings]) – A list containing 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

Examples

# Code Snippet to showcase the use of the combined_bias function
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

# The function combined_bias() allows to combine multiple ObservationBiasSettings objects.
# Let's combine absolute, relative and time_drift biases.
bias_array = np.array([1e-2])

# Define absolute and relative bias settings
absolute_bias_settings = observation.absolute_bias(bias_array)
relative_bias_settings = observation.absolute_bias(bias_array)

# Define Time Drift Bias
time_link_end = observation.receiver
ref_epoch = 0
time_drift_bias_settings = observation.time_drift_bias(bias_array, time_link_end, ref_epoch)

# combined_bias takes a list of ObservationBiasSettings objects as input
bias_list = [absolute_bias_settings, relative_bias_settings, time_drift_bias_settings]
combined_bias = observation.combined_bias(bias_list)

# Show that it returns an ObservationBiasSettings object.
print(combined_bias)
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 0x77d53276d4b0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Function for creating settings for a one-way range observable.

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:

\[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 light_time_convergence_settings() entry

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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

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

Return type:

ObservationSettings

Examples

# Code Snippet to showcase the use of the one_way_range function
from tudatpy.numerical_simulation.estimation_setup import observation

# Create Link Ends dictionary
link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# Create a Link Definition Object from link_ends dictionary. This will be the input to the function.
Link_Definition_Object = observation.LinkDefinition(link_ends)

# Create minimal ObservationSettings object (only required Link_Definition_Object argument is passed)
# Note: other optional parameters (bias_settings, light_time_correction_settings,  light_time_convergence_settings) can be set
observation_settings = observation.one_way_range(Link_Definition_Object)

# Show that this returns an ObservationSettings object.
print(observation_settings)
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 0x77d5327bd6b0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Function for creating settings for a n-way range observable.

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 ObservationAncilliarySimulationSettings()) when creating observation simulation setings.

For this 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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings derived NWayRangeObservationSettings class.

Return type:

NWayRangeObservationSettings

Examples

# Code Snippet to showcase the use of the n_way_range function
from tudatpy.numerical_simulation.estimation_setup import observation

# Create Link Ends dictionary
link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# n_way_range() takes a Link Definition Object as input to the function.
# Let's create it from link_ends
Link_Definition_Object = observation.LinkDefinition(link_ends)

# Create minimal ObservationSettings object (only required Link_Definition_Object argument is passed)
# Note: other optional parameters (bias_settings, light_time_correction_settings,  light_time_convergence_settings) can be set
observation_settings = observation.n_way_range(Link_Definition_Object)

# Show that n_way_range() returns an NWayRangeObservationSettings object.
print(observation_settings)

Function for creating settings for a n-way range observable.

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[ ObservationSettings ]) – 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 retransmitter 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 \(\text{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 ObservationSettings derived NWayRangeObservationSettings class.

Return type:

NWayRangeObservationSettings

Examples

# Code Snippet to showcase the use of the n_way_range_from_one_way_links function
from tudatpy.numerical_simulation.estimation_setup import observation

# Create Link Ends dictionary
link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# n_way_range_from_one_way_links() takes 1) a list of ObservationSettings objects and 2) bias as input (default is None)
# Let's create it.
Link_Definition_Object = observation.LinkDefinition(link_ends) # define LinkDefinition object
n_way_observation_settings_list = [observation.n_way_range(Link_Definition_Object)] # define (minimal) ObservationSettings object

n_way_from_one_link_observation_settings = observation.n_way_range_from_one_way_links(n_way_observation_settings_list, bias_settings = None)

# Show that n_way_range_from_one_way_links() returns an NWayRangeObservationSettings object.
print(n_way_from_one_link_observation_settings)
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 0x77d5327bd630>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings derived NWayRangeObservationSettings class.

Return type:

NWayRangeObservationSettings

Examples

# Code Snippet to showcase the use of the two_way_range function
from tudatpy.numerical_simulation.estimation_setup import observation

# two_way_range() takes a Link Definition Object as input to the function.
# Note: as for this case, transmitter, retransmitter and receiver are required to define the Link Ends dictionary
link_ends = dict()
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Earth")
link_ends[observation.retransmitter] = observation.body_origin_link_end_id("Delfi-C3")
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")

# Create the LinkDefinition object
Link_Definition_Object = observation.LinkDefinition(link_ends)

# Create minimal ObservationSettings object (only required Link_Definition_Object argument is passed)
# Note: other optional parameters (bias_settings, light_time_correction_settings,  light_time_convergence_settings) can be set
observation_settings = observation.two_way_range(Link_Definition_Object)

# Show that two_way_range() returns an NWayRangeObservationSettings object.
print(observation_settings)

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[ ObservationSettings ]) – 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 retransmitter 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 ObservationSettings derived NWayRangeObservationSettings class.

Return type:

NWayRangeObservationSettings

Examples

# Code Snippet to showcase the use of the two_way_range_from_one_way_links function
from tudatpy.numerical_simulation.estimation_setup import observation

# two_way_range_from_one_way_links() takes a list of ObservationSettings objects
# Note: as for this case, transmitter, retransmitter and receiver are required to define the Link Ends dictionary
link_ends = dict()
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Earth")
link_ends[observation.retransmitter] = observation.body_origin_link_end_id("Delfi-C3")
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")

# Create the LinkDefinition object to be used as input
Link_Definition_Object = observation.LinkDefinition(link_ends) # define LinkDefinition object
two_way_range_observation_settings_list = [observation.two_way_range(Link_Definition_Object)] # define (minimal) NWayRangeObservationSettings object
two_way_range_one_way_link_settings = observation.two_way_range_from_one_way_links(two_way_range_observation_settings_list)

# Show that two_way_range_from_one_way_links() returns an NWayRangeObservationSettings object.
print(two_way_range_one_way_link_settings)
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 0x77d5327bd830>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Function for creating settings for an angular position observable.

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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings 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 0x77d5327bd8f0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Function for creating settings for a relative angular position observable.

Function for creating observation model settings of relative angular position type observables (as right ascension difference \(\Delta \alpha\) and declination difference \(\Delta \delta\)), from two link definitions. 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}_1=\mathbf{r}_{R}(t_{R})-\mathbf{r}_{T1}(t_{T1}) \\ \tan\alpha_{1} =\frac{\Delta r_{1y}}{\Delta r_{1x}} \\ \delta_{1} =\frac{\Delta r_{1z}}{\sqrt{\Delta r_{1x}^{2}+\Delta r_{1y}^{2}}} \\ \Delta\mathbf{r}_2=\mathbf{r}_{R}(t_{R})-\mathbf{r}_{T2}(t_{T2}) \\ \tan\alpha_{2} =\frac{\Delta r_{2y}}{\Delta r_{2x}} \\ \delta_{2} =\frac{\Delta r_{2z}}{\sqrt{\Delta r_{2x}^{2}+\Delta r_{2y}^{2}}} \\ \mathbf{h}_{_{\text{rel.ang.pos.}}} = [\alpha_{2}-\alpha_{1};\delta_{2}-\delta_{1}]\end{split}\]

The relative position vectors \(\Delta\mathbf{r}_1\) and \(\Delta\mathbf{r}_2\) are computed identically as described for the one_way_range() The relative angular position observable can be used for optical astrometry, optical navigation, 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, transmitter2 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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings class defining the settings for the relative 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 0x77d5327bd9b0>, normalized_with_speed_of_light: bool = False) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Function for creating settings for a one-way instantaneous Doppler observable.

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 in: Moyer, T.D. (2000) Formulation for Observed and Computed Values of Deep Space Network Data Types for Navigation. Monograph 2, Deep Space Communications and Navigation Series, JPL Publication 00-7.

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 arguments (inputs, see Parameters). Whenever 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 = light_time_convergence_settings()) – Settings for convergence of the light-time

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

Returns:

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

Return type:

OneWayDopplerObservationSettings

Function for creating settings for a two-way instantaneous Doppler observable.

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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings 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 0x77d5327bdcb0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Function for creating settings for a one-way averaged Doppler observable.

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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings 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 0x77d53278ddf0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Function for creating settings for an n-way averaged Doppler observable.

Function for creating observation model settings for n-way averaged Doppler observables, for a single link definition. The implementation 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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings derived ~tudatpy.numerical_simulation.estimation_setup.observation.NWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.

Return type:

ObservationSettings

Function for creating settings for an n-way averaged Doppler observable.

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[ ObservationSettings ]) – 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 retransmitter 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 \(\text{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 ObservationSettings derived ~tudatpy.numerical_simulation.estimation_setup.observation.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 0x77d5327bc4f0>) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

Function for creating settings for an n-way averaged Doppler observable.

Function for creating observation model settings for n-way averaged Doppler observables, for a single link definition. The implementation 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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings derived ~tudatpy.numerical_simulation.estimation_setup.observation.NWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.

Return type:

ObservationSettings

Function for creating settings for an n-way averaged Doppler observable.

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 = light_time_convergence_settings()) – Settings for convergence of the light-time

Returns:

Instance of the ObservationSettings derived ~tudatpy.numerical_simulation.estimation_setup.observation.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

Function for creating settings for a Cartesian position observable.

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 ObservationSettings class defining the settings for the cartesian position observable.

Return type:

ObservationSettings

relative_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

Function for creating settings for a relative Cartesian position observable.

Function for creating observation model settings of relative 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 Cartesian position of the observed_body, w.r.t. the observer 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 and observer 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 ObservationSettings class defining the settings for the relative 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

Function for creating settings for a Cartesian velocity observable.

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 ObservationSettings class defining the settings for the cartesian velocity observable.

Return type:

ObservationSettings

euler_angles_313(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

No documentation found.

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

Function for defining single elevation angle viability setting.

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 LinkEndId), 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]

Function for defining list of elevation angle viability settings.

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 LinkEndId), 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

Function for defining body avoidance observation viability settings.

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 LinkEndId ), 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]

Function for defining list of body avoidance viability settings.

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 LinkEndId), 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

Function for defining body occultation viability settings.

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 LinkEndId), 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

Function for defining body occultation viability settings.

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 LinkEndId), 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

Function for creating ancilliary settings for averaged Doppler observable.

Function for creating ancilliary settings for an averaged Doppler observable. Specifically, this function can be used to create settings for the integration time of the observable. Note: in case no retransmission delays (or other additional ancilliary settings) are to be defined, this setting may be used for one-, two-, or N-way averaged Doppler.

Parameters:

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

Returns:

Instance of the ObservationAncilliarySimulationSettings with the required settings.

Return type:

ObservationAncilliarySimulationSettings

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

Function for creating ancilliary settings for two-way range observable.

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

Function for creating ancilliary settings for two-way averaged Doppler observable.

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(link_end_delays: list[float] = [], frequency_bands: list[tudat::observation_models::FrequencyBands] = []) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings

Function for creating ancilliary settings for n-way range observable.

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, link_end_delays: list[float] = [], frequency_bands: list[tudat::observation_models::FrequencyBands] = []) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings

Function for creating ancilliary settings for n-way averaged Doppler observable.

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, ancilliary_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings

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

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 should be 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]

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

Function for creating multiple tabulated observation simulation settings objects in a list. This function is equivalent to calling the tabulated_simulation_settings() repeatedly, 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 ]

Function for automatically retrieving the reference link end associated with a given observable type.

Parameters:

observable_type (ObservableType) – Observable type for which the associated reference link end is to be retrieved.

Returns:

Defines the link end (via the LinkEndType) which is typically used as a reference for observation times in e.g. tabulated_simulation_settings().

Return type:

LinkEndType

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

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

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 reaches 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

continuous_arc_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]], 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] = []) → list[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings]

Function for creating a list of settings object for observation simulation, using observation times according to a requirement for a continuous tracking arc.

Function for creating multiple settings objects for observation simulation in a list. This function is equivalent to calling the continuous_arc_simulation_settings() repeatedly, 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.

  • 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.

Returns:

List of ObservationSimulationSettings derived TabulatedObservationSimulationSettings objects.

Return type:

List[ 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:
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

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

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 and link_definition.

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.

  • link_definition (LinkDefinition) – Identifies the link definition in the observation simulation settings for which the noise is to be added.

Returns:

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

Return type:

None

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:
Returns:

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

Return type:

None

add_viability_check_to_observable(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) → None

Function for including viability checks into existing observation simulation settings.

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

Parameters:
Returns:

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

Return type:

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:
Return type:

None

add_dependent_variables_to_all(observation_simulation_settings: list[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], dependent_variable_settings: list[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationDependentVariableSettings], bodies: tudatpy.kernel.numerical_simulation.environment.SystemOfBodies) → None

Function for including dependent variables into all existing observation simulation settings.

Function for including the computation and reporting of dependent variables into the observation simulation settings of all observables. Note: The associated functionality is not yet mature enough for the end user. Function is exposed for development purposes only.

Modifications are applied to all given ObservationSimulationSettings object(s), matching each ObservationSimulationSettings object with the corresponding ObservationDependentVariableSettings entry in the dependent_variable_settings parameter. Note that the ObservationSimulationSettings objects are modified in-place and thus the function does not return anything.

Parameters:
add_dependent_variables_to_observable(observation_simulation_settings: list[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], dependent_variable_settings: list[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationDependentVariableSettings], bodies: tudatpy.kernel.numerical_simulation.environment.SystemOfBodies, observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType) → None

Function for including dependent variables into selected existing observation simulation settings.

As add_dependent_variables_to_all(), except that the function only adds includes the computation and reporting of dependent variables to entries of the observation_simulation_settings list that matches the specified observable_type.

Parameters:
add_noise_function_to_all(observation_simulation_settings_list: list[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], noise_amplitude: Callable[[float], numpy.ndarray[numpy.float64[m, 1]]]) → None

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

Function for including a custom noise function to the simulation settings of all observables. 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:
Returns:

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

Return type:

None

add_noise_function_to_observable(observation_simulation_settings_list: list[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], noise_amplitude: Callable[[float], numpy.ndarray[numpy.float64[m, 1]]], observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType) → None

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

As add_noise_function_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 (List[ ObservationSimulationSettings ]) – Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

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

  • 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

Function for adding a custom noise function to existing observation simulation settings of a given observable type and link definition.

As add_noise_function_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.

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

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

  • link_definition (LinkDefinition) – Identifies the link definition in the observation simulation settings for which the noise is to be added.

Returns:

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

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.

ObservationAncilliarySimulationVariable

Enumeration of observation ancillary variable types.
class LinkEndType

Enumeration of available link end types.

Examples

# Code snippet to print all available Link End Types
from tudatpy.numerical_simulation import estimation_setup

# Check how many Link End Types are available in Tudatpy
num_link_end_types = len(estimation_setup.observation.LinkEndType.__members__)
print(f'The length of all available Tudatpy Link End Types is: {num_link_end_types}')

# Print all available Link End Types using the "name" property
for i in range(num_link_end_types):
    print(i, estimation_setup.observation.LinkEndType(i).name)

Members:

unidentified_link_end

transmitter

reflector1

retransmitter

reflector2

reflector3

reflector4

receiver

transmitter2

observer

observed_body

property name
class ObservableType

Enumeration of available observable types.

Examples

# Code snippet to print all available Observable Types
from tudatpy.numerical_simulation import estimation_setup

num_observable_types = len(estimation_setup.observation.ObservableType.__members__)
print(f'The length of all available Tudatpy Observable Types is: {num_observable_types}')

# Print all available Observable Types using the "name" property
for i in range(num_observable_types):
    print(i, estimation_setup.observation.ObservableType(i).name)

Members:

one_way_range_type

n_way_range_type

angular_position_type

relative_angular_position_type

position_observable_type

velocity_observable_type

relative_position_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

dsn_one_way_averaged_doppler

dsn_n_way_averaged_doppler

doppler_measured_frequency_type

dsn_n_way_range

property name
class ObservationViabilityType

Enumeration of observation viability criterion types.

Examples

# Code snippet to print all available Observation Viability Types
from tudatpy.numerical_simulation import estimation_setup

num_observation_viability_types = len(estimation_setup.observation.ObservationViabilityType.__members__)
print(f'The length of all available Tudatpy Observation Viability Types is: {num_observation_viability_types}')

# Print all available Observation Viability Types using the "name" property
for i in range(num_observation_viability_types):
    print(i, estimation_setup.observation.ObservationViabilityType(i).name)

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.

Examples

# Code snippet to print all available Light Time Failure Handling Types
from tudatpy.numerical_simulation import estimation_setup

num_LightTimeFailureHandling_types = len(estimation_setup.observation.LightTimeFailureHandling.__members__)
print(f'The length of all available Tudatpy Light Time Failure Handling Types is: {num_LightTimeFailureHandling_types}')

# Print all available Observation Viability Types using the "name" property
for i in range(num_LightTimeFailureHandling_types):
    print(i, estimation_setup.observation.LightTimeFailureHandling(i).name)

Members:

accept_without_warning

print_warning_and_accept

throw_exception

property name
class ObservationAncilliarySimulationVariable

Enumeration of observation ancillary variable types.

Examples

# Code snippet to print all available Observation Ancillary Variable Types
from tudatpy.numerical_simulation import estimation_setup

num_observation_ancillary_variable_types = len(estimation_setup.observation.ObservationAncilliarySimulationVariable.__members__)
print(f'The length of all available Tudatpy  Observation Ancillary Variable Types is: {num_observation_ancillary_variable_types}')

# Print all Observation Ancillary Variable Types using the "name" property
for i in range(num_observation_ancillary_variable_types):
    print(i, estimation_setup.observation.ObservationAncilliarySimulationVariable(i).name)

Members:

link_ends_delays

doppler_integration_time

doppler_reference_frequency

frequency_bands

reception_reference_frequency_band

sequential_range_reference_frequency

sequential_range_lowest_ranging_component

range_conversion_factor

property name

Classes

LinkEndId

Base class serving as identifier of a specific link end.

LinkDefinition

Base class storing the link ends involved in a given observation.

DopplerProperTimeRateSettings

Base class to define proper time rate settings.

ObservationSettings

Base class to define settings of observation models.

OneWayDopplerObservationSettings

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

NWayRangeObservationSettings

No documentation found.

LightTimeCorrectionSettings

Base class to define light time correction settings.

LightTimeConvergenceCriteria

Base class to define criteria of light time convergence.

ObservationBiasSettings

Base class to defining observation bias settings.

ObservationSimulationSettings

Base class for defining settings for simulated observations.

TabulatedObservationSimulationSettings

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

ObservationViabilitySettings

Class for defining observation viability calculator settings.

ObservationDependentVariableSettings

Base class for setting observation dependent variables as part of the observation output.

ObservationAncilliarySimulationSettings

Base class for holding ancilliary settings for observation simulation.
class LinkEndId

Base class serving as identifier of a specific link end.

Base class serving as identifier of a specific link end. Instances of this class are typically created via the body_origin_link_end_id() function, whose output is indeed a LinkEndId object, representing the center of mass of a body.

Examples

# Code Snippet to produce a LinkEndId object
from tudatpy.numerical_simulation.estimation_setup import observation

link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# The keys of this dictionary are LinkEndType objects.
print(link_ends.keys())
# The values of this dictionary are LinkEndId objects.
print(link_ends.values())

# Print out (explicitly) the keys (link types) and values (link names).
# [Note: To accomplish this, we use the "name" property (link_type.name) of the LinkEndType enumeration,
# and the "body_name" property (link_name.body_name) of the LinkEndId class]

for link_type, link_name in link_ends.items():
    print(f'LinkEndType: {link_type.name}, LinkEndId: {link_name.body_name}')
property body_name

Name of the body where the reference point is located, str

Examples

# Code Snippet to produce a LinkEndId object
from tudatpy.numerical_simulation.estimation_setup import observation

link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# The keys of this dictionary are LinkEndType objects.
print(link_ends.keys())
# The values of this dictionary are LinkEndId objects.
print(link_ends.values())

# Print out the keys (link types) and values (link names)
for link_type, link_name in link_ends.items():
    print(f'LinkEndType: {link_type.name}, LinkEndId: {link_name.body_name}')
property reference_point

Function for setting a name for the reference point on a body.

Function for setting a name for the reference point on a body (tipically, the name of a ground station).

Examples

# Code Snippet to produce a LinkEndId object (e.g. ground station) on the Earth Surface
# and retrieve the link reference point using the  "reference_point" property

from tudatpy.numerical_simulation.estimation_setup import observation

# Set CoolTrackingStation (defined as a Reference Point on Earth) as a receiver
link_ends = dict()
link_ends[observation.receiver] = observation.body_reference_point_link_end_id("Earth", "CoolTrackingStation")

# Verify that CoolTracking Station is associated to the key observation.receiver
link_end_body = link_ends[observation.receiver].body_name # body on which the reference point is located
link_end_name = link_ends[observation.receiver].reference_point #reference point name
print(f'Link End Name: {link_end_name} is found on body: {link_end_body}')
class LinkDefinition

Base class storing the link ends involved in a given observation. Instances of this class are typically created defining a Link_Ends dictionary via the link_definition() function, whose output is a LinkDefinition object, storing the Link Ends involved in a given observation.

Examples

# Code Snippet to produce a LinkDefinition object
from tudatpy.numerical_simulation.estimation_setup import observation

link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# Show that what we created is a LinkDefinition object
Link_Definition_Object = observation.link_definition(link_ends)
print(Link_Definition_Object)

# [Optional]: Print the Link Ends (receiver and transmitter)  names
receiver_name = observation.link_definition(link_ends).link_end_id(observation.receiver).body_name
transmitter_name = observation.link_definition(link_ends).link_end_id(observation.transmitter).body_name
print(receiver_name)
print(transmitter_name)

Function to provide a dictionary of link ends.

Function to provide a dictionary of link ends, with the key denoting the role in the observation, and the associated value the identifier for the link end.

Parameters:

"link_end_type"

Returns:

Dictionary of link ends

Return type:

type: dict[LinkEndType,LinkEndId]

Examples

# Code Snippet to retrieve the LinkEnds names from a LinkDefinition object,
# using the "link_end_id" property of LinkDefinition (LinkDefinition.link_end_id)
from tudatpy.numerical_simulation.estimation_setup import observation

link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

Link_Definition_Object = observation.link_definition(link_ends)

# [Optional] Show that what we created is a LinkDefinition object
print(Link_Definition_Object)

# Print the Link Ends (receiver and transmitter)  names using the "link_end_id" property
print(observation.link_definition(link_ends).link_end_id(observation.receiver).body_name)
print(observation.link_definition(link_ends).link_end_id(observation.transmitter).body_name)
class DopplerProperTimeRateSettings

Base class to define proper time rate settings.

Base class to define proper time rate settings (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 functions.

class ObservationSettings

Base class to define settings of observation models.

Base class to define 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. Instances of this class are typically created via 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 functions.

Examples

# Code snippet to show the creation of an ObservationSettings object
from tudatpy.numerical_simulation.estimation_setup import observation

# Create Link Ends dictionary
link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# Create a Link Definition Object from link_ends dictionary
Link_Definition_Object = observation.LinkDefinition(link_ends)

# Create minimal ObservationSettings object (only required Link_Definition_Object argument is passed)
# Other optional parameters (bias_settings, light_time_correction_settings,  light_time_convergence_settings) are set by default
observation_settings = observation.one_way_range(Link_Definition_Object)

# Show that it is an ObservationSettings object.
print(observation_settings)
class OneWayDopplerObservationSettings

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

Derived Class for defining the settings of one-way instantaneous Doppler observation models. 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() function. Associated base class: ObservationSettings.

Examples

# Code snippet to show the creation of a OneWayDopplerObservationSettings object
from tudatpy.numerical_simulation.estimation_setup import observation

# Create Link Ends dictionary
link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# Create a Link Definition Object from link_ends dictionary
Link_Definition_Object = observation.LinkDefinition(link_ends)

# Use: observation.one_way_doppler_instantaneous to create a OneWayDopplerObservationSettings object (only required Link_Definition_Object argument is passed)
# Other optional parameters (bias_settings, light_time_correction_settings,  light_time_convergence_settings, proper time rate) are set by default
doppler_observation_settings = observation.one_way_doppler_instantaneous(Link_Definition_Object)

# Show that it is an OneWayDopplerObservationSettings object.
print(doppler_observation_settings)
class NWayRangeObservationSettings

No documentation found.

class LightTimeCorrectionSettings

Base class to define light time correction settings.

Base class to define light time correction settings. 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.

Instances of this class are typically created via the first_order_relativistic_light_time_correction() function

Examples

# Code snippet to show the creation of a LightTimeCorrectionSettings object
from tudatpy.numerical_simulation.estimation_setup import observation

# Create Link Ends dictionary
link_ends = dict()
link_ends[observation.receiver] = observation.body_origin_link_end_id("Earth")
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Delfi-C3")

# Create a Link Definition Object from link_ends dictionary
Link_Definition_Object = observation.LinkDefinition(link_ends)

# Case 1: perturbing body (Earth) involved in the observations
# In this case, Earth is a receiver, so the body’s state will be evaluated at the reception time.
perturbing_body = ['Earth']
doppler_observation_settings = observation.first_order_relativistic_light_time_correction(perturbing_body)

# Show that it is a LightTimeCorrectionSettings object.
print(doppler_observation_settings)

# Case 2: perturbing body (Sun) not involved in the observations
# In this case, the body's state will be evaluated at the midpoint time between the transmission and reception events.
perturbing_body = ['Sun']

# Use: observation.first_order_relativistic_light_time_correction to create a LightTimeCorrectionSettings object
# Note: first_order_relativistic_light_time_correction only requires the perturbing list of bodies to be passed as arguments
doppler_observation_settings = observation.first_order_relativistic_light_time_correction(perturbing_body)

# Show that it is an LightTimeCorrectionSettings object.
print(doppler_observation_settings.transmitter_proper_time_rate_settings)
print(dir(doppler_observation_settings))
class LightTimeConvergenceCriteria

Base class to define criteria of light time convergence.

Base class to define criteria of light time convergence. This class is not used for calculations of corrections, but is used for the purpose of defining the light time convergence criteria. Specific light time convergence criteria must be defined using an object derived from this class. Instances of this class are typically created via the light_time_convergence_settings() function.

Examples

# Code snippet to show the creation of a LightTimeConvergenceCriteria object
from tudatpy.numerical_simulation.estimation_setup import observation

# Create Default Light Time Convergence Settings (no args specified = setting default arguments)
light_time_convergence_settings = observation.light_time_convergence_settings()

# Show that it is an LightTimeConvergenceCriteria object.
print(light_time_convergence_settings)
class ObservationBiasSettings

Base class to defining observation bias settings.

Base class to defining observation bias settings. Specific observation bias settings must be defined using an object derived from this class. Instances of this class are typically created via the absolute_bias() or relative_bias() function.

Examples

# Code snippet to show the creation of an ObservationBiasSettings object
# using absolute and relative bias settings
from tudatpy.numerical_simulation.estimation_setup import observation
import numpy as np

bias_array = np.array([1e-2])

# Use absolute_bias function
absolute_bias_settings = observation.absolute_bias(bias_array)
# Show that it is an ObservationBiasSettings object.
print(absolute_bias_settings)

# Use relative_bias function
relative_bias_settings = observation.relative_bias(bias_array)
# Show that it is an ObservationBiasSettings object.
print(relative_bias_settings)
class ObservationSimulationSettings

Base class for defining settings for simulated observations.

property noise_function

Callable[ [float], numpy.ndarray[numpy.float64[m, 1]] ], default = None - Function providing the observation noise as a function of observation time (can be constant or time-dependent), default is None.

Type:

noise_function

property viability_settings_list

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

Type:

viability_settings_list

class TabulatedObservationSimulationSettings

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

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 typically created via the tabulated_simulation_settings() and tabulated_simulation_settings_list() functions.

Associated base class: ObservationSettings

Examples

# Code snippet to show the creation of a TabulatedObservationSimulationSettings object
import numpy as np
from tudatpy.astro.time_conversion import DateTime
from tudatpy.numerical_simulation.estimation_setup import observation

# Set simulation start and end epochs
simulation_start_epoch = DateTime(2000, 1, 1).epoch()
simulation_end_epoch   = DateTime(2000, 1, 4).epoch()

# Define the uplink link ends for one-way observable
link_ends = dict()
link_ends[observation.transmitter] = observation.body_origin_link_end_id("Earth")
link_ends[observation.receiver] = observation.body_origin_link_end_id("Delfi-C3")

# Create LinkDefinition Object and set observation settings for each link/observable
link_definition = observation.LinkDefinition(link_ends)
observation_settings_list = [observation.one_way_doppler_instantaneous(link_definition)]

# Define observation simulation times (separated by steps of 1 minute)
observation_times = np.arange(simulation_start_epoch, simulation_end_epoch, 60.0)

# Create TabulatedObservationSimulationSettings object
tabulated_observation_simulation_settings = observation.tabulated_simulation_settings(
    observation.one_way_instantaneous_doppler_type,
    link_definition,
    observation_times
)

# Show that this is indeed a TabulatedObservationSimulationSettings object
print(tabulated_observation_simulation_settings)
class ObservationViabilitySettings

Class for defining observation viability calculator settings.

Class for defining the settings for observation viability calculator creation. Instances of this class are typically be created through various dedicated functions,such as elevation_angle_viability(), body_avoidance_viability() and body_occultation_viability()

Examples

# Code snippet to show the creation of an ObservationViabilitySettings object
import numpy as np
from tudatpy.numerical_simulation.estimation_setup import observation

# Create ObservationViabilitySettings object
# In this case, we exclude observations for which the local elevation angle at link end is less 15 degrees.
min_elevation = np.deg2rad(15)
# We apply these settings to every ground station on Earth using the following link_end_id: [“Earth”, “”]
viability_settings = observation.elevation_angle_viability(["Earth", ""], min_elevation)

# Show that this is indeed an ObservationViabilitySettings object
print(viability_settings)
class ObservationDependentVariableSettings

Base class for setting observation dependent variables as part of the observation output.

Base class for setting observation dependent variables as part of the observation output. The user can create instances of this class via the elevation_angle_dependent_variable() function. Note: The associated functionality is not yet mature enough for the end user. Class is exposed for development purposes only.

Examples

# Code snippet to show the creation of an ObservationDependentVariableSettings object
from tudatpy.numerical_simulation.estimation_setup import observation

# Create ObservationDependentVariableSettings object
elevation_angle_settings = observation.elevation_angle_dependent_variable(observation.receiver)

# Show that this is indeed an ObservationDependentVariableSettings object
print(elevation_angle_settings)
class ObservationAncilliarySimulationSettings

Base class for holding ancilliary settings for observation simulation.

Base class for holding ancilliary settings for observation simulation. The user can create instances of this class via the elevation_angle_dependent_variable() function.

Examples

# Code snippet to show the creation of an ObservationAncillarySimulationSettings object
from tudatpy.numerical_simulation.estimation_setup import observation

# Example 1: Create ObservationAncillarySimulationSettings object using observation.n_way_range_ancilliary_settings function
# In this case the frequency bands of the retransmitter - we set it to x band.
n_way_range_ancillary_settings = observation.n_way_range_ancilliary_settings(frequency_bands=[observation.FrequencyBands.x_band])

# Show that this is indeed an ObservationAncillarySimulationSettings object
print(n_way_range_ancillary_settings)

# Example 2: Create ObservationAncillarySimulationSettings object using observation.one_way_doppler_instantaneous function
# In this case the integration time (in seconds) has to be given as input - we set it to 60s
doppler_ancillary_settings = observation.doppler_ancilliary_settings(60)

# Show that this is indeed an ObservationAncillarySimulationSettings object
print(doppler_ancillary_settings)

# [OPTIONAL] Verify that we indeed added Frequency Bands as Ancillary Simulation Variables for the n_way_range_ancillary_settings.
list_num = n_way_range_ancillary_settings.get_float_list_settings(observation.ObservationAncilliarySimulationVariable.frequency_bands)
for num in list_num:
    name = observation.ObservationAncilliarySimulationVariable(int(num)).name
    print(f'Ancillary Simulation Variable(s): {name}, corresponding to enumeration object n. {int(num)} of the ObservationAncilliarySimulationVariable Enumeration')
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 ]

Examples

# Code snippet to show how to retrieve ObservationAncillarySimulationSettings info
# using the ObservationAncilliarySimulationSettings.get_float_settings function

from tudatpy.numerical_simulation.estimation_setup import observation

# Create Ancillary Settings
n_way_range_ancillary_settings = observation.n_way_range_ancilliary_settings(frequency_bands=[observation.FrequencyBands.x_band])

# Verify that we indeed added Frequency Bands as Ancillary Simulation Variables, using n_way_range_ancillary_settings.get_float_list_settings
list_num = n_way_range_ancillary_settings.get_float_list_settings(observation.ObservationAncilliarySimulationVariable.frequency_bands)
for num in list_num:
    name = observation.ObservationAncilliarySimulationVariable(int(num)).name
    print(f'Ancillary Simulation Variable(s): {name}, corresponding to enumeration object n. {int(num)} of the ObservationAncilliarySimulationVariable Enumeration')
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