class FK4NoETerms(BaseRADecFrame): """ A coordinate or frame in the FK4 system, but with the E-terms of aberration removed. The frame attributes are listed under **Other Parameters**. """ equinox = TimeAttribute(default=EQUINOX_B1950) obstime = TimeAttribute(default=None, secondary_attribute='equinox') @staticmethod def _precession_matrix(oldequinox, newequinox): """ Compute and return the precession matrix for FK4 using Newcomb's method. Used inside some of the transformation functions. Parameters ---------- oldequinox : `~astropy.time.Time` The equinox to precess from. newequinox : `~astropy.time.Time` The equinox to precess to. Returns ------- newcoord : array The precession matrix to transform to the new equinox """ return earth._precession_matrix_besselian(oldequinox.byear, newequinox.byear)
class FK4(BaseRADecFrame): """ A coordinate or frame in the FK4 system. Note that this is a barycentric version of FK4 - that is, the origin for this frame is the Solar System Barycenter, *not* the Earth geocenter. The frame attributes are listed under **Other Parameters**. """ equinox = TimeAttribute(default=EQUINOX_B1950) obstime = TimeAttribute(default=None, secondary_attribute='equinox')
class PrecessedGeocentric(BaseRADecFrame): """ A coordinate frame defined in a similar manner as GCRS, but precessed to a requested (mean) equinox. Note that this does *not* end up the same as regular GCRS even for J2000 equinox, because the GCRS orientation is fixed to that of ICRS, which is not quite the same as the dynamical J2000 orientation. The frame attributes are listed under **Other Parameters** """ equinox = TimeAttribute(default=EQUINOX_J2000) obstime = TimeAttribute(default=DEFAULT_OBSTIME) obsgeoloc = CartesianRepresentationAttribute(default=[0, 0, 0], unit=u.m) obsgeovel = CartesianRepresentationAttribute(default=[0, 0, 0], unit=u.m/u.s)
class FK5(BaseRADecFrame): """ A coordinate or frame in the FK5 system. Note that this is a barycentric version of FK5 - that is, the origin for this frame is the Solar System Barycenter, *not* the Earth geocenter. The frame attributes are listed under **Other Parameters**. """ equinox = TimeAttribute(default=EQUINOX_J2000) @staticmethod def _precession_matrix(oldequinox, newequinox): """ Compute and return the precession matrix for FK5 based on Capitaine et al. 2003/IAU2006. Used inside some of the transformation functions. Parameters ---------- oldequinox : `~astropy.time.Time` The equinox to precess from. newequinox : `~astropy.time.Time` The equinox to precess to. Returns ------- newcoord : array The precession matrix to transform to the new equinox """ return earth.precession_matrix_Capitaine(oldequinox, newequinox)
class GeocentricTrueEcliptic(BaseEclipticFrame): """ Geocentric true ecliptic coordinates. These origin of the coordinates are the geocenter (Earth), with the x axis pointing to the *true* (not mean) equinox at the time specified by the ``equinox`` attribute, and the xy-plane in the plane of the ecliptic for that date. Be aware that the definition of "geocentric" here means that this frame *includes* light deflection from the sun, aberration, etc when transforming to/from e.g. ICRS. The frame attributes are listed under **Other Parameters**. """ equinox = TimeAttribute(default=EQUINOX_J2000) obstime = TimeAttribute(default=DEFAULT_OBSTIME)
class TETE(BaseRADecFrame): """ An equatorial coordinate or frame using the True Equator and True Equinox (TETE). Equatorial coordinate frames measure RA with respect to the equinox and declination with with respect to the equator. The location of the equinox and equator vary due the gravitational torques on the oblate Earth. This variation is split into precession and nutation, although really they are two aspects of a single phenomena. The smooth, long term variation is known as precession, whilst smaller, periodic components are called nutation. Calculation of the true equator and equinox involves the application of both precession and nutation, whilst only applying precession gives a mean equator and equinox. TETE coordinates are often referred to as "apparent" coordinates, or "apparent place". TETE is the apparent coordinate system used by JPL Horizons and is the correct coordinate system to use when combining the right ascension with local apparent sidereal time to calculate the apparent (TIRS) hour angle. For more background on TETE, see the references provided in the :ref:`astropy:astropy-coordinates-seealso` section of the documentation. Of particular note are Sections 5 and 6 of `USNO Circular 179 <https://arxiv.org/abs/astro-ph/0602086>`_) and especially the diagram at the top of page 57. This frame also includes frames that are defined *relative* to the center of the Earth, but that are offset (in both position and velocity) from the center of the Earth. You may see such non-geocentric coordinates referred to as "topocentric". The frame attributes are listed under **Other Parameters**. """ obstime = TimeAttribute(default=DEFAULT_OBSTIME) location = EarthLocationAttribute(default=EARTH_CENTER)
class LunarTopo(BaseCoordinateFrame): """ An "East/North/Up" coordinate frame on the lunar surface, analogous to the AltAz frame in astropy. """ frame_specific_representation_info = { SphericalRepresentation: [ RepresentationMapping('lon', 'az'), RepresentationMapping('lat', 'alt') ] } default_representation = SphericalRepresentation default_differential = SphericalCosLatDifferential obstime = TimeAttribute(default=DEFAULT_OBSTIME) location = MoonLocationAttribute(default=None) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) @property def zen(self): """ The zenith angle for this coordinate """ return _90DEG.to(self.alt.unit) - self.alt
class UVW(BaseCoordinateFrame): """ Written by Joshua G. Albert - [email protected] A coordinate or frame in the UVW system. This frame has the following frame attributes, which are necessary for transforming from UVW to some other system: * ``obstime`` The time at which the observation is taken. Used for determining the position and orientation of the Earth. * ``location`` The location on the Earth. This can be specified either as an `~astropy.coordinates.EarthLocation` object or as anything that can be transformed to an `~astropy.coordinates.ITRS` frame. * ``phaseDir`` The phase tracking center of the frame. This can be specified either as an (ra,dec) `~astropy.units.Qunatity` or as anything that can be transformed to an `~astropy.coordinates.ICRS` frame. Parameters ---------- representation : `BaseRepresentation` or None A representation object or None to have no data (or use the other keywords) u : :class:`~astropy.units.Quantity`, optional, must be keyword The u coordinate for this object (``v`` and ``w`` must also be given and ``representation`` must be None). v : :class:`~astropy.units.Quantity`, optional, must be keyword The v coordinate for this object (``u`` and ``w`` must also be given and ``representation`` must be None). w : :class:`~astropy.units.Quantity`, optional, must be keyword The w coordinate for this object (``u`` and ``v`` must also be given and ``representation`` must be None). Notes ----- This is useful for radio astronomy. """ frame_specific_representation_info = { 'cartesian': [ RepresentationMapping('x', 'u'), RepresentationMapping('y', 'v'), RepresentationMapping('z', 'w') ], } default_representation = CartesianRepresentation obstime = TimeAttribute(default=None) location = EarthLocationAttribute(default=None) phase = CoordinateAttribute(ICRS, default=None) def __init__(self, *args, **kwargs): super(UVW, self).__init__(*args, **kwargs) @property def elevation(self): """ Elevation above the horizon of the direction """ return self.phase.transform_to( AltAz(location=self.location, obstime=self.obstime)).alt
class CIRS(BaseRADecFrame): """ A coordinate or frame in the Celestial Intermediate Reference System (CIRS). The frame attributes are listed under **Other Parameters**. """ obstime = TimeAttribute(default=DEFAULT_OBSTIME)
class HeliocentricTrueEcliptic(BaseEclipticFrame): """ Heliocentric true ecliptic coordinates. These origin of the coordinates are the center of the sun, with the x axis pointing in the direction of the *true* (not mean) equinox as at the time specified by the ``equinox`` attribute (as seen from Earth), and the xy-plane in the plane of the ecliptic for that date. The frame attributes are listed under **Other Parameters**. {params} """ equinox = TimeAttribute(default=EQUINOX_J2000) obstime = TimeAttribute(default=DEFAULT_OBSTIME)
class ENU(BaseCoordinateFrame): """ Written by Joshua G. Albert - [email protected] A coordinate or frame in the East-North-Up (ENU) system. This frame has the following frame attributes, which are necessary for transforming from ENU to some other system: * ``obstime`` The time at which the observation is taken. Used for determining the position and orientation of the Earth. * ``location`` The location on the Earth. This can be specified either as an `~astropy.coordinates.EarthLocation` object or as anything that can be transformed to an `~astropy.coordinates.ITRS` frame. Parameters ---------- representation : `BaseRepresentation` or None A representation object or None to have no data (or use the other keywords) east : :class:`~astropy.units.Quantity`, optional, must be keyword The east coordinate for this object (``north`` and ``up`` must also be given and ``representation`` must be None). north : :class:`~astropy.units.Quantity`, optional, must be keyword The north coordinate for this object (``east`` and ``up`` must also be given and ``representation`` must be None). up : :class:`~astropy.units.Quantity`, optional, must be keyword The up coordinate for this object (``north`` and ``east`` must also be given and ``representation`` must be None). Notes ----- This is useful as an intermediate frame between ITRS and UVW for radio astronomy """ frame_specific_representation_info = { 'cartesian': [ RepresentationMapping('x', 'east'), RepresentationMapping('y', 'north'), RepresentationMapping('z', 'up') ], } default_representation = CartesianRepresentation obstime = TimeAttribute( default=None ) #at.Time("2000-01-01T00:00:00.000",format="isot",scale="tai")) location = EarthLocationAttribute(default=None) def __init__(self, *args, **kwargs): super(ENU, self).__init__(*args, **kwargs) @property def elevation(self): """ Elevation above the horizon of the direction, in degrees """ return np.arctan2(self.up, np.sqrt(self.north**2 + self.east**2)) * 180. / np.pi
class BarycentricMeanEcliptic(BaseEclipticFrame): """ Barycentric mean ecliptic coordinates. These origin of the coordinates are the barycenter of the solar system, with the x axis pointing in the direction of the *mean* (not true) equinox as at the time specified by the ``equinox`` attribute (as seen from Earth), and the xy-plane in the plane of the ecliptic for that date. The frame attributes are listed under **Other Parameters**. """ equinox = TimeAttribute(default=EQUINOX_J2000)
class HADec(BaseCoordinateFrame): """ A coordinate or frame in the Hour Angle-Declination system (Equatorial coordinates) with respect to the WGS84 ellipsoid. Hour Angle is oriented with respect to upper culmination such that the hour angle is negative to the East and positive to the West. This frame is assumed to *include* refraction effects if the ``pressure`` frame attribute is non-zero. The frame attributes are listed under **Other Parameters**, which are necessary for transforming from HADec to some other system. """ frame_specific_representation_info = { r.SphericalRepresentation: [ RepresentationMapping('lon', 'ha', u.hourangle), RepresentationMapping('lat', 'dec') ] } default_representation = r.SphericalRepresentation default_differential = r.SphericalCosLatDifferential obstime = TimeAttribute(default=None) location = EarthLocationAttribute(default=None) pressure = QuantityAttribute(default=0, unit=u.hPa) temperature = QuantityAttribute(default=0, unit=u.deg_C) relative_humidity = QuantityAttribute(default=0, unit=u.dimensionless_unscaled) obswl = QuantityAttribute(default=1 * u.micron, unit=u.micron) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if self.has_data: self._set_data_lon_wrap_angle(self.data) @staticmethod def _set_data_lon_wrap_angle(data): if hasattr(data, 'lon'): data.lon.wrap_angle = 180. * u.deg return data def represent_as(self, base, s='base', in_frame_units=False): """ Ensure the wrap angle for any spherical representations. """ data = super().represent_as(base, s, in_frame_units=in_frame_units) self._set_data_lon_wrap_angle(data) return data
class AltAz(BaseCoordinateFrame): """ A coordinate or frame in the Altitude-Azimuth system (Horizontal coordinates) with respect to the WGS84 ellipsoid. Azimuth is oriented East of North (i.e., N=0, E=90 degrees). Altitude is also known as elevation angle, so this frame is also in the Azimuth-Elevation system. This frame is assumed to *include* refraction effects if the ``pressure`` frame attribute is non-zero. The frame attributes are listed under **Other Parameters**, which are necessary for transforming from AltAz to some other system. """ frame_specific_representation_info = { r.SphericalRepresentation: [ RepresentationMapping('lon', 'az'), RepresentationMapping('lat', 'alt') ] } default_representation = r.SphericalRepresentation default_differential = r.SphericalCosLatDifferential obstime = TimeAttribute(default=None) location = EarthLocationAttribute(default=None) pressure = QuantityAttribute(default=0, unit=u.hPa) temperature = QuantityAttribute(default=0, unit=u.deg_C) relative_humidity = QuantityAttribute(default=0, unit=u.dimensionless_unscaled) obswl = QuantityAttribute(default=1 * u.micron, unit=u.micron) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) @property def secz(self): """ Secant of the zenith angle for this coordinate, a common estimate of the airmass. """ return 1 / np.sin(self.alt) @property def zen(self): """ The zenith angle (or zenith distance / co-altitude) for this coordinate. """ return _90DEG.to(self.alt.unit) - self.alt
class HeliocentricEclipticIAU76(BaseEclipticFrame): """ Heliocentric mean (IAU 1976) ecliptic coordinates. These origin of the coordinates are the center of the sun, with the x axis pointing in the direction of the *mean* (not true) equinox of J2000, and the xy-plane in the plane of the ecliptic of J2000 (according to the IAU 1976/1980 obliquity model). It has, therefore, a fixed equinox and an older obliquity value than the rest of the frames. The frame attributes are listed under **Other Parameters**. {params} """ obstime = TimeAttribute(default=DEFAULT_OBSTIME)
class TEME(BaseCoordinateFrame): """ A coordinate or frame in the True Equator Mean Equinox frame (TEME). This frame is a geocentric system similar to CIRS or geocentric apparent place, except that the mean sidereal time is used to rotate from TIRS. TEME coordinates are most often used in combination with orbital data for satellites in the two-line-ephemeris format. Different implementations of the TEME frame exist. For clarity, this frame follows the conventions and relations to other frames that are set out in Vallado et al (2006). For more background on TEME, see the references provided in the :ref:`astropy:astropy-coordinates-seealso` section of the documentation. """ default_representation = CartesianRepresentation default_differential = CartesianDifferential obstime = TimeAttribute()
class HCRS(BaseRADecFrame): """ A coordinate or frame in a Heliocentric system, with axes aligned to ICRS. The ICRS has an origin at the Barycenter and axes which are fixed with respect to space. This coordinate system is distinct from ICRS mainly in that it is relative to the Sun's center-of-mass rather than the solar system Barycenter. In principle, therefore, this frame should include the effects of aberration (unlike ICRS), but this is not done, since they are very small, of the order of 8 milli-arcseconds. For more background on the ICRS and related coordinate transformations, see the references provided in the :ref:`astropy:astropy-coordinates-seealso` section of the documentation. The frame attributes are listed under **Other Parameters**. """ obstime = TimeAttribute(default=DEFAULT_OBSTIME)
class GCRS(BaseRADecFrame): """ A coordinate or frame in the Geocentric Celestial Reference System (GCRS). GCRS is distinct form ICRS mainly in that it is relative to the Earth's center-of-mass rather than the solar system Barycenter. That means this frame includes the effects of aberration (unlike ICRS). For more background on the GCRS, see the references provided in the :ref:`astropy-coordinates-seealso` section of the documentation. (Of particular note is Section 1.2 of `USNO Circular 179 <http://aa.usno.navy.mil/publications/docs/Circular_179.php>`_) This frame also includes frames that are defined *relative* to the Earth, but that are offset (in both position and velocity) from the Earth. The frame attributes are listed under **Other Parameters**. """ obstime = TimeAttribute(default=DEFAULT_OBSTIME) obsgeoloc = CartesianRepresentationAttribute(default=[0, 0, 0], unit=u.m) obsgeovel = CartesianRepresentationAttribute(default=[0, 0, 0], unit=u.m / u.s)
class MCMF(BaseCoordinateFrame): """ A coordinate or frame in the lunar "Mean Earth/ Mean Rotation frame". This is a "Moon-Centered/Moon-Fixed" frame, defined by an X axis through the mean position of the Earth-Moon direction and a Z axis through the mean rotational axis. In JPL ephemeris data, this is called MOON_ME. """ default_representation = CartesianRepresentation default_differential = CartesianDifferential obstime = TimeAttribute(default=DEFAULT_OBSTIME) @property def moon_location(self): """ The data in this frame as an `~astropy.coordinates.MoonLocation` class. """ from .moon import MoonLocation cart = self.represent_as(CartesianRepresentation) return MoonLocation(x=cart.x, y=cart.y, z=cart.z)
class ITRS(BaseCoordinateFrame): """ A coordinate or frame in the International Terrestrial Reference System (ITRS). This is approximately a geocentric system, although strictly it is defined by a series of reference locations near the surface of the Earth. For more background on the ITRS, see the references provided in the :ref:`astropy:astropy-coordinates-seealso` section of the documentation. """ default_representation = CartesianRepresentation default_differential = CartesianDifferential obstime = TimeAttribute(default=DEFAULT_OBSTIME) @property def earth_location(self): """ The data in this frame as an `~astropy.coordinates.EarthLocation` class. """ from astropy.coordinates.earth import EarthLocation cart = self.represent_as(CartesianRepresentation) return EarthLocation(x=cart.x, y=cart.y, z=cart.z)
class MyFK4(FK4): # equinox inherited from FK4, obstime overridden, and newattr is new obstime = TimeAttribute(default=_EQUINOX_B1980) newattr = Attribute(default='newattr')