a ߙfb:@sdZddlZddlZddlZddlmZddlmZddl m Z ddl m Z ddlmZmZmZmZmZddlmZgZGd d d ZGd d d eZGd ddeZdS)z This module contains a helper function to fill erfa.astrom struct and a ScienceState, which allows to speed up coordinate transformations at the expense of accuracy. N)Time) ScienceState)AstropyWarning)get_jd12get_cipprepare_earth_position_velget_polar_motionpav2pv)rotation_matrixc@s4eZdZdZeddZeddZeddZdS) ErfaAstromz The default provider for astrometry values. A utility class to extract the necessary arguments for erfa functions from frame attributes, call the corresponding erfa functions and return the astrom object. cCs|jd\}}}|j}t|d\}}t|\}}t||} t||\} } } tjt|d} t |\}}t |drt |j tj|j tj|jj|j tj\}}nd\}}t||||| | | | | tj| tj| tj||| ||Sa Wrapper for ``erfa.apco``, used in conversions AltAz <-> ICRS and CIRS <-> ICRS Parameters ---------- frame_or_coord : ``astropy.coordinates.BaseCoordinateFrame`` or ``astropy.coordinates.SkyCoord`` Frame or coordinate instance in the corresponding frame for which to calculate the calculate the astrom values. For this function, an AltAz or CIRS frame is expected. WGS84ttut1pressure)r)location to_geodeticobstimerr erfasp00rera00rhasattrrefcorto_valueuhPa temperaturedeg_Crelative_humidityvalueobswlmicronapcoradianm)frame_or_coordlonlatheightrjd1_ttjd2_ttxpypspxyseraearth_pvearth_heliocentricrefarefbr8>lib/python3.9/site-packages/astropy/coordinates/erfa_astrom.pyr$"s.            zErfaAstrom.apcocCsRt|jd\}}t|jjddj|jjddj}t|j\}}t |||||S)a Wrapper for ``erfa.apcs``, used in conversions GCRS <-> ICRS Parameters ---------- frame_or_coord : ``astropy.coordinates.BaseCoordinateFrame`` or ``astropy.coordinates.SkyCoord`` Frame or coordinate instance in the corresponding frame for which to calculate the calculate the astrom values. For this function, a GCRS frame is expected. rZxyz_axis) rrr obsgeolocget_xyzr! obsgeovelrrapcs)r'r+r,Zobs_pvr4r5r8r8r9r?Ms zErfaAstrom.apcscCstjt|jd}tjt|jd}|jd\}}}|tj }|tj }t |j\}} t j |jj tjd} t|dtj dt| dtj dt| dtj dt||dtj d} | d } | d } t | | }|| d <| d }t |t | | | | | d <| d} | d} t | |  | d<t||| d<t || d<t || d<t|jtj|jtj|jj|jtj\| d<| d<| S)a1 Slightly modified equivalent of ``erfa.apio``, used in conversions AltAz <-> CIRS. Since we use a topocentric CIRS frame, we have dropped the steps needed to calculate diurnal aberration. Parameters ---------- frame_or_coord : ``astropy.coordinates.BaseCoordinateFrame`` or ``astropy.coordinates.SkyCoord`` Frame or coordinate instance in the corresponding frame for which to calculate the calculate the astrom values. For this function, an AltAz frame is expected. rrrZdtypez)Zunitr0r1).rr).rreral).rZxpl).rrC).rCrCZyplZalongZsphiZcphir6r7)rrrrrrrrrr%r npZzerosshapeZ dt_eraASTROMr Zarctan2ZsqrtZanpmZsinZcosrrrrrr r!r"r#)r'r/Zthetar(r)r*ZelongZphir-r.ZastromrabrBcr8r8r9apioasB   "   zErfaAstrom.apioN)__name__ __module__ __qualname____doc__ staticmethodr$r?rJr8r8r8r9r s * r c@sneZdZdZejejdddZddZe ddZ e d d Z e d d Z e d dZ ddZddZdS)ErfaAstromInterpolatora A provider for astrometry values that does not call erfa for each individual timestamp but interpolates linearly between support points. For the interpolation, float64 MJD values are used, so time precision for the interpolation will be around a microsecond. This can dramatically speed up coordinate transformations, e.g. between CIRS and ICRS, when obstime is an array of many values (factors of 10 to > 100 depending on the selected resolution, number of points and the time range of the values). The precision of the transformation will still be in the order of microseconds for reasonable values of time_resolution, e.g. ``300 * u.s``. Users should benchmark performance and accuracy with the default transformation for their specific use case and then choose a suitable ``time_resolution`` from there. This class is intended be used together with the ``erfa_astrom`` science state, e.g. in a context manager like this Example ------- >>> from astropy.coordinates import SkyCoord, CIRS >>> from astropy.coordinates.erfa_astrom import erfa_astrom, ErfaAstromInterpolator >>> import astropy.units as u >>> from astropy.time import Time >>> import numpy as np >>> obstime = Time('2010-01-01T20:00:00') + np.linspace(0, 4, 1000) * u.hour >>> crab = SkyCoord(ra='05h34m31.94s', dec='22d00m52.2s') >>> with erfa_astrom.set(ErfaAstromInterpolator(300 * u.s)): ... cirs = crab.transform_to(CIRS(obstime=obstime)) )time_resolutioncCs:|tjdkr(td|jjdt|tj|_ dS)N zUsing z with `time_resolution` below 10 microseconds might lead to numerical inaccuracies as the MJD-based interpolation is limited by floating point precision to about a microsecond of precision) rruswarningswarn __class__rKrdaymjd_resolution)selfrQr8r8r9__init__s zErfaAstromInterpolator.__init__cCsHt|j|j}ttt|t|g}t||jd|j dS)aH Calculate support points for the interpolation. We divide the MJD by the time resolution (as single float64 values), and calculate ceil and floor. Then we take the unique and sorted values and scale back to MJD. This will create a sparse support for non-regular input obstimes. mjd)formatscale) rDZravelr[rXuniqueZ concatenateZfloorZceilrr])rYrZ mjd_scaledZmjd_ur8r8r9_get_support_pointss z*ErfaAstromInterpolator._get_support_pointsc Cst|\}}tj|jtjd}t|jd}tdD]Z}dD].}t|j|j||d|f||d|f<q>t|j|j|d|f|d|f<q6||fS)z Calculate Earth's position and velocity. Uses the coarser grid ``support`` to do the calculation, and interpolates onto the finer grid ``obstime``. r@)r`pv.) rrDemptyrErZdt_pvrangeinterpr[)supportrZ pv_supportZheliocentric_supportr4r5Zdimkeyr8r8r9_prepare_earth_position_vels  z2ErfaAstromInterpolator._prepare_earth_position_velc Cspt|d\}}t||}t|jd}tdD]8}tdD]*}t|j|j|d||f|d||f<q>q2|S)z Calculate the Celestial-to-Intermediate rotation matrix. Uses the coarser grid ``support`` to do the calculation, and interpolates onto the finer grid ``obstime``. r)r`r`r`.) rrZc2i06arDrbrErcrdr[)rerjd1_tt_supportjd2_tt_supportZ c2i_supportZc2iZdim1Zdim2r8r8r9_get_c2i s   *zErfaAstromInterpolator._get_c2ics0td\}}t||}tfdd|DS)z Find the X, Y coordinates of the CIP and the CIO locator, s. Uses the coarser grid ``support`` to do the calculation, and interpolates onto the finer grid ``obstime``. rc3s |]}tjj|VqdSNrDrdr[).0Z cip_componentrrer8r9 'sz2ErfaAstromInterpolator._get_cip..)rrtuple)rerrhriZ cip_supportr8rnr9_get_cips  zErfaAstromInterpolator._get_cipcs t}tfdd|DS)z Find the two polar motion components in radians Uses the coarser grid ``support`` to do the calculation, and interpolates onto the finer grid ``obstime``. c3s |]}tjj|VqdSrkrl)rmZpolar_motion_componentrnr8r9ro5sz;ErfaAstromInterpolator._get_polar_motion..)r rp)rerZpolar_motion_supportr8rnr9_get_polar_motion,sz(ErfaAstromInterpolator._get_polar_motioncCs|jd\}}}|j}||}t|d\}}|||\} } |||\} } t||} | ||\}}}tj t|d}t |drt |j tj|jtj|jj|jtj\}}nd\}}t||| | |||||tj|tj|tj| | | ||Sr )rrrr_rrgrrrrrqrrrrrrrrrr r!r"r#r$r%r&)rYr'r(r)r*rrer+r,r4r5r-r.r/r0r1r2r3r6r7r8r8r9r$:s0           zErfaAstromInterpolator.apcoc Csb|j}||}|||\}}t|jjddj|jjddj}t|d\}}t |||||S)a Wrapper for ``erfa.apci``, used in conversions GCRS <-> ICRS Parameters ---------- frame_or_coord : ``astropy.coordinates.BaseCoordinateFrame`` or ``astropy.coordinates.SkyCoord`` Frame or coordinate instance in the corresponding frame for which to calculate the calculate the astrom values. For this function, a GCRS frame is expected. r:r;r) rr_rgr r<r=r!r>rrr?) rYr'rrer4r5rar+r,r8r8r9r?hs  zErfaAstromInterpolator.apcsN)rKrLrMrNrZquantity_inputrWrZr_rOrgrjrqrrr$r?r8r8r8r9rPs%      .rPc@s"eZdZdZeZeddZdS) erfa_astromz` ScienceState to select with astrom provider is used in coordinate transformations. cCst|tstdt|S)NzMust be an instance of ) isinstancer TypeError)clsr!r8r8r9validates zerfa_astrom.validateN)rKrLrMrNr Z_value classmethodrwr8r8r8r9rssrs)rNrTZnumpyrDrZ astropy.timerZastropy.utils.staterZ astropy.unitsZunitsrZastropy.utils.exceptionsrZbuiltin_frames.utilsrrrr r Zmatrix_utilitiesr __all__r rPrsr8r8r8r9s     Y