`ground_station`¶

This module contains a set of factory functions for setting up ground stations and associated models. Note that in Tudat, no distinction is made between a ground station/lander on Earth or a different body.

The main interfaces with Tudat is the ground_station_settings list attribute (with entries of type GroundStationSettings) of the body settings, which defines settings for the ground stations of a body. The functions in this submodule are used to create these settings objects. When creating a body (typically using the create_system_of_bodies() function), a list of objects of type GroundStation (or a derived class) is created and added to the associated Body object based on the settings object, which can be retrieved using the ground_station_list attribute. The ground station can also be safely added to the Body after its creation using the add_ground_station() function.

A ground station defines a reference point (and other relevant properties) on a celestial body. Although ground stations are considered part of the environment in Tudat (as properties of a Body object), they do not influence the numerical propagation (unless a custom model imposing this is implemented by the user).

Properties such as a transmitting frequency of the station is added after its creation (to the GroundStation object). When creating the settings for a ground stations (using the functions in this module) the body may be endowed with a list of GroundStationMotionSettings settings, which define station dependent models to define the station-specific motion of a ground station (such as plate motion). Models for the deformation of the full body (such as tidal shape variations) are to be defined through the shape_deformation module.

For Earth, we provide several options to create default stations, such as the dsn_stations() and evn_stations().

Functions¶

`basic_station`(station_name, ...)	Function for creating settings for a ground station
`dsn_station`(station_name)	Function for creating settings for single DSN station (see `dsn_stations()`)
`dsn_stations`()	Function for creating settings for all DSN stations
`radio_telescope_stations`()	Function for creating settings for all DSN and EVN stations, combining `evn_stations()` and `dsn_stations()`
`evn_stations`()	Function for creating settings for all EVN stations.
`default_ilrs_sinex_state_file`()	Return the default SINEX station-state file path for ILRS station loading.
`default_ilrs_sinex_eccentricity_file`()	Return the default SINEX station-eccentricity file path for ILRS station loading.
`ilrs_stations_from_sinex_domes`(domes_ids, ...)	Function for creating ILRS station settings from SINEX state/eccentricity files using IERS DOMES identifiers.
`linear_station_motion`(linear_velocity[, ...])	Function for creating settings for a linear station motion
`piecewise_constant_station_motion`(...)	Function for creating settings for a piecewise constant ground station position variation
`custom_station_motion`(...)	Function for creating settings for a custom ground station position variation
`get_approximate_dsn_ground_station_positions`()	This function returns the approximate positions of the DSN ground stations.
`get_vlbi_station_positions`()	This function returns the positions of VLBI stations.
`get_vlbi_station_velocities`()	This function returns the velocities of VLBI stations.
`get_radio_telescope_positions`()	This function returns the positions of DSN ground stations and VLBI stations.
`optical_telescope_stations`()	Function for creating settings for existing MPC stations.

basic_station(station_name: str, station_nominal_position: numpy.ndarray[numpy.float64[3, 1]], station_position_element_type: tudatpy.kernel.astro.element_conversion.PositionElementTypes = <PositionElementTypes.cartesian_position_type: 0>, station_motion_settings: list[tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationMotionSettings] = []) → tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationSettings¶

Function for creating settings for a ground station

Function for creating settings for a ground station, defining only its name, body-fixed position, and (optionally) time-variations of its position

Parameters:

station_name (string) – Name (unique identifier) by which the station is to be known.
station_position_element_type (PositionElementTypes, default = cartesian_position) – Type of elements for station_nominal_position.
station_nominal_position (numpy.ndarray([3,1])) – Nominal position of the station in a body-fixed frame. Depending on the choice of station_position_element_type input, this vector must contain * Cartesian (for cartesian_position input) - \([x,y,z]\), denoting \(x-\), \(y-\) and \(z-\) components of body-fixed position (w.r.t body-fixed frame origin, typically center of mass) * Spherical (for spherical_position input) - - \([r,\phi',\theta]\), denoting distance from body-fixed frame origin (typically center of mass), latitude and longitude * Geodetic (for geodetic_position input) - - \([h,\phi,\theta]\), denoting the altitude w.r.t. the body shape model, geodetic latitude and longitude. Note that, in this case, the conversion to Cartesian position depends on the body’s shape model
station_motion_settings (list[ GroundStationMotionSettings ], default = None) – List of settings defining time-variations of the individual ground station

Returns:

Instance of the GroundStationSettings defining settings of the to be created ground station

Return type:

GroundStationSettings

Examples

In this example, we create a station using geodetic coordinates at the approximate location of the city of Delft, and no motion settings:

# Define the position of the ground station on Earth
station_altitude = 0.0
delft_latitude = np.deg2rad(52.00667)
delft_longitude = np.deg2rad(4.35556)

# Create ground station settings
ground_station_settings = environment_setup.ground_station.basic_station(
    "TrackingStation",
     [station_altitude, delft_latitude, delft_longitude],
     element_conversion.geodetic_position_type)

# Append station settings to existing (default is empty) list
        body_settings.get( "Earth" ).ground_station_settings.append( ground_station_settings )

dsn_station(station_name: str) → tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationSettings¶

Function for creating settings for single DSN station (see dsn_stations())

Parameters:: station_name (str) – String with the name of the station, e.g. “DSS-12”
Returns:: Settings to create DSN station
Return type:: GroundStationSettings

Examples

In this example, settings for the 70m DSN dishes DSS-14, DSS-43 and DSS-63 are created and assigned to the Earth ground station settings:

from tudatpy.dynamics.environment_setup.ground_station import \
    dsn_station

dss_station_names = ["DSS-14", "DSS-43", "DSS-63"]
dss_station_settings = [dsn_station(station_name) for station_name in dss_station_names]

body_settings.get("Earth").ground_station_settings = dss_station_settings

dsn_stations() → list[tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationSettings]¶

Function for creating settings for all DSN stations

Function for creating settings for all DSN stations, defined by nominal positions and linear velocities, as defined by Cartesian elements in DSN No. 810-005, 301, Rev. O, see this link. Note that calling these settings will use the Cartesian elements provided in this document (in ITRF93) and apply them to the Earth-fixed station positions, regardless of the selected Earth rotation model.

Returns:: List of settings to create DSN stations
Return type:: list[ GroundStationSettings ]

radio_telescope_stations() → list[tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationSettings]¶

Function for creating settings for all DSN and EVN stations, combining evn_stations() and dsn_stations()

Returns:: List of settings to create DSN + EVN stations
Return type:: list[ GroundStationSettings ]

evn_stations() → list[tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationSettings]¶

Function for creating settings for all EVN stations.

Function for creating settings for all EVN stations. EVN stations are defined by nominal positions and linear velocities, as defined by the glo.sit station file, see this link. Note that calling these settings will use the Cartesian elements provided by these documents and apply them to the Earth-fixed station positions, regardless of the selected Earth rotation model.

Returns:: List of settings to create EVN stations
Return type:: list[ GroundStationSettings ]

default_ilrs_sinex_state_file() → str¶

Return the default SINEX station-state file path for ILRS station loading.

Returns:: Path to the default ILRS SINEX state file in Tudat resources.
Return type:: str

default_ilrs_sinex_eccentricity_file() → str¶

Return the default SINEX station-eccentricity file path for ILRS station loading.

Returns:: Path to the default ILRS SINEX eccentricity file in Tudat resources.
Return type:: str

ilrs_stations_from_sinex_domes(domes_ids: list[str], sinex_state_file: str, sinex_eccentricity_file: str, throw_exception_on_missing_data: bool = False) → list[tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationSettings]¶

Function for creating ILRS station settings from SINEX state/eccentricity files using IERS DOMES identifiers.

Parameters:

domes_ids (List[str]) – List of IERS DOMES identifiers to load (for example, ["14201S018"] for Wettzell).
sinex_state_file (str) – Path to SINEX station-state file (position/velocity).
sinex_eccentricity_file (str) – Path to SINEX eccentricity file. Set to an empty string to disable eccentricity offsets.
throw_exception_on_missing_data (bool, default = False) – Whether to throw when requested stations cannot be mapped or found.

Returns:

Ground station settings for the selected ILRS DOMES stations.

Return type:

list[ GroundStationSettings ]

linear_station_motion(linear_velocity: numpy.ndarray[numpy.float64[3, 1]], reference_epoch: float | SupportsIndex = 0.0) → tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationMotionSettings¶

Function for creating settings for a linear station motion

Function for creating settings for a linear station motion, implementing \(\Delta \mathbf{r}=\dot{\mathbf{r}}(t-t_{0})\).

Parameters:

linear_velocity (numpy.ndarray([3,1])) – Linear velocity \(\dot{\mathbf{r}}\) of the station (in m/s)
reference_epoch (astro.time_representation.Time, default = 0.0) – Reference epoch \(t_{0}\) (Time object representing seconds since J2000 TDB)

Returns:

Instance of the GroundStationMotionSettings derived LinearGroundStationMotionSettings class

Return type:

GroundStationMotionSettings

piecewise_constant_station_motion(displacement_list: dict[float | SupportsIndex, numpy.ndarray[numpy.float64[3, 1]]]) → tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationMotionSettings¶

Function for creating settings for a piecewise constant ground station position variation

Function for creating settings for a piecewise constant ground station position. Using this model, the added station velocity in a body-fixed frame \(\dot{\mathbf{r}}\) is always zero, but its displacement \(\Delta\mathbf{r}\) is set according to the input list, which contains a list of times and displacements \([t_{i},\Delta\mathbf{r}_{i}]\). When the resulting model is queried at a given time \(t\), the nearest lower neighbour \(t_{i}\) from this list is found, and the associated \(\Delta\mathbf{r}_{i}\) is applied.

Parameters:: displacement_list (dict[astro.time_representation.Time,numpy.ndarray([3,1])]) – Dictionary with the epochs \(t_{i}\) as keys (as Time objects), and the associated displacement \(\Delta\mathbf{r}_{i}\) as values
Returns:: Instance of the GroundStationMotionSettings derived PiecewiseConstantGroundStationMotionSettings class
Return type:: GroundStationMotionSettings

custom_station_motion(custom_displacement_function: Callable[[float | SupportsIndex], numpy.ndarray[numpy.float64[3, 1]]]) → tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationMotionSettings¶

Function for creating settings for a custom ground station position variation

Function for creating settings for a custom ground station position. An arbitrary user-defined function of the signature \(\Delta\mathbf{r}=\Delta\mathbf{r}(t)\) is provided and applied to the station position

Parameters:: custom_displacement_function (callable[[Time],numpy.ndarray([3,1])]) – Function returning \(\Delta\mathbf{r}\), with the time \(t\) (as Time object) as input.
Returns:: Instance of the GroundStationMotionSettings derived CustomGroundStationMotionSettings class
Return type:: GroundStationMotionSettings

get_approximate_dsn_ground_station_positions() → dict[str, numpy.ndarray[numpy.float64[3, 1]]]¶

This function returns the approximate positions of the DSN ground stations.

The function returns ground station positions for all present ground stations specified in DSN 810-005, 301 Coverage and Geometry, Revision O (2024), DSN/JPL. Additionally, historic positions for DSS-12, DSS-42 and DSS-61 are provided, retrieved from NAIF. The positions of the ground stations are specified at 2003.0 with respect to ITRF93.

Returns:: Dictionary mapping DSN station names (str, format: “DSS-<id>”) to approximate positions.
Return type:: dict[str, numpy.ndarray([3,1])]

get_vlbi_station_positions() → dict[str, numpy.ndarray[numpy.float64[3, 1]]]¶

This function returns the positions of VLBI stations.

The VLBI station positions are retrieved from pysctrack.

Returns:: Dictionary mapping station name to positions.
Return type:: dict[str, numpy.ndarray([3,1])]

get_vlbi_station_velocities() → dict[str, numpy.ndarray[numpy.float64[3, 1]]]¶

This function returns the velocities of VLBI stations.

The VLBI station velocities are retrieved from pysctrack.

Returns:: Dictionary mapping station name to velocities.
Return type:: dict[str, numpy.ndarray([3,1])]

get_radio_telescope_positions() → dict[str, numpy.ndarray[numpy.float64[3, 1]]]¶

This function returns the positions of DSN ground stations and VLBI stations.

The function returns ground station positions for all DSN ground stations (as given by get_approximate_dsn_ground_station_positions()) and VLBI stations (as given by get_vlbi_station_positions()).

Returns:: Dictionary mapping station name to positions.
Return type:: dict[str, numpy.ndarray([3,1])]

optical_telescope_stations() → list[tudatpy.kernel.dynamics.environment_setup.ground_station.GroundStationSettings]¶

Function for creating settings for existing MPC stations. Observatories cartesian coordinates were converted using parallax info (rho_cos_phi, rho_sin_phi) from Project Pluto’s list: https://www.projectpluto.com/mpc_stat.txt, which has them in geodetic coordinates. Some station positions (e.g. amateur observatories positions) might lack accuracy, especially in altitude, as it is sometimes not clear whether their altitude has to be intended as a geodetic or ellipsoidal altitude. For more info and insights, please check the following discussion: https://www.projectpluto.com/mpc_stat.htm.

Returns:: List of settings to create MPC stations
Return type:: list[ GroundStationSettings ]

Classes¶

`GroundStationSettings`	Base class for providing settings for the creation of a ground station.
`GroundStationMotionSettings`	Base class for providing settings for the motion of a single ground station.
`LinearGroundStationMotionSettings`	Class for defining linear motion (in an Earth-fixed frame) in time of a ground station.
`PiecewiseConstantGroundStationMotionSettings`	Class for defining piecewise-constant position (e.g. instantaneous change in position at given epochs) of a ground station.
`CustomGroundStationMotionSettings`	Class for defining custom time-dependent motion of a ground station.

class GroundStationSettings¶

Bases: pybind11_object

Base class for providing settings for the creation of a ground station.

class GroundStationMotionSettings¶

Bases: pybind11_object

Base class for providing settings for the motion of a single ground station.

Non-functional base class for settings for the motion of a single ground station Station motion settings requiring additional information must be defined using an object derived from this class.

class LinearGroundStationMotionSettings¶

Bases: GroundStationMotionSettings

Class for defining linear motion (in an Earth-fixed frame) in time of a ground station.

GroundStationMotionSettings derived class for time-linear station motion

class PiecewiseConstantGroundStationMotionSettings¶

Bases: GroundStationMotionSettings

Class for defining piecewise-constant position (e.g. instantaneous change in position at given epochs) of a ground station.

GroundStationMotionSettings derived class for piecewise-constant position of a ground station

class CustomGroundStationMotionSettings¶

Bases: GroundStationMotionSettings

Class for defining custom time-dependent motion of a ground station.

CustomGroundStationMotionSettings derived class for custom time-dependent motion of a ground station

ground_station¶

Functions¶

Classes¶

`ground_station`¶