R1i+dZddlmZmZmZmZmZmZmZddl m Z ddl m Z m Z mZmZmZmZmZmZddlmZddlmZddlmZmZmZmZmZmZmZm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.m/Z/d Z0 d%dZ1e0ddddfdZ2 d&dZ3Gdde4Z5e5Z6Gdde5Z7Gdde5Z8Gdde5Z9Gdde5Z:Gdde5Z;dZGd!d"e5Z?d#Z@d'd$ZAy)(z>Classes representing different kinds of astronomical position.)arraycoseinsumfullreshapenan nan_to_num)framelib)ANGVELAU_MCERADDAY_SRAD2DEGpitau)reify)compute_limb_angle) _T _to_array_to_spherical_and_rates angle_betweenfrom_spherical length_ofmxmmxvrot_z to_spherical)intersect_line_and_sphere)add_aberrationadd_deflection)Time)Angle AngleRateDistanceVelocity_interpret_angleg W1sBNcV|dk(rt}n|dk(rt}nt}||||||S)Nr) Barycentric GeocentricICRF) position_auvelocity_au_per_dtcentertargetclss X/home/cursorai/projects/iching/venv/lib/python3.12/site-packages/skyfield/positionlib.pybuild_positionr5s3 { 3 {-q&& AAct|dz tz}t|dz tz}t|||} |t|j| } t | d|||S)a Build a position object from a right ascension and declination. If a specific ``distance_au`` is not provided, Skyfield returns a position vector a gigaparsec in length. This puts the position at a great enough distance that it will stand at the same right ascension and declination from any viewing position in the Solar System, to very high precision (within a few hundredths of a microarcsecond). If an ``epoch`` is specified, the input coordinates are understood to be in the dynamical system of that particular date. Otherwise, they will be assumed to be ICRS (the modern replacement for J2000). .. versionadded:: 1.21 This replaces a deprecated function ``position_from_radec()`` whose ``distance`` argument was not as well designed. v@8@N)rrrrMTr5) ra_hours dec_degrees distance_auepochr0r1r2thetaphir.s r4position_of_radecrAsc& k "U *S 0E H  $s *C eS9K %((K0 +tQ ??r6c $t|||||||S)uoDEPRECATED version of ``position_of_radec()``. Problems: * The ``distance`` parameter specifies no unit, contrary to Skyfield best practices. I have no idea what I was thinking. * The default ``distance`` is far too small, since most objects for which users specify an RA and declination are out on the celestial sphere. The hope was that users would see the length 1.0 and think, “ah, yes, that’s obviously a fake placeholder value.” But it’s more likely that users will not even check the distance, or maybe not even realize that a distance is involved. )rA)r;r<distancer>r0r1r2s r4position_from_radecrD8s " X{He 00r6c@eZdZdZdZdZdZdZ d%dZe e dfdZ e dZ dZ dZdZd Zd Zd Zed Zd&d ZdZd'dZdZdZdZd&dZdZd&dZdZdZeZ eZ!dZ"dZ#dZ$dZ%d&dZ&dZ'dZ(dZ)d Z*ed!Z+dddde,d"#fd$Z-y)(r-aAn |xyz| position and velocity oriented to the ICRF axes. The International Coordinate Reference Frame (ICRF) is a permanent reference frame that is the replacement for J2000. Their axes agree to within 0.02 arcseconds. It also supersedes older equinox-based systems like B1900 and B1950. Each instance of this class provides a ``.position`` vector and a ``.velocity`` vector that specify |xyz| coordinates along the axes of the ICRF. A specific time ``.t`` might be specified or might be ``None``. Nc||_t|x|_|_|.t |jj j t}t||_ | |jn||_ ||_ |dk(r||_ yy)Nr)r0r&positionxyzraushaperr'velocity_default_centerr1r2center_barycentric)selfr.r/r0r1r2s r4__init__z ICRF.__init___sz#+K#88   $ $T]]%5%5%;%;S A  !23 .4nd**&  Q;&*D # r6ct|dz tz}t|dz tz}t|||}|t|j|}||S)Nr8r9)rrrrr:)r3r;r<r=r>r?r@r.s r4 from_radeczICRF.from_radecks[+&.4!D(3.$[%=  ehh 4K;r6c|j|j}}t|dd}|||}|t||z }t |j |} t| |}t| |}||||S)uwConstructor: build a position from two vectors in a reference frame. * ``t`` — The :class:`~skyfield.timelib.Time` of the position. * ``frame`` — A reference frame listed at `reference_frames`. * ``distance`` — A `Distance` |xyz| vector in the given frame. * ``velocity`` — A `Velocity` ẋ,ẏ,ż vector in the given frame. _dRdt_times_RT_atN)rIau_per_dgetattrrr rotation_at) r3r0framerCrKrvatVRTs r4from_time_and_frame_vectorsz ICRF.from_time_and_frame_vectorsus|{{H--1 U/ 6 >1AC1I A !!!$ % AJ AJ1a|r6c |jj}|j}|dk(r|dk(rd}n|dk(r|dk(rd}n |dk7rd}nd }|j}|j}t |d d}| t |}t |d d}| t |}d j |||jd nd |jd nd |jd ndj ||jd Sdj |S)Nr+rz BCRSApparentr*z GCRSr-z ICRS target_namez<{0}{1} position{2}{3}{4}{5}>z and velocityz at date tz center={0}z target={0}) __class____name__r1r2rUstrformatrKr0)rNnamer1suffixr2 center_nameras r4__repr__z ICRF.__repr__s~~&& = Vq[F Z FcMF V^FFfmT:  f+KfmT:  f+K.55  ==(B&&.Bl++%B=+?+? +L++%B   ,9+?+? +L   r6cF|jj|jjz }|j |jd}n-|jj|jjz }t |||j |j |j S)z-Subtract two ICRF vectors to produce a third.N)rGrIrKrTr5r0r2)rNbodyprYs r4__sub__z ICRF.__sub__su MM  t}}// / == DMM$9A &&)?)??AaDFFDKKEEr6ct||jjdd|f|jjdd|f|j ||j |jSN)typerGrIrKrTr0r1r2)rNis r4 __getitem__zICRF.__getitem__sZtDz MM  QqS ! MM " "1Q3 ' FF1I KK KK   r6ct||jj |jj |j |j |jSro)rprGrIrKrTr0r2r1rNs r4__neg__z ICRF.__neg__sJtDz ]]    ]] # # # FF KK KK   r6cRtt|jjS)aCompute the distance from the origin to this position. The return value is a :class:`~skyfield.units.Distance` that prints itself out in astronomical units (au) but that also offers attributes ``au``, ``km``, and ``m`` if you want to access its magnitude as a number. >>> v = ICRF([1, 1, 0]) >>> print(v.distance()) 1.41421 au )r&rrGrIrts r4rCz ICRF.distances $--"2"2344r6cRtt|jjS)zCompute the magnitude of the velocity vector. >>> v = ICRF([0, 0, 0], [1, 2, 3]) >>> print(v.speed()) 3.74166 au/day )r'rrKrTrts r4speedz ICRF.speeds $--"8"89::r6cR|jjtz tz S)z3Length of this vector in days of light travel time.)rCmrrrts r4 light_timezICRF.light_times }}  1$u,,r6c\|jj}|bt|trn;t|trtd|}n|dk(r |j }n t dt|j|}t|\}}}t|dt|dt|fS) aCompute equatorial RA, declination, and distance. When called without a parameter, this returns standard ICRF right ascension and declination: >>> from skyfield.api import load >>> ts = load.timescale() >>> t = ts.utc(2020, 5, 13, 10, 32) >>> eph = load('de421.bsp') >>> astrometric = eph['earth'].at(t).observe(eph['sun']) >>> ra, dec, distance = astrometric.radec() >>> print(ra, dec, sep='\n') 03h 21m 47.67s +18deg 28' 55.3" If you instead want the coordinates referenced to the dynamical system defined by the Earth's true equator and equinox, provide a specific epoch time. >>> ra, dec, distance = astrometric.apparent().radec(epoch='date') >>> print(ra, dec, sep='\n') 03h 22m 54.73s +18deg 33' 04.5" To get J2000.0 coordinates, simply pass ``ts.J2000``. Nttdatepthe epoch= must be a Time object, a floating point Terrestrial Time (TT), or the string "date" for epoch-of-datehoursradians preferenceTrsigned) rGrI isinstancer#floatr0 ValueErrorrMrr$r&)rNr>r.r_audecras r4radecz ICRF.radecs8mm&&  %&E5)Te,& "KLLegg{3K$[1 c2bW5c$/  r6ctjj|j}t ||j j }t|\}}}t|jdd}|tt|j|z }|tz }|tz}|tz}t|ddt|dt!|fS)uzCompute hour angle, declination, and distance. Returns a tuple of two :class:`~skyfield.units.Angle` objects plus the :class:`~skyfield.units.Distance` to the target. The angles are the hour angle (±12 hours) east or west of your meridian along the ITRS celestial equator, and the declination (±90 degees) above or below it. This only works for positions whose center is a geographic location; otherwise, there is no local meridian from which to measure the hour angle. Because this declination is measured from the plane of the Earth’s physical geographic equator, it will be slightly different than the declination returned by ``radec()`` if you have loaded a :ref:`polar motion` file. The coordinates are not adjusted for atmospheric refraction near the horizon. longitudeNrT)rrrr)r itrsrVr0rrGrIrrUr1r_hadec_messagerrrr$r&)rNRrXrIr sublongtiudelonhas r4hadecz ICRF.hadecs( MM % %dff - 4==## $ ,QCdkk;5 ;^, , [[< ' b c  bbWTBc$/  r6ct|||S)uCompute (alt, az, distance) relative to the observer's horizon The altitude returned is an :class:`~skyfield.units.Angle` measured in degrees above the horizon, while the azimuth :class:`~skyfield.units.Angle` measures east along the horizon from geographic north (so 0 degrees means north, 90 is east, 180 is south, and 270 is west). By default, Skyfield does not adjust the altitude for atmospheric refraction. If you want Skyfield to estimate how high the atmosphere might lift the body's image, give the argument ``temperature_C`` either the temperature in degrees centigrade, or the string ``'standard'`` (in which case 10°C is used). When calculating refraction, Skyfield uses the observer’s elevation above sea level to estimate the atmospheric pressure. If you want to override that value, simply provide a number through the ``pressure_mbar`` parameter. ) _to_altaz)rN temperature_C pressure_mbars r4altazz ICRF.altaz7s,}m<>> from skyfield.api import load >>> ts = load.timescale() >>> t = ts.utc(2020, 4, 18) >>> eph = load('de421.bsp') >>> sun, venus, earth = eph['sun'], eph['venus'], eph['earth'] >>> e = earth.at(t) >>> s = e.observe(sun) >>> v = e.observe(venus) >>> print(s.separation_from(v)) 43deg 23' 23.1" You can also compute separations across an array of positions. >>> t = ts.utc(2020, 4, [18, 19, 20]) >>> e = earth.at(t) >>> print(e.observe(sun).separation_from(e.observe(venus))) 3 values from 43deg 23' 23.1" to 42deg 49' 46.6" rr r)rGrIlenrJrr$r)rN another_icrfurY differences r4separation_fromzICRF.separation_fromOs, MM    ! ! $ $\CL0 A~Aqww )::;Aqww );;<]1a011r6ct|trn;t|trtd|}n|dk(r |j}n t dt |j |jj}t|S)aOCompute cartesian CIRS coordinates at a given epoch |xyz|. Calculate coordinates in the Celestial Intermediate Reference System (CIRS), a dynamical coordinate system referenced to the Celestial Intermediate Origin (CIO). As this is a dynamical system it must be calculated at a specific epoch. Nr}rr) rr#rr0rrrrGrIr&)rNr>vectors r4cirs_xyzz ICRF.cirs_xyzuss eT "  u %%(E f_FFEGH HUWWdmm../r6ct|j|j\}}}t|dt|dt |fS)aYGet spherical CIRS coordinates at a given epoch (ra, dec, distance). Calculate coordinates in the Celestial Intermediate Reference System (CIRS), a dynamical coordinate system referenced to the Celestial Intermediate Origin (CIO). As this is a dynamical system it must be calculated at a specific epoch. rrTr)rrrIr$r&)rNr>rrrs r4 cirs_radeczICRF.cirs_radecsH%T]]5%9%<%<= c2bW5c$/  r6c||jtjSt||jtjSro) frame_xyzr ecliptic_J2000_frame_Fakeecliptic_framerNr>s r4 ecliptic_xyzzICRF.ecliptic_xyzs: =>>("?"?@ @T5!++H,C,CDDr6cF|jtjdS)Nr )frame_xyz_and_velocityr rrts r4ecliptic_velocityzICRF.ecliptic_velocitys**8+H+HI!LLr6c||jtjSt||jtjSro) frame_latlonr rrrrs r4ecliptic_latlonzICRF.ecliptic_latlons< =$$X%B%BC CT5!..x/F/FGGr6c@|jtjSro)rr galactic_framerts r4 galactic_xyzzICRF.galactic_xyzs4>>(2I2I#JJr6c@|jtjSro)rr rrts r4galactic_latlonzICRF.galactic_latlonsd&7&78O8O&PPr6ctt|j|j|jj S)zReturn this position as an |xyz| vector in a reference frame. Returns a :class:`~skyfield.units.Distance` object giving the |xyz| of this position in the given ``frame``. See `reference_frames`. )r&rrVr0rGrI)rNrWs r4rzICRF.frame_xyzs/E--dff5t}}7G7GHIIr6cL|j|j}|jj|jj }}t ||}t ||}t|dd}|!||j}|t ||z }t|t|fS)aEReturn |xyz| position and velocity vectors in a reference frame. Returns two vectors in the given coordinate ``frame``: a :class:`~skyfield.units.Distance` providing an |xyz| position and a :class:`~skyfield.units.Velocity` giving (xdot,ydot,zdot) velocity. See `reference_frames`. rSN) rVr0rGrIrKrTrrUr&r')rNrWrrXrYrZr[s r4rzICRF.frame_xyz_and_velocitys   dff %}}!7!71 1I 1I U/ 6 >466 A QNA{HQK''r6ct|j|j|jj}t |\}}}t |dt |t|fS)a*Return longitude, latitude, and distance in the given frame. Returns a 3-element tuple giving the latitude and longitude as :class:`~skyfield.units.Angle` objects and the range to the target as a :class:`~skyfield.units.Distance`. See `reference_frames`. Trr)rrVr0rGrIrr$r&)rNrWrdlatrs r4rzICRF.frame_latlons\U&&tvv. 0@0@A"6* 3c$/c"  r6c*|j|\}}|j}|j}t||\}}}}}} t |dt |t |t j|t j| t|fS)uReturn a reference frame longitude, latitude, range, and rates. Return a 6-element tuple of 3 coordinates and 3 rates-of-change for this position in the given reference ``frame``: * Latitude :class:`~skyfield.units.Angle` from +90° north to −90° south * Longitude :class:`~skyfield.units.Angle` 0°–360° east * Radial :class:`~skyfield.units.Distance` * Latitude :class:`~skyfield.units.AngleRate` * Longitude :class:`~skyfield.units.AngleRate` * Radial :class:`~skyfield.units.Velocity` If the reference frame is the ICRS, or is J2000, or otherwise involves the celestial equator and pole, then the latitude and longitude returned will measure what are more commonly called “declination” and “right ascension”. Note that right ascension is usually expressed as hours (24 in a circle), rather than in the degrees that this routine will return. Trr) rrIrTrr$r&r%_from_radians_per_dayr') rNrWrXrYrrrd_ratelat_ratelon_rates r4frame_latlon_and_rateszICRF.frame_latlon_and_ratess***511 DD JJ2I!Q2O/3VXxc$/c" //9//9 " "r6cDddlm}ddlm}|jdk(rd}n[|jdk(r(ddlm}||j j}n$tdj|j|jj\}}}||d |||| S) zConvert this distance to an AstroPy ``SkyCoord`` object. Currently, this will only work with Skyfield positions whose center is the Solar System barycenter or else the geocenter. r)SkyCoordrIicrsr*)GCRS)obstimezSkyfield can only return AstroPy positions for barycentric and geocentric coordinates; if you are interested in adding support for positions whose center={}, please open an issue cartesian)rWrepresentation_typeunitxyz) astropy.coordinatesr astropy.unitsrIr1rr0 to_astropyNotImplementedErrorrerG) rNrrrIrWrrrrs r4 to_skycoordzICRF.to_skycoords 1$ ;;! E [[C  0!2!2!45E%O $  --""1ae1Q0 0r6c|j|j}|jj}||jjz |jjjz}t t ||S)uBReturn this position’s phase angle: the angle Sun-target-observer. Given a Sun object (which you can build by loading an ephemeris and looking up ``eph['Sun']``), return the `Angle` from the body's point of view between light arriving from the Sun and the light departing toward the observer. This angle is 0° if the observer is in the same direction as the Sun and sees the body as fully illuminated, and 180° if the observer is behind the body and sees only its dark side. .. versionadded:: 1.42 r)rZr0rGrIrMr$r)rNsunsrrYs r4 phase_anglezICRF.phase_angles_ FF466N MM     7 7 @ @ C C C]1a011r6cZ|j|j}ddt|zzS)ujReturn the fraction of the target’s disc that is illuminated. Given a Sun object (which you can build by loading an ephemeris and looking up ``eph['Sun']``), compute what fraction from 0.0 to 1.0 of this target’s disc is illuminated, under the assumption that the target is a sphere. .. versionadded:: 1.42 g??)rrr)rNras r4fraction_illuminatedzICRF.fraction_illuminated)s-   S ! ) )cCFl##r6c~|jdk(r|jj }n:|j}| t d|jj |t zz }|d|dz j |jjj}t||z|t\}}t|dkS)uReturn whether a position in Earth orbit is in sunlight. Returns ``True`` or ``False``, or an array of such values, to indicate whether this position is in sunlight or is blocked by the Earth’s shadow. It should work with positions produced either by calling ``at()`` on a satellite object, or by calling ``at()`` on the relative position ``sat - topos`` of a satellite with respect to an Earth observer’s position. See :ref:`satellite-is-sunlit`. r*z+cannot tell whether this position is sunlitrearthr) r1rGrz_observer_gcrs_aurr rZr0r rr )rN ephemerisearth_m gcrs_positionsun_mnearfars r4 is_sunlitzICRF.is_sunlit7s ;;#  'G 22M$ !NOO '-$*>>G5!Ig$66::466BKKMM-egowM c#!##r6c|j}| td| tz}|jj}t ||t \}}t|}t|dkDt||kzS)zReturn whether the Earth blocks the view of this object. For a position centered on an Earth-orbiting satellite, return whether the target is in eclipse behind the disc of the Earth. See :ref:`is-behind-earth`. zQcan only compute Earth occultation for positions observed from an Earth satelliter) rrr rGrzr rrr )rNobserver_gcrs_aurvector_mrrlength_ms r4is_behind_earthzICRF.is_behind_earthOs 11  #KL L$$t+==??-hF cX&3!# 4(88(CDDr6cvt|jdd}|tt||jS)NrV)rUr2r_altaz_messager0)rNrVs r4_altaz_rotationzICRF._altaz_rotationas6 dkk=$?  ^, ,466""r6g?rc t|jdd}|tt||j}t d||}t d||}|j }t|||} td|| } t| S)a:Generate an Apparent position from an altitude and azimuth. The altitude and azimuth can each be provided as an `Angle` object, or else as a number of degrees provided as either a float or a tuple of degrees, arcminutes, and arcseconds:: alt=Angle(...), az=Angle(...) alt_degrees=23.2289, az_degrees=142.1161 alt_degrees=(23, 13, 44.1), az_degrees=(142, 6, 58.1) The distance should be a :class:`~skyfield.units.Distance` object, if provided; otherwise a default of 0.1 au is used. rVNaltazzji...,j...->i...) rUr2rrr0r(rIrrr_) rNrr alt_degrees az_degreesrCrVrrXrls r4 from_altazzICRF.from_altazks$dkk=$?  ^, ,  uc;7 dB 3 KK 1c2 & %q! ,{r6NNNNro)Nstandard).rc __module__ __qualname____doc__rMrrL _ephemerisrO classmethod_GIGAPARSEC_AUrQr]rirmrrrurCrxrr{rrrrrrrrrrrecliptic_positiongalactic_positionrrrrrrrrrrr&rr6r4r-r-Ls/ OJ>B%) +-T  & @F   5; - -, \ D=0"2L ,  "EMH KP$$J(& "@042* $$0E$ # #"d$,r6r-ceZdZdZy) GeometricaAn |xyz| vector between two instantaneous position. A geometric position is the difference between the Solar System positions of two bodies at exactly the same instant. It is *not* corrected for the fact that, in real physics, it will take time for light to travel from one position to the other. Both the ``.position`` and ``.velocity`` are |xyz| vectors oriented along the axes of the International Celestial Reference System (ICRS), the modern replacement for J2000 coordinates. Nrcrrrrr6r4rrs r6rceZdZdZdZdZy)r+uTAn |xyz| position measured from the Solar System barycenter. Skyfield generates a `Barycentric` position measured from the gravitational center of the Solar System whenever you ask a body for its location at a particular time: >>> t = ts.utc(2003, 8, 29) >>> mars.at(t) This class’s ``.position`` and ``.velocity`` are |xyz| vectors in the Barycentric Celestial Reference System (BCRS), the modern replacement for J2000 coordinates measured from the Solar System Barycenter. rc|j|\}}}}t||||j|j}|j|_||_||_|S)aCompute the `Astrometric` position of a body from this location. To compute the body's astrometric position, it is first asked for its position at the time `t` of this position itself. The distance to the body is then divided by the speed of light to find how long it takes its light to arrive. Finally, the light travel time is subtracted from `t` and the body is asked for a series of increasingly exact positions to learn where it was when it emitted the light that is now reaching this position. >>> earth.at(t).observe(mars) )_observe_from_bcrs Astrometricr2rrMr{)rNrkrlrYr0r{ astrometrics r4observezBarycentric.observesY#55d;1a!!Q4;; D !% )- &!+ r6N)rcrrrrLr rr6r4r+r+s Or6r+ceZdZdZdZdZy)r aAn astrometric |xyz| position relative to a particular observer. The astrometric position of a body is its position relative to an observer, adjusted for light-time delay. It is the position of the body back when it emitted (or reflected) the light that is now reaching the observer's eye or telescope. Astrometric positions are usually generated in Skyfield by calling the `Barycentric` method `observe()`, which performs the light-time correction. Both the ``.position`` and ``.velocity`` are |xyz| vectors oriented along the axes of the ICRF, the modern replacement for the J2000 reference frame. It is common to either call ``.radec()`` (with no argument) on an astrometric position to generate an *astrometric place* right ascension and declination with respect to the ICRF axes, or else to call ``.apparent()`` to generate an :class:`Apparent` position. ctd)Nzwit is not useful to call .altaz() on an astrometric position; try calling .apparent() first to get an apparent position)rrts r4rzAstrometric.altazs I  r6c|j}|jjj}|j}|jj}|j j }|j}t|jt|jkrD|jdz}|j|}|j|}||j|}| td}nt||\} } | dk\}t|||j||t|||j |j j } |  t#|| ||j$|j&} |j| _|| _| S)aCompute an :class:`Apparent` position for this body. This applies two effects to the position that arise from relativity and shift slightly where the other body will appear in the sky: the deflection that the image will experience if its light passes close to large masses in the Solar System, and the aberration of light caused by the observer's own velocity. >>> earth.at(t).observe(mars).apparent() These transforms convert the position from the BCRS reference frame of the Solar System barycenter and to the reference frame of the observer. In the specific case of an Earth observer, the output reference frame is the GCRS. rFg?)r0rGrIcopyrMrKrTrrrJrrrr"rr!r{r_r1r2) rNr0 target_aucb bcrs_position bcrs_velocityrrJinclude_earth_deflection limb_angle nadir_anglerYapparents r4rzAstrometric.apparentsd$ FFMM$$))+  $ $   ,, // }"" #c)//&: :!''$.E)11%8M)11%8M+#3#;#;E#B  #',X $&8+'- #J '2c'9 $y-+C E y-A MM " " = Iq!T[[$++F&*&=&=#%5"r6N)rcrrrrrrr6r4r r s& 8r6r ceZdZdZy)r_uAn apparent |xyz| position relative to a particular observer. This class’s vectors provide the position and velocity of a body relative to an observer, adjusted to predict where the body’s image will really appear (hence "apparent") in the sky: * Light-time delay, as already present in an `Astrometric` position. * Deflection: gravity bends light, and thus the image of a distant object, as the light passes massive objects like Jupiter, Saturn, and the Sun. For an observer on the Earth’s surface or in Earth orbit, the slight deflection by the gravity of the Earth itself is also included. * Aberration: incoming light arrives slanted because of the observer's motion through space. These positions are usually produced in Skyfield by calling the `apparent()` method of an `Astrometric` object. Both the ``.position`` and ``.velocity`` are |xyz| vectors oriented along the axes of the ICRF, the modern replacement for the J2000 reference frame. If the observer is at the geocenter, they are more specifically GCRS coordinates. Two common coordinates that this vector can generate are: * *Proper place:* call ``.radec()`` without arguments to compute right ascension and declination with respect to the fixed axes of the ICRF. * *Apparent place,* the most popular option: call ``.radec('date')`` to generate right ascension and declination with respect to the equator and equinox of date. Nrrr6r4r_r_s"r6r_c eZdZdZdZdZdZy)r,a,An |xyz| position measured from the center of the Earth. A geocentric position is the difference between the position of the Earth at a given instant and the position of a target body at the same instant, without accounting for light-travel time or the effect of relativity on the light itself. Its ``.position`` and ``.velocity`` vectors have |xyz| axes that are those of the Geocentric Celestial Reference System (GCRS), an inertial system that is an update to J2000 and that does not rotate with the Earth itself. r*c@|jtjS)zODeprecated; instead, call ``.frame_xyz(itrs)``. See `reference_frames`.)rr rrts r4itrf_xyzzGeocentric.itrf_xyzPs~~hmm,,r6c0ddlm}|j|S)z_Deprecated; instead, call either ``iers2010.subpoint(pos)`` or ``wgs84.subpoint(pos)``.r )iers2010)toposlibrsubpoint)rNrs r4r zGeocentric.subpointUs '  &&r6N)rcrrrrLrr rr6r4r,r,@s O- 'r6r,c|j}| |j}n:t|jd}|||j}nt t t||jj}t|\}}} | t|}nLt|jdd} | t t |jj|tz||}|t| t|fS)z?Compute (alt, az, distance) relative to the observer's horizon.NrVrrefract)rMrrUr1r0rrrrGrIrr$r"rr&) rGrrrrrVr.rrrr"s r4rr[s  $ $B ~   hoo}=  "HJJ'A^, ,a**--.K -MD#rC (//9d; ?^, ,oo%% 'M=-  b!8D> 11r6ueto compute a body’s hour angle, you must observe it from a specific latitude and longitude on Earthzto compute altitude and azimuth, you must observe it from a specific latitude and longitude on Earth, or else from a location on another Solar System body that you have loaded from a set of planetary constantsceZdZdZy)rc|j|_t|tr||_yt|trtd||_y|dk(r|j|_yt d)Nr}rr)rGrr#r0rr)rNoriginalr>s r4rOz_Fake.__init__s_ )) eT "DF u %$5)DF f_ZZDFGH Hr6N)rcrrrOrr6r4rrs Hr6rcftttjj ||Sro)rrr rrV)r0rITRFs r4 ITRF_to_GCRSr(s# r(--++A./ 77r6ct|}t|}|r`dtz }|jj|j|j |z}|j |j z dz tz}nt}t|j dz tz} t|j| } d|z} t| t |z| ft|z| | f| | | ff} |t| |z}t| |}t| |}||fS)Nrr9g) rrtstt_jdwhole tt_fractiongastrr rrr:r) r0r'vITRF_high_accuracyrGrK _one_secondt_laterangvelspinrrr[s r4 ITRF_to_GCRS2r5sU|HU|HEk $$**QWWammk&AB,,'4/#5 $$ %D ADD$A f A E6F?1 ! 1Q A #a**H1hH1hH X r6r)rNNNNr)Brnumpyrrrrrrr r`r constantsr r rrrrrr descriptorlibrearthlibr functionsrrrrrrrrrrgeometryr relativityr!r"timelibr#unitsr$r%r&r'r(rr5rArDobjectr-ICRSrr+r r_r,rrrrr(r5rr6r4rAsDDDDEEE (06II#:>'+B:H Dd@4DH480({6{~   '$'XR$Rh#t#J''6287 P HD H8!r6