Source code for

# Licensed under a 3-clause BSD style license - see LICENSE.rst
from __future__ import (absolute_import, division, print_function,

# Standard library
from abc import ABCMeta

# Third-party
import astropy.units as u
from astropy.coordinates import (SkyCoord, ICRS, UnitSphericalRepresentation,

__all__ = ["Target", "FixedTarget", "NonFixedTarget"]

# Docstring code examples include printed SkyCoords, but the format changed
# in astropy 1.3. Thus the doctest needs astropy >=1.3 and this is the
# easiest way to make it work.

__doctest_requires__ = {'FixedTarget.*': ['astropy.modeling.Hermite1D']}

[docs]class Target(object): """ Abstract base class for target objects. This is an abstract base class -- you can't instantiate examples of this class, but must work with one of its subclasses such as `` or ``. """ __metaclass__ = ABCMeta def __init__(self, name=None, ra=None, dec=None, marker=None): """ Defines a single observation target. Parameters ---------- name : str, optional ra : WHAT TYPE IS ra ? dec : WHAT TYPE IS dec ? marker : str, optional User-defined markers to differentiate between different types of targets (e.g., guides, high-priority, etc.). """ raise NotImplementedError() @property def ra(self): """ Right ascension. """ if isinstance(self, FixedTarget): return self.coord.ra raise NotImplementedError() @property def dec(self): """ Declination. """ if isinstance(self, FixedTarget): return self.coord.dec raise NotImplementedError()
[docs]class FixedTarget(Target): """ Coordinates and metadata for an object that is "fixed" with respect to the celestial sphere. Examples -------- Create a `~astroplan.FixedTarget` object for Sirius: >>> from astroplan import FixedTarget >>> from astropy.coordinates import SkyCoord >>> import astropy.units as u >>> sirius_coord = SkyCoord(ra=101.28715533*u.deg, dec=16.71611586*u.deg) >>> sirius = FixedTarget(coord=sirius_coord, name="Sirius") Create an equivalent `~astroplan.FixedTarget` object for Sirius by querying for the coordinates of Sirius by name: >>> from astroplan import FixedTarget >>> sirius = FixedTarget.from_name("Sirius") """ def __init__(self, coord, name=None, **kwargs): """ Parameters ---------- coord : `~astropy.coordinates.SkyCoord` Coordinate of the target name : str (optional) Name of the target, used for plotting and representing the target as a string """ if not (hasattr(coord, 'transform_to') and hasattr(coord, 'represent_as')): raise TypeError('`coord` must be a coordinate object.') = name self.coord = coord @classmethod
[docs] def from_name(cls, query_name, name=None, **kwargs): """ Initialize a `FixedTarget` by querying for a name from the CDS name resolver, using the machinery in `~astropy.coordinates.SkyCoord.from_name`. This Parameters ---------- query_name : str Name of the target used to query for coordinates. name : string or `None` Name of the target to use within astroplan. If `None`, query_name is used as ``name``. Examples -------- >>> from astroplan import FixedTarget >>> sirius = FixedTarget.from_name("Sirius") >>> sirius.coord # doctest: +FLOAT_CMP <SkyCoord (ICRS): (ra, dec) in deg ( 101.28715533, -16.71611586)> """ # Allow manual override for name keyword so that the target name can # be different from the query name, otherwise assume name=queryname. if name is None: name = query_name return cls(SkyCoord.from_name(query_name), name=name, **kwargs)
def __repr__(self): """ String representation of `~astroplan.FixedTarget`. Examples -------- Show string representation of a `~astroplan.FixedTarget` for Vega: >>> from astroplan import FixedTarget >>> from astropy.coordinates import SkyCoord >>> vega_coord = SkyCoord(ra='279.23473479d', dec='38.78368896d') >>> vega = FixedTarget(coord=vega_coord, name="Vega") >>> print(vega) # doctest: +FLOAT_CMP <FixedTarget "Vega" at SkyCoord (ICRS): (ra, dec) in deg ( 279.23473479, 38.78368894)> """ class_name = self.__class__.__name__ fmt_coord = repr(self.coord).replace('\n ', '')[1:-1] return '<{} "{}" at {}>'.format(class_name,, fmt_coord) @classmethod def _from_name_mock(cls, query_name, name=None): """ Mock method to replace `FixedTarget.from_name` in tests without internet connection. """ stars = { "rigel": {"ra": 78.63446707*u.deg, "dec": -8.20163837*u.deg}, "sirius": {"ra": 101.28715533*u.deg, "dec": -16.71611586*u.deg}, "vega": {"ra": 279.23473479*u.deg, "dec": 38.78368896*u.deg}, "aldebaran": {"ra": 68.98016279*u.deg, "dec": 16.50930235*u.deg}, "polaris": {"ra": 37.95456067*u.deg, "dec": 89.26410897*u.deg}, "deneb": {"ra": 310.35797975*u.deg, "dec": 45.28033881*u.deg}, "m13": {"ra": 250.423475*u.deg, "dec": 36.4613194*u.deg}, "altair": {"ra": 297.6958273*u.deg, "dec": 8.8683212*u.deg} } if query_name.lower() in stars: return cls(coord=SkyCoord(**stars[query_name.lower()]), name=query_name) else: raise ValueError("Target named {} not in mocked FixedTarget " "method".format(query_name))
[docs]class NonFixedTarget(Target): """ Placeholder for future function. """
def get_skycoord(targets): """ Return an `~astropy.coordinates.SkyCoord` object. When performing calculations it is usually most efficient to have a single `~astropy.coordinates.SkyCoord` object, rather than a list of `FixedTarget` or `~astropy.coordinates.SkyCoord` objects. This is a convenience routine to do that. Parameters ----------- targets : list, `~astropy.coordinates.SkyCoord`, `Fixedtarget` either a single target or a list of targets Returns -------- coord : `~astropy.coordinates.SkyCoord` a single SkyCoord object, which may be non-scalar """ if not isinstance(targets, list): return getattr(targets, 'coord', targets) # get the SkyCoord object itself coords = [getattr(target, 'coord', target) for target in targets] # are all SkyCoordinate's in equivalent frames? If not, convert to ICRS convert_to_icrs = not all([coord.frame.is_equivalent_frame(coords[0].frame) for coord in coords[1:]]) # we also need to be careful about handling mixtures of UnitSphericalRepresentations and others targets_is_unitsphericalrep = [ is UnitSphericalRepresentation for x in coords] longitudes = [] latitudes = [] distances = [] get_distances = not all(targets_is_unitsphericalrep) if convert_to_icrs: # mixture of frames for coordinate in coords: icrs_coordinate = coordinate.icrs longitudes.append(icrs_coordinate.ra) latitudes.append(icrs_coordinate.dec) if get_distances: distances.append(icrs_coordinate.distance) frame = ICRS() else: # all the same frame, get the longitude and latitude names mappings = coords[0].frame_specific_representation_info[SphericalRepresentation] lon_name, lat_name = [mapping.framename for mapping in mappings] frame = coords[0].frame for coordinate in coords: longitudes.append(getattr(coordinate, lon_name)) latitudes.append(getattr(coordinate, lat_name)) if get_distances: distances.append(coordinate.distance) # now let's deal with the fact that we may have a mixture of coords with distances and # coords with UnitSphericalRepresentations if all(targets_is_unitsphericalrep): return SkyCoord(longitudes, latitudes, frame=frame) elif not any(targets_is_unitsphericalrep): return SkyCoord(longitudes, latitudes, distances, frame=frame) else: """ We have a mixture of coords with distances and without. Since we don't know in advance the origin of the frame where further transformation will take place, it's not safe to drop the distances from those coords with them set. Instead, let's assign large distances to those objects with none. """ distances = [distance if distance != 1 else 100*u.kpc for distance in distances] return SkyCoord(longitudes, latitudes, distances, frame=frame)