Telescope

Telescope is a helper class for telescope-related metadata. Several of the primary user classes need telescope metdata, so they have a Telescope object as an attribute.

Attributes

The attributes on Telescope hold all of the metadata required to describe interferometric telescopes. Under the hood, the attributes are implemented as properties based on pyuvdata.parameter.UVParameter objects but this is fairly transparent to users.

Most commonly, Telescope objects are found as the telescope attribute on UVData, UVCal and UVFlag objects and they are typically initialized when those objects are initialized.

Stand-alone Telescope objects can be initialized in many ways: from arrays in memory using the pyuvdata.Telescope.from_params() class method, from our known telescope information using the pyuvdata.Telescope.from_known_telescopes() class method, from uvh5, calh5 or uvflag HDF5 files using the pyuvdata.Telescope.from_hdf5() class method, or as an empty object (as tel = Telescope()). When an empty Telescope object is initialized, it has all of these attributes defined but set to None. The attributes can be set directly on the object. Some of these attributes are required to be set to have a fully defined object while others are optional. The pyuvdata.Telescope.check() method can be called on the object to verify that all of the required attributes have been set in a consistent way.

Required

These parameters are required to have a basic well-defined Telescope object.

Nants: Number of antennas in the array.
antenna_names: Array of antenna names, shape (Nants), with numbers given by antenna_numbers.
antenna_numbers: Array of integer antenna numbers corresponding to antenna_names, shape (Nants).
antenna_positions: Array giving coordinates of antennas relative to location (ITRF frame), shape (Nants, 3), units meters. See the tutorial page in the documentation for an example of how to convert this to topocentric frame.
location: telescope location: Either an astropy.EarthLocation object or a lunarsky MoonLocation object.
name: name of telescope (string)

Optional

These parameters are needed by by one or of the primary user classes but are not always required. Some of them are required when attached to the primary classes.

Nfeeds: Number of feeds.
antenna_diameters: Antenna diameters in meters. Used by CASA to construct a default beam if no beam is supplied.
feed_angle: Position angle of a given feed, shape (Nants, Nfeeds), units of radians. A feed angle of 0 is typically oriented toward zenith for steerable antennas, otherwise toward north for fixed antennas (e.g., HERA, LWA).More details on this can be found on the “Conventions” page of the docs.Optional parameter, required if feed_array is set.
feed_array: Array of feed orientations. shape (Nants, Nfeeds), type str. Options are: x/y or r/l. Optional parameter, required if feed_angle is set.
instrument: Receiver or backend. Sometimes identical to name.
mount_type: Antenna mount type, which describes the optics of the antenna in question.Supported options include: “alt-az” (primary rotates in azimuth andelevation), “equatorial” (primary rotates in hour angle and declination), “orbiting” (antenna is in motion, and its orientation depends on orbitalparameters), “x-y” (primary rotates first in the plane connecting east, west, and zenith, and then perpendicular to that plane), “alt-az+nasmyth-r” (“alt-az” mount with a right-handed 90-degree tertiary mirror), “alt-az+nasmyth-l” (“alt-az” mount with a left-handed 90-degree tertiary mirror), “phased” (antenna is “electronically steered” by summing the voltages of multiple elements, e.g. MWA), “fixed” (antenna beam pattern is fixed in azimuth and elevation, e.g., HERA), and “other” (also referred to in some formats as “bizarre”). See the “Conventions” page of the documentation for further details. shape (Nants,).

Methods

class pyuvdata.Telescope[source]

A class for telescope metadata, used on UVData, UVCal and UVFlag objects.

UVParameter objects: For full list see the documentation on ReadTheDocs: http://pyuvdata.readthedocs.io/en/latest/.

get_x_orientation_from_feeds() → Literal['east', 'north', None][source]

Get x-orientation equivalent value based on feed information.

Returns:: x_orientation (str) – One of “east”, “north”, or None, based on values present in Telescope.feed_array and Telescope.feed_angle.

set_feeds_from_x_orientation(x_orientation, feeds=None, polarization_array=None, flex_polarization_array=None)[source]

Set feed information based on x-orientation value.

Populates newer parameters describing feed-orientation (Telescope.feed_array and Telescope.feed_angle) based on the “older” x-orientation string. Note that this method will overwrite any previously populated values, and if x-orientation is set to None, feed information will be removed from the object.

Parameters:

x_orientation (str) – String describing how the x-orientation is oriented. Must be either “north”/ “n”/”ns” (x-polarization of antenna has a position angle of 0 degrees with respect to zenith/north) or “east”/”e”/”ew” (x-polarization of antenna has a position angle of 90 degrees with respect to zenith/north).
feeds (list of str or None) – List of strings denoting feed orientations/polarizations. Must be one of “x”, “y”, “l”, “r” (the former two for linearly polarized feeds, the latter for circularly polarized feeds). Default uses what is already present in feed_array if set, otherwise assumes a pair of linearly polarized feeds ([“x”, “y”]).
polarization_array (array-like of int or None) – Array listing the polarization codes present, based on the UVFITS numbering scheme. See utils.POL_NUM2STR_DICT for a mapping between codes and polarization types. Used with utils.pol.get_feeds_from_pols to determine feeds present if not supplied, ignored if flex_polarization_array is set to anything but None.
flex_polarization_array (array-like of int or None) – Array listing the polarization codes present per spectral window (used with certain “flexible-polarization” objects), based on the UVFITS numbering scheme. See utils.POL_NUM2STR_DICT for a mapping between codes and polarization types. Used with utils.pol.get_feeds_from_pols to determine feeds present if not supplied.

check(*, check_extra=True, run_check_acceptability=True)[source]

Add some extra checks on top of checks on UVBase class.

Check that required parameters exist. Check that parameters have appropriate shapes and optionally that the values are acceptable.

Parameters:

check_extra (bool) – If true, check all parameters, otherwise only check required parameters.
run_check_acceptability (bool) – Option to check if values in parameters are acceptable.

Returns:

bool – True if check passes

Raises:

ValueError – if parameter shapes or types are wrong or do not have acceptable values (if run_check_acceptability is True)

update_params_from_known_telescopes(*, overwrite: bool = False, warn: bool = True, run_check: bool = True, check_extra: bool = True, run_check_acceptability: bool = True, override_known_params: bool = True, feeds: str | list[str] | None = None, polarization_array: ndarray | None = None, flex_polarization_array: ndarray | None = None, **kwargs)[source]

Update the parameters based on telescope in known_telescopes.

This fills in any missing parameters (or to overwrite parameters that have inaccurate values) on self that are available for a telescope from either Astropy sites and/or from the KNOWN_TELESCOPES dict. This is primarily used on UVData, UVCal and UVFlag to fill in information that is missing, especially in older files.

Parameters:

overwrite (bool) – If set, overwrite parameters with information from Astropy sites and/or from the KNOWN_TELESCOPES dict. Defaults to False.
warn (bool) – Option to issue a warning listing all modified parameters. Defaults to True.
run_check (bool) – Option to check for the existence and proper shapes of parameters after updating.
check_extra (bool) – Option to check optional parameters as well as required ones.
run_check_acceptability (bool) – Option to check acceptable range of the values of parameters after updating.
override_known_params (bool) – Normally, when passing arguments for individual parameters for the Telescope object, they will be used over what is present in the KNOWN_TELESCOPES dict. However, if set to False, the information in the KNOWN_TELESCOPES dict is used if/when present, even if supplied as an argument when calling this method. Default is True.
x_orientation (str) – String describing how the x-orientation is oriented. Must be either “north”/ “n”/”ns” (x-polarization of antenna has a position angle of 0 degrees with respect to zenith/north) or “east”/”e”/”ew” (x-polarization of antenna has a position angle of 90 degrees with respect to zenith/north). Ignored if “x_orientation” is relevant entry for the KNOWN_TELESCOPES dict, or if feed_array and feed_angle supplied (either by passing an argument or in the KNOWN_TELESCOPES dict).
feeds (list of str or None) – List of strings denoting feed orientations/polarizations. Must be one of “x”, “y”, “l”, “r” (the former two for linearly polarized feeds, the latter for circularly polarized feeds). Default assumes a pair of linearly polarized feeds ([“x”, “y”]).
polarization_array (array-like of int or None) – Array listing the polarization codes present, based on the UVFITS numbering scheme. See utils.POL_NUM2STR_DICT for a mapping between codes and polarization types. Used with utils.pol.get_feeds_from_pols to determine feeds present if not supplied, ignored if flex_polarization_array is set to anything but None.
flex_polarization_array (array-like of int or None) – Array listing the polarization codes present per spectral window (used with certain “flexible-polarization” objects), based on the UVFITS numbering scheme. See utils.POL_NUM2STR_DICT for a mapping between codes and polarization types. Used with utils.pol.get_feeds_from_pols to determine feeds present if not supplied.
location (EarthLocation or MoonLocation) – Location of the telescope (phase reference position). Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
citation (str) – Source of telescope information. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_positions_file (str) – Path to a csv-formatted file containing a total of five columns, which describe (on a per-antenna basis) the name, number, and x/y/z location (relative to the phase center, units of meters) of each antenna. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
Nants (int) – Number of antennas present in the telescope. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_numbers (array-like of int) – Antenna numbers that correspond to entries in antenna_names, array-like of shape (Nants,), dtype int. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_names (array-like of str) – Names of the antennas present in the telescope object, array-like of shape (Nants,), dtype str. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_positions (array of float) – Coordinates of antennas relative to the telescope location, shape (Nants, 3), dtype float, units meters. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
mount_type (str or array-like of str) – Antenna mount type, which describes the optics for each antenna. Can either be supplied on a per-antenna basis, in which case an array of shape (Nants,) with dtype str is expected, or if all antennas share the same optics type, a single string can be provided (see supported types in the documentation for Telescope.mount_type). Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
feed_array (array-like of str) – Feed types present within each telescope in terms of polarization response, must be one of “r”, “l”, “x”, or “y”. Can be supplied on a per-antenna basis, in which case an array of shape (Nants, Nfeeds) is expected, or if the same for all antennas, an array of shape (Nfeeds,) can be provided ( note that Nfeeds cannot be greater than 2). Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
feed_angle (array-like of float) – Relative receptor angle for each feed (see more information about his in the documentation for Telescope.feed_angle). Can be supplied on a per-antenna basis, in which case an array of shape (Nants, Nfeeds) is expected, or if the same for all antennas, an array of shape (Nfeeds,) can be provided ( note that Nfeeds cannot be greater than 2). Expected dtype is float. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_diameters (float or array-like of float) – Diameter of the antennas within the telescope, dtype float, units of meters. Can be supplied on a per-antenna basis, in which case an array of shape (Nants,) is expected, or if the same for all antennas, a single float can be provided. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.

Raises:

ValueError – If self.name is not set or if ((location is missing or overwrite is set) and self.name is not found either astropy sites our our known_telescopes dict)

classmethod from_known_telescopes(name: str, *, run_check: bool = True, check_extra: bool = True, run_check_acceptability: bool = True, **kwargs)[source]

Create a new Telescope object using information from known_telescopes.

Parameters:

name (str) – Name of the telescope.
run_check (bool) – Option to check for the existence and proper shapes of parameters.
check_extra (bool) – Option to check optional parameters as well as required ones.
run_check_acceptability (bool) – Option to check acceptable range of the values of parameters.
x_orientation (str) – String describing how the x-orientation is oriented. Must be either “north”/ “n”/”ns” (x-polarization of antenna has a position angle of 0 degrees with respect to zenith/north) or “east”/”e”/”ew” (x-polarization of antenna has a position angle of 90 degrees with respect to zenith/north). Ignored if “x_orientation” is relevant entry for the KNOWN_TELESCOPES dict, or if feed_array and feed_angle supplied (either by passing an argument or in the KNOWN_TELESCOPES dict).
feeds (list of str or None) – List of strings denoting feed orientations/polarizations. Must be one of “x”, “y”, “l”, “r” (the former two for linearly polarized feeds, the latter for circularly polarized feeds). Default assumes a pair of linearly polarized feeds ([“x”, “y”]).
polarization_array (array-like of int or None) – Array listing the polarization codes present, based on the UVFITS numbering scheme. See utils.POL_NUM2STR_DICT for a mapping between codes and polarization types. Used with utils.pol.get_feeds_from_pols to determine feeds present if not supplied, ignored if flex_polarization_array is set to anything but None.
flex_polarization_array (array-like of int or None) – Array listing the polarization codes present per spectral window (used with certain “flexible-polarization” objects), based on the UVFITS numbering scheme. See utils.POL_NUM2STR_DICT for a mapping between codes and polarization types. Used with utils.pol.get_feeds_from_pols to determine feeds present if not supplied.
override_known_params (bool) – Normally, when passing arguments for individual parameters for the Telescope object, they will be used over what is present in the KNOWN_TELESCOPES dict. However, if set to False, the information in the KNOWN_TELESCOPES dict is used if/when present, even if supplied as an argument when calling this method.
location (EarthLocation or MoonLocation) – Location of the telescope (phase reference position). Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
citation (str) – Source of telescope information. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_positions_file (str) – Path to a csv-formatted file containing a total of five columns, which describe (on a per-antenna basis) the name, number, and x/y/z location (relative to the phase center, units of meters) of each antenna. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
Nants (int) – Number of antennas present in the telescope. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_numbers (array-like of int) – Antenna numbers that correspond to entries in antenna_names, array-like of shape (Nants,), dtype int. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_names (array-like of str) – Names of the antennas present in the telescope object, array-like of shape (Nants,), dtype str. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_positions (array of float) – Coordinates of antennas relative to the telescope location, shape (Nants, 3), dtype float, units meters. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
mount_type (str or array-like of str) – Antenna mount type, which describes the optics for each antenna. Can either be supplied on a per-antenna basis, in which case an array of shape (Nants,) with dtype str is expected, or if all antennas share the same optics type, a single string can be provided (see supported types in the documentation for Telescope.mount_type). Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
feed_array (array-like of str) – Feed types present within each telescope in terms of polarization response, must be one of “r”, “l”, “x”, or “y”. Can be supplied on a per-antenna basis, in which case an array of shape (Nants, Nfeeds) is expected, or if the same for all antennas, an array of shape (Nfeeds,) can be provided ( note that Nfeeds cannot be greater than 2). Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
feed_angle (array-like of float) – Relative receptor angle for each feed (see more information about his in the documentation for Telescope.feed_angle). Can be supplied on a per-antenna basis, in which case an array of shape (Nants, Nfeeds) is expected, or if the same for all antennas, an array of shape (Nfeeds,) can be provided ( note that Nfeeds cannot be greater than 2). Expected dtype is float. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.
antenna_diameters (float or array-like of float) – Diameter of the antennas within the telescope, dtype float, units of meters. Can be supplied on a per-antenna basis, in which case an array of shape (Nants,) is expected, or if the same for all antennas, a single float can be provided. Ignored if information is present in KNOWN_TELESCOPES dict and override_known_params=False.

Returns:

Telescope – A new Telescope object populated with information from known_telescopes.

classmethod new(name: str, location, antenna_positions: ndarray | dict[str | int, numpy.ndarray] | None = None, antenna_names: list[str] | ndarray | None = None, antenna_numbers: list[int] | ndarray | None = None, antname_format: str = '{0:03d}', instrument: str | None = None, x_orientation: Literal['east', 'north', 'e', 'n', 'ew', 'ns'] | None = None, antenna_diameters: list[float] | ndarray | None = None, feeds: Literal['x', 'y', 'l', 'r'] | list[str] | None = None, feed_array: list[str] | ndarray | None = None, feed_angle: list[float] | ndarray | None = None, mount_type: Literal['alt-az', 'equatorial', 'orbiting', 'x-y', 'alt-az+nasmyth-r', 'alt-az+nasmyth-l', 'phased', 'fixed', 'other'] | list[str] | None = None, update_from_known: bool = True)[source]

Initialize a new Telescope object from keyword arguments.

Parameters:

name (str) – Telescope name.
location (EarthLocation or MoonLocation object) – Telescope location as an astropy EarthLocation object or MoonLocation object.
antenna_positions (ndarray of float or dict of ndarray of float) – Array of antenna positions in ECEF coordinates in meters. If a dict, keys can either be antenna numbers or antenna names, and values are position arrays. Keys are interpreted as antenna numbers if they are integers, otherwise they are interpreted as antenna names if strings. You cannot provide a mix of different types of keys.
antenna_names (list or np.ndarray of str, optional) – List or array of antenna names. Not used if antenna_positions is a dict with string keys. Otherwise, if not provided, antenna numbers will be used to form the antenna_names, according to the antname_format.
antenna_numbers (list or np.ndarray of int, optional) – List or array of antenna numbers. Not used if antenna_positions is a dict with integer keys. Otherwise, if not provided, antenna names will be used to form the antenna_numbers, but in this case the antenna_names must be strings that can be converted to integers.
antname_format (str, optional) – Format string for antenna names. Default is ‘{0:03d}’.
instrument (str, optional) – Instrument name.
x_orientation (str) – Orientation of the x-axis. Options are ‘east’, ‘north’, ‘e’, ‘n’, ‘ew’, ‘ns’. Ignored if feed_array and feed_angle are provided.
antenna_diameters (list or np.ndarray of float, optional) – List or array of antenna diameters.
feeds (list of str or None:) – List of feeds present in the Telescope, which must be one of “x”, “y”, “l”, “r”. Length of the list must be either 1 or 2. Used to populate feed_array and feed_angle parameters if only supplying x_orientation, default is [“x”, “y”].
feed_array (array-like of str or None) – List of feeds for each antenna in the Telescope object, must be one of “x”, “y”, “l”, “r”. Shape (Nants, Nfeeds), dtype str. Can also be shape (Nfeeds,), in which case the same values for feed_array are used for all antennas in the object.
feed_angle (array-like of float or None) – Orientation of the feed with respect to zenith (or with respect to north if pointed at zenith). Units is in rads, x-polarization is nominally pi / 2, and x-polarization (as well as r- and l-polarizations) is nominally pi / 2. Shape (Nants, Nfeeds), dtype float. Can also be shape (Nfeeds,), in which case the same values for feed_angle are used for all antennas in the object.
mount_type (str or array-like of str) – Antenna mount type, which describes the optics of the antenna in question. Supported options include: “alt-az” (primary rotates in azimuth and elevation), “equatorial” (primary rotates in hour angle and declination) “orbiting” (antenna is in motion, and its orientation depends on orbital parameters), “x-y” (primary rotates first in the plane connecting east, west, and zenith, and then perpendicular to that plane), “alt-az+nasmyth-r” (“alt-az” mount with a right-handed 90-degree tertiary mirror), “alt-az+nasmyth-l” (“alt-az” mount with a left-handed 90-degree tertiary mirror), “phased” (antenna is “electronically steered” by summing the voltages of multiple elements, e.g. MWA), “fixed” (antenna beam pattern is fixed in azimuth and elevation, e.g., HERA), and “other” (also referred to in some formats as “bizarre”). See the “Conventions” page of the documentation for further details. Shape (Nants,), dtype str. Can also provide a single string, in which case the same mount_type is used for all antennas in the object.
update_from_known (bool) – If set to True and the telescope name is found in the KNOWN_TELESCOPES dictionary, then any missing parameters will be filled in using the information from said dictionary if available. Otherwise if set to False, any missing parameters are left set to None. Default is True.

Returns:

Telescope object – A Telescope object with the specified metadata.

classmethod from_hdf5(filename: str | Path | HDF5Meta, required_keys: list | None = None, run_check: bool = True, check_extra: bool = True, run_check_acceptability: bool = True)[source]

Initialize a new Telescope object from an HDF5 file.

The file must have a Header dataset that has the appropriate header items. UVH5, CalH5 and UVFlag HDF5 files have these.

Parameters:: path (str or Path or subclass of hdf5_utils.HDF5Meta) – The filename to read from.

write_hdf5_header(header)[source]

Write the telescope metadata to an hdf5 dataset.

This is assumed to be writing to a general header (e.g. for uvh5), so the header names include ‘telescope’.

Parameters:: header (HDF5 dataset) – Dataset to write the telescope metadata to.

get_enu_antpos()[source]

Get antenna positions in East, North, Up coordinates in units of meters.

Returns:: antpos (ndarray) – Antenna positions in East, North, Up coordinates in units of meters, shape=(Nants, 3)

reorder_feeds(order='AIPS', *, run_check=True, check_extra=True, run_check_acceptability=True)[source]

Arrange feed axis according to desired order.

Parameters:

order (str) – Either a string specifying a canonical ordering (‘AIPS’ or ‘CASA’) or list of strings specifying the preferred ordering of the four feed types (“x”, “y”, “l”, and “r”).
run_check (bool) – Option to check for the existence and proper shapes of parameters after reordering.
check_extra (bool) – Option to check optional parameters as well as required ones.
run_check_acceptability (bool) – Option to check acceptable range of the values of parameters after reordering.

Raises:

ValueError – If the order is not one of the allowed values.

reorder_antennas(order='number', *, run_check=True, check_extra=True, run_check_acceptability=True)[source]

Arrange the antenna axis according to desired order.

Parameters:: order (str or array like of int) – If a string, allowed values are “name” and “number” to sort on the antenna name or number respectively. A ‘-’ can be prepended to signify descending order instead of the default ascending order (e.g. “-number”). An array of integers of length Nants representing indexes along the existing ant_array can also be supplied to sort in any desired order (note these are indices into the ant_array not antenna numbers).
Returns:: None
Raises:: ValueError – Raised if order is not an allowed string or is an array that does not contain all the required numbers.

Known Telescopes

pyuvdata uses Astropy sites for telescope location information, in addition to the following telescope information that is tracked within pyuvdata. Note that the location entry is actually stored as an astropy.coordinates.EarthLocation object, which is shown here using the Geodetic representation. Also note that for some telescopes we store csv files giving antenna layout information which can be used if data files are missing that information. We also provide a convenience function to get known telescope locations.

{
   "ATA": {
       "antenna_diameters": 6.1,
       "citation": "Private communication (D. DeBoer to G. Keating; 2024)",
       "feed_angle": [
           1.5707963267948966,
           0.0
       ],
       "feed_array": [
           "x",
           "y"
       ],
       "location": "GeodeticLocation(lon=<Longitude -121.47073611 deg>, lat=<Latitude 40.81743056 deg>, height=<Quantity 1019.222 m>)",
       "mount_type": "alt-az"
   },
   "HERA": {
       "antenna_diameters": 14.0,
       "antenna_positions_file": "hera_ant_pos.csv",
       "citation": "value taken from hera_mc geo.py script (using hera_cm_db_updates under the hood.)",
       "location": "GeodeticLocation(lon=<Longitude 21.42830383 deg>, lat=<Latitude -30.72152612 deg>, height=<Quantity 1051.69 m>)",
       "mount_type": "fixed"
   },
   "MWA": {
       "antenna_positions_file": "mwa_ant_pos.csv",
       "feed_angle": [
           1.5707963267948966,
           0.0
       ],
       "feed_array": [
           "x",
           "y"
       ],
       "mount_type": "phased"
   },
   "OVRO-LWA": {
       "citation": "OVRO Sharepoint Documentation",
       "feed_angle": [
           1.5707963267948966,
           0.0
       ],
       "feed_array": [
           "x",
           "y"
       ],
       "location": "GeodeticLocation(lon=<Longitude -118.28166669 deg>, lat=<Latitude 37.23977727 deg>, height=<Quantity 1183.48 m>)",
       "mount_type": "fixed"
   },
   "PAPER": {
       "citation": "value taken from capo/cals/hsa7458_v000.py, comment reads KAT/SA  (GPS), altitude from elevationmap.net",
       "feed_angle": [
           1.5707963267948966,
           0.0
       ],
       "feed_array": [
           "x",
           "y"
       ],
       "location": "GeodeticLocation(lon=<Longitude 21.42830556 deg>, lat=<Latitude -30.72152778 deg>, height=<Quantity 1073. m>)",
       "mount_type": "fixed"
   },
   "SMA": {
       "Nants": 8,
       "antenna_diameters": 6.0,
       "citation": "Ho, P. T. P., Moran, J. M., & Lo, K. Y. 2004, ApJL, 616, L1",
       "location": "GeodeticLocation(lon=<Longitude -155.477523 deg>, lat=<Latitude 19.82420526 deg>, height=<Quantity 4083.948144 m>)",
       "mount_type": "alt-az+nasmyth-l"
   },
   "SZA": {
       "Nants": 8,
       "antenna_diameters": 3.5,
       "citation": "Unknown",
       "feed_angle": [
           1.5707963267948966,
           0.0
       ],
       "feed_array": [
           "x",
           "y"
       ],
       "location": "GeodeticLocation(lon=<Longitude -118.14164239 deg>, lat=<Latitude 37.2803805 deg>, height=<Quantity 2400. m>)",
       "mount_type": "alt-az+nasmyth-l"
   }
}

pyuvdata.telescopes.known_telescope_location(name: str, return_citation: bool = False, **kwargs)[source]

Get the location for a known telescope.

Parameters:

name (str) – Name of the telescope
return_citation (bool) – Option to return the citation.
location (EarthLocation or MoonLocation) – Location of the telescope, can be used to overwrite or supplement information in the KNOWN_TELESCOPES dictionary.
citation (str) – Source of location information, can be used to overwrite or supplement information in the KNOWN_TELESCOPES dictionary.

Returns:

location (EarthLocation) – Telescope location as an EarthLocation object.
citation (str, optional) – Citation string.

last updated: 2026-04-13