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

Function for defining oneway downlinks via LinkEnds types. 

Function for defining oneway uplinks via LinkEnds types. 
Factory function for creating settings for firstorder relativistic lighttime corrections. 


Factory function for creating settings for an absolute observation bias. 

Factory function for creating settings for a relative observation bias. 

Overloaded function. 

Overloaded function. 

Overloaded function. 

Overloaded function. 

Factory function for creating settings for a combined observation bias. 

Factory function for creating settings for a oneway range observable. 

Factory function for creating settings for a nway range observable. 

Factory function for creating settings for observable containing the body orientation as Euler angles. 
Factory function for creating settings for a twoway openloop Doppler observable. 


Overloaded function. 

Overloaded function. 

Factory function for creating settings for an angular position observable. 

Factory function for creating settings for a Cartesian position observable. 

Factory function for creating settings for a Cartesian velocity observable. 

Factory function for defining single elevation angle viability setting. 

Factory function for defining list of elevation angle viability settings. 

Factory function for defining body avoidance observation viability settings. 

Factory function for defining list of body avoidance viability settings. 

Factory function for defining body occultation viability settings. 

Factory function for defining body occultation viability settings. 
Factory function for creating settings object for observation simulation. 

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

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


Overloaded function. 

Overloaded function. 
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 oneway downlinks via LinkEnds types.
Function for defining single or multiple oneway 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 oneway downlink. A LinkEnds type for a one oneway 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 oneway uplinks via LinkEnds types.
Function for defining single or multiple oneway 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 oneway uplink. A LinkEnds type for a one oneway 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 firstorder relativistic lighttime corrections.
Factory function for creating settings for firstorder relativistic lighttime 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 Earthbased 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 lighttime correction is to be taken into account.
 Returns
Instance of the
LightTimeCorrectionSettings
derivedFirstOrderRelativisticLightTimeCorrectionSettings
class, defining the settings for the lighttime 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 componentwise.
 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
derivedConstantObservationBiasSettings
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 componentwise.
 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
derivedConstantObservationBiasSettings
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 arcwise absolute observation biases.
Factory function for creating settings for arcwise 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 arcwise 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.
ArcWiseConstantObservationBiasSettings
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
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 arcwise absolute observation biases.
Factory function for creating settings for arcwise 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_type
LinkEndType
Defines the link end (via the
LinkEndType
) which is used as a reference for observation times.
ArcWiseConstantObservationBiasSettings
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
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 arcwise absolute observation biases.
Factory function for creating settings for arcwise 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 arcwise 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.
ArcWiseConstantObservationBiasSettings
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
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 arcwise absolute observation biases.
Factory function for creating settings for arcwise 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_type
LinkEndType
Defines the link end (via the
LinkEndType
) which is used as a reference for observation times.
ArcWiseConstantObservationBiasSettings
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
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 arcwise relative observation biases.
Factory function for creating settings for arcwise 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 arcwise 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.
ArcWiseConstantObservationBiasSettings
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
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 arcwise relative observation biases.
Factory function for creating settings for arcwise 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_type
LinkEndType
Defines the link end (via the
LinkEndType
) which is used as a reference for observation times.
ArcWiseConstantObservationBiasSettings
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
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 arcwise relative observation biases.
Factory function for creating settings for arcwise 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 arcwise 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.
ArcWiseConstantObservationBiasSettings
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
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 arcwise relative observation biases.
Factory function for creating settings for arcwise 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_type
LinkEndType
Defines the link end (via the
LinkEndType
) which is used as a reference for observation times.
ArcWiseConstantObservationBiasSettings
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
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
derivedMultipleObservationBiasSettings
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 oneway range observable.
Factory function for creating observation model settings of oneway 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 receiverLinkEndType
entries to be defined.light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the lighttime 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 lightbias_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 oneway observable. Return type
 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 nway range observable.
Factory function for creating observation model settings of nway 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 nway 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 nway 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
derivedNWayRangeObservationSettings
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 bodyfixed orientation of the body specified by the observed_body in the link_ends input. The observable has size 3, and contains the 313 (e.g. zxz) 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
 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 twoway openloop Doppler observable.
Factory function for creating observation model settings of twoway openloop Doppler type observables. The observable is approximately equal to the twoway rangerate between the link ends, divided by c. This model uses two combined oneway openloop observables, defined by the
one_way_open_loop_doppler()
function. The combined effect from two oneway 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 nondimensional (but can be converted to an observed rangerate by multiplying with speed of light \(c\))
 Parameters
uplink_doppler_settings (
OneWayDopplerObservationSettings
) – Settings for uplink leg of oneway observable, created usingone_way_open_loop_doppler()
downlink_doppler_settings (
OneWayDopplerObservationSettings
) – Settings for downlink leg of oneway observable, created usingone_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 twoway observable, the constituent oneway observables may still be biased.
 Returns
Instance of the
ObservationModelSettings
derivedTwoWayDopplerObservationSettings
class defining the settings for the twoway 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 oneway closedloop Doppler observable.
Factory function for creating observation model settings of oneway closedloop 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 lighttime 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)
ObservationSettings
Instance of the
ObservationModelSettings
derived OneWayDifferencedRangeRateObservationSettings class defining the settings for the oneway closedloop doppler observable.
 link_endsDict[
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 oneway closedloop Doppler observable.
Factory function for creating observation model settings of oneway closedloop 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 lighttime 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)
OneWayDifferencedRangeRateObservationSettings
Instance of the
ObservationModelSettings
derivedOneWayDifferencedRangeRateObservationSettings
class defining the settings for the oneway closedloop doppler observable.
 link_endsDict[
 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 oneway closedloop Doppler observable.
Factory function for creating observation model settings of oneway closedloop 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 lighttime 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)
ObservationSettings
Instance of the
ObservationModelSettings
derived OneWayDifferencedRangeRateObservationSettings class defining the settings for the oneway closedloop doppler observable.
 link_endsDict[
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 oneway closedloop Doppler observable.
Factory function for creating observation model settings of oneway closedloop 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 lighttime 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)
OneWayDifferencedRangeRateObservationSettings
Instance of the
ObservationModelSettings
derivedOneWayDifferencedRangeRateObservationSettings
class defining the settings for the oneway closedloop doppler observable.
 link_endsDict[
 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 receiverLinkEndType
entries to be defined.light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the lighttime 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 lightbias_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
 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
 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
 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.
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 bodyfixed orientation of the body specified by the observed_body in the link_ends input. The observable has size 3, and contains the 313 (e.g. zxz) 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
 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
 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
 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 lineofsight vector from a link end to a given third body
The lineofsight between two link ends
This constraint is typically used to prevent the Sun from being too close to the fieldofview of the telescope(s), as defined by a socalled ‘SPE’ (SunProbeEarth) 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
 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 lineofsight vector from a link end to a given third body
The lineofsight between two link ends
This constraint is typically used to prevent the Sun from being too close to the fieldofview of the telescope(s), as defined by a socalled ‘SPE’ (SunProbeEarth) angle constraint. The present viability setting generalizes this constraint.
 Parameters
link_end_ids (List[ Tuple[str,str] ]) – List of individual link ends (as defined by body/reference point pair, see TODO), for which the elevation angle viability setting is to be created. To apply these settings to all ground station on a given body (such as “Earth”), use [“Earth”, “”].
body_to_avoid (str) – Name of the body which the signal path should not pass ‘too close’ to.
avoidance_angle (float) – Limit angle (generalization of SPE angle), below which no observations are produced when using the
simulate_observations()
function. Note: this value must be in radians.
 Returns
List of
ObservationViabilitySettings
objects, each defining the settings for observation viability of one link end. Return type
 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
 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
 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 theLinkEndType
) 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
derivedTabulatedObservationSimulationSettings
class. Return type
 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 theLinkEndType
) 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
derivedTabulatedObservationSimulationSettings
objects. Return type
 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 timeindependent and timeuncorrelated 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 theObservableType
given by the observable_type parameter. Note that theObservationSimulationSettings
objects are modified inplace 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 existingObservationSimulationSettings
objects.noise_amplitude (float) – Standard deviation defining the unbiased 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 inplace. 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 eachObservationSimulationSettings
object with the correspondingObservationViabilitySettings
entry in the viability_settings parameter. Note that theObservationSimulationSettings
objects are modified inplace 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 inplace.
 observation_simulation_settingsList[
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 correspondingObservationViabilitySettings
entry in the viability_settings parameter, but modifications are only applied to thoseObservationSimulationSettings
which match theObservableType
given by the observable_type parameter. Note that theObservationSimulationSettings
objects are modified inplace 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_type
ObservableType
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 inplace.
 observation_simulation_settingsList[
 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 eachObservationSimulationSettings
object with the correspondingObservationViabilitySettings
entry in the viability_settings parameter. Note that theObservationSimulationSettings
objects are modified inplace 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 inplace.
 observation_simulation_settingsList[
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 correspondingObservationViabilitySettings
entry in the viability_settings parameter, but modifications are only applied to thoseObservationSimulationSettings
which match theObservableType
given by the observable_type parameter. Note that theObservationSimulationSettings
objects are modified inplace 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_type
ObservableType
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 inplace.
 observation_simulation_settingsList[
 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#
Enumeration of available link end types. 

Enumeration of available observable types. 

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#
Classes#
Base class to defining proper time rate settings. 

Base class for defining observation settings. 

Class for defining the settings of oneway Doppler observation models. 

Base class to defining light time correction settings. 

Base class to defining observation bias settings. 

Base structure for defining observation simulation settings. 

Structure for setting a list of observation times. 

Enumeration of observation viability criterion types. 

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 oneway 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 oneway Doppler observation models.
ObservationSettings
derived class for oneway 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 theone_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 theObservationSimulator
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()
andcreate_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.