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

Function to create a link definition object. 

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

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

Function for defining oneway downlinks via LinkDefinition types. 

Function for defining oneway uplinks via LinkDefinition types. 
Factory function for creating settings for a oneway range observable. 

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 a nway range observable. 


Factory function for creating settings for a twoway range observable. 
Factory function for creating settings for a twoway range observable. 


Factory function for creating settings for an angular position observable. 

Factory function for creating settings for an angular position observable. 

Factory function for creating settings for a oneway instantaneous Doppler observable. 
Factory function for creating settings for a twoway instantaneous Doppler observable. 


Factory function for creating settings for a oneway averaged Doppler observable. 

Factory function for creating settings for an nway averaged Doppler observable. 
Factory function for creating settings for an nway averaged Doppler observable. 


Factory function for creating settings for an nway averaged Doppler observable. 
Factory function for creating settings for an nway averaged Doppler 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. 

No documentation found. 
Factory function for creating ancilliary settings for twoway range observable. 

Factory function for creating ancilliary settings for twoway averaged Doppler observable. 

Factory function for creating ancilliary settings for nway range observable. 

Factory function for creating ancilliary settings for nway averaged Doppler observable. 

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

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

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

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

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

No documentation found. 

Function for including viability checks into existing observation simulation settings. 

Function for including viability checks into existing observation simulation settings. 
 link_definition(link_ends: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndId]) tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition #
Function to create a link definition object.
 Parameters:
link_ends (dict[LinkEndType,LinkEndId]) – Dictionary of link ends, with the key denoting the role in the observaton, and the associated value the identifier for the link end.
 Returns:
The
LinkDefinition
object storing the link ends of the observation Return type:
 body_origin_link_end_id(body_name: str) tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndId #
Function to create a link end identifier for the origin (typically center of mass) of a body.
Function to create a link end identifier for the origin (typically center of mass) of a body. Using this option will simulate the origin of a body transmitter, receiving, etc. the observation. Although this is typically not physically realistic, it can be a useful approximation, in particular for simulation studies.
 body_reference_point_link_end_id(body_name: str, reference_point_id: str) tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndId #
Function to create a link end identifier for a reference point on a body.
Function to create a link end identifier for a reference point on a body, where the reference point is typically the identifier of a ground stations
 one_way_downlink_link_ends(transmitter: tudat::observation_models::LinkEndId, receivers: List[tudat::observation_models::LinkEndId]) List[Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, tudat::observation_models::LinkEndId]] #
Function for defining oneway downlinks via LinkDefinition 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 LinkDefinition type.
 Parameters:
transmitter (Tuple[str, str]) – LinkEndId type (tuple of strings), where the first entrance identifies the body and the second entry the reference point of the single transmitter link end.
receivers (List[ Tuple[str, str] ]) – List of LinkEndId types (tuple of strings), where for each tuple the first entrance identifies the body and the second entry the reference point of the receiver link end(s).
 Returns:
List of one or more LinkDefinition types, each defining the geometry for one oneway downlink. A LinkDefinition 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[ LinkDefinition ]
 one_way_uplink_link_ends(transmitters: List[tudat::observation_models::LinkEndId], receiver: tudat::observation_models::LinkEndId) List[Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType, tudat::observation_models::LinkEndId]] #
Function for defining oneway uplinks via LinkDefinition 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 LinkDefinition type.
 Parameters:
transmitters (List[ Tuple[str, str] ]) – List of LinkEndId types (tuple of strings), where for each tuple the first entrance identifies the body and the second entry the reference point of the transmitter link end(s).
receiver (Tuple[str, str]) – LinkEndId type (tuple of strings), where the first entrance identifies the body and the second entry the reference point of the single receiver link end.
 Returns:
List of one or more LinkDefinition types, each defining the geometry for one oneway uplink. A LinkDefinition 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[ LinkDefinition ]
 light_time_convergence_settings(iterate_corrections: bool = False, maximum_number_of_iterations: int = 50, absolute_tolerance: float = nan, failure_handling: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeFailureHandling = <LightTimeFailureHandling.accept_without_warning: 0>) tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria #
Factory function for creating settings for a oneway range observable.
Factory function for creating observation model settings of oneway range type observables, for a single link definition. The associated observation model creates a singlevalued observable \(h_{_{\text{1range}}}\) as follows (in the unbiased case):
\[h_{_{\text{1range}}}(t_{R},t_{T})=\mathbf{r}_{R}(t_{R})\mathbf{r}_{T}(t_{T}) + \Delta s\]where \(\mathbf{r}_{R}\), \(\mathbf{r}_{T}\), \(t_{R}\) and \(t_{T}\) denote the position function of receiver and transmitter, and evaluation time of receiver and transmitter. The term \(\Delta s\) denotes lighttime corrections due to e.g relativistic, atmospheric effects (as defined by the
light_time_correction_settings
input). The transmission and reception time are related to the lighttime \(T=t_{R}t_{T}\), which is in turn related to the oneway range as \(T=h/c\) As a result, the calculation of the oneway range (and lighttime) requires the iterative solution of the equation:\[ \begin{align}\begin{aligned}t_{R}t_{T}=c\left(\mathbf{r}_{R}(t_{R})\mathbf{r}(t_{R}) + \Delta s\right)\\The method for the iterative solution is described in the :func:`light_time_convergence_settings` entry\end{aligned}\end{align} \] Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver
LinkEndType
entries to be defined.light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
class defining the settings for the oneway observable. Return type:
 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. Parameters:
arc_start_times (List[ float ]) – List containing starting times for each arc.
bias_values (List[ 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 theLinkEndType
) which is used as a reference for observation times.
 Returns:
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
class. Return type:
ArcWiseConstantObservationBiasSettings
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. Parameters:
bias_values_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the bias value vectors for each arc are directly mapped to the starting times of the respective arc. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)
reference_link_end_type (
LinkEndType
) – Defines the link end (via theLinkEndType
) which is used as a reference for observation times.
 Returns:
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
class. Return type:
ArcWiseConstantObservationBiasSettings
 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. Parameters:
arc_start_times (List[ float ]) – List containing starting times for each arc.
bias_values (List[ 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 theLinkEndType
) which is used as a reference for observation times.
 Returns:
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
class. Return type:
ArcWiseConstantObservationBiasSettings
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. Parameters:
bias_values_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the bias value vectors for each arc are directly mapped to the starting times of the respective arc. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)
reference_link_end_type (
LinkEndType
) – Defines the link end (via theLinkEndType
) which is used as a reference for observation times.
 Returns:
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
class. Return type:
ArcWiseConstantObservationBiasSettings
 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. Parameters:
arc_start_times (List[ float ]) – List containing starting times for each arc.
bias_values (List[ 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 theLinkEndType
) which is used as a reference for observation times.
 Returns:
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
class. Return type:
ArcWiseConstantObservationBiasSettings
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. Parameters:
bias_values_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the bias value vectors for each arc are directly mapped to the starting times of the respective arc. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)
reference_link_end_type (
LinkEndType
) – Defines the link end (via theLinkEndType
) which is used as a reference for observation times.
 Returns:
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
class. Return type:
ArcWiseConstantObservationBiasSettings
 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. Parameters:
arc_start_times (List[ float ]) – List containing starting times for each arc.
bias_values (List[ 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 theLinkEndType
) which is used as a reference for observation times.
 Returns:
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
class. Return type:
ArcWiseConstantObservationBiasSettings
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. Parameters:
bias_values_per_start_time (Dict[float, numpy.ndarray[numpy.float64[m, 1]]]) – Dictionary, in which the bias value vectors for each arc are directly mapped to the starting times of the respective arc. The vectors should be the same size as the observable to which it is applied (e.g. size 1 for a range observable, size 2 for angular position, etc.)
reference_link_end_type (
LinkEndType
) – Defines the link end (via theLinkEndType
) which is used as a reference for observation times.
 Returns:
Instance of the
ObservationBiasSettings
derivedArcWiseConstantObservationBiasSettings
class. Return type:
ArcWiseConstantObservationBiasSettings
 combined_bias(bias_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings]) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationBiasSettings #
Factory function for creating settings for a combined observation bias.
Factory function for creating settings for a combined observation bias, calculating by combining any number of bias types. Each contribution of the combined bias is computed from the unbiased observable, so when applying both a relative and absolute bias, we get:
\[\tilde{h}=h+K_{a}+hK_{r}\]And, crucially:
\[\tilde{h}\neq (h+K_{a})(1+K_{r})\]where \(K_{r}\) and \(K_{a}\) is the relative and absolute bias, respectively.
 Parameters:
bias_list (List[ class:ObservationBiasSettings ]) – A list containing the bias the bias settings that are to be applied to the observable.
 Returns:
Instance of the
ObservationBiasSettings
derivedMultipleObservationBiasSettings
class, combining the settings for multiple observation biases. Return type:
MultipleObservationBiasSettings
 one_way_range(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e2135deb0>) 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, for a single link definition. The associated observation model creates a singlevalued observable \(h_{_{\text{1range}}}\) as follows (in the unbiased case):
\[h_{_{\text{1range}}}(t_{R},t_{T})=\mathbf{r}_{R}(t_{R})\mathbf{r}_{T}(t_{T}) + \Delta s\]where \(\mathbf{r}_{R}\), \(\mathbf{r}_{T}\), \(t_{R}\) and \(t_{T}\) denote the position function of receiver and transmitter, and evaluation time of receiver and transmitter. The term \(\Delta s\) denotes lighttime corrections due to e.g relativistic, atmospheric effects (as defined by the
light_time_correction_settings
input). The transmission and reception time are related to the lighttime \(T=t_{R}t_{T}\), which is in turn related to the oneway range as \(T=h/c\) As a result, the calculation of the oneway range (and lighttime) requires the iterative solution of the equation:\[ \begin{align}\begin{aligned}t_{R}t_{T}=c\left(\mathbf{r}_{R}(t_{R})\mathbf{r}(t_{R}) + \Delta s\right)\\The method for the iterative solution is described in the :func:`light_time_convergence_settings` entry\end{aligned}\end{align} \] Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver
LinkEndType
entries to be defined.light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
class defining the settings for the oneway observable. Return type:
 n_way_range(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e213614b0>) 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, for a single link definition. The associated observation model creates a singlevalued observable \(h_{_{\text{Nrange}}}\) by combining together a series \(n\) oneway range observations (see
one_way_range()
). By default, the reception time of the \(i^{th}\) oneway range is set as the transmission time of the \((i+1)^{th}\) oneway range. A retransmission delay may be defined by ancilliary settings (see TODO) when creating observation simulation setings.For this factory function, the settings for each constituent oneway range (with the exception of the link end identifiers) are equal.
 Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver
LinkEndType
entries to be defined, as well as a retransmitter1, retransmitter2, …. (with the number of retransmitters to be defined by the user).light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the lighttime that are to be used for each constituent oneway range. 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). Note that only one bias setting is applied to the nway observable.light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
derivedNWayRangeObservationSettings
class. Return type:
NWayRangeObservationSettings
 n_way_range_from_one_way_links(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for a nway range observable.
Factory function for creating observation model settings of nway range type observables, for a single link definition. The implementation is the same as
n_way_range()
, with the difference that the constituent oneway ranges may have different settings.s Parameters:
one_way_range_settings (List[
ObservationModelSettings
]) – List of observation model settings for each of the \(n\) constituent oneway ranges of the nway range observable. TheLinkDefinition
of this nway range observable is created from this list, with thetransmitter
andretransmitter1
defined by thetransmitter
andreceiver
of the first entry in this list. Theretransmitter``(n1) and ``receiver
are defined by thetransmitter
andreceiver
of the :math:`n`^{th} entry of this list.bias_settings (
ObservationBiasSettings
, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation). Note that only one bias setting is applied to the nway observable.
 Returns:
Instance of the
ObservationModelSettings
derivedNWayRangeObservationSettings
class. Return type:
NWayRangeObservationSettings
 two_way_range(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e21361530>) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for a twoway range observable.
Same as
n_way_range()
, with \(n=2\). This function is provided for convenience. Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter, retransmitter and receiver
LinkEndType
entries to be definedlight_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the lighttime that are to be used for each constituent oneway range. 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). Note that only one bias setting is applied to the nway observable.light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
derivedNWayRangeObservationSettings
class. Return type:
NWayRangeObservationSettings
 two_way_range_from_one_way_links(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for a twoway range observable.
Same as
n_way_range_from_one_way_links()
, with \(n=2\). This function is provided for convenience. Parameters:
one_way_range_settings (List[
ObservationModelSettings
]) – List of observation model settings of size two, with the first entry the oneway range settings for the uplink, and the second entry the oneway range settings for the downlink. TheLinkDefinition
of this twoway range observable is created from this list, with thetransmitter
andretransmitter1
defined by thetransmitter
andreceiver
of the first entry in this list. Theretransmitter
andreceiver
are defined by thetransmitter
andreceiver
of the second entry of this list.bias_settings (
ObservationBiasSettings
, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation). Note that only one bias setting is applied to the nway observable.
 Returns:
Instance of the
ObservationModelSettings
derivedNWayRangeObservationSettings
class. Return type:
NWayRangeObservationSettings
 angular_position(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e214400f0>) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for an angular position observable.
Factory function for creating observation model settings of angular position type observables (as right ascension \(\alpha\) and declination \(\delta\)), for a single link definition. The associated observation model creates an observable \(\mathbf{h}_{_{\text{ang.pos.}}}\) of type two as follows (in the unbiased case):
\[\begin{split}\Delta\mathbf{r}=\mathbf{r}_{R}(t_{R})\mathbf{r}_{T}(t_{T})\\ \tan\alpha=\frac{\Delta r_{y}}{\Delta r_{x}}\\ \delta=\frac{\Delta r_{z}}{\sqrt{\Delta r_{x}^{2}+\Delta r_{y}^{2}}}\\ \mathbf{h}_{_{\text{ang.pos.}}} = [\alpha;\delta]\end{split}\]The relative position vector \(\Delta\mathbf{r}\) is computed identically as described for the
one_way_range()
The angular position observable can be used for optical astrometry, VLBI, etc. Due to the definition of this observable, the xyplane is defined by the global frame orientation of the environment. Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver
LinkEndType
entries to be defined.light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
class defining the settings for the angular position observable. Return type:
 relative_angular_position(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e213f6bb0>) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for an angular position observable.
Factory function for creating observation model settings of angular position type observables (as right ascension \(\alpha\) and declination \(\delta\)), for a single link definition. The associated observation model creates an observable \(\mathbf{h}_{_{\text{ang.pos.}}}\) of type two as follows (in the unbiased case):
\[\begin{split}\Delta\mathbf{r}=\mathbf{r}_{R}(t_{R})\mathbf{r}_{T}(t_{T})\\ \tan\alpha=\frac{\Delta r_{y}}{\Delta r_{x}}\\ \delta=\frac{\Delta r_{z}}{\sqrt{\Delta r_{x}^{2}+\Delta r_{y}^{2}}}\\ \mathbf{h}_{_{\text{ang.pos.}}} = [\alpha;\delta]\end{split}\]The relative position vector \(\Delta\mathbf{r}\) is computed identically as described for the
one_way_range()
The angular position observable can be used for optical astrometry, VLBI, etc. Due to the definition of this observable, the xyplane is defined by the global frame orientation of the environment. Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver
LinkEndType
entries to be defined.light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
class defining the settings for the angular position observable. Return type:
 one_way_doppler_instantaneous(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, transmitter_proper_time_rate_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.DopplerProperTimeRateSettings = None, receiver_proper_time_rate_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.DopplerProperTimeRateSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e21361470>, normalized_with_speed_of_light: bool = False) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for a oneway instantaneous Doppler observable.
Factory function for creating settings for a oneway instantaneous Doppler observable for a single link definition. The associated observation model creates a singlevalued observable \(h_{_{\text{1Dopp.}}}\) as follows (in the unbiased case):
\[h_{_{\text{1Dopp.}}}=c\left(\frac{d\tau_{T}}{dt_{T}}\frac{t_{T}}{dt_{R}}\frac{dt_{R}}{d\tau_{R}}1\right)\]where \(t\) and \(\tau\) denote coordinate and proper time of the transmitter T and receiver R, respectively. The receiver and transmitter position and coordinate time are computed identically as described for the
one_way_range()
. The detailed mathematical implementation are described on TODO.This observable represents the ‘instantaneous (nonintegrated)’ Doppler observable, as obtained from openloop observations. It should not be used for the modelling of the typical closedloop observations used in deep space tracking (for which the
one_way_doppler_averaged()
should be used)The coordinate time derivative \(\frac{t_{A}}{dt_{B}}\) is always computed when generating this observable. Settings for the proper time rates \(\frac{d\tau}{dt}\) can be specified by the user through the
transmitter_proper_time_rate_settings
andreceiver_proper_time_rate_settings
inputs. Whene these are left empty, the proper time rates are omitted (set to 1.0).The observable may be nondimensionalized by the speed of light \(c\), which results in the observable being equal to thee received and transmitted signal frequencies \(f_{R}/f_{T}1\).
 Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the transmitter and receiver
LinkEndType
entries to be defined.light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)transmitter_proper_time_rate_settings (
DopplerProperTimeRateSettings
, default = None) – Settings for computing the transmitter proper time rate \(\frac{d\tau}{dt}\), default is none (\(\frac{d\tau}{dt}=1\))receiver_proper_time_rate_settings (
DopplerProperTimeRateSettings
, default = None) – Settings for computing the receiver proper time rate \(\frac{d\tau}{dt}\), default is none (\(\frac{d\tau}{dt}=1\))light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)normalized_with_speed_of_light (bool, default = false) – Option to nondimensionalize the observable with speed of light \(c\)
 Returns:
Instance of the
ObservationModelSettings
derivedOneWayDopplerObservationSettings
class defining the settings for the oneway open doppler observable observable. Return type:
 two_way_doppler_instantaneous_from_one_way_links(uplink_doppler_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.OneWayDopplerObservationSettings, downlink_doppler_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.OneWayDopplerObservationSettings, bias_settings: tudat::observation_models::ObservationBiasSettings = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for a twoway instantaneous Doppler observable.
Factory function for creating settings for a twoway instantaneous Doppler observable for a single link definition. The implementation is the same as
two_way_doppler_instantaneous()
, with the difference that the constituent oneway ranges may have different settings.The observable may be nondimensionalized by the speed of light \(c\) (in the constituent oneway Doppler observable settings), which results in the observable being equal to the received and transmitted signal frequencies \(f_{R}/f_{T}1\).
 Parameters:
uplink_doppler_settings (
OneWayDopplerObservationSettings
) – Settings for uplink leg of 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.light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
derivedTwoWayDopplerObservationSettings
class defining the settings for the twoway open doppler observable. Return type:
TwoWayDopplerObservationSettings
 one_way_doppler_averaged(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e21358ab0>) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for a oneway averaged Doppler observable.
Factory function for creating observation model settings for oneway averaged Doppler observables, for a single link definition. The associated observation model creates a singlevalued observable \(h_{_{\text{1\bar{Dopp}}}}\) as follows (in the unbiased case):
\[\begin{split}h_{_{\text{1\bar{Dopp}}}}&=c\int_{t\Delta t}^{t+\Delta t}\frac{t_{T}}{dt_{R}}d\bar{t}\\ &=\frac{h_{_{\text{1range}}}(t_{R}=t+\Delta t,t_{T})h_{_{\text{1range}}}(t_{R}=t,t_{T})}{\Delta t}\end{split}\]where, in the latter formulation (which is the one that is implemented), the observable is referenced to the receiver time. This averaged Doppler observable is computed as the difference of two oneway range observables (see
one_way_range()
), with the reference time shifted by \(\Delta t\). As such, it is sensitive to numerical errors for small \(\Delta t\)The integration time \(\Delta t\) is defined in the ancilliary settings when simulating the observations (with 60 s as default).
 Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the transmitter and receiver
LinkEndType
entries to be defined.light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
derived OneWayDifferencedRangeRateObservationSettings class defining the settings for the oneway closedloop doppler observable. Return type:
 n_way_doppler_averaged(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e213615f0>) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for an nway averaged Doppler observable.
Factory function for creating observation model settings for nway averaged Doppler observables, for a single link definition. The implemenation is analogous to the
one_way_doppler_averaged()
observable. But, in the present case the observable is computed from the difference of two nway range observables, with the reference time shifted by \(\Delta t\).The integration time \(\Delta t\) is defined in the ancilliary settings when simulating the observations (with 60 s as default).
 Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver
LinkEndType
entries to be defined, as well as a retransmitter1, retransmitter2, …. (with the number of retransmitters to be defined by the user).light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
derived NWayDifferencedRangeRateObservationSettings class defining the settings for the oneway closedloop doppler observable. Return type:
 n_way_doppler_averaged_from_one_way_links(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for an nway averaged Doppler observable.
Factory function for creating observation model settings for nway averaged Doppler observables, for a single link definition. The implementation is the same as
n_way_doppler_averaged()
, with the difference that the constituent oneway range observables may have different settings. Parameters:
one_way_range_settings (List[
ObservationModelSettings
]) – List of observation model settings for each of the \(n\) constituent oneway ranges of the nway averaged range rate observable. TheLinkDefinition
of this nway range observable is created from this list, with thetransmitter
andretransmitter1
defined by thetransmitter
andreceiver
of the first entry in this list. Theretransmitter``(n1) and ``receiver
are defined by thetransmitter
andreceiver
of the :math:`n`^{th} entry of this list.bias_settings (
ObservationBiasSettings
, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)
 Returns:
Instance of the
ObservationModelSettings
derived NWayDifferencedRangeRateObservationSettings class defining the settings for the oneway closedloop doppler observable. Return type:
 two_way_doppler_averaged(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, light_time_correction_settings: List[tudat::observation_models::LightTimeCorrectionSettings] = [], bias_settings: tudat::observation_models::ObservationBiasSettings = None, light_time_convergence_settings: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria = <tudatpy.kernel.numerical_simulation.estimation_setup.observation.LightTimeConvergenceCriteria object at 0x7f3e213cfc70>) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for an nway averaged Doppler observable.
Factory function for creating observation model settings for nway averaged Doppler observables, for a single link definition. The implemenation is analogous to the
one_way_doppler_averaged()
observable. But, in the present case the observable is computed from the difference of two nway range observables, with the reference time shifted by \(\Delta t\).The integration time \(\Delta t\) is defined in the ancilliary settings when simulating the observations (with 60 s as default).
 Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver
LinkEndType
entries to be defined, as well as a retransmitter1, retransmitter2, …. (with the number of retransmitters to be defined by the user).light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
derived NWayDifferencedRangeRateObservationSettings class defining the settings for the oneway closedloop doppler observable. Return type:
 two_way_doppler_averaged_from_one_way_links(one_way_range_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings], bias_settings: tudat::observation_models::ObservationBiasSettings = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for an nway averaged Doppler observable.
Factory function for creating observation model settings for nway averaged Doppler observables, for a single link definition. The implemenation is analogous to the
one_way_doppler_averaged()
observable. But, in the present case the observable is computed from the difference of two nway range observables, with the reference time shifted by \(\Delta t\).The integration time \(\Delta t\) is defined in the ancilliary settings when simulating the observations (with 60 s as default).
 Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires the transmitter and receiver
LinkEndType
entries to be defined, as well as a retransmitter1, retransmitter2, …. (with the number of retransmitters to be defined by the user).light_time_correction_settings (List[
LightTimeCorrectionSettings
], default = list()) – List of corrections for the 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)light_time_convergence_settings (
LightTimeConvergenceCriteria
, default = :func:`light_time_convergence_settings`()) – Settings for convergence of the lighttime (default settings defined inlight_time_convergence_settings()
)
 Returns:
Instance of the
ObservationModelSettings
derived NWayDifferencedRangeRateObservationSettings class defining the settings for the oneway closedloop doppler observable. Return type:
 cartesian_position(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, bias_settings: tudat::observation_models::ObservationBiasSettings = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for a Cartesian position observable.
Factory function for creating observation model settings of Cartesian position type observables. Note that this observable is typically not realized in reality, but can be very useful for verification or analysis purposes. This observable provides the inertial (w.r.t. global frame origin) Cartesian position of the observed_body defined by the link_ends input. The observable has size 3, and contains the \(x\), \(y\) and \(z\) position
 Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body`
LinkEndType
entries to be defined.bias_settings (
ObservationBiasSettings
, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)
 Returns:
Instance of the
ObservationModelSettings
class defining the settings for the cartesian position observable. Return type:
 cartesian_velocity(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, bias_settings: tudat::observation_models::ObservationBiasSettings = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for a Cartesian velocity observable.
Factory function for creating observation model settings of Cartesian position type observables. Note that this observable is typically not realized in reality, but can be very useful for verification or analysis purposes. This observable provides the inertial (w.r.t. global frame origin) Cartesian velocity of the observed_body defined by the link_ends input. The observable has size 3, and contains the \(x\), \(y\) and \(z\) velocity
 Parameters:
link_ends (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body`
LinkEndType
entries to be defined.bias_settings (
ObservationBiasSettings
, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)
 Returns:
Instance of the
ObservationModelSettings
class defining the settings for the cartesian velocity observable. Return type:
 313_euler_angles(link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, bias_settings: tudat::observation_models::ObservationBiasSettings = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSettings #
Factory function for creating settings for observable containing the body orientation as Euler angles.
Factory function for creating observation model settings of Euler angle type observables. This observable can be used for e.g. body attitude observations, but can also be very useful as ‘synthetic’ observable for verification or analysis purposes. This observable provides the rotation from inertial (defined by the global frame orientation) to 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 (LinkDefinition) – Set of link ends that define the geometry of the observation. This observable requires that the observed_body`
LinkEndType
entries to be defined.bias_settings (
ObservationBiasSettings
, default = None) – Settings for the observation bias that is to be used for the observation, default is none (unbiased observation)
 Returns:
Instance of the
ObservationModelSettings
class defining the settings for the Euler angle observable. Return type:
 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:
 doppler_ancilliary_settings(integration_time: float = 60.0) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings #
No documentation found.
 two_way_range_ancilliary_settings(retransmission_delay: float = 0.0) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings #
Factory function for creating ancilliary settings for twoway range observable.
Factory function for creating ancilliary settings for a twoway range observable. Specifically, this function can be used to create settings for the retransmission delay of the observable. NOTE: this function is provided for convenience, and is equivalent to calling
n_way_range_ancilliary_settings()
with a single retransmission delay. Parameters:
retransmission_delay (float, default = 0.0) – Retransmission delay that is to be applied to the simulation of the twoway observable
 Returns:
Instance of the
ObservationAncilliarySimulationSettings
with the required settings. Return type:
 two_way_doppler_ancilliary_settings(integration_time: float = 60.0, retransmission_delay: float = 0.0) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings #
Factory function for creating ancilliary settings for twoway averaged Doppler observable.
Factory function for creating ancilliary settings for a twoway range observable. Specifically, this function can be used to create settings for the retransmission delay of the observable. NOTE: this function is provided for convenience, and is equivalent to calling
n_way_doppler_ancilliary_settings()
with a single retransmission delay. Parameters:
 Returns:
Instance of the
ObservationAncilliarySimulationSettings
with the required settings. Return type:
 n_way_range_ancilliary_settings(retransmission_delays: List[float] = []) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings #
Factory function for creating ancilliary settings for nway range observable.
Factory function for creating ancilliary settings for a nway range observable. Specifically, this function can be used to create settings for the retransmission delays of the observable, for each of the retransmitters.
 Parameters:
retransmission_delays (list[ float ], default = None) – Retransmission delays that are to be applied to the simulation of the nway observable. If kept empty, this results in 0 retransmission delay at each retransmitter. If defined, this list must be the same length as the number of retransmitters, and the \(i^{th}\) entry contains the retransmission delay of the \(i^{th}\) retrasmitter
 Returns:
Instance of the
ObservationAncilliarySimulationSettings
with the required settings. Return type:
 n_way_doppler_ancilliary_settings(integration_time: float = 60.0, retransmission_delays: List[float] = []) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings #
Factory function for creating ancilliary settings for nway averaged Doppler observable.
Factory function for creating ancilliary settings for a nway averaged Doppler observable. Specifically, this function can be used to create settings for the integration time of the observable, and the retransmission delays for each of the retransmitters.
 Parameters:
integration_time (float, default = 60.0) – Integration time that is to be used for the averaged Doppler observable
retransmission_delays (list[ float ], default = None) – Retransmission delays that are to be applied to the simulation of the nway observable. If kept empty, this results in 0 retransmission delay at each retransmitter. If defined, this list must be the same length as the number of retransmitters, and the \(i^{th}\) entry contains the retransmission delay of the \(i^{th}\) retrasmitter
 Returns:
Instance of the
ObservationAncilliarySimulationSettings
with the required settings. Return type:
 tabulated_simulation_settings(observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, simulation_times: List[float], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType = <LinkEndType.receiver: 5>, viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings] = [], noise_function: Callable[[float], numpy.ndarray[numpy.float64[m, 1]]] = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings #
Factory function for creating settings object for observation simulation, using a predefined list of observation times.
Factory function for creating single simulation settings object, using a predefined list of observation times. The list of resulting observations may be reduced compared to the
simulation_times
provided here, as only observations that meet the viability settings are retained during observation simulation (these may be provide directly here through theviability_settings
input, or added later to the resulting settings object). Parameters:
observable_type (
ObservableType
) – Observable type of which observations are to be simulated.link_ends (LinkDefinition) – Link ends for which observations are to be simulated.
simulation_times (List[float]) – List of times at which to perform the observation simulation.
reference_link_end_type (
LinkEndType
, default =LinkEndType
.receiver) – Defines the link end (via theLinkEndType
) which is used as a reference time for the observation.viability_settings (List[
ObservationViabilitySettings
], default = [ ]) – Settings for the creation of the viability criteria calculators, which conduct viability checks on the simulated observations.noise_function (Callable[ [float], numpy.ndarray[numpy.float64[m, 1]] ], default = None) – Function providing the observation noise factors as a function of observation time.
 Returns:
Instance of the
ObservationSimulationSettings
derivedTabulatedObservationSimulationSettings
class. Return type:
 tabulated_simulation_settings_list(link_ends_per_observable: Dict[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition]], simulation_times: List[float], reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType = <LinkEndType.receiver: 5>, viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings] = []) List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings] #
Factory function for creating a list of settings object for observation simulation, using a predefined list of observation times.
Factory function for creating multiple tabulated observation simulation settings objects in a list. This function is equivalent to calling the
tabulated_simulation_settings()
repeatly, with the different observables and link definition provided here through link_ends_per_observable. During a single call to this function, one simulation settings object is created for each combination of observable type and link geometry given by the link_ends_per_observable parameter. Parameters:
link_ends_per_observable (Dict[
ObservableType
, List[LinkDefinition]]]) – Link geometry per observable type of which observations are to be simulated.simulation_times (List[ float ]) – List of times at which to perform the observation simulation.
reference_link_end_type (
LinkEndType
, default = LinkEndType.receiver) – Defines the link end (via 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:
 continuous_arc_simulation_settings(observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition, start_time: float, end_time: float, interval_between_observations: float, arc_limiting_constraints: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings, minimum_arc_duration: float, maximum_arc_duration: float, minimum_time_between_arcs: float, reference_link_end_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkEndType = <LinkEndType.receiver: 5>, additional_viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings] = [], noise_function: Callable[[float], numpy.ndarray[numpy.float64[m, 1]]] = None) tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings #
Factory function for creating settings object for observation simulation, using observation times according to a requirement for a continuous tracking arc.
Factory function for creating settings object for observation simulation. Unlike the
tabulated_simulation_settings()
function, the resulting settings do not define the observation times explicitly. Instead, this settings object determines the observation times adaptively during the simulation of the observation, with the requirement that observations should be simulated over a set of contiguous arcs (if possible). The exact algorithm meets the following conditions:Observations are only simulated within the time span of
start_time
andend_time
A contiguous tracking arc has simulated observations separated by
interval_between_observations
Starting from
start_time
, an observation is simulated eachinterval_between_observations
. Once an observation is unviable, as defined by thearc_limiting_constraints
input, it is checked whether the arc up until that point is longer in duration thanminimum_arc_duration
. If it is, the arc is added to the simulated observations. If not, the arc is discarded. In either case, a new arc is started once a viable is observation is encounteredIf the current arc reaching a duration greater than
maximum_arc_duration
, the arc is added to the existing observations, and a new arc is startedIf defined (e.g. if not NaN), the current observation time is incremented by
minimum_time_between_arcs
when an arc has been added to the observations.
Nominally, this algorithm ensures that any arc of observations has a minimum and maximum duration. In addition, it ensures that (if desired) there is a minimum time interval between two tracking arcs. This behaviour can be modified by adding
additional_viability_settings
, which are not used when computing the tracking arcs, but which are instead only used to reduce the set of simulated observations afterwards. Parameters:
observable_type (
ObservableType
) – Observable type of which observations are to be simulated.link_ends (LinkDefinition) – Link ends for which observations are to be simulated.
start_time (float) – First time at which an observation is to be simulated (and checked for viability).
end_time (float) – Maximum time at which an observation is to be simulated (and checked for viability).
interval_between_observations (float) – Cadence (in seconds) of subsequent observations in an arc
arc_limiting_constraints (List[
ObservationViabilitySettings
], default = [ ]) – List of settings for the creation of the viability criteria calculators, which are used to check if an observation is viable, and define whether an arc should be terminated.minimum_arc_duration (float) – Minimum permissible time for a tracking arc
maximum_arc_duration (float) – Maximum permissible time for a tracking arc
minimum_time_between_arc (float, default = NaN) – Minimum time between two tracking arcs. If NaN, this is effectively set to the
interval_between_observations
additional_viability_settings (List[
ObservationViabilitySettings
], default = [ ]) – Settings for the creation of the viability criteria calculators, which conduct viability checks on the simulated observations. These settings are not used to determine whether an arc is to be terminated, but are instead applied after the arcs have been computed.noise_function (Callable[ [float], numpy.ndarray[numpy.float64[m, 1]] ], default = None) – Function providing the observation noise factors as a function of observation time.
 Returns:
Instance of the
ObservationSimulationSettings
derivedTabulatedObservationSimulationSettings
class. Return type:
 add_gaussian_noise_to_all(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], noise_amplitude: float) None #
Function for adding gaussian noise function to all existing observation simulation settings.
Function for including simple timeindependent and timeuncorrelated Gaussian noise function to the simulation settings of one or more observable(s). The noise settings are added to all
ObservationSimulationSettings
object(s) in the observation_simulation_settings list.Note: the
ObservationSimulationSettings
objects are modified inplace by this function, and thus the function does not return anything. Parameters:
observation_simulation_settings (List[
ObservationSimulationSettings
]) – Observation simulation settings, given by a list of one or more existingObservationSimulationSettings
objects.noise_amplitude (float) – Standard deviation defining the unbiased Gaussian distribution for the noise.
 Returns:
The
ObservationSimulationSettings
object(s) are changed inplace. Return type:
None
 add_gaussian_noise_to_observable(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], noise_amplitude: float, observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType) None #
Function for adding gaussian noise function to existing observation simulation settings of a given observable type.
As
add_gaussian_noise_to_all()
, except that the function only adds noise to entries of the observation_simulation_settings list that matches the specified observable_type. Parameters:
observation_simulation_settings (List[
ObservationSimulationSettings
]) – Observation simulation settings, given by a list of one or more 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_gaussian_noise_to_observable_for_link_ends(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], noise_amplitude: float, observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, link_definition: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition) None #
No documentation found.
 add_viability_check_to_all(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings]) None #
Function for including viability checks into existing observation simulation settings.
Function for adding viability checks to the observation simulation settings, such that only observations meeting certain conditions are retained. The noise settings are added to all
ObservationSimulationSettings
object(s) in the observation_simulation_settings list. Note: theObservationSimulationSettings
objects are modified inplace by this function, and thus the function does not return anything. Parameters:
observation_simulation_settings (List[
ObservationSimulationSettings
]) – Observation simulation settings, given by a list of one or more existingObservationSimulationSettings
objects.viability_settings (List[
ObservationViabilitySettings
]) – List of one or moreObservationViabilitySettings
objects, defining the viability checks to be included.
 Returns:
The
ObservationSimulationSettings
object(s) are changed inplace. Return type:
None
 add_viability_check_to_observable_for_link_ends(observation_simulation_settings_list: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationSimulationSettings], viability_settings: List[tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationViabilitySettings], observable_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservableType, link_ends: tudatpy.kernel.numerical_simulation.estimation_setup.observation.LinkDefinition) None #
Function for including viability checks into existing observation simulation settings.
As
add_viability_check_to_all()
, except that the function only adds noise to entries of the observation_simulation_settings list that matches the specified observable_type and link_definition. Parameters:
observation_simulation_settings (List[
ObservationSimulationSettings
]) – Observation simulation settings, given by a list of one or more existingObservationSimulationSettings
objects.viability_settings (List[
ObservationViabilitySettings
]) – List of one or moreObservationViabilitySettings
objects, defining the viability checks to be included.observable_type (
ObservableType
) – Identifies the observable type in the observation simulation settings for which the viability checks are to be considered.link_definition (
LinkDefinition
) – Identifies the link definition in the observation simulation settings for which the viability checks are to be considered.
 Returns:
The :class
 Return type:
None
Enumerations#
Enumeration of available link end types. 

Enumeration of available observable types. 

Enumeration of observation viability criterion types. 

Enumeration of behaviour when failing to converge lighttime with required settings. 
 class LinkEndType#
Enumeration of available link end types.
Members:
unidentified_link_end
transmitter
reflector1
retransmitter
reflector2
reflector3
reflector4
receiver
observed_body
 property name#
 class ObservableType#
Enumeration of available observable types.
Members:
one_way_range_type
n_way_range_type
angular_position_type
relative_angular_position_type
position_observable_type
velocity_observable_type
one_way_instantaneous_doppler_type
one_way_averaged_doppler_type
two_way_instantaneous_doppler_type
n_way_averaged_doppler_type
euler_angle_313_observable_type
 property name#
Classes#
Object serving as identifier of a specific link end. 

Object storing the link ends involved in a given observation. 

Base class to defining proper time rate settings. 

Base class for defining observation settings. 

Class for defining the settings of oneway instantaneous Doppler observation models. 

Base class to defining light time correction settings. 

Base class to defining observation bias settings. 

Base class for defining settings for simulating observations. 

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

Enumeration of observation viability criterion types. 

Base class for setting observation dependent variables. 

Class for holding ancilliary settings for observation simulation. 
 class LinkEndId#
Object serving as identifier of a specific link end.
 property body_name#
No documentation found.
 property reference_point#
No documentation found.
 class LinkDefinition#
Object storing the link ends involved in a given observation.
 class DopplerProperTimeRateSettings#
Base class to defining proper time rate settings.
Functional (base) class for settings of proper time rate (at a single link end) for instantaneous Doppler observation model settings. Specific proper time rate settings must be defined using an object derived from this class. The derived classes are made accessible via dedicated factory functions.
 class ObservationSettings#
Base class for defining observation settings.
Functional (base) class for settings of observation models. Observation model settings define at least the type and geometry of a given observation. They can furthermore set observation biases and/or lighttime 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 instantaneous Doppler observation models.
ObservationSettings
derived class for oneway instantaneous Doppler observation model settings. Settings object can account for additional observation model aspects such as light time corrections and proper time rate settings. Instances of this class can be created via theone_way_doppler_instantaneous()
factory function.
 class LightTimeCorrectionSettings#
Base class to defining light time correction settings.
Functional (base) class for settings of light time corrections. This class is not used for calculations of corrections, but is used for the purpose of defining the light time correction properties. Specific light time correction settings must be defined using an object derived from this class. The derived classes are made accessible via dedicated factory functions, such as e.g.
first_order_relativistic_light_time_correction()
 class ObservationBiasSettings#
Base class to defining observation bias settings.
Functional (base) class for settings of observation bias. Specific observation bias settings must be defined using an object derived from this class. The derived classes are made accessible via dedicated factory functions.
 class ObservationSimulationSettings#
Base class for defining settings for simulating observations.
Base class for defining settings for simulating observations. This simulation settings object defines observation times, noise and viability criteria, etc. at which observations are to be simulated. Therefore, one simulation settings object of this type can only refer to one combination of observable type and link geometry (LinkDefinition). The user does not interact with this class directly, but defines specific observation simulation settings using an object derived from this class (created through the associated factory function).
 property noise_function#
No documentation found.
 property viability_settings_list#
No documentation found.
 class TabulatedObservationSimulationSettings#
Class for defining settings for simulating observations at a predefined set of times.
ObservationSimulationSettings
derived class for defining settings for simulating observations at a predefined set of times This type defines predefined time epochs at which applicable observations are to be simulated, stored in a rigid, “tabulated” form. Some observation times may be discarded due to the use of viability settings. Instances of this class are typicall created via thetabulated_simulation_settings()
andtabulated_simulation_settings_list()
factory functions.
 class ObservationViabilitySettings#
Enumeration of observation viability criterion types.
 class ObservationDependentVariableSettings#
Base class for setting observation dependent variables.
Functional (base) class for setting observation dependent variables as part of the observation output. Note: The associated functionality is not yet mature enough for the end user. Class is exposed for development purposes only.
 class ObservationAncilliarySimulationSettings#
Class for holding ancilliary settings for observation simulation.
 get_float_list_settings(self: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings, setting_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationVariable, throw_exception: bool = True) List[float] #
 Parameters:
setting_type (ObservationAncilliarySimulationVariable) – Type of the setting for which the value is to be returned
throw_exception (bool, default = false) – Boolean defining whether to throw an exception if the requested setting does not exist, or does not exist as list of floating point values.
 Returns:
Value of the requested ancilliary variable (or empty list if it does not exist)
 Return type:
 get_float_settings(self: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationSettings, setting_type: tudatpy.kernel.numerical_simulation.estimation_setup.observation.ObservationAncilliarySimulationVariable, throw_exception: bool = True) float #
 Parameters:
setting_type (ObservationAncilliarySimulationVariable) – Type of the setting for which the value is to be returned
throw_exception (bool, default = false) – Boolean defining whether to throw an exception if the requested setting does not exist, or does not exist as a floating point value.
 Returns:
Value of the requested ancilliary variable (or NaN if it does not exist)
 Return type: