`observation`#

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

Functions#

`one_way_downlink_link_ends`(transmitter, ...)	Function for defining one-way downlinks via LinkEnds types.
`one_way_uplink_link_ends`(transmitters, receiver)	Function for defining one-way uplinks via LinkEnds types.
`first_order_relativistic_light_time_correction`(...)	Factory function for creating settings for first-order relativistic light-time corrections.
`absolute_bias`(bias_value)	Factory function for creating settings for an absolute observation bias.
`relative_bias`(bias_value)	Factory function for creating settings for a relative observation bias.
`arcwise_absolute_bias`(args, *kwargs)	Overloaded function.
`arcwise_absolute_bias`(args, *kwargs)	Overloaded function.
`arcwise_relative_bias`(args, *kwargs)	Overloaded function.
`arcwise_relative_bias`(args, *kwargs)	Overloaded function.
`combined_bias`(bias_list)	Factory function for creating settings for a combined observation bias.
`one_way_range`(link_ends, Tuple[str, str]], ...)	Factory function for creating settings for a one-way range observable.
`n_way_range`(one_way_range_settings, ...)	Factory function for creating settings for a n-way range observable.
`one_way_open_loop_doppler`(link_ends, ...)	Factory function for creating settings for observable containing the body orientation as Euler angles.
`two_way_open_loop_doppler_from_one_way_links`(...)	Factory function for creating settings for a two-way open-loop Doppler observable.
`one_way_closed_loop_doppler`(args, *kwargs)	Overloaded function.
`one_way_closed_loop_doppler`(args, *kwargs)	Overloaded function.
`angular_position`(link_ends, Tuple[str, ...)	Factory function for creating settings for an angular position observable.
`cartesian_position`(link_ends, Tuple[str, ...)	Factory function for creating settings for a Cartesian position observable.
`cartesian_velocity`(link_ends, Tuple[str, ...)	Factory function for creating settings for a Cartesian velocity observable.
`elevation_angle_viability`(link_end_id, ...)	Factory function for defining single elevation angle viability setting.
`elevation_angle_viability_list`(link_end_ids, ...)	Factory function for defining list of elevation angle viability settings.
`body_avoidance_viability`(link_end_id, ...)	Factory function for defining body avoidance observation viability settings.
`body_avoidance_viability_list`(link_end_ids, ...)	Factory function for defining list of body avoidance viability settings.
`body_occultation_viability`(link_end_id, ...)	Factory function for defining body occultation viability settings.
`body_occultation_viability_list`(link_end_id, ...)	Factory function for defining body occultation viability settings.
`tabulated_simulation_settings`(...)	Factory function for creating settings object for observation simulation.
`tabulated_simulation_settings_list`(...)	Factory function for creating multiple settings object, each defining observation simulation times.
`add_gaussian_noise_to_settings`(...)	Function for adding gaussian noise function to existing observation simulation settings.
`add_viability_check_to_settings`(args, *kwargs)	Overloaded function.
`add_viability_check_to_settings`(args, *kwargs)	Overloaded function.
`add_dependent_variables_to_settings`(...)	Function for including dependent variables into existing observation simulation settings.

one_way_downlink_link_ends(transmitter: Tuple[str, str], receivers: List[Tuple[str, str]]) → List[Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]]]#

Function for defining one-way downlinks via LinkEnds types.

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

Parameters

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

Returns

List of one or more LinkEnds types, each defining the geometry for one one-way downlink. A LinkEnds 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[ Dict[LinkEndType, Tuple[str, str] ]

one_way_uplink_link_ends(transmitters: List[Tuple[str, str]], receiver: Tuple[str, str]) → List[Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]]]#

Function for defining one-way uplinks via LinkEnds types.

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

Parameters

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

Returns

List of one or more LinkEnds types, each defining the geometry for one one-way uplink. A LinkEnds 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[ Dict[LinkEndType, Tuple[str, str] ]

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

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

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

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

Parameters: perturbing_bodies (str) – A list containing the names of the bodies due to which the light-time correction is to be taken into account.
Returns: Instance of the LightTimeCorrectionSettings derived FirstOrderRelativisticLightTimeCorrectionSettings class, defining the settings for the light-time corrections
Return type: FirstOrderRelativisticLightTimeCorrectionSettings

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

Factory function for creating settings for an absolute observation bias.

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

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

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

Parameters: bias_value (numpy.ndarray) – A vector containing the bias that is to be applied to the observable. This vector should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)
Returns: Instance of the ObservationBiasSettings derived ConstantObservationBiasSettings class, defining the settings for a constant, absolute observation bias.
Return type: ConstantObservationBiasSettings

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

Factory function for creating settings for a relative observation bias.

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

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

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

Parameters: bias_value (numpy.ndarray) – A vector containing the bias that is to be applied to the observable. This vector should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)
Returns: Instance of the ObservationBiasSettings derived ConstantObservationBiasSettings class, defining the settings for a constant, relative observation bias.
Return type: ConstantObservationBiasSettings

arcwise_absolute_bias(*args, **kwargs)#

Overloaded function.

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

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

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

arc_start_timesList[ float ]
List containing starting times for each arc.

bias_valuesList[ 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_typeLinkEndType
Defines the link end (via the LinkEndType) which is used as a reference for observation times.

ArcWiseConstantObservationBiasSettings
Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.
arcwise_absolute_bias(bias_values_per_start_time: Dict[float, numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

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

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

bias_values_per_start_timeDict[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_typeLinkEndType
Defines the link end (via the LinkEndType) which is used as a reference for observation times.

ArcWiseConstantObservationBiasSettings
Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

arcwise_absolute_bias(*args, **kwargs)#

Overloaded function.

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

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

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

arc_start_timesList[ float ]
List containing starting times for each arc.

bias_valuesList[ 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_typeLinkEndType
Defines the link end (via the LinkEndType) which is used as a reference for observation times.

ArcWiseConstantObservationBiasSettings
Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.
arcwise_absolute_bias(bias_values_per_start_time: Dict[float, numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

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

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

bias_values_per_start_timeDict[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_typeLinkEndType
Defines the link end (via the LinkEndType) which is used as a reference for observation times.

ArcWiseConstantObservationBiasSettings
Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

arcwise_relative_bias(*args, **kwargs)#

Overloaded function.

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

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

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

arc_start_timesList[ float ]
List containing starting times for each arc.

bias_valuesList[ 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_typeLinkEndType
Defines the link end (via the LinkEndType) which is used as a reference for observation times.

ArcWiseConstantObservationBiasSettings
Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.
arcwise_relative_bias(bias_values_per_start_time: Dict[float, numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

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

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

bias_values_per_start_timeDict[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_typeLinkEndType
Defines the link end (via the LinkEndType) which is used as a reference for observation times.

ArcWiseConstantObservationBiasSettings
Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

arcwise_relative_bias(*args, **kwargs)#

Overloaded function.

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

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

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

arc_start_timesList[ float ]
List containing starting times for each arc.

bias_valuesList[ 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_typeLinkEndType
Defines the link end (via the LinkEndType) which is used as a reference for observation times.

ArcWiseConstantObservationBiasSettings
Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.
arcwise_relative_bias(bias_values_per_start_time: Dict[float, numpy.ndarray[numpy.float64[m, 1]]], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings

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

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

bias_values_per_start_timeDict[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_typeLinkEndType
Defines the link end (via the LinkEndType) which is used as a reference for observation times.

ArcWiseConstantObservationBiasSettings
Instance of the ObservationBiasSettings derived ArcWiseConstantObservationBiasSettings class.

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

Factory function for creating settings for a combined observation bias.

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

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

And, crucially:

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

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

Parameters: bias_list (List[ class:ObservationBiasSettings ]) – A list containing the bias the bias settings that are to be applied to the observable.
Returns: Instance of the ObservationBiasSettings derived MultipleObservationBiasSettings class, combining the settings for multiple observation biases.
Return type: MultipleObservationBiasSettings

one_way_range(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings#

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

Factory function for creating observation model settings of one-way range type observables. Each combination of observable type and link geometry (link_ends) needs a dedicated ObservationModelSettings object.

Parameters

link_ends (Dict[LinkEndType, Tuple[str, str]) – 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)

Returns

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

Return type

ObservationSettings

n_way_range(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None, retransmission_times_function: Callable[[float], List[float]] = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings#

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

Factory function for creating observation model settings of n-way range type observables. Each combination of observable type and link geometry (link_ends) needs a dedicated ObservationModelSettings object.

Parameters

one_way_range_settings (List[ ObservationModelSettings ]) – List of observation model settings for each of the n components of the n-way range observable.
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.
retransmission_times_function (Callable[[float], List[float]]], default = None) – Function that provides a list of retransmission delay of each intermediate link end as a function of the observation time at the retransmitting link end.

Returns

Instance of the ObservationModelSettings derived NWayRangeObservationSettings class.

Return type

NWayRangeObservationSettings

one_way_open_loop_doppler(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], 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) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings#

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

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

Parameters

link_ends (Dict[LinkEndType, Tuple[str, str]) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body` LinkEndType entries to be defined.
bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

Returns

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

Return type

ObservationSettings

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

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

Factory function for creating observation model settings of two-way open-loop Doppler type observables. The observable is approximately equal to the two-way range-rate between the link ends, divided by c. This model uses two combined one-way open-loop observables, defined by the one_way_open_loop_doppler() function. The combined effect from two one-way Doppler effects: one from link end \(A\) to link end \(B\), and one from \(B\) to \(C\), computed as:

\[h_{D(2),ABC}=(h_{D(1),AB}+1)(h_{D(1),BC}+1)-1\]

The resulting observable is non-dimensional (but can be converted to an observed range-rate by multiplying with speed of light \(c\))

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.

Returns

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

Return type

TwoWayDopplerObservationSettings

one_way_closed_loop_doppler(*args, **kwargs)#

Overloaded function.

one_way_closed_loop_doppler(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], integration_time: float, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

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

Factory function for creating observation model settings of one-way closed-loop Doppler type observables. This interface only allows for one constant integration time in the observations model.

link_endsDict[LinkEndType, Tuple[str, str]
Set of link ends that define the geometry of the observation. This observable requires that the transmitter and receiver LinkEndType entries to be defined.

integration_timefloat
Integration time that is to be used for the observable. NOTE: This setting is to be moved to the ObservationSimulationSettings class and associated factory functions.

light_time_correction_settingsList[ 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_settingsObservationBiasSettings, default = None
Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

ObservationSettings
Instance of the ObservationModelSettings derived OneWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.
one_way_closed_loop_doppler(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], integration_time_function: Callable[[float], float], light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

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

Factory function for creating observation model settings of one-way closed-loop Doppler type observables. This interface only allows for variable (as a function of observation time) integration times in the observations model.

link_endsDict[LinkEndType, Tuple[str, str]
Set of link ends that define the geometry of the observation. This observable requires that the transmitter and receiver LinkEndType entries to be defined.

integration_time_functionCallable[float, float]
Integration time that is to be used for the observable as a function of observation time. NOTE: This setting is to be moved to the ObservationSimulationSettings class and associated factory functions.

light_time_correction_settingsList[ 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_settingsObservationBiasSettings, default = None
Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

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

one_way_closed_loop_doppler(*args, **kwargs)#

Overloaded function.

one_way_closed_loop_doppler(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], integration_time: float, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

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

Factory function for creating observation model settings of one-way closed-loop Doppler type observables. This interface only allows for one constant integration time in the observations model.

link_endsDict[LinkEndType, Tuple[str, str]
Set of link ends that define the geometry of the observation. This observable requires that the transmitter and receiver LinkEndType entries to be defined.

integration_timefloat
Integration time that is to be used for the observable. NOTE: This setting is to be moved to the ObservationSimulationSettings class and associated factory functions.

light_time_correction_settingsList[ 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_settingsObservationBiasSettings, default = None
Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

ObservationSettings
Instance of the ObservationModelSettings derived OneWayDifferencedRangeRateObservationSettings class defining the settings for the one-way closed-loop doppler observable.
one_way_closed_loop_doppler(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], integration_time_function: Callable[[float], float], light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None) -> tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings

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

Factory function for creating observation model settings of one-way closed-loop Doppler type observables. This interface only allows for variable (as a function of observation time) integration times in the observations model.

link_endsDict[LinkEndType, Tuple[str, str]
Set of link ends that define the geometry of the observation. This observable requires that the transmitter and receiver LinkEndType entries to be defined.

integration_time_functionCallable[float, float]
Integration time that is to be used for the observable as a function of observation time. NOTE: This setting is to be moved to the ObservationSimulationSettings class and associated factory functions.

light_time_correction_settingsList[ 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_settingsObservationBiasSettings, default = None
Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

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

angular_position(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings#

Factory function for creating settings for an angular position observable.

Factory function for creating observation model settings of angular position type observables. This observable can be used for optical astrometry, VLBI, etc. and computes the relative angular position in terms of right ascension \(alpha\) and declination \(delta\)

Parameters

link_ends (Dict[LinkEndType, Tuple[str, str]) – 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)

Returns

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

Return type

ObservationSettings

cartesian_position(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings#

Factory function for creating settings for a Cartesian position observable.

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

Parameters

link_ends (Dict[LinkEndType, Tuple[str, str]) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body` LinkEndType entries to be defined.
bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

Returns

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

Return type

ObservationSettings

cartesian_velocity(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings#

Factory function for creating settings for a Cartesian velocity observable.

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

Parameters

link_ends (Dict[LinkEndType, Tuple[str, str]) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body` LinkEndType entries to be defined.
bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

Returns

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

Return type

ObservationSettings

313_euler_angles(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]], bias_settings: tudat::observation_models::ObservationBiasSettings = None) → tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings#

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

Parameters

link_ends (Dict[LinkEndType, Tuple[str, str]) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body` LinkEndType entries to be defined.
bias_settings (ObservationBiasSettings, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)

Returns

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

Return type

ObservationSettings

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

Factory function for defining single elevation angle viability setting.

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

Parameters

link_end_id (Tuple[str,str]) – Link end (as defined by body/reference point pair, see TODO), for which the elevation angle viability setting is to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”].
elevation_angle (float) – Limit elevation angle, below which no observations are produced when using the simulate_observations() function. Note: this value must be in radians.

Returns

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

Return type

ObservationViabilitySettings

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

Factory function for defining list of elevation angle viability settings.

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

Parameters

link_end_ids (List[ Tuple[str,str] ]) – List of individual link ends (as defined by body/reference point pair, see TODO), for which the elevation angle viability setting is to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”]. For each link end included in this list, it will be checked if a signal received by and/or transmitted (or reflected) by this link end violates the minimum elevation angle constraint.
elevation_angle (float) – Limit elevation angle, below which no observations are produced when using the simulate_observations() function. Note: this value must be in radians.

Returns

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

Return type

ObservationViabilitySettings

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

Factory function for defining body avoidance observation viability settings.

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

The line-of-sight vector from a link end to a given third body
The line-of-sight between two link ends

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

Parameters

link_end_id (Tuple[str,str]) – Link end (as defined by body/reference point pair, see TODO), for which the viability settings are to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”] is entry in this list. For each link end included in this list, it will be checked if a signal received by and/or transmitted (or reflected) by this link end passes too close to the specified body.
body_to_avoid (str) – Name of the body which the signal path should not pass ‘too close’ to.
avoidance_angle (float) – Limit angle (generalization of SPE angle), below which no observations are produced when using the simulate_observations() function. Note: this value must be in radians.

Returns

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

Return type

ObservationViabilitySettings

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

Factory function for defining list of body avoidance viability settings.

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

The line-of-sight vector from a link end to a given third body
The line-of-sight between two link ends

Parameters

link_end_ids (List[ Tuple[str,str] ]) – List of individual link ends (as defined by body/reference point pair, see TODO), for which the elevation angle viability setting is to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”].
body_to_avoid (str) – Name of the body which the signal path should not pass ‘too close’ to.
avoidance_angle (float) – Limit angle (generalization of SPE angle), below which no observations are produced when using the simulate_observations() function. Note: this value must be in radians.

Returns

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

Return type

ObservationViabilitySettings

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

Factory function for defining body occultation viability settings.

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

Parameters

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

Returns

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

Return type

ObservationViabilitySettings

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

Factory function for defining body occultation viability settings.

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

Parameters

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

Returns

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

Return type

ObservationViabilitySettings

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

Factory function for creating settings object for observation simulation.

Factory function for creating single simulation settings object. For more information about the characteristics of the resulting settings object, please refer to the description of the TabulatedObservationSimulationSettings class.

Parameters

observable_type (ObservableType) – Observable type of which observations are to be simulated.
link_ends (Dict[LinkEndType, Tuple[str, str]) – 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 for observation times.
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[Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, Tuple[str, str]]]], simulation_times: List[float], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType = <LinkEndType.receiver: 5>, viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings] = []) → List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings]#

Factory function for creating multiple settings object, each defining observation simulation times.

Factory function for creating multiple observation simulation settings objects in a list. 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. All resulting simulation settings objects are created considering the same tabulated simulation times ( given by the simulation_times parameter), reference link end (reference_link_end_type) and viability criteria viability_settings. For more information about the characteristics of the resulting settings objects, please refer to the description of the TabulatedObservationSimulationSettings class.

Note that this interface does not allow noise functions to be considered during creation of the simulation settings object. For adding noise functions, please use the add_gaussian_noise_to_settings() function.

Parameters

link_ends_per_observable (Dict[ObservableType, List[Dict[LinkEndType, Tuple[str, str]]]]) – 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 ]

add_gaussian_noise_to_settings(observation_simulation_settings: 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.

Function for including simple time-independent and time-uncorrelated Gaussian noise function to the simulation settings of one or more observable(s). Out of the given ObservationSimulationSettings object(s) in the observation_simulation_settings parameter, the modification is only applied to the ones which match the ObservableType given by the observable_type parameter. Note that the ObservationSimulationSettings objects are modified in-place and thus the function does not return anything.

Parameters

observation_simulation_settings (List[ ObservationSimulationSettings ]) – Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.
noise_amplitude (float) – Standard deviation defining the un-biased Gaussian distribution for the noise.
observable_type (ObservableType) – Identifies the observable type in the observation simulation settings to which the noise is to be added.

Returns

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

Return type

None

add_viability_check_to_settings(*args, **kwargs)#

Overloaded function.

add_viability_check_to_settings(observation_simulation_settings: 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 including viability checks into the simulation settings of one or more observable(s). Modifications are applied to all given ObservationSimulationSettings object(s), matching each ObservationSimulationSettings object with the corresponding ObservationViabilitySettings entry in the viability_settings parameter. Note that the ObservationSimulationSettings objects are modified in-place and thus the function does not return anything.

observation_simulation_settingsList[ ObservationSimulationSettings ]
Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

viability_settingsList[ ObservationViabilitySettings ]
List of one or more ObservationViabilitySettings objects, defining the viability checks to be included.

None
The ObservationSimulationSettings object(s) are changed in-place.
add_viability_check_to_settings(observation_simulation_settings: 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.

Function for including viability checks into the simulation settings of one or more observable(s). Each of the given ObservationSimulationSettings objects is matched with the corresponding ObservationViabilitySettings entry in the viability_settings parameter, but modifications are only applied to those ObservationSimulationSettings which match the ObservableType given by the observable_type parameter. Note that the ObservationSimulationSettings objects are modified in-place and thus the function does not return anything.

observation_simulation_settingsList[ ObservationSimulationSettings ]
Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

viability_settingsList[ ObservationViabilitySettings ]
List of one or more ObservationViabilitySettings objects, defining the viability checks to be included.

observable_typeObservableType
Identifies the observable type in the observation simulation settings for which the viability checks are to be considered.

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

add_viability_check_to_settings(*args, **kwargs)#

Overloaded function.

add_viability_check_to_settings(observation_simulation_settings: 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 including viability checks into the simulation settings of one or more observable(s). Modifications are applied to all given ObservationSimulationSettings object(s), matching each ObservationSimulationSettings object with the corresponding ObservationViabilitySettings entry in the viability_settings parameter. Note that the ObservationSimulationSettings objects are modified in-place and thus the function does not return anything.

observation_simulation_settingsList[ ObservationSimulationSettings ]
Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

viability_settingsList[ ObservationViabilitySettings ]
List of one or more ObservationViabilitySettings objects, defining the viability checks to be included.

None
The ObservationSimulationSettings object(s) are changed in-place.
add_viability_check_to_settings(observation_simulation_settings: 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.

Function for including viability checks into the simulation settings of one or more observable(s). Each of the given ObservationSimulationSettings objects is matched with the corresponding ObservationViabilitySettings entry in the viability_settings parameter, but modifications are only applied to those ObservationSimulationSettings which match the ObservableType given by the observable_type parameter. Note that the ObservationSimulationSettings objects are modified in-place and thus the function does not return anything.

observation_simulation_settingsList[ ObservationSimulationSettings ]
Observation simulation settings, given by a list of one or more existing ObservationSimulationSettings objects.

viability_settingsList[ ObservationViabilitySettings ]
List of one or more ObservationViabilitySettings objects, defining the viability checks to be included.

observable_typeObservableType
Identifies the observable type in the observation simulation settings for which the viability checks are to be considered.

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

add_dependent_variables_to_settings(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 existing observation simulation settings.

Function for including the computation and reporting of dependent variables into the observation simulation settings of one or more observable(s). Note: The associated functionality is not yet mature enough for the end user. Function is exposed for development purposes only.

Enumerations#

`LinkEndType`	Enumeration of available link end types.
`ObservableType`	Enumeration of available observable types.
`ObservationViabilityType`	Enumeration of observation viability criterion types.

class LinkEndType#

Enumeration of available link end types.

Members:

unidentified_link_end

transmitter

reflector1

retransmitter

reflector2

reflector3

reflector4

receiver

observed_body

property name#

class ObservableType#

Enumeration of available observable types.

Members:

one_way_range_type

angular_position_type

position_observable_type

one_way_doppler_type

one_way_differenced_range_type

n_way_range_type

two_way_doppler_type

euler_angle_313_observable_type

velocity_observable_type

property name#

class ObservationViabilityType#

Enumeration of observation viability criterion types.

Members:

minimum_elevation_angle

body_avoidance_angle

body_occultation

property name#

Classes#

`DopplerProperTimeRateSettings`	Base class to defining proper time rate settings.
`ObservationSettings`	Base class for defining observation settings.
`OneWayDopplerObservationSettings`	Class for defining the settings of one-way Doppler observation models.
`LightTimeCorrectionSettings`	Base class to defining light time correction settings.
`ObservationBiasSettings`	Base class to defining observation bias settings.
`ObservationSimulationSettings`	Base structure for defining observation simulation settings.
`TabulatedObservationSimulationSettings`	Structure for setting a list of observation times.
`ObservationViabilitySettings`	Enumeration of observation viability criterion types.
`ObservationDependentVariableSettings`	Base class for setting observation dependent variables.

class DopplerProperTimeRateSettings#

Base class to defining proper time rate settings.

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

class ObservationSettings#

Base class for defining observation settings.

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

class OneWayDopplerObservationSettings#

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

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

class LightTimeCorrectionSettings#

Base class to defining light time correction settings.

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

class ObservationBiasSettings#

Base class to defining observation bias settings.

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

class ObservationSimulationSettings#

Base structure for defining observation simulation settings.

Functional (base) structure for settings of observation simulation. A simulation settings object defines observation times, noise and viability criteria for the ObservationSimulator object to which it is applied during the simulation of observations. Therefore, one simulation settings object can only refer to one combination of observable type and link geometry (LinkEnds). Typically, the user does not interact with this class directly, but defines specific observation simulation settings using an object derived from this class.

class TabulatedObservationSimulationSettings#

Structure for setting a list of observation times.

ObservationSimulationSettings derived structure for settings of observation simulation. A simulation settings object defines observation times, noise and viability criteria for the ObservationSimulator object to which it is applied during the simulation of observations. Therefore, one simulation settings object can only refer to one combination of observable type and link geometry (LinkEnds).

In this structure, discrete time instances at which applicable observations are to be simulated are defined and stored in a rigid, “tabulated” form. Some observation times may be discarded due to the use of viability settings. Instances of this class can be created via the tabulated_simulation_settings() and create_tabulated_simulation_settings() factory functions.

class ObservationViabilitySettings#: Enumeration of observation viability criterion types.

class ObservationDependentVariableSettings#

Base class for setting observation dependent variables.

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

observation#

Functions#

Enumerations#

Classes#

`observation`#