light_time_corrections¶

This module contains a set of factory functions for setting up the light-time corrections for observation models.

Most functions in this module create objects of type LightTimeCorrectionSettings, which define settings for a type of light-time correction. The main interface with Tudat is that these objects are used as input to the observation model functions created in the model_settings module.

When not applying any light-time corrections, a signal is assumed to travel in a straight line (in Euclidean space) with the speed of light \(c\). The light-time corrections defined through this module are used to compute corrections \(\Delta t\) to the light time, such that:

\[\frac{||\mathbf{r}_{1}(t_{1}) - \mathbf{r}_{0}(t_{0})||}{c}=\left(t_{1}-t_{0}\right)+\Delta t(t_{0},t_{1};\mathbf{r}_{1}(t_{1}),\mathbf{r}_{0}(t_{0}))\]

for a signal transmitted from link end \(0\) at \(t_{0}\) and received by link end \(1\) at \(t_{1}\). More details on the link with the observation model, and the manner in which this equation is solved, is given on the user guide .

Functions¶

light_time_convergence_settings(...)

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

first_order_relativistic_light_time_correction(...)

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

approximated_second_order_relativistic_light_time_correction(...)

Function for creating settings for Moyer, 2000 Eq 8.55 approximated second-order relativistic light-time corrections.

dsn_tabulated_tropospheric_light_time_correction(...)

No documentation found.

saastamoinen_tropospheric_light_time_correction(...)

No documentation found.

dsn_tabulated_ionospheric_light_time_correction(...)

No documentation found.

jakowski_ionospheric_light_time_correction([...])

Function for creating settings for Jakowski VTEC ionospheric light-time corrections.

ionex_ionospheric_light_time_correction(...)

vmf3_tropospheric_light_time_correction(...)

Create VMF3 tropospheric light time correction settings.

inverse_power_series_solar_corona_light_time_correction([...])

No documentation found.

set_vmf_troposphere_data(data_files, ...)

Set VMF/VMF3/VMF3o troposphere (and optional meteo) data in Earth ground stations.

set_ionosphere_model_from_ionex(data_files, ...)

Load IONEX global ionosphere map data and set the resulting ionosphere model on the Earth body.
light_time_convergence_settings(iterate_corrections: bool = False, maximum_number_of_iterations: int | SupportsIndex = 50, absolute_tolerance: float | SupportsIndex = nan, failure_handling: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeFailureHandling = <LightTimeFailureHandling.accept_without_warning: 0>) → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeConvergenceCriteria¶

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

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

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

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

Parameters:

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

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

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

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

Returns:

Instance of the LightTimeConvergenceCriteria with the required settings.

Return type:

LightTimeConvergenceCriteria

Examples

# Code Snippet to showcase the use of the light_time_convergence_settings function
from tudatpy.estimation.observable_models_setup import light_time_corrections

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

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

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

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

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

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

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

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

Parameters:

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

Returns:

Instance of the LightTimeCorrectionSettings configured to include first-order relativistic light-time corrections.

Return type:

LightTimeCorrectionSettings

Examples

# Code Snippet to showcase the use of the first_order_relativistic_light_time_correction function
from tudatpy.estimation.observable_models_setup import light_time_corrections, links

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

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

# The function first_order_relativistic_light_time_correction() requires a list of strings (perturbing body/bodies) as input
# and a boolean value for bending (default is True).
perturbing_body = ['Earth']
doppler_observation_settings = light_time_corrections.first_order_relativistic_light_time_correction(perturbing_body)

# Show that it returns a LightTimeCorrectionSettings object.
print(doppler_observation_settings)
approximated_second_order_relativistic_light_time_correction(perturbing_bodies: list[str]) → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeCorrectionSettings¶

Function for creating settings for Moyer, 2000 Eq 8.55 approximated second-order relativistic light-time corrections.

Function for creating settings for approximated second-order relativistic light-time corrections: These corrections account for the delay in light travel time caused by stationary point masses, calculated up to \(c^{-2}\) according to general relativity ( Moyer, 2000 Eq 8.55; correction term for Sun) and it includes the bending of light due to the perturbing body. A key consideration in the model is the time at which the states of the perturbing bodies are evaluated. This depends on their involvement in the observation link ends:

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

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

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

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

Parameters:

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

Returns:

Instance of the LightTimeCorrectionSettings configured to include approximated second-order relativistic light-time corrections.

Return type:

LightTimeCorrectionSettings

Examples

# Code Snippet to showcase the use of the first_order_relativistic_light_time_correction function
from tudatpy.estimation.observable_models_setup import light_time_corrections, links

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

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

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

# Show that it returns a LightTimeCorrectionSettings object.
print(doppler_observation_settings)
dsn_tabulated_tropospheric_light_time_correction(file_names: list[str], body_with_atmosphere_name: str = 'Earth', mapping_model: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.TroposphericMappingModel = <TroposphericMappingModel.niell: 1>) → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeCorrectionSettings¶

No documentation found.

saastamoinen_tropospheric_light_time_correction(body_with_atmosphere_name: str = 'Earth', mapping_model: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.TroposphericMappingModel = <TroposphericMappingModel.niell: 1>, water_vapor_partial_pressure_model: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.WaterVaporPartialPressureModel = <WaterVaporPartialPressureModel.tabulated: 0>) → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeCorrectionSettings¶

No documentation found.

dsn_tabulated_ionospheric_light_time_correction(file_names: list[str], spacecraft_name_per_id: dict[int | SupportsIndex, str] = {}, quasar_name_per_id: dict[int | SupportsIndex, str] = {}, reference_frequency: float | SupportsIndex = 2295000000.0, body_with_atmosphere_name: str = 'Earth') → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeCorrectionSettings¶

No documentation found.

jakowski_ionospheric_light_time_correction(ionosphere_height: float | SupportsIndex = 400000.0, first_order_delay_coefficient: float | SupportsIndex = 40.3, solar_activity_data_path: str = '/home/docs/.tudat/resource/space_weather/sw19571001.txt', geomagnetic_pole_latitude: float | SupportsIndex = 1.4119713648634127, geomagnetic_pole_longitude: float | SupportsIndex = -1.2671090369478832, use_utc_for_local_time_computation: bool = False, body_with_atmosphere_name: str = 'Earth') → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeCorrectionSettings¶

Function for creating settings for Jakowski VTEC ionospheric light-time corrections.

Computes the ionospheric delay using the Jakowski et al. (2011) analytical VTEC model with a Modified Single Layer Model (MSLM) mapping function. The model computes VTEC at the sub-ionospheric point as a function of geomagnetic latitude, local time, and solar activity (F10.7 index), then maps to slant TEC via \(\text{STEC} = \text{VTEC} / \cos(z')\), where \(z'\) is the zenith angle at the ionospheric pierce point.

This correction is suitable for ground-to-GNSS geometries where the receiver is below the ionosphere.

Parameters:

  • ionosphere_height (float, default = 400.0e3) – Height of the ionospheric single-layer shell [m].

  • first_order_delay_coefficient (float, default = 40.3) – Coefficient relating STEC to range delay: \(\Delta\rho = c_1 \cdot \text{STEC} / f^2\) [m 3 /s 2].

  • solar_activity_data_path (str) – Path to space weather data file containing F10.7 solar radio flux values.

  • geomagnetic_pole_latitude (float, default = 80.9 deg (in radians)) – Geodetic latitude of the geomagnetic north pole [rad].

  • geomagnetic_pole_longitude (float, default = -72.6 deg (in radians)) – Geodetic longitude of the geomagnetic north pole [rad].

  • use_utc_for_local_time_computation (bool, default = False) – If True, use UTC for local time computation instead of TDB.

  • body_with_atmosphere_name (str, default = "Earth") – Name of the body with the ionosphere.

Returns:

Instance of the LightTimeCorrectionSettings configured for Jakowski VTEC ionospheric corrections.

Return type:

LightTimeCorrectionSettings

ionex_ionospheric_light_time_correction(body_with_ionosphere_name: str, ionosphere_height: float | SupportsIndex, first_order_delay_coefficient: float | SupportsIndex = 40.3) → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeCorrectionSettings¶

Deprecated since version Use: nequick2_ionospheric_light_time_correction() instead, which provides physically correct path-integrated ionospheric corrections for all geometries including space-based receivers.

Function for creating settings for IONEX-based ionospheric light-time corrections using the Modified Single Layer Model (MSLM). This approximation maps VTEC to STEC via \(\text{STEC} = \text{VTEC} / \cos(z')\) and is only valid when the receiver is below the ionosphere and the transmitter is above it. For receivers inside the ionosphere (e.g., ISS at ~420 km), this mapping is geometrically meaningless.

Parameters:

  • body_with_ionosphere_name (str) – Name of the body with the ionosphere (e.g., "Earth").

  • ionosphere_height (float) – Height of the ionospheric single-layer shell [m]. Typically 450e3 for IONEX maps.

  • first_order_delay_coefficient (float, default = 40.3) – Coefficient relating STEC to range delay [m 3 /s 2].

vmf3_tropospheric_light_time_correction(body_with_atmosphere_name: str = 'Earth', use_gradient_correction: bool = True, tropospheric_mapping_model: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.TroposphericMappingModel = <TroposphericMappingModel.vmf3: 2>) → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeCorrectionSettings¶

Create VMF3 tropospheric light time correction settings.

inverse_power_series_solar_corona_light_time_correction(coefficients: list[float | SupportsIndex] = [130000000000000.0, 500000000000.0], positive_exponents: list[float | SupportsIndex] = [6.0, 2.0], delay_coefficient: float | SupportsIndex = 40.3, sun_body_name: str = 'Sun') → tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.LightTimeCorrectionSettings¶

No documentation found.

set_vmf_troposphere_data(data_files: list[str], file_has_meteo: bool, file_has_gradient: bool, bodies: tudatpy.kernel.dynamics.environment.SystemOfBodies, set_troposphere_data: bool = True, set_meteo_data: bool = True, interpolator_settings: tudatpy.kernel.math.interpolators.InterpolatorSettings = <tudatpy.kernel.math.interpolators.InterpolatorSettings object at 0x7fa5cc7dc9b0>, retrieve_mapping_internally: bool = False) → None¶

Set VMF/VMF3/VMF3o troposphere (and optional meteo) data in Earth ground stations.

If retrieve_mapping_internally is True, station-name matching first attempts direct key matching and then internally maps ILRS station code <-> DOMES identifiers using the default ILRS SINEX SITE/ID registry.

set_ionosphere_model_from_ionex(data_files: list[str], bodies: tudatpy.kernel.dynamics.environment.SystemOfBodies, interpolator_settings: tudatpy.kernel.math.interpolators.InterpolatorSettings = None, station_subset: list[tuple[str, str]] = [], subset_padding_deg: float | SupportsIndex = 30.0) → None¶

Load IONEX global ionosphere map data and set the resulting ionosphere model on the Earth body.

Reads one or more IONEX files (e.g., from IGS, CODE, JPL, ESA, UPC analysis centres), builds a 3D interpolator over [time, latitude, longitude], and attaches the resulting TabulatedIonosphereModel to the "Earth" body. This model provides VTEC values at arbitrary locations and times, which can then be used by the NeQuick-2 ionospheric light-time correction.

When station_subset is provided, the IONEX map is spatially cropped to a bounding box around the specified ground stations (plus subset_padding_deg on each side). This significantly reduces memory usage and interpolation time, especially for long arcs with high-resolution IONEX products. The station geodetic positions are looked up from the bodies object.

Parameters:

  • data_files (list[str]) – List of paths to IONEX files (*.INX or *.ionex). Files from any IGS analysis centre (COD, EMR, ESA, IGS, JPL, UPC) and any temporal resolution (15 min to 2 hours) are supported.

  • bodies (SystemOfBodies) – System of bodies. The ionosphere model will be set on the "Earth" body.

  • interpolator_settings (InterpolatorSettings, optional) – Settings for the 3D multi-linear interpolator. If not provided, defaults to multi-linear interpolation with hunting algorithm and boundary value extrapolation.

  • station_subset (list[tuple[str, str]], default = []) – List of (body_name, station_name) pairs defining the ground stations around which to crop the IONEX grid. When empty (default), the full global grid is loaded. Example: [("Earth", "OPMT"), ("Earth", "WTZR")].

  • subset_padding_deg (float, default = 30.0) – Padding in degrees of latitude and longitude around the bounding box of the station locations.

Examples

# Load full global IONEX grid (default)
light_time_corrections.set_ionosphere_model_from_ionex(
    data_files=["path/to/ionex.INX"], bodies=bodies)

# Load only a regional subset around two stations (saves memory)
light_time_corrections.set_ionosphere_model_from_ionex(
    data_files=["path/to/ionex.INX"], bodies=bodies,
    station_subset=[("Earth", "OPMT"), ("Earth", "WTZR")],
    subset_padding_deg=30.0)

Enumerations¶

LightTimeFailureHandling

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

TroposphericMappingModel

No documentation found.

WaterVaporPartialPressureModel

No documentation found.
class LightTimeFailureHandling¶

Bases: pybind11_object

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

Examples

# Code snippet to print all available Light Time Failure Handling Types
from tudatpy.estimation.observable_models_setup import light_time_corrections

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

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

Members:

accept_without_warning

print_warning_and_accept

throw_exception

LightTimeFailureHandling.name -> str
class TroposphericMappingModel¶

Bases: pybind11_object

No documentation found.

Members:

simplified_chao

niell

vmf3

TroposphericMappingModel.name -> str
class WaterVaporPartialPressureModel¶

Bases: pybind11_object

No documentation found.

Members:

tabulated

bean_and_dutton

WaterVaporPartialPressureModel.name -> str

Classes¶

LightTimeConvergenceCriteria

Base class to define criteria of light time convergence.

LightTimeCorrectionSettings

Base class to define light time correction settings.

JakowskiVtecCalculator

GlobalIonosphereModelVtecCalculator

VTEC calculator that wraps an IonosphereModel (e.g., from IONEX data).
class LightTimeConvergenceCriteria¶

Bases: pybind11_object

Base class to define criteria of light time convergence.

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

Examples

# Code snippet to show the creation of a LightTimeConvergenceCriteria object
from tudatpy.estimation.observable_models_setup import light_time_corrections

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

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

Bases: pybind11_object

Base class to define light time correction settings.

Base class to define light time correction settings. This class is not used for calculations of corrections, but is used for the purpose of defining the light time correction properties. Specific light time correction settings must be defined using an object derived from this class.

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

Examples

# Code snippet to show the creation of a LightTimeCorrectionSettings object
from tudatpy.estimation.observable_models_setup import light_time_corrections, links

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

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

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

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

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

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

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

Bases: VtecCalculator

__init__(self: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.JakowskiVtecCalculator, sun_declination_function: Callable[[float | SupportsIndex], float], f10p7_function: Callable[[float | SupportsIndex], float], use_utc_time_for_local_time: bool = False) → None¶
calculate_vtec(self: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.JakowskiVtecCalculator, time: float | SupportsIndex, sub_ionospheric_point: numpy.ndarray[numpy.float64[3, 1]]) → float¶
class GlobalIonosphereModelVtecCalculator¶

Bases: VtecCalculator

VTEC calculator that wraps an IonosphereModel (e.g., from IONEX data).

Computes the vertical total electron content at a given sub-ionospheric point by querying the underlying ionosphere model. This is used internally by the IONEX ionospheric light-time correction, but can also be used directly to sample VTEC on a grid for visualization (e.g., global VTEC maps).

The sub-ionospheric point is specified as a geodetic position vector [altitude_m, latitude_rad, longitude_rad].

Examples

from tudatpy.estimation.observable_models_setup import light_time_corrections

ionosphere_model = bodies.get_body("Earth").get_ionosphere_model()
vtec_calc = light_time_corrections.GlobalIonosphereModelVtecCalculator(ionosphere_model)

# Sample VTEC at 450 km, 45 deg N, 15 deg E
import numpy as np
geodetic = np.array([450e3, np.deg2rad(45.0), np.deg2rad(15.0)])
vtec = vtec_calc.calculate_vtec(epoch_tdb, geodetic)  # returns VTEC in el/m^2
__init__(self: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.GlobalIonosphereModelVtecCalculator, ionosphere_model: tudatpy.kernel.dynamics.environment.IonosphereModel) → None¶

Construct a VTEC calculator from an ionosphere model.

Parameters:

ionosphere_model (IonosphereModel) – The ionosphere model to wrap (e.g., from bodies.get_body("Earth").get_ionosphere_model()).

calculate_vtec(self: tudatpy.kernel.estimation.observable_models_setup.light_time_corrections.GlobalIonosphereModelVtecCalculator, time: float | SupportsIndex, sub_ionospheric_point: numpy.ndarray[numpy.float64[3, 1]]) → float¶

Calculate the vertical total electron content at a sub-ionospheric point.

Parameters:

  • time (float) – Time [seconds since J2000 TDB].

  • sub_ionospheric_point (numpy.ndarray) – Geodetic position as [altitude_m, latitude_rad, longitude_rad].

Returns:

Vertical TEC in electrons/m^2 (multiply by 1e-16 to convert to TECU).

Return type:

float