a ߙfb@sddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Zddl mZddlmZddlmZddlmZddlmZd d lmZmZmZd d lmZmZm Z d d l!m"Z"d d l#m$Z$gdZ%e&dgdZ'iZ(dej)ej*+d ej,e-Z.d$ddZ/ddZ0GdddeZ1Gdddej2Z3dZ4ee4GdddeZ5ee4Gddde5Z6ee4Gd d!d!e5Z7ee4Gd"d#d#e5Z8dS)%)warnN)units) constants)QuantityInfoBase)data) format_doc)AstropyUserWarning)Angle LongitudeLatitude)BaseRepresentationCartesianRepresentationCartesianDifferential)matrix_transpose)UnknownSiteException) EarthLocationBaseGeodeticRepresentationWGS84GeodeticRepresentationWGS72GeodeticRepresentationGRS80GeodeticRepresentationGeodeticLocationlonlatheightg+6 ?WGS84cCs.|dur |}|tvr*td|dtd|S)Nz Ellipsoid z not among known ones ()) ELLIPSOIDS ValueError) ellipsoiddefaultr"8lib/python3.9/site-packages/astropy/coordinates/earth.py_check_ellipsoid4s r$c Cs ddlm}z,tjj|tjjd}t | d}Wntj j y}zBt|jtjrn||jdd|n||j|jd|WYd}~n,d}~0tjy||jddYn0|r|dg}|ddd kr||jd dn|}|s||jd d|S) Nr )NameResolveError)timeoututf8zconnection timed out)msgresultsZstatusZOKzunknown failure with Google APIzno results returned)Z name_resolver%urllibZrequestZurlopenrZconfZremote_timeoutjsonloadsreaddecodeerrorZURLError isinstancereasonsocketr&formatget)Zurlerr_str use_googler%ZrespZ resp_dataer)r"r"r#_get_json_result<s$ ( r8c@s&eZdZdZdZddZd ddZdS) EarthLocationInfoz Container for meta information like name, description, format. This is required when the object is used as a mixin column within a table, but can be used as a general way to store meta information. )xyzr cCs$|d}|jfi|}||_|S)Nr )popZ _parent_clsr )selfmapr outr"r"r#_construct_from_dictks z&EarthLocationInfo._construct_from_dictrNc s|||d}|d|f|d}tjtj|djddjddfdd |jD}| |}| D]\} } t |j | | qx|S) a Return a new EarthLocation instance which is consistent with the input ``cols`` and has ``length`` rows. This is intended for creating an empty column object whose elements can be set in-place for table operations like join or vstack. Parameters ---------- cols : list List of input columns length : int Length of the output column object metadata_conflicts : str ('warn'|'error'|'silent') How to handle metadata conflicts name : str Output column name Returns ------- col : EarthLocation (or subclass) Empty instance of this class consistent with ``cols`` )metar3Z descriptiondtypeshaper)rDrCF)unitcopycs,i|]$}||dvr|n td|qS)xyz)getattr).0keycolsrr"r# sz.EarthLocationInfo.new_like..) Zmerge_cols_attributesr=uQuantitynpZzerosrCrE_represent_as_dict_attrsrAitemssetattrinfo) r>rMlengthZmetadata_conflictsnameattrsrDr?r@attrvaluer"rLr#new_likess     zEarthLocationInfo.new_like)rN)__name__ __module__ __qualname____doc__rRrAr[r"r"r"r#r9csr9cseZdZdZdZegdejgddZeejdfZ e Z ddZ e dDfd d Ze dEd dZe ddZe dFddZe ddZe dGddZeddZejddZeddZdHddZedd Zed!d"Zed#d$Zed%d&Zd'd(ZdId)d*Zeed+d,Zd-d.Z d/d0Z!d1d2Z"gd3ifd4d5Z#ed6d7Z$ed8d9Z%ed:d;Z&fdd?Z(fd@dAZ)gfdBdCZ*Z+S)Jra Location on the Earth. Initialization is first attempted assuming geocentric (x, y, z) coordinates are given; if that fails, another attempt is made assuming geodetic coordinates (longitude, latitude, height above a reference ellipsoid). When using the geodetic forms, Longitudes are measured increasing to the east, so west longitudes are negative. Internally, the coordinates are stored as geocentric. To ensure a specific type of coordinates is used, use the corresponding class methods (`from_geocentric` and `from_geodetic`) or initialize the arguments with names (``x``, ``y``, ``z`` for geocentric; ``lon``, ``lat``, ``height`` for geodetic). See the class methods for details. Notes ----- This class fits into the coordinates transformation framework in that it encodes a position on the `~astropy.coordinates.ITRS` frame. To get a proper `~astropy.coordinates.ITRS` object from this object, use the ``itrs`` property. rr:r;r<)namesZformats)rac Ost|dkr2t|dkr2t|dtr2|dSz|j|i|}Wnttjtfy}zVz|j|i|}Wn4t y}ztd ||WYd}~n d}~00WYd}~n d}~00|S)Nr rzjCoordinates could not be parsed as either geocentric or geodetic, with respective exceptions "{}" and "{}") lenr0rrFfrom_geocentricrO UnitsError TypeError from_geodetic Exceptionr3)clsargskwargsr>Zexc_geocentricZ exc_geodeticr"r"r#__new__s  2zEarthLocation.__new__Ncs|dur2z |j}Wq<ty.tddYq<0n t|}|jdkrPtdz4tj||dd}tj||dd}tj||dd}WntjytdYn0t |||\}}}t |j |j }||||d<|d <|d <t j|||ddS) a Location on Earth, initialized from geocentric coordinates. Parameters ---------- x, y, z : `~astropy.units.Quantity` or array-like Cartesian coordinates. If not quantities, ``unit`` should be given. unit : unit-like or None Physical unit of the coordinate values. If ``x``, ``y``, and/or ``z`` are quantities, they will be converted to this unit. Raises ------ astropy.units.UnitsError If the units on ``x``, ``y``, and ``z`` do not match or an invalid unit is given. ValueError If the shapes of ``x``, ``y``, and ``z`` do not match. TypeError If ``x`` is not a `~astropy.units.Quantity` and no unit is given. NzMGeocentric coordinates should be Quantities unless an explicit unit is given.rVz4Geocentric coordinates should be in units of length.FrFz5Geocentric coordinate units should all be consistent.r:r;r<)rEAttributeErrorrfrOUnitZ physical_typererPrQZbroadcast_arraysemptyrD_location_dtypesuperrl)rir:r;r<rEZstruc __class__r"r#rds(      zEarthLocation.from_geocentriccCst||jd}t|tjdddtj}t|tjdd}t|tjsXtj|tj dd}t ||||dd}| j dd|j >}||j||j}||_|S)aY Location on Earth, initialized from geodetic coordinates. Parameters ---------- lon : `~astropy.coordinates.Longitude` or float Earth East longitude. Can be anything that initialises an `~astropy.coordinates.Angle` object (if float, in degrees). lat : `~astropy.coordinates.Latitude` or float Earth latitude. Can be anything that initialises an `~astropy.coordinates.Latitude` object (if float, in degrees). height : `~astropy.units.Quantity` ['length'] or float, optional Height above reference ellipsoid (if float, in meters; default: 0). ellipsoid : str, optional Name of the reference ellipsoid to use (default: 'WGS84'). Available ellipsoids are: 'WGS84', 'GRS80', 'WGS72'. Raises ------ astropy.units.UnitsError If the units on ``lon`` and ``lat`` are inconsistent with angular ones, or that on ``height`` with a length. ValueError If ``lon``, ``lat``, and ``height`` do not have the same shape, or if ``ellipsoid`` is not recognized as among the ones implemented. Notes ----- For the conversion to geocentric coordinates, the ERFA routine ``gd2gc`` is used. See https://github.com/liberfa/erfa r!FrmrHxyz_axis)r$ _ellipsoidr rOZdegreeZwrap_atr r0rPmr to_cartesianget_xyzrEviewrqreshaperD)rirrrr geodeticrGr>r"r"r#rgs! zEarthLocation.from_geodeticc Cs~|}z ||}Wn8tyL}z t|jd|jd|WYd}~n d}~00||jur\|S|j|}|jj|j_|SdS)a Return an object of this class for a known observatory/site by name. This is intended as a quick convenience function to get basic site information, not a fully-featured exhaustive registry of observatories and all their properties. Additional information about the site is stored in the ``.info.meta`` dictionary of sites obtained using this method (see the examples below). .. note:: When this function is called, it will attempt to download site information from the astropy data server. If you would like a site to be added, issue a pull request to the `astropy-data repository `_ . If a site cannot be found in the registry (i.e., an internet connection is not available), it will fall back on a built-in list, In the future, this bundled list might include a version-controlled list of canonical observatories extracted from the online version, but it currently only contains the Greenwich Royal Observatory as an example case. Parameters ---------- site_name : str Name of the observatory (case-insensitive). Returns ------- site : `~astropy.coordinates.EarthLocation` (or subclass) instance The location of the observatory. The returned class will be the same as this class. Examples -------- >>> from astropy.coordinates import EarthLocation >>> keck = EarthLocation.of_site('Keck Observatory') # doctest: +REMOTE_DATA >>> keck.geodetic # doctest: +REMOTE_DATA +FLOAT_CMP GeodeticLocation(lon=, lat=, height=) >>> keck.info # doctest: +REMOTE_DATA name = W. M. Keck Observatory dtype = void192 unit = m class = EarthLocation n_bad = 0 >>> keck.info.meta # doctest: +REMOTE_DATA {'source': 'IRAF Observatory Database', 'timezone': 'US/Hawaii'} See Also -------- get_site_names : the list of sites that this function can access EarthLocation.get_site_names) close_namesN) _get_site_registryrZsiterrtrg to_geodeticrUrW)riZ site_nameregistryZelr7Znewelr"r"r#of_site5s6   zEarthLocation.of_siteFcCs8|du}|s|rtd|r:tj||d}d|}ntj|dd}d|}d|d }t|||d }|r|d d d } | d} | d} n |d } t| d} t| d} |r| dd| d|d}tj|}d|} d|d }t| ||d } | d dtj}nd}|j| tj | tj |dS)a Return an object of this class for a given address by querying either the OpenStreetMap Nominatim tool [1]_ (default) or the Google geocoding API [2]_, which requires a specified API key. This is intended as a quick convenience function to get easy access to locations. If you need to specify a precise location, you should use the initializer directly and pass in a longitude, latitude, and elevation. In the background, this just issues a web query to either of the APIs noted above. This is not meant to be abused! Both OpenStreetMap and Google use IP-based query limiting and will ban your IP if you send more than a few thousand queries per hour [2]_. .. warning:: If the query returns more than one location (e.g., searching on ``address='springfield'``), this function will use the **first** returned location. Parameters ---------- address : str The address to get the location for. As per the Google maps API, this can be a fully specified street address (e.g., 123 Main St., New York, NY) or a city name (e.g., Danbury, CT), or etc. get_height : bool, optional This only works when using the Google API! See the ``google_api_key`` block below. Use the retrieved location to perform a second query to the Google maps elevation API to retrieve the height of the input address [3]_. google_api_key : str, optional A Google API key with the Geocoding API and (optionally) the elevation API enabled. See [4]_ for more information. Returns ------- location : `~astropy.coordinates.EarthLocation` (or subclass) instance The location of the input address. Will be type(this class) References ---------- .. [1] https://nominatim.openstreetmap.org/ .. [2] https://developers.google.com/maps/documentation/geocoding/start .. [3] https://developers.google.com/maps/documentation/elevation/start .. [4] https://developers.google.com/maps/documentation/geocoding/get-api-key NzCurrently, `get_height` only works when using the Google geocoding API, which requires passing a Google API key with `google_api_key`. See: https://developers.google.com/maps/documentation/geocoding/get-api-key for information on obtaining an API key.)addressrKz2https://maps.googleapis.com/maps/api/geocode/json?r+)qr3z+https://nominatim.openstreetmap.org/search?z,Unable to retrieve coordinates for address 'z'; {msg})r5r6rZgeometrylocationrZlngrz.8f,)Z locationsrKz4https://maps.googleapis.com/maps/api/elevation/json?z*Unable to retrieve elevation for address 'Z elevationrur) rr*parseZ urlencoder8floatrOZmeterrgdeg)rirZ get_heightZgoogle_api_keyr6ZparsZgeo_urlr5Z geo_resultlocrrZele_urlZ ele_resultrr"r"r# of_addressysL3         zEarthLocation.of_addresscCs |jS)ai Get list of names of observatories for use with `~astropy.coordinates.EarthLocation.of_site`. .. note:: When this function is called, it will first attempt to download site information from the astropy data server. If it cannot (i.e., an internet connection is not available), it will fall back on the list included with astropy (which is a limited and dated set of sites). If you think a site should be added, issue a pull request to the `astropy-data repository `_ . Returns ------- names : list of str List of valid observatory names See Also -------- of_site : Gets the actual location object for one of the sites names this returns. )rrb)rir"r"r#get_site_namessrcCsddlm}m}|r |r td|r2|}|_npt|dd}|sF|szt|tr\||}n|}Wn6ty|rxd}t t | |j |}Yn0||_|S)a Gets the site registry. The first time this either downloads or loads from the data file packaged with astropy. Subsequent calls will use the cached version unless explicitly overridden. Parameters ---------- force_download : bool or str If not False, force replacement of the cached registry with a downloaded version. If a str, that will be used as the URL to download from (if just True, the default URL will be used). force_builtin : bool If True, load from the data file bundled with astropy and set the cache to that. Returns ------- reg : astropy.coordinates.sites.SiteRegistry r )get_builtin_sitesget_downloaded_sitesz6Cannot have both force_builtin and force_download True_site_registryNzCould not access the online site list. Falling back on the built-in version, which is rather limited. If you want to retry the download, do {0}._get_site_registry(force_download=True)) ZsitesrrrrrIr0strOSErrorrrr3r\)riZforce_downloadZ force_builtinrrZregr(r"r"r#rs&      z EarthLocation._get_site_registrycCs|jS)z>The default ellipsoid used to convert to geodetic coordinates.)rzr>r"r"r#r -szEarthLocation.ellipsoidcCst||_dSN)r$rz)r>r r"r"r#r 2scCs|S)z:Convert to geodetic coordinates for the default ellipsoid.)rrr"r"r#r6szEarthLocation.geodeticcCsht||jd}||jtj}t|dddt|}t t |j tj dtj dd|j tj >|j|j>S)aYConvert to geodetic coordinates. Parameters ---------- ellipsoid : str, optional Reference ellipsoid to use. Default is the one the coordinates were initialized with. Available are: 'WGS84', 'GRS80', 'WGS72' Returns ------- lon, lat, height : `~astropy.units.Quantity` The tuple is a ``GeodeticLocation`` namedtuple and is comprised of instances of `~astropy.coordinates.Longitude`, `~astropy.coordinates.Latitude`, and `~astropy.units.Quantity`. Raises ------ ValueError if ``ellipsoid`` is not recognized as among the ones implemented. Notes ----- For the conversion to geodetic coordinates, the ERFA routine ``gc2gd`` is used. See https://github.com/liberfa/erfa rvrHFryrFrw)Z wrap_anglerF)r$r r~ _array_dtyperOrPrZ represent_asrrr rrrrrE)r>r rGZllhr"r"r#r;szEarthLocation.to_geodeticcCs |jdS)z5Longitude of the location, for the default ellipsoid.rrrr"r"r#r]szEarthLocation.loncCs |jdS)z4Latitude of the location, for the default ellipsoid.r rrr"r"r#rbszEarthLocation.latcCs |jdS)z2Height of the location, for the default ellipsoid.rrr"r"r#rgszEarthLocation.heightcCs|Sz1Convert to a tuple with X, Y, and Z as quantities) to_geocentricrr"r"r# geocentricmszEarthLocation.geocentriccCs|j|j|jfSrr`rr"r"r#rrszEarthLocation.to_geocentriccCsH|r&|jdkr&|jr&tj||jdd}ddlm}||j|j|j|dS)a Generates an `~astropy.coordinates.ITRS` object with the location of this object at the requested ``obstime``. Parameters ---------- obstime : `~astropy.time.Time` or None The ``obstime`` to apply to the new `~astropy.coordinates.ITRS`, or if None, the default ``obstime`` will be used. Returns ------- itrs : `~astropy.coordinates.ITRS` The new object in the ITRS frame r T)Zsubok)ITRS)r:r;r<obstime) sizerDrQZ broadcast_tobuiltin_framesrr:r;r<)r>rrr"r"r#get_itrsvs zEarthLocation.get_itrszAn `~astropy.coordinates.ITRS` object with for the location of this object at the default ``obstime``.)doccCs6ddlm}||\}}t||jd<|||dS)aXGCRS position with velocity at ``obstime`` as a GCRS coordinate. Parameters ---------- obstime : `~astropy.time.Time` The ``obstime`` to calculate the GCRS position/velocity at. Returns ------- gcrs : `~astropy.coordinates.GCRS` instance With velocity included. r )GCRSs)r)rrget_gcrs_posvelrfrom_cartesianZ differentials)r>rrrvelr"r"r#get_gcrss zEarthLocation.get_gcrsc Cs\t|}|t|}t|dtddd}t|j|j|jdd}||}||} || fS)aCalculate GCRS position and velocity given transformation matrices. The reference frame z axis must point to the Celestial Intermediate Pole (as is the case for CIRS and TETE). This private method is used in intermediate_rotation_transforms, where some of the matrices are already available for the coordinate transformation. The method is faster by an order of magnitude than just adding a zero velocity to ITRS and transforming to GCRS, because it avoids calculating the velocity via finite differencing of the results of the transformation at three separate times. ).rrHFrrm)rr OMEGA_EARTHr:r;r<Z transformZcross) r>rZ ref_to_itrsZ gcrs_to_refZ ref_to_gcrsZ itrs_to_gcrsZ rot_vec_gcrsZ itrs_cartposrr"r"r#_get_gcrs_posvels    zEarthLocation._get_gcrs_posvelcCs&ddlm}m}||||||S)a Calculate the GCRS position and velocity of this object at the requested ``obstime``. Parameters ---------- obstime : `~astropy.time.Time` The ``obstime`` to calculate the GCRS position/velocity at. Returns ------- obsgeoloc : `~astropy.coordinates.CartesianRepresentation` The GCRS position of the object obsgeovel : `~astropy.coordinates.CartesianRepresentation` The GCRS velocity of the object r )cirs_to_itrs_matgcrs_to_cirs_mat)Z/builtin_frames.intermediate_rotation_transformsrrr)r>rrrr"r"r#rs zEarthLocation.get_gcrs_posvel)sunjupitermoonc sddlmt|}d|vr&|d|dtjtjtjdt j tj d}| |g}t j t tjt j f}|D]}z,|||t jdt jd|gWqzty}ztd|d |WYd }~qzd }~0t jy} z| jd 7_WYd } ~ qzd } ~ 00qzfd d |Dfdd d dD} | t|jdd t|| D} t| d d dS)aReturn the gravitational redshift at this EarthLocation. Calculates the gravitational redshift, of order 3 m/s, due to the requested solar system bodies. Parameters ---------- obstime : `~astropy.time.Time` The ``obstime`` to calculate the redshift at. bodies : iterable, optional The bodies (other than the Earth) to include in the redshift calculation. List elements should be any body name `get_body_barycentric` accepts. Defaults to Jupiter, the Sun, and the Moon. Earth is always included (because the class represents an *Earth* location). masses : dict[str, `~astropy.units.Quantity`], optional The mass or gravitational parameters (G * mass) to assume for the bodies requested in ``bodies``. Can be used to override the defaults for the Sun, Jupiter, the Moon, and the Earth, or to pass in masses for other bodies. Returns ------- redshift : `~astropy.units.Quantity` Gravitational redshift in velocity units at given obstime. r )get_body_barycentricearthgXJ\D)rrrrrarzbody "z" does not have a mass.N)zD"masses" argument values must be masses or gravitational parameters.csg|]}|qSr"r")rJrW)rrr"r# z8EarthLocation.gravitational_redshift..csg|]}|dqS)rH)norm)rJr) positionsr"r#rrrHcSs g|]\}}| tj|qSr")constsc)rJZGMZdistancer"r"r#r r)Z solar_systemrlistremoveappendrZGM_sunZGM_jupGrOZkgZGM_earthupdaterotor{rKeyErrorrerjrrrzipsum) r>rZbodiesZmassesZ_massesZGMsZM_GM_equivalencybodyerrexcZ distancesZ redshiftsr")rrrr#gravitational_redshifts8    ,&z$EarthLocation.gravitational_redshiftcCs|dS)z.The X component of the geocentric coordinates.r:r"rr"r"r#r:&szEarthLocation.xcCs|dS)z.The Y component of the geocentric coordinates.r;r"rr"r"r#r;+szEarthLocation.ycCs|dS)z.The Z component of the geocentric coordinates.r<r"rr"r"r#r<0szEarthLocation.zcs4t|}|j|jur$||jS|tjSdSr)rr __getitem__rCr~rtrOrP)r>itemresultrsr"r#r5s   zEarthLocation.__getitem__cs"t|t|dr|j|_dSNrz)rr__array_finalize__hasattrrz)r>objrsr"r#r<s  z EarthLocation.__array_finalize__cs"|jdkrtdn tSdS)Nr"z*0-d EarthLocation arrays cannot be indexed)rD IndexErrorrr__len__rrsr"r#rAs  zEarthLocation.__len__cCsD||jtj}|gkr|j}|jj|||d}||j|j S)z"Helper method for to and to_value.) equivalencies) r~rrQZndarrayZ_equivalenciesrErrCrrD)r>rErZ array_viewZ new_arrayr"r"r# _to_valueGs zEarthLocation._to_value)N)ruN)FN)FF)N)N),r\r]r^r_rzrQrCZfloat64rqrr9rUrl classmethodrdrgrrrrpropertyr setterrrrrrrrrZitrsrrrrr:r;r<rrrr __classcell__r"r"rsr#rsl  0 . C f  1    "      " D      ra{__doc__} Parameters ---------- lon, lat : angle-like The longitude and latitude of the point(s), in angular units. The latitude should be between -90 and 90 degrees, and the longitude will be wrapped to an angle between 0 and 360 degrees. These can also be instances of `~astropy.coordinates.Angle` and either `~astropy.coordinates.Longitude` not `~astropy.coordinates.Latitude`, depending on the parameter. height : `~astropy.units.Quantity` ['length'] The height to the point(s). copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. csPeZdZdZeeejdZfddZ d fdd Z d d Z e d d Z ZS)rzBase geodetic representation.rc s*tjfi|d|jvr&|t|j<dSr)rr__init_subclass____dict__rrz)rirkrsr"r#ros z,BaseGeodeticRepresentation.__init_subclass__NTcsZ|durt||jsdtj>}tj||||d|jjtjsVt |jj ddS)Nrrmz& requires height with units of length.) r0rtrOr{rr__init__rrEZ is_equivalentZ UnitTypeErrorr\)r>rrrrFrsr"r#rts  z#BaseGeodeticRepresentation.__init__cCs,ttt|j|j|j|j}t|dddS)zs Converts WGS84 geodetic coordinates to 3D rectangular (geocentric) cartesian coordinates. rHFr)erfaZgd2gcrIrzrrrr)r>rGr"r"r#r|}s z'BaseGeodeticRepresentation.to_cartesiancCs2ttt|j|jdd\}}}||||ddS)z{ Converts 3D rectangular cartesian coordinates (assumed geocentric) to WGS84 geodetic coordinates. rHrxFrm)rZgc2gdrIrzr})riZcartrrrr"r"r#rs z)BaseGeodeticRepresentation.from_cartesian)NNT)r\r]r^r_r r rOrPZ attr_classesrrr|rrrr"r"rsr#rgs   rc@seZdZdZdZdS)rz:Representation of points in WGS84 3D geodetic coordinates.rNr\r]r^r_rzr"r"r"r#rsrc@seZdZdZdZdS)rz:Representation of points in WGS72 3D geodetic coordinates.ZWGS72Nrr"r"r"r#rsrc@seZdZdZdZdS)rz:Representation of points in GRS80 3D geodetic coordinates.ZGRS80Nrr"r"r"r#rsr)Nr)9warningsr collectionsr2r+Zurllib.requestr*Z urllib.errorZ urllib.parseZnumpyrQrZastropyrrOrrZastropy.units.quantityrZ astropy.utilsrZastropy.utils.decoratorsrZastropy.utils.exceptionsrZanglesr r r Zrepresentationr rrZmatrix_utilitiesrerrorsr__all__ namedtuplerrcycleZdayrrZdimensionless_anglesrr$r8r9rPrZgeodetic_base_docrrrrr"r"r"r#sT          'A4)