`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. 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). Ground stations can be defined through the BodySettings as any other model. But, as the rest of the environment does not depend on them, they can safely be added to a body after it is created. The process is similar to the one described for decorate_empty_body. Specifically, ground station settings are created, and these are then used to create a ground station and add it to the body. The specifics of creating ground station settings is described in the API documentation. An example is given below:

# 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)

# Add the ground station to the environment
environment_setup.add_ground_station(
    bodies.get_body("Earth"),
    ground_station_settings )

where a simple ground station is created (with only a name and a position), with its position defined in geodetic elements. The position of a ground station in a body-fixed frame can have two sources of time-variability:

From shape deformation models of the body on which it is located
From a list of GroundStationMotionSettings objects, which can be assigned to the ground station settings (see e.g. basic_station()). These models define time-variability of individual ground stations, in addition to the global shape deformation.

To automatically create a list of settings for all DSN stations (which are then typically assigned to the ground_station_settings of Earth), the dsn_station_settings() can be used.

Functions#

`basic_station`(station_name, ...)	Factory function for creating settings for a ground station
`dsn_stations`()	Factory function for creating settings for all DSN stations
`linear_station_motion`(linear_velocity[, ...])	Factory function for creating settings for a linear station motion
`piecewise_constant_station_motion`(...)	Factory function for creating settings for a piecewise constant ground station position variation
`custom_station_motion`(...)	Factory function for creating settings for a custom ground station position variation

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.numerical_simulation.environment_setup.ground_station.GroundStationMotionSettings] = []) → tudatpy.kernel.numerical_simulation.environment_setup.ground_station.GroundStationSettings#

Factory function for creating settings for a ground station

Factory 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. Choose between cartesian_position, spherical_position and geodetic_position
station_nominal_position (np.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 - \([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 - \([r,\phi',\theta]\), denoting distance from body-fixed frame origin (typically center of mass), latitude and longitude * Geodetic - \([h,\phi,\theta]\), denoting the altitude w.r.t. the body shape model, geodetic latitude and longitude
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_stations() → list[tudatpy.kernel.numerical_simulation.environment_setup.ground_station.GroundStationSettings]#

Factory function for creating settings for all DSN stations

Factory 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. K, 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 ]

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

Factory function for creating settings for a linear station motion

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

Parameters:

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

Returns:

Instance of the GroundStationMotionSettings derived LinearGroundStationMotionSettings class

Return type:

GroundStationMotionSettings

piecewise_constant_station_motion(displacement_list: dict[float, numpy.ndarray[numpy.float64[3, 1]]]) → tudatpy.kernel.numerical_simulation.environment_setup.ground_station.GroundStationMotionSettings#

Factory function for creating settings for a piecewise constant ground station position variation

Factory 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 displacments \([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[float,np.ndarray([3,1])]) – Dictionary with the epochs \(t_{i}\) as values, and the associated displacement \(\Delta\mathbf{r}_{i}\) as value
Returns:: Instance of the GroundStationMotionSettings derived PiecewiseConstantGroundStationMotionSettings class
Return type:: GroundStationMotionSettings

custom_station_motion(custom_displacement_function: Callable[[float], numpy.ndarray[numpy.float64[3, 1]]]) → tudatpy.kernel.numerical_simulation.environment_setup.ground_station.GroundStationMotionSettings#

Factory function for creating settings for a custom ground station position variation

Factory 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 (dict[float,np.ndarray([3,1])]) – Function returning \(\Delta\mathbf{r}\), with the time \(t\) as input.
Returns:: Instance of the GroundStationMotionSettings derived CustomGroundStationMotionSettings class
Return type:: GroundStationMotionSettings

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.
`CustomGroundStationMotionSettings`	Class for defining custom time-dependent motion of a ground station.

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

class GroundStationMotionSettings#

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#

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#

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#

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`#