Bases: MaskableShapedLikeNDArray
High-level object providing a flexible interface for celestial coordinate representation, manipulation, and transformation between systems.
The SkyCoord class accepts a wide variety of inputs for initialization. At a minimum these must provide one or more celestial coordinate values with unambiguous units. Inputs may be scalars or lists/tuples/arrays, yielding scalar or array coordinates (can be checked via SkyCoord.isscalar). Typically one also specifies the coordinate frame, though this is not required. The general pattern for spherical representations is:
SkyCoord(COORD, [FRAME], keyword_args ...) SkyCoord(LON, LAT, [FRAME], keyword_args ...) SkyCoord(LON, LAT, [DISTANCE], frame=FRAME, unit=UNIT, keyword_args ...) SkyCoord([FRAME], <lon_attr>=LON, <lat_attr>=LAT, keyword_args ...)
It is also possible to input coordinate values in other representations such as cartesian or cylindrical. In this case one includes the keyword argument representation_type='cartesian' (for example) along with data in x, y, and z.
See also: https://docs.astropy.org/en/stable/coordinates/
BaseCoordinateFrame class or str, optional
Type of coordinate frame this SkyCoord should represent. Defaults to to ICRS if not given or given as None.
Unit, str, or tuple of Unit or str, optional
Units for supplied coordinate values. If only one unit is supplied then it applies to all values. Note that passing only one unit might lead to unit conversion errors if the coordinate values are expected to have mixed physical meanings (e.g., angles and distances).
Time(s) of observation.
Coordinate frame equinox time.
str or BaseRepresentation class
Specifies the representation, e.g. ‘spherical’, ‘cartesian’, or ‘cylindrical’. This affects the positional args and other keyword args which must correspond to the given representation.
If True (default), a copy of any coordinate data is made. This argument can only be passed in as a keyword argument.
Other keyword arguments as applicable for user-defined coordinate frames. Common options include:
RA and Dec for frames where ra and dec are keys in the frame’s representation_component_names, including ICRS, FK5, FK4, and FK4NoETerms.
Quantity [‘angular speed’], optional
Proper motion components, in angle per time units.
Galactic l and b for for frames where l and b are keys in the frame’s representation_component_names, including the Galactic frame.
Quantity [‘angular speed’], optional
Proper motion components in the Galactic frame, in angle per time units.
Quantity [‘length’], optional
Cartesian coordinates values
Quantity [‘length’], optional
Cartesian coordinates values for the Galactic frame.
Quantity [‘speed’], optional
The component of the velocity along the line-of-sight (i.e., the radial direction), in velocity units.
Examples
The examples below illustrate common ways of initializing a SkyCoord object. For a complete description of the allowed syntax see the full coordinates documentation. First some imports:
>>> from astropy.coordinates import SkyCoord # High-level coordinates >>> from astropy.coordinates import ICRS, Galactic, FK4, FK5 # Low-level frames >>> from astropy.coordinates import Angle, Latitude, Longitude # Angles >>> import astropy.units as u
The coordinate values and frame specification can now be provided using positional and keyword arguments:
>>> c = SkyCoord(10, 20, unit="deg") # defaults to ICRS frame
>>> c = SkyCoord([1, 2, 3], [-30, 45, 8], frame="icrs", unit="deg") # 3 coords
>>> coords = ["1:12:43.2 +31:12:43", "1 12 43.2 +31 12 43"]
>>> c = SkyCoord(coords, frame=FK4, unit=(u.hourangle, u.deg), obstime="J1992.21")
>>> c = SkyCoord("1h12m43.2s +1d12m43s", frame=Galactic) # Units from string
>>> c = SkyCoord(frame="galactic", l="1h12m43.2s", b="+1d12m43s")
>>> ra = Longitude([1, 2, 3], unit=u.deg) # Could also use Angle
>>> dec = np.array([4.5, 5.2, 6.3]) * u.deg # Astropy Quantity
>>> c = SkyCoord(ra, dec, frame='icrs')
>>> c = SkyCoord(frame=ICRS, ra=ra, dec=dec, obstime='2001-01-02T12:34:56')
>>> c = FK4(1 * u.deg, 2 * u.deg) # Uses defaults for obstime, equinox
>>> c = SkyCoord(c, obstime='J2010.11', equinox='B1965') # Override defaults
>>> c = SkyCoord(w=0, u=1, v=2, unit='kpc', frame='galactic',
... representation_type='cartesian')
>>> c = SkyCoord([ICRS(ra=1*u.deg, dec=2*u.deg), ICRS(ra=3*u.deg, dec=4*u.deg)])
Velocity components (proper motions or radial velocities) can also be provided in a similar manner:
>>> c = SkyCoord(ra=1*u.deg, dec=2*u.deg, radial_velocity=10*u.km/u.s) >>> c = SkyCoord(ra=1*u.deg, dec=2*u.deg, pm_ra_cosdec=2*u.mas/u.yr, pm_dec=1*u.mas/u.yr)
As shown, the frame can be a BaseCoordinateFrame class or the corresponding string alias – lower-case versions of the class name that allow for creating a SkyCoord object and transforming frames without explicitly importing the frame classes.
Attributes Summary
Methods Summary
Attributes Documentation
The mask associated with these coordinates.
Combines the masks of all components of the underlying representation, including possible differentials.
Whether the underlying data is masked.
ValueError
If the frame has no associated data.
Methods Documentation
Compute the position to a new time using the velocities.
Compute the position of the source represented by this coordinate object to a new time using the velocities stored in this object and assuming linear space motion (including relativistic corrections). This is sometimes referred to as an “epoch transformation”.
The initial time before the evolution is taken from the obstime attribute of this coordinate. Note that this method currently does not support evolving coordinates where the frame has an obstime frame attribute, so the obstime is only used for storing the before and after times, not actually as an attribute of the frame. Alternatively, if dt is given, an obstime need not be provided at all.
Time, optional
The time at which to evolve the position to. Requires that the obstime attribute be present on this frame.
Quantity, TimeDelta, optional
An amount of time to evolve the position of the source. Cannot be given at the same time as new_obstime.
SkyCoord
A new coordinate object with the evolved location of this coordinate at the new time. obstime will be set on this object to the new time only if self also has obstime.
Determines if the SkyCoord is contained in the given wcs footprint.
WCS
The coordinate to check if it is within the wcs coordinate.
array
Optional. The image associated with the wcs object that the coordinate is being checked against. If not given the naxis keywords will be used to determine if the coordinate falls within the wcs footprint.
Additional arguments to pass to to_pixel
True means the WCS footprint contains the coordinate, False means it does not.
Computes coordinates at the given offset from this coordinate.
Angle
position_angle of offset
Angle
offset angular separation
SkyCoord
The coordinates for the location that corresponds to offsetting by the given position_angle and separation.
Notes
Returned SkyCoord frame retains only the frame attributes that are for the resulting frame type. (e.g. if the input frame is ICRS, an equinox value will be retained, but an obstime will not.)
For a more complete set of transform offsets, use WCS. skyoffset_frame() can also be used to create a spherical frame with (lat=0, lon=0) at a reference point, approximating an xy cartesian system for small offsets. This method is distinct in that it is accurate on the sphere.
Given a name, query the CDS name resolver to attempt to retrieve coordinate information for that object. The search database, sesame url, and query timeout can be set through configuration items in astropy.coordinates.name_resolve – see docstring for get_icrs_coordinates for more information.
str
The name of the object to get coordinates for, e.g. 'M42'.
str or BaseCoordinateFrame class or instance
The frame to transform the object to.
Whether to attempt extracting the coordinates from the name by parsing with a regex. For objects catalog names that have J-coordinates embedded in their names, e.g., ‘CRTS SSS100805 J194428-420209’, this may be much faster than a Sesame query for the same object name. The coordinates extracted in this way may differ from the database coordinates by a few deci-arcseconds, so only use this option if you do not need sub-arcsecond accuracy for coordinates.
Determines whether to cache the results or not. To update or overwrite an existing value, pass cache='update'.
SkyCoord
Instance of the SkyCoord class.
Create a new SkyCoord from pixel coordinates using a World Coordinate System.
float or ndarray
The coordinates to convert.
WCS
The WCS to use for convert
int
Whether to return 0 or 1-based pixel coordinates.
Whether to do the transformation including distortions ('all') or only including only the core WCS transformation ('wcs').
SkyCoord
A new object with sky coordinates corresponding to the input xp and yp.
Determines the constellation(s) of the coordinates this SkyCoord contains.
If True, the returned names are the IAU-sanctioned abbreviated names. Otherwise, full names for the constellations are used.
str
The set of constellations to use. Currently only 'iau' is supported, meaning the 88 “modern” constellations endorsed by the IAU.
str or str array
If this is a scalar coordinate, returns the name of the constellation. If it is an array SkyCoord, it returns an array of names.
Notes
To determine which constellation a point on the sky is in, this first precesses to B1875, and then uses the Delporte boundaries of the 88 modern constellations, as tabulated by Roman 1987.
Get the mask associated with these coordinates.
str
Attributes from which to get the masks to combine. Items can be dotted, like "data.lon", "data.lat". By default, get the combined mask of all components (including from differentials), ignoring possible masks of attributes.
ndarray of bool
The combined, read-only mask. If the instance is not masked, it is an array of False with the correct shape.
ValueError
If the coordinate frame has no associated data.
A convenience method to create and return a new SkyCoord from the data in an astropy Table.
This method matches table columns that start with the case-insensitive names of the components of the requested frames (including differentials), if they are also followed by a non-alphanumeric character. It will also match columns that end with the component name if a non-alphanumeric character is before it.
For example, the first rule means columns with names like 'RA[J2000]' or 'ra' will be interpreted as ra attributes for ICRS frames, but 'RAJ2000' or 'radius' are not. Similarly, the second rule applied to the Galactic frame means that a column named 'gal_l' will be used as the l component, but gall or 'fill' will not.
The definition of alphanumeric here is based on Unicode’s definition of alphanumeric, except without _ (which is normally considered alphanumeric). So for ASCII, this means the non-alphanumeric characters are <space>_!"#$%&'()*+,-./\:;<=>?@[]^`{|}~).
Table or subclass
The table to load data from.
Any additional keyword arguments are passed directly to this class’s constructor.
SkyCoord or subclass
The new instance.
ValueError
If more than one match is found in the table for a component, unless the additional matches are also valid frame component names. If a “coord_kwargs” is provided for a value also found in the table.
Make a copy with coordinate values inserted before the given indices.
The values to be inserted must conform to the rules for in-place setting of the object.
The API signature matches the np.insert API, but is more limited. The specification of insert index obj must be a single integer, and the axis must be 0 for simple insertion before the index.
int
Integer index before which values is inserted.
Value(s) to insert. If the type of values is different from that of quantity, values is converted to the matching type.
int, optional
Axis along which to insert values. Default is 0, which is the only allowed value and will insert a row.
SkyCoord, BaseCoordinateFrame
Copy of instance with new values inserted.
Checks if this object’s frame is the same as that of the other object.
To be the same frame, two objects must be the same frame class and have the same frame attributes. For two SkyCoord objects, all of the frame attributes have to match, not just those relevant for the object’s frame.
SkyCoord or BaseCoordinateFrame
The other object to check.
True if the frames are the same, False if not.
TypeError
If other isn’t a SkyCoord or a subclass of BaseCoordinateFrame.
Determines if this coordinate frame can be transformed to another given frame.
frame class, frame object, or str
The proposed frame to transform into.
Notes
A return value of ‘same’ means the transformation will work, but it will just give back a copy of this object. The intended usage is:
if coord.is_transformable_to(some_unknown_frame):
coord2 = coord.transform_to(some_unknown_frame)
This will work even if some_unknown_frame turns out to be the same frame class as coord. This is intended for cases where the frame is the same regardless of the frame attributes (e.g. ICRS), but be aware that it might also indicate that someone forgot to define the transformation between two objects of the same frame class but with different attributes.
Finds the nearest 3-dimensional matches of this coordinate to a set of catalog coordinates.
This finds the 3-dimensional closest neighbor, which is only different from the on-sky distance if distance is set in this object or the catalogcoord object.
For more on how to use this (and related) functionality, see the examples in Separations, Offsets, Catalog Matching, and Related Functionality.
SkyCoord or BaseCoordinateFrame
The base catalog in which to search for matches. Typically this will be a coordinate object that is an array (i.e., catalogcoord.isscalar == False)
int, optional
Which closest neighbor to search for. Typically 1 is desired here, as that is correct for matching one set of coordinates to another. The next likely use case is 2, for matching a coordinate catalog against itself (1 is inappropriate because each point will find itself as the closest match).
int array
Indices into catalogcoord to get the matched points for each of this object’s coordinates. Shape matches this object.
Angle
The on-sky separation between the closest match for each element in this object in catalogcoord. Shape matches this object.
Quantity [:ref: ‘length’]
The 3D distance between the closest match for each element in this object in catalogcoord. Shape matches this object.
Notes
This method requires SciPy to be installed or it will fail.
Finds the nearest on-sky matches of this coordinate in a set of catalog coordinates.
For more on how to use this (and related) functionality, see the examples in Separations, Offsets, Catalog Matching, and Related Functionality.
SkyCoord or BaseCoordinateFrame
The base catalog in which to search for matches. Typically this will be a coordinate object that is an array (i.e., catalogcoord.isscalar == False)
int, optional
Which closest neighbor to search for. Typically 1 is desired here, as that is correct for matching one set of coordinates to another. The next likely use case is 2, for matching a coordinate catalog against itself (1 is inappropriate because each point will find itself as the closest match).
int array
Indices into catalogcoord to get the matched points for each of this object’s coordinates. Shape matches this object.
Angle
The on-sky separation between the closest match for each element in this object in catalogcoord. Shape matches this object.
Quantity [:ref: ‘length’]
The 3D distance between the closest match for each element in this object in catalogcoord. Shape matches this object. Unless both this and catalogcoord have associated distances, this quantity assumes that all sources are at a distance of 1 (dimensionless).
Notes
This method requires SciPy to be installed or it will fail.
Compute the correction required to convert a radial velocity at a given time and place on the Earth’s Surface to a barycentric or heliocentric velocity.
str
The kind of velocity correction. Must be ‘barycentric’ or ‘heliocentric’.
Time or None, optional
The time at which to compute the correction. If None, the obstime frame attribute on the SkyCoord will be used.
EarthLocation or None, optional
The observer location at which to compute the correction. If None, the location frame attribute on the passed-in obstime will be used, and if that is None, the location frame attribute on the SkyCoord will be used.
Quantity [:ref: ‘speed’]
The correction with a positive sign. I.e., add this to an observed radial velocity to get the barycentric (or heliocentric) velocity. If m/s precision or better is needed, see the notes below.
ValueError
If either obstime or location are passed in (not None) when the frame attribute is already set on this SkyCoord.
TypeError
If obstime or location aren’t provided, either as arguments or as frame attributes.
Notes
The barycentric correction is calculated to higher precision than the heliocentric correction and includes additional physics (e.g time dilation). Use barycentric corrections if m/s precision is required.
The algorithm here is sufficient to perform corrections at the mm/s level, but care is needed in application. The barycentric correction returned uses the optical approximation v = z * c. Strictly speaking, the barycentric correction is multiplicative and should be applied as:
>>> from astropy.time import Time
>>> from astropy.coordinates import SkyCoord, EarthLocation
>>> from astropy.constants import c
>>> t = Time(56370.5, format='mjd', scale='utc')
>>> loc = EarthLocation('149d33m00.5s','-30d18m46.385s',236.87*u.m)
>>> sc = SkyCoord(1*u.deg, 2*u.deg)
>>> vcorr = sc.radial_velocity_correction(kind='barycentric', obstime=t, location=loc)
>>> rv = rv + vcorr + rv * vcorr / c
Also note that this method returns the correction velocity in the so-called optical convention:
where zb is the barycentric correction redshift as defined in section 3 of Wright & Eastman (2014). The application formula given above follows from their equation (11) under assumption that the radial velocity rv has also been defined using the same optical convention. Note, this can be regarded as a matter of velocity definition and does not by itself imply any loss of accuracy, provided sufficient care has been taken during interpretation of the results. If you need the barycentric correction expressed as the full relativistic velocity (e.g., to provide it as the input to another software which performs the application), the following recipe can be used:
>>> zb = vcorr / c >>> zb_plus_one_squared = (zb + 1) ** 2 >>> vcorr_rel = c * (zb_plus_one_squared - 1) / (zb_plus_one_squared + 1)
or alternatively using just equivalencies:
>>> vcorr_rel = vcorr.to(u.Hz, u.doppler_optical(1*u.Hz)).to(vcorr.unit, u.doppler_relativistic(1*u.Hz))
See also doppler_optical, doppler_radio, and doppler_relativistic for more information on the velocity conventions.
The default is for this method to use the builtin ephemeris for computing the sun and earth location. Other ephemerides can be chosen by setting the solar_system_ephemeris variable, either directly or via with statement. For example, to use the JPL ephemeris, do:
>>> from astropy.coordinates import solar_system_ephemeris
>>> sc = SkyCoord(1*u.deg, 2*u.deg)
>>> with solar_system_ephemeris.set('jpl'):
... rv += sc.radial_velocity_correction(obstime=t, location=loc)
Searches for all coordinates in this object around a supplied set of points within a given 3D radius.
This is intended for use on SkyCoord objects with coordinate arrays, rather than a scalar coordinate. For a scalar coordinate, it is better to use separation_3d().
For more on how to use this (and related) functionality, see the examples in Separations, Offsets, Catalog Matching, and Related Functionality.
SkyCoord or BaseCoordinateFrame
The coordinates to search around to try to find matching points in this SkyCoord. This must be a one-dimensional coordinate array.
Quantity [:ref: ‘length’]
The physical radius to search within. It should be broadcastable to the same shape as searcharoundcoords.
int array
Indices into searcharoundcoords that match the corresponding elements of idxself. Shape matches idxself.
int array
Indices into self that match the corresponding elements of idxsearcharound. Shape matches idxsearcharound.
Angle
The on-sky separation between the coordinates. Shape matches idxsearcharound and idxself.
Quantity [:ref: ‘length’]
The 3D distance between the coordinates. Shape matches idxsearcharound and idxself.
Notes
This method requires SciPy to be installed or it will fail.
In the current implementation, the return values are always sorted in the same order as the searcharoundcoords (so idxsearcharound is in ascending order). This is considered an implementation detail, though, so it could change in a future release.
Searches for all coordinates in this object around a supplied set of points within a given on-sky separation.
This is intended for use on SkyCoord objects with coordinate arrays, rather than a scalar coordinate. For a scalar coordinate, it is better to use separation().
For more on how to use this (and related) functionality, see the examples in Separations, Offsets, Catalog Matching, and Related Functionality.
The coordinates to search around to try to find matching points in this SkyCoord. This must be a one-dimensional coordinate array.
Quantity [:ref: ‘angle’]
The on-sky separation to search within. It should be broadcastable to the same shape as searcharoundcoords.
int array
Indices into searcharoundcoords that match the corresponding elements of idxself. Shape matches idxself.
int array
Indices into self that match the corresponding elements of idxsearcharound. Shape matches idxsearcharound.
Angle
The on-sky separation between the coordinates. Shape matches idxsearcharound and idxself.
Quantity [:ref: ‘length’]
The 3D distance between the coordinates. Shape matches idxsearcharound and idxself.
Notes
This method requires SciPy to be installed or it will fail.
In the current implementation, the return values are always sorted in the same order as the searcharoundcoords (so idxsearcharound is in ascending order). This is considered an implementation detail, though, so it could change in a future release.
Returns the sky offset frame with this SkyCoord at the origin.
The final rotation of the frame about the origin. The sign of the rotation is the left-hand rule. That is, an object at a particular position angle in the un-rotated system will be sent to the positive latitude (z) direction in the final frame.
SkyOffsetFrame
A sky offset frame of the same type as this SkyCoord (e.g., if this object has an ICRS coordinate, the resulting frame is SkyOffsetICRS, with the origin set to this object)
Computes the coordinate that is a specified pair of angular offsets away from this coordinate.
The angular offset in the longitude direction. The definition of “longitude” depends on this coordinate’s frame (e.g., RA for equatorial coordinates).
The angular offset in the latitude direction. The definition of “latitude” depends on this coordinate’s frame (e.g., Dec for equatorial coordinates).
SkyCoord
The coordinates for the location that corresponds to offsetting by d_lat in the latitude direction and d_lon in the longitude direction.
Notes
This internally uses SkyOffsetFrame to do the transformation. For a more complete set of transform offsets, use SkyOffsetFrame or WCS manually. This specific method can be reproduced by doing SkyCoord(SkyOffsetFrame(d_lon, d_lat, origin=self.frame).transform_to(self)).
Computes angular offsets to go from this coordinate to another.
BaseCoordinateFrame
The coordinate to find the offset to.
Angle
The angular offset in the longitude direction. The definition of “longitude” depends on this coordinate’s frame (e.g., RA for equatorial coordinates).
Angle
The angular offset in the latitude direction. The definition of “latitude” depends on this coordinate’s frame (e.g., Dec for equatorial coordinates).
ValueError
If the tocoord is not in the same frame as this one. This is different from the behavior of the separation()/separation_3d() methods because the offset components depend critically on the specific choice of frame.
Notes
This uses the sky offset frame machinery, and hence will produce a new sky offset frame if one does not already exist for this object’s frame class.
Convert this coordinate to pixel coordinates using a WCS object.
WCS
The WCS to use for convert
int
Whether to return 0 or 1-based pixel coordinates.
Whether to do the transformation including distortions ('all') or only including only the core WCS transformation ('wcs').
numpy.ndarray
The pixel coordinates
A string representation of the coordinates.
The default styles definitions are:
'decimal': 'lat': {'decimal': True, 'unit': "deg"}
'lon': {'decimal': True, 'unit': "deg"}
'dms': 'lat': {'unit': "deg"}
'lon': {'unit': "deg"}
'hmsdms': 'lat': {'alwayssign': True, 'pad': True, 'unit': "deg"}
'lon': {'pad': True, 'unit': "hour"}
See to_string() for details and keyword arguments (the two angles forming the coordinates are are both Angle instances). Keyword arguments have precedence over the style defaults and are passed to to_string().
The formatting specification to use. These encode the three most common ways to represent coordinates. The default is decimal.
Keyword args passed to to_string().
Convert this SkyCoord to a QTable.
Any attributes that have the same length as the SkyCoord will be converted to columns of the QTable. All other attributes will be recorded as metadata.
Examples
>>> sc = SkyCoord(ra=[40, 70]*u.deg, dec=[0, -20]*u.deg,
... obstime=Time([2000, 2010], format='jyear'))
>>> t = sc.to_table()
>>> t
<QTable length=2>
ra dec obstime
deg deg
float64 float64 Time
------- ------- -------
40.0 0.0 2000.0
70.0 -20.0 2010.0
>>> t.meta
{'representation_type': 'spherical', 'frame': 'icrs'}
Transform this coordinate to a new frame.
The precise frame transformed to depends on merge_attributes. If False, the destination frame is used exactly as passed in. But this is often not quite what one wants. E.g., suppose one wants to transform an ICRS coordinate that has an obstime attribute to FK4; in this case, one likely would want to use this information. Thus, the default for merge_attributes is True, in which the precedence is as follows: (1) explicitly set (i.e., non-default) values in the destination frame; (2) explicitly set values in the source; (3) default value in the destination frame.
Note that in either case, any explicitly set attributes on the source SkyCoord that are not part of the destination frame’s definition are kept (stored on the resulting SkyCoord), and thus one can round-trip (e.g., from FK4 to ICRS to FK4 without losing obstime).
str, BaseCoordinateFrame class or instance, or SkyCoord instance
The frame to transform this coordinate into. If a SkyCoord, the underlying frame is extracted, and all other information ignored.
Whether the default attributes in the destination frame are allowed to be overridden by explicitly set attributes in the source (see note above; default: True).
SkyCoord
A new object with this coordinate represented in the frame frame.
ValueError
If there is no possible transformation route.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4