HR-eGtdZddlZddlZddlZddlmZmZddlZddl m Z ddl m Z mZddlmZmZmZddlmZmZdd lmZdd lmZdd lmZdd lmZgd ZeZ dZ!dZ"dZ#eddZ$Gdde$Z%dZ&dZ'ee&e'dGdde Z(Gdde(Z)dS)zR Framework and base classes for coordinate frames/"low-level" coordinate classes. N) defaultdict namedtuple)units)ShapedLikeNDArraycheck_broadcast) deprecated format_doc lazyproperty)AstropyDeprecationWarningAstropyWarning)representationAngle) Attribute)TransformGraph)BaseCoordinateFrameframe_transform_graph GenericFrameRepresentationMappingc|tjvrtj|}n[t|trt |tjs,t d|dttj|S)zP Return a valid representation class from ``value`` or raise exception. zRepresentation is zE but must be a BaseRepresentation class or one of the string aliases )rREPRESENTATION_CLASSES isinstancetype issubclassBaseRepresentation ValueErrorlistvalues =lib/python3.11/site-packages/astropy/coordinates/baseframe.py _get_repr_clsr#)s ((((/ t $ $ Jua>R,S,S  M M M,01I,J,J M M    Lc|tjvrtj|}n[t|trt |tjs,t d|dttj|S)z Return a valid differential class from ``value`` or raise exception. As originally created, this is only used in the SkyCoord initializer, so if that is refactored, this function my no longer be necessary. zDifferential is zC but must be a BaseDifferential class or one of the string aliases )rDIFFERENTIAL_CLASSESrrrBaseDifferentialrrr s r" _get_diff_clsr(7s &&&&u- t $ $ Jua>P,Q,Q  Ku K K,01G,H,H K K    Lr$c t|}d|i}|D]\}}|dkr3tj|d}n{|tjvrtj|}nZ|Xt |trt|tj s)tdttj|||<|S)aGet valid representation and differential classes. Parameters ---------- base : str or `~astropy.coordinates.BaseRepresentation` subclass class for the representation of the base coordinates. If a string, it is looked up among the known representation classes. **differentials : dict of str or `~astropy.coordinates.BaseDifferentials` Keys are like for normal differentials, i.e., 's' for a first derivative in time, etc. If an item is set to `None`, it will be guessed from the base class. Returns ------- repr_classes : dict of subclasses The base class is keyed by 'base'; the others by the keys of ``diffferentials``. baseNzhDifferential is {differential_type!r} but must be a BaseDifferential class or one of the string aliases ) r#itemsrr&getget_namerrrr'rr)r* differentials repr_classesnamedifferential_types r"_get_repr_classesr2Hs&   DD>L#0#6#6#8#8//  & & ! 6 : :4==??D Q Q   !"8 8 8 ! 67H I    *,d33+/1CDD+V7;A().representation_info``. differential_type : `~astropy.coordinates.BaseDifferential` subclass, str, dict, optional A differential class or dictionary of differential classes (currently only a velocity differential with key 's' is supported). This sets the expected input differential class, thereby changing the expected keyword arguments of the data passed in. For example, passing ``differential_type='cartesian'`` will make the classes expect velocity data with the argument names ``v_x, v_y, v_z`` unless overridden via ``frame_specific_representation_info``. To see this frame's names, check out ``().representation_info``. copy : bool, optional If `True` (default), make copies of the input coordinate arrays. Can only be passed in as a keyword argument. {footer} z\ *args, **kwargs Coordinate components, with names that depend on the subclass. ) componentsfootercleZdZdZdZdZiZiZfdZdddddZ dZ dZ e d Z e dBd Zed Zed Zed ZedZdZdZedZedZe dZeddde dZdCdZdDdZeeedZedZej dZe d Z!ed!Z"dCd"Z#dCd#Z$ee#Z%ee$Z&dEd%Z'dEd&Z(dEd'Z)d(Z*dFd)Z+d*Z,d+Z-d,Z.e/d-Z0d.Z1d/Z2d0Z3d1Z4fd2Z5d3Z6fd4Z7d5Z8fd6Z9d7Z:d8Z;d9Zed<Z?ed=Z@ed>ZAed?ZBed@ZCedAZDxZES)Gra The base class for coordinate frames. This class is intended to be subclassed to create instances of specific systems. Subclasses can implement the following attributes: * `default_representation` A subclass of `~astropy.coordinates.BaseRepresentation` that will be treated as the default representation of this frame. This is the representation assumed by default when the frame is created. * `default_differential` A subclass of `~astropy.coordinates.BaseDifferential` that will be treated as the default differential class of this frame. This is the differential class assumed by default when the frame is created. * `~astropy.coordinates.Attribute` class attributes Frame attributes such as ``FK4.equinox`` or ``FK4.obstime`` are defined using a descriptor class. See the narrative documentation or built-in classes code for details. * `frame_specific_representation_info` A dictionary mapping the name or class of a representation to a list of `~astropy.coordinates.RepresentationMapping` objects that tell what names and default units should be used on this frame for the components of that representation. Unless overridden via `frame_specific_representation_info`, velocity name defaults are: * ``pm_{lon}_cos{lat}``, ``pm_{lat}`` for `~astropy.coordinates.SphericalCosLatDifferential` velocity components * ``pm_{lon}``, ``pm_{lat}`` for `~astropy.coordinates.SphericalDifferential` velocity components * ``radial_velocity`` for any ``d_distance`` component * ``v_{x,y,z}`` for `~astropy.coordinates.CartesianDifferential` velocity components where ``{lon}`` and ``{lat}`` are the frame names of the angular components. Nc t|dd}t|dd}t|dd}|t|trt|dd}|t|trt|dd}|t|trt|dd}||}|d|d|d|d|dt j|d i}t|jD]1}t|tr| |j 2|j D]\}}t|tr|||< ||_ t!|d s|j|_nDt|jvr6|jd |jDvr|j|_i|_t+jd i||dS) Ndefault_representationdefault_differential"frame_specific_representation_info_default_representation_default_differential#_frame_specific_representation_infoz(Default representation for position dataz=Default representation for differential data (e.g., velocity)z*Mapping for frame-specific component namesr0c0g|]}t|ddS)r0Ngetattr).0r*s r" z9BaseCoordinateFrame.__init_subclass__..s7G G G ,0GD&$ ' 'G G G r$)rQrproperty_infer_repr_info_create_readonly_propertycopydeepcopyreversed __bases__rrupdateframe_attributes__dict__r+rhasattrr>lowerr0_frame_class_cacher:__init_subclass__get_frame_attr_defaults) r<kwargs default_repr default_diff repr_info frame_attrsbaseclskvr=s r"rbz%BaseCoordinateFrame.__init_subclass__ss$z0BaseCoordinateFrame.__init__..[sBC5'2..U[r$r z0non-scalar attributes with inconsistent shapes: rTsFr)_attr_names_with_defaults_infer_representation_representation _infer_data_datarcr+popsetattrrQappend TypeErrorr=r>rlenrvalues_no_data_shaperpopitemr.cache) selfrXrlr1argsrdr~rqfdefaultr!shapeserrkeys r"__init__zBaseCoordinateFrame.__init__.s*,&#99 !2  %%dD&99 !99;;AACC ; ;MC f}} 3cCi///&dC00s cCi222.55c::::  ,DN$;,,!&\\,,  : "(,,..F  )v;;??#.=v}}.O++%###(WvWW"## &++c****++1..*:*:1*=D''')# : !dj...J(1J,S1;D z+4e<15 DJ' ( - - - " !s E&& F0FFcH|||j|jdS||j}tj|rt |t jrd|i}nGt|trt j |}d|i}n|||jkr d|ji}nddi}t|fi|S)Nr*rsrsr*) rIrJinspectisclassrrr'rstrr&r2)rrlr1diff_clss r"ruz)BaseCoordinateFrame._infer_representations  &+<+D 7d>WXX X  &"&"=  ?, - - 2* q13 3  2 "%&7 8   )3 / / 2-.?@H!$h    &"d&AAA%($*C$D!!%(&M! !4JJ8IJJJr$cb d}d}t|}|rt|dtjs|d|d}t |dkrt d|Y|j}|dd}|t |dks|%t |dkrtd|n| }i}|j D]M\} } t |dkr|d|| <1| |vr|| || <N|r|dd|d=t|tjr d|vr|j} |dd|i|}n#t $r} |jdd|i|}n#t $rt#| } |} | D]\}}| ||} | d |jjd } | f| _| wxYwYd} ~ nd} ~ wwxYw| d}|d}i}| D]M\} } t |dkr|d|| <1| |vr|| || <N|rt/|d r d |vr|j}n#t |dkrd |vr tj} |dd|i|}n#t $r} t#| } |d} | D]\}}| ||} | d |jjd } | f| _d} ~ wwxYwt |dkr:t d |jjt |||td|r |jD]}d|x}|jvr|j|}|j|}|t:jz }||s| D]\}}||kr|}n|d D]\}}||kr|}nt|d|d|j d|d|d|j d|j d|!d|i}|S)NrzVCannot create a frame with both a representation object and other positional argumentsrsr zMultiple differentials are associated with the representation object passed in to the frame initializer. Only a single velocity differential is supported. Got: distanceTrXz __init__()z()_unit_differential d_distancez0{}.__init__ had {} remaining unhandled argumentszTCannot pass in differential component data without positional (representation) data.d_z has unit "z" with physical type "z", but z has incompatible unit "z" instead of the expected "z".rT)"rrrrryr}r|r.r,rget_representation_clsrepresentation_component_namesr+rSphericalRepresentation_unit_representation Exceptionr"get_representation_component_namesreplacer=r>rr_rRadialDifferentialformatrE_unitsurs is_equivalent physical_typewith_differentials)rrrXrdrepresentation_datadifferential_datadiffsrepresentation_cls repr_kwargsnmkwnmrepemsgnames frame_name repr_namedifferential_clsdiff_component_names diff_kwargscomp diff_compcurrent_repr_unitcurrent_diff_unit expected_unitrvalcurrent_repr_namecurrent_diff_names r"rwzBaseCoordinateFrame._infer_datas" Dzz h ZQ)=>>h $q'/"&((1++ 4yy1}}5 #.+9$)IIc4$8$8!%-#e**q..%1c%jj1nn$MEJMM"&!!> K#BHHJJ : : et99q==)-!K&&V^^)/D)9)9K& ??:t44<#J/113LMMQ"+55);)P& *<*<*V*V$*V+*V*V''     .U.@.U//!%/)4//++%   !!ff $ G G I I5:[[]]EE1J "%++i"D"DCC!kk,4>;R8V8V8VWW"% ,++++  * $::3?? #'#J#J3#O#O K399;; : : et99q==)-!K&&V^^)/D)9)9K& ,.BCC<$K77'7'J$$%%**|{/J/J'(';$ (8(8(R(Rd(Rk(R(R%%    a&&C CCCHHE16AA- I!kk)Z@@++lt~7N4R4R4RSSC!VAF  t99q==BIIN+SYY   &+<+H<  #  ,6  !,d,I1B1MMM(;(B4(H%(9(@(K%$5$;M,::=II"DDFFLLNN&&"d{{47 1 % +)-(O(O))%''&&HC #i//47 1 % 0)0LL=NLL/@/NLL 1LL"3LL"3!@ LL ,9*G LLL#6"H"H'(## #"sD F I'F76I 7B II  I" L-- N<7BN77N<c x|i}t|D]>}t|tr't |}||||<?|tjtddtddgd|tjD}|tj tddj di|tj tjz tddj di|tj tjz tdd tjtjz g|tjtd d j di|tj tjz tddj di|tj tjz tdd tjtjz g|tjtd d tjtjz tddtjtjz tddtjtjz g|tj|tj|tj|tj |tj|tj|S)Nlonlatc(i|]}|j|jSrT)r3r4rRms r"rrz8BaseCoordinateFrame._infer_repr_info..hs+   ()AJ    r$ d_lon_coslatzpm_{lon}_cos{lat}d_latzpm_{lat}rradial_velocityd_lonzpm_{lon}d_xv_xd_yv_yd_zv_zrT)tuplekeysrrr#ry setdefaultrrrSphericalCosLatDifferentialrrmasyrkmrsSphericalDifferentialCartesianDifferentialUnitSphericalRepresentationUnitSphericalCosLatDifferentialUnitSphericalDifferential)r<rg cls_or_name_clssph_component_maps r"rVz$BaseCoordinateFrame._infer_repr_infoFs  I!!1!122 = =K+s++ =%[11"+-- "<"< $  % "5% 0 02Gu2U2U V     -6q7P-Q     )%".'.CC1BCCEADL &.Z.CC1BCCQUQT\&l4EqtaczRR    #%.Z.CC1BCCQUQT\&.Z.CC1BCCQUQT\&l4EqtaczRR    #%eUAD13J??%eUAD13J??%eUAD13J??      )9Q5N+O     -y9V/W     '13J)K   r$c~d|zfd}t||t||t||dS)Nrnc$t|Sr9rP)r private_attrs r"getterz=BaseCoordinateFrame._create_readonly_property..getters4.. .r$)doc)rzrU)r< attr_namer!rrrs @r"rWz-BaseCoordinateFrame._create_readonly_propertys^Y  / / / / / \5)))YS 9 9 9:::::r$c*ttS)aCache for this frame, a dict. It stores anything that should be computed from the coordinate data (*not* from the frame attributes). This can be used in functions to store anything that might be expensive to compute but might be re-used by some other function. E.g.:: if 'user_data' in myframe.cache: data = myframe.cache['user_data'] else: myframe.cache['user_data'] = data = expensive_func(myframe.lat) If in-place modifications are made to the frame data, the cache should be cleared:: myframe.cache.clear() )rdictrs r"rzBaseCoordinateFrame.caches(4   r$cD|jtd|d|jS)z The coordinate data for this object. If this frame has no data, an `ValueError` will be raised. Use `has_data` to check if data is present on this frame object. NzThe frame object "z" does not have associated data)rxrrs r"datazBaseCoordinateFrame.datas6 : LTLLL zr$c|jduS)zA True if this frame has `data`, False otherwise. N)rxrs r"has_datazBaseCoordinateFrame.has_datas z%%r$c6|jr |jjn|jSr9)rrrprrs r"rpzBaseCoordinateFrame.shapes"&-HtyT5HHr$c*t|jSr9)r}rrs r"__len__zBaseCoordinateFrame.__len__s49~~r$c&|jo |jdkS)Nr)rsizers r"__bool__zBaseCoordinateFrame.__bool__s}.Q.r$c|jjSr9)rrrs r"rzBaseCoordinateFrame.sizes y~r$c(|jo |jjSr9)rrisscalarrs r"rzBaseCoordinateFrame.isscalars}3!33r$c*fdjDS)9Return a dict with the defaults for each frame attribute.c2i|]}|t|SrTrP)rRr0r<s r"rrz?BaseCoordinateFrame.get_frame_attr_defaults..s%JJJTgc4((JJJr$)r]r<s`r"rcz+BaseCoordinateFrame.get_frame_attr_defaultss#KJJJS5IJJJJr$z5.2rczThe {func}() {obj_type} is deprecated and may be removed in a future version. Use {alternative}() to obtain a dict of frame attribute names and default values. The fastest way to obtain the names is frame_attributes.keys()) alternativemessagec*|S)r)rcrs r"get_frame_attr_namesz(BaseCoordinateFrame.get_frame_attr_namess**,,,r$r*c.| |j|S|jS)a.The class used for part of this frame's data. Parameters ---------- which : ('base', 's', `None`) The class of which part to return. 'base' means the class used to represent the coordinates; 's' the first derivative to time, i.e., the class representing the proper motion and/or radial velocity. If `None`, return a dict with both. Returns ------- representation : `~astropy.coordinates.BaseRepresentation` or `~astropy.coordinates.BaseDifferential`. )rv)rwhichs r"rz*BaseCoordinateFrame.get_representation_clss!  '. .' 'r$cP| |jd}t|||_dS)aSet representation and/or differential class for this frame's data. Parameters ---------- base : str, `~astropy.coordinates.BaseRepresentation` subclass, optional The name or subclass to use to represent the coordinate data. s : `~astropy.coordinates.BaseDifferential` subclass, optional The differential subclass to use to represent any velocities, such as proper motion and radial velocity. If equal to 'base', which is the default, it will be inferred from the representation. If `None`, the representation will drop any differentials. Nr*r)rvr2)rr*rss r"set_representation_clsz*BaseCoordinateFrame.set_representation_clss1 <'/D0da@@@r$aeThe representation class used for this frame's data. This will be a subclass from `~astropy.coordinates.BaseRepresentation`. Can also be *set* using the string name of the representation. If you wish to set an explicit differential class (rather than have it be inferred), use the ``set_representation_cls`` method. )fgetfsetrc,|dS)a The differential used for this frame's data. This will be a subclass from `~astropy.coordinates.BaseDifferential`. For simultaneous setting of representation and differentials, see the ``set_representation_cls`` method. rs)rrs r"r1z%BaseCoordinateFrame.differential_type0s**3///r$c2||dS)N)rs)rrr!s r"r1z%BaseCoordinateFrame.differential_type;s ##e#,,,,,r$ch|jddtjkri}t tjt tjzD]}ggd||<|j D]j\}}||d |t|tr tjnd}||d |k|j D]\}}||d}||d}d|D} t!|jD]J\} }|| vrA| |} | j|| <t'| jt*r | jdks | j|| <Kt-|||d<t-|||d<||jd<tj|jd<|jdS)Nlast_reprdiff_hash)rrrrci|] }|j| SrT)r3rs r"rrz@BaseCoordinateFrame._get_representation_info..^s===qQZ===r$r7representation_info)rar,rget_reprdiff_cls_hashrrr~r& attr_classesr+r{rrrdegrN enumeraterr4rr5rr) r< repr_attrs repr_diff_clscc_clsrec_unitmappingsnmsuns comptomapimapps r"_get_representation_infoz,BaseCoordinateFrame._get_representation_info?sV  " & &';T B B&(( ) )J!%a&>&E&E&G&G!H!H4&--//LL" H H 792,F,F =) - : @ @ B BHHHAu}-g6==a@@@(25%(@(@JquudH}-g6==hGGGGH8>>@@ @ @ !/8 /8==H=== %m&@&E&E&G&GHH 6 6DAqI~~(|!%A 't'7==6 $ 0M A A%)%5CF6;3ZZ =)'25:3ZZ =)'22?H $' J$?$? ' ' Iy&C NN r$ci}||}||S|j|}|d}|d}t||D] \}}|r|||< |S)Nrr)rrr) rrrrrr repr_unitsr repr_units r""get_representation_component_unitsz6BaseCoordinateFrame.get_representation_component_unitss}66u==  #J-.>? ( ( $' J$?$? + + Iy +!*I r$Fc tj|rtd|r||}|jD]:}||jvr/||vr+t ||}|r|}|||<;|j|fddi|S)aBase for replicating a frame, with possibly different attributes. Produces a new instance of the frame using the attributes of the old frame (unless overridden) and with the data given. Parameters ---------- data : `~astropy.coordinates.BaseRepresentation` or None Data to use in the new frame instance. If `None`, it will be a data-less frame. copy : bool, optional Whether data and the attributes on the old frame should be copied (default), or passed on by reference. **kwargs Any attributes that should be overridden. zClass passed as data instead of a representation instance. If you called frame.representation, this returns the representation class. frame.data returns the instantiated object - you may want to use this instead.NrXF)rrr|rXr]rtrQr=)rrrXrdattrr!s r" _replicatezBaseCoordinateFrame._replicates( ?4  !   D$99;;D) % %D4999d&>P>Pd++)!JJLLE$t t~d999&999r$c ,|j|jfd|i|S)a Return a replica of the frame, optionally with new frame attributes. The replica is a new frame object that has the same data as this frame object and with frame attributes overridden if they are provided as extra keyword arguments to this method. If ``copy`` is set to `True` then a copy of the internal arrays will be made. Otherwise the replica will use a reference to the original arrays when possible to save memory. The internal arrays are normally not changeable by the user so in most cases it should not be necessary to set ``copy`` to `True`. Parameters ---------- copy : bool, optional If True, the resulting object is a copy of the data. When False, references are used where possible. This rule also applies to the frame attributes. **kwargs Any additional keywords are treated as frame attributes to be set on the new frame object. Returns ------- frameobj : `~astropy.coordinates.BaseCoordinateFrame` subclass instance Replica of this object, but possibly with new frame attributes. rX)r!rrrXrds r" replicatezBaseCoordinateFrame.replicates%6tty>>t>v>>>r$c |jdd|i|S)a6 Return a replica without data, optionally with new frame attributes. The replica is a new frame object without data but with the same frame attributes as this object, except where overridden by extra keyword arguments to this method. The ``copy`` keyword determines if the frame attributes are truly copied vs being references (which saves memory for cases where frame attributes are large). This method is essentially the converse of `realize_frame`. Parameters ---------- copy : bool, optional If True, the resulting object has copies of the frame attributes. When False, references are used where possible. **kwargs Any additional keywords are treated as frame attributes to be set on the new frame object. Returns ------- frameobj : `~astropy.coordinates.BaseCoordinateFrame` subclass instance Replica of this object, but without data and possibly with new frame attributes. NrXr9r!r#s r"replicate_without_dataz*BaseCoordinateFrame.replicate_without_datas!6t99$9&999r$c |j|fi|S)a Generates a new frame with new data from another frame (which may or may not have data). Roughly speaking, the converse of `replicate_without_data`. Parameters ---------- data : `~astropy.coordinates.BaseRepresentation` The representation to use as the data for the new frame. **kwargs Any additional keywords are treated as frame attributes to be set on the new frame object. In particular, `representation_type` can be specified. Returns ------- frameobj : `~astropy.coordinates.BaseCoordinateFrame` subclass instance A new object in *this* frame, with the same frame attributes as this one, but with the ``data`` as the coordinate data. r&)rrrds r" realize_framez!BaseCoordinateFrame.realize_frames*tt..v...r$cHt|trtjdt|}d}t ||}|d}d|jjvrE|dkr6|jjdj|j vr|jjdj}n#|d}n||dkrd}ntd|r|j |j |f}n |j |f}|j d |}|s|rt|jtjrot!|tjrUt|jjdtjtjtjfst+jd|j||jdn|j||j |} | re|rcfd jD} t5j| d D]%\} } | r| | | | | <&jdd d i| |r0|jjd} |j |} | r|rfd jD}t5j| d D]\} } t| tjtjfr| | jjvr:t| tjr| | jjvrc| r@t;| r0 || | || <#t<$rYwxYwjdd d i|j di|j d|<|j d|S)a Generate and return a new representation of this frame's `data` as a Representation object. Note: In order to make an in-place change of the representation of a Frame or SkyCoord object, set the ``representation`` attribute of that object to the desired new representation, or use the ``set_representation_cls`` method to also set the differential. Parameters ---------- base : subclass of BaseRepresentation or string The type of representation to generate. Must be a *class* (not an instance), or the string name of the representation class. s : subclass of `~astropy.coordinates.BaseDifferential`, str, optional Class in which any velocities should be represented. Must be a *class* (not an instance), or the string name of the differential class. If equal to 'base' (default), inferred from the base class. If `None`, all velocity information is dropped. in_frame_units : bool, keyword-only Force the representation units to match the specified units particular to this frame Returns ------- newrep : BaseRepresentation-derived object A new representation object of this frame's `data`. Raises ------ AttributeError If this object had no `data` Examples -------- >>> from astropy import units as u >>> from astropy.coordinates import SkyCoord, CartesianRepresentation >>> coord = SkyCoord(0*u.deg, 0*u.deg) >>> coord.represent_as(CartesianRepresentation) # doctest: +FLOAT_CMP >>> coord.representation_type = CartesianRepresentation >>> coord # doctest: +FLOAT_CMP znThe argument position for `in_frame_units` in `represent_as` has changed. Use as a keyword argument if needed.r*rrsNzFrame data has no associated differentials (i.e. the frame has no velocity data) - represent_as() only accepts a new representation.rzneed a distance to retrieve a cartesian representation when both radial velocity and proper motion are present, since otherwise the units cannot match.c2i|]}|t|SrTrP)rRrrs r"rrz4BaseCoordinateFrame.represent_as..s%TTTDdGD$$7$7TTTr$rrXFc2i|]}|t|SrTrP)rRrdiffs r"rrz4BaseCoordinateFrame.represent_as..s%!X!X!X$d(;(;!X!X!Xr$rT)!rboolwarningswarnr r2rr.r=_compatible_differentialsr|r>rr,rrrCartesianRepresentationrrrrUnitConversionError represent_asrrErtorr_r_differentialsr\)rr*rsin_frame_unitsr/rr cache_key cached_repr new_attrs datakwargsr new_attr_unit data_diff diffkwargsrr-s @@r"r4z BaseCoordinateFrame.represent_assmj a    MA    NA )da888 )&1 $)) ) )F{{ ',6%?@@$(9#:3#?#I  #/#4  Y!v++#  V   F"+ )II ,4nEIj!1266yAA a ; B ty!*GHH"#5q7PQQ' /47=0/By--.@BRSS)#.y--.@AA0445GHHI @^ @TTTTDOTTT +.t '@R+S+SNN'D-$N+5d+;+>+>}+M+M 4(%t~??5?J??8 < I3C8 !4889IJJ 1<1CCuC CCD'..T{;;;6:DJ' ( 3z*+I66s&M MMcddlm}|jtdt |jddrQt |drAt |dr1tj|j |j krtdtj |r$tjdt|}t |d r|j}t"|j|j}|N||jur||jSd }|||j|j|||S) a] Transform this object's coordinate data to a new frame. Parameters ---------- new_frame : coordinate-like or `~astropy.coordinates.BaseCoordinateFrame` subclass instance The frame to transform this coordinate frame into. The frame class option is deprecated. Returns ------- transframe : coordinate-like A new object with the coordinate data represented in the ``newframe`` system. Raises ------ ValueError If there is no possible transformation route. r ) ConvertErrorNz%Cannot transform a frame with no datar.obstimezYou cannot transform a frame that has velocities to another frame at a different obstime. If you think this should (or should not) be possible, please comment at https://github.com/astropy/astropy/issues/6280aTransforming a frame instance to a frame class (as opposed to another frame instance) will not be supported in the future. Either explicitly instantiate the target frame, or first convert the source frame instance to a `astropy.coordinates.SkyCoord` and use its `transform_to()` method._sky_coord_framez Cannot transform from {0} to {1})errorsr@rxrrQrr_npanyrANotImplementedErrorrrr/r0r rBr get_transformr=r)r)r new_framer@transrs r" transform_toz BaseCoordinateFrame.transform_tos{* )((((( : DEE E DI 5 5 i((  9-- t|y'8899  &B  ?9 % % $ M+ *    " I 90 1 1 3"2I%33DNIDWXX =DN** ..ty9994C,szz$.):MNNOO OuT9%%%r$ctj|r|n|j}t|j|}| ||jurdSdSdS)a Determines if this coordinate frame can be transformed to another given frame. Parameters ---------- new_frame : `~astropy.coordinates.BaseCoordinateFrame` subclass or instance The proposed frame to transform into. Returns ------- transformable : bool or str `True` if this can be transformed to ``new_frame``, `False` if not, or the string 'same' if ``new_frame`` is the same system as this object but no transformation is defined. Notes ----- A return value of 'same' means the transformation will work, but it will just give back a copy of this object. The intended usage is:: if coord.is_transformable_to(some_unknown_frame): coord2 = coord.transform_to(some_unknown_frame) This will work even if ``some_unknown_frame`` turns out to be the same frame class as ``coord``. This is intended for cases where the frame is the same regardless of the frame attributes (e.g. ICRS), but be aware that it *might* also indicate that someone forgot to define the transformation between two objects of the same frame class but with different attributes. NsameFT)rrr=rrG)rrH new_frame_clsrIs r"is_transformable_toz'BaseCoordinateFrame.is_transformable_tosX@&-_Y%?%?X YEX %33DNMRR =..vu4r$c||jvS)a Determine whether or not a frame attribute has its value because it's the default value, or because this frame was created with that value explicitly requested. Parameters ---------- attrnm : str The name of the attribute to check. Returns ------- isdefault : bool True if the attribute ``attrnm`` has its value by default, False if it was specified at creation of this frame. )rt)rattrnms r"is_frame_attr_defaultz)BaseCoordinateFrame.is_frame_attr_defaultDs"777r$curdSdSttj}ttj}|r|rtddstddrt jdt dStjr&tj fdj DStj j  j kS|s|rdStt}tt}|r1|r/rtj kSdS|s|rdStj kS)a Determine if two frame attributes are equivalent. Implemented as a staticmethod mainly as a convenient location, although conceivable it might be desirable for subclasses to override this behavior. Primary purpose is to check for equality of representations. This aspect can actually be simplified/removed now that representations have equality defined. Secondary purpose is to check for equality of coordinate attributes, which first checks whether they themselves are in equivalent frames before checking for equality in the normal fashion. This is because checking for equality with non-equivalent frames raises an error. TNFr.zTwo representation frame attributes were checked for equivalence when at least one of them has differentials. This yields False even if the underlying representations are equivalent (although this may change in future versions of Astropy)cTg|]$}t|t|k%SrTrP)rRr left_fattr right_fattrs r"rSz8BaseCoordinateFrame._frameattr_equiv..sB !T22gk46P6PPr$)rr BaseRepresentationOrDifferentialrQr/r0r r=rDallrE to_cartesianxyzris_equivalent_frame)rTrU left_is_repr right_is_repr left_is_coordright_is_coords`` r"_frameattr_equivz$BaseCoordinateFrame._frameattr_equivWs  $ $4  ;#65!*a.PQQ ";0RSS  M z?E:: g_e??  F# u+z';<< v$.$9v++--1[5M5M5O5O5SS ] 5":/BCC #K1DEE  ^ --k:: vjK7888u  n 5vjK/000r$c|j|jkrA|jD]7}|t||t||sdS8dSt |t st ddS)a Checks if this object is the same frame as the ``other`` object. To be the same frame, two objects must be the same frame class and have the same frame attributes. Note that it does *not* matter what, if any, data either object has. Parameters ---------- other : :class:`~astropy.coordinates.BaseCoordinateFrame` the other frame to check Returns ------- isequiv : bool True if the frames are the same, False if not. Raises ------ TypeError If ``other`` isn't a `~astropy.coordinates.BaseCoordinateFrame` or subclass. FTz?Tried to do is_equivalent_frame on something that isn't a frame)r=r]r_rQrrr|)rotherframe_attr_names r"rZz'BaseCoordinateFrame.is_equivalent_frames. >U_ , ,#'#8 ! !,,D/22GE?4S4S!!55!4E#677 Q 5r$c|}|}|rd|d}|rd|jjd|d|dSd|jjd|dS)Nz ()z Frame)_frame_attrs_repr _data_reprr=r>)r frameattrs data_reprs r"__repr__zBaseCoordinateFrame.__repr__s++-- OO%%  ,+j+++J  DUt~.UU:UUUUU UCt~.CCjCCC Cr$c|jsdS|jrt|jdr,t|j|jjr |jj}n|j}d|jjvr`|d}|jjd}t|tj tj tj fr|j}nd}| ||d}t|}|d\}}}|dkr|d\} }} | d } d |jD} t'| D]\} }| ||| | <|dzd | zdz| z}n|j}t|j}|d |jjzr%|t1|jjd zd }nd|z}d|jjvrK|d}d|d vrt|jdd}|dd r.s.&Fr$rezData:  zhas differentialsr r rf)rrlr_rrrr=r.rrrrrr4repr partitionsplitrr+rr,join startswithr>r}rrendswith)rrep_clsdif_clsdif_datarrjpart1rn remaindercomp_strpart2 comp_namesinvnamesrr0 data_repr_spldiffreprfrm_nmrep_nms r"rhzBaseCoordinateFrame._data_reprs} 2  #, (t/1GHH 3Z 43HNN 3)-2di---55c::923739,1'0G$$Wgd$KKDT I"+"5"5c":": E1iB%.%8%8%=%="!U%^^D11 *.*M*S*S*U*U )44==GAt$,LLt$<$ > ."3t~'>#?#?!#Cr"IJII!I-I $)) ) )%OOD11M"mB&777 23 788>>tDDA;))#..M"%!1B1B31G1G1K(L(L"LHQK&*&M&M''%''FFNFF#+1+"5"5ff"E"EHQKKB<((--5#+B<#4HRL$(IIh$7$7 b! -00Ir$cg}|jD]`}t||}t|dr|}nt |}||d|ad|S)zT Returns a string representation of the frame's attributes, if any. _astropy_repr_in_frame=ro)r]rQr_rrr{rz)r attr_strsattribute_namer attrstrs r"rgz%BaseCoordinateFrame._frame_attrs_reprs "3 < .apply_methodCs%!233 C#u|F.esf ===S4Z 8 8'2FF>S4Z((.>==r$r r)r:r;r=r_rvrXrtr]rzrQrrrxr}rr) rrrrdrr _attrr!rrr=s ``` @r"rzBaseCoordinateFrame._apply)s4 C C C C C C Cggoodn-- 4* + + >"&"6";";"="=C (,(F(K(K(M(M%) + +D$JEt555UGD%$8$89999e,,5'2..-(L//EEv%%9)<)<!Ie,,EUE**** = ($ TY//CIICI0F (03F aOV,,VAY""&(" r$c|j|jur)td|jjd|jj||st d|jt d|jt d|jdkrtd|jjd|jt d |jj|jjur3td|jjjd|jjj|jjr|jj|jjkrt d |jj D]\\}}|j|jj|jur9td|jjd|jj|jj]|j|j|<|j dS) Nz(can only set from object of same class:  vs. z0can only set frame item from an equivalent framez+can only set frame with value that has dataz"cannot set frame which has no datarTzscalar 'z/' frame object does not support item assignmentz!can only set frame if it has dataz*setitem value must have same differentials) r=r|r>rZrrxrpr6rr+rclear)ritemr!r self_diffs r" __setitem__zBaseCoordinateFrame.__setitem__vsY > 0 0/4>;R//O,//  ''.. QOPP P ; JKK K : ABB B :  34>2333  : @AA A : u{'< < <X:'0XX7<{7L7UXX  : $ z(--//5;3M3R3R3T3TTT !MNNN"&*";"A"A"C"C  Y&ek.H.M.WWW#P$.7PP ;5c:DMPPX!; 4 r$ctttt|jzt|dzS)z Override the builtin `dir` behavior to include representation names. TODO: dynamic representation transforms (i.e. include cylindrical et al.). rs)sortedsetr:__dir__rr)rr=s r"rzBaseCoordinateFrame.__dir__sb !! " "$566 7$99#>>?? @   r$c|dr||S|j}||vrB|j|j||jd}t|||}|S|d}||vrS|j|j|jdddi| d}t|j d||}|S||S)a$ Allow access to attributes on the representation and differential as found via ``self.get_representation_component_names``. TODO: We should handle dynamic representation transforms here (e.g., `.cylindrical`) instead of defining properties as below. rnNTrmrsr7rT) r{__getattribute__rrxrr4rlrQrrr.)rr rrepr diff_namess r" __getattr__zBaseCoordinateFrame.__getattr__s! ??3   /((.. .8 :  z! ##D$w+GHHHH?**()Q4)Q)QRRR D%(((((r$c`t|tstS||}|j |j|S|s9t d|d||jdu|jdukrtd|j|jkS)zEquality operator for frame. This implements strict equality and requires that the frames are equivalent and that the representation data are exactly equal. Nz5cannot compare: objects must have equivalent frames: rz9cannot compare: one frame has data and the other does not)rrNotImplementedrZrxr|r'r)rr!is_equivs r"__eq__zBaseCoordinateFrame.__eq__s %!455 "! !++E22 : %+"5O X..00XX7<7S7S7U7UXX  K4 TZ4%7 8 8K zU[((r$c2tj||kSr9)rD logical_notrs r"__ne__zBaseCoordinateFrame.__ne__ s~dem,,,r$c2ddlm}ddlm}|t j}||}|t j}||j|j |j|j }||tj S)a Computes on-sky separation between this coordinate and another. .. note:: If the ``other`` coordinate object is in a different frame, it is first transformed to the frame of this object. This can lead to unintuitive behavior if not accounted for. Particularly of note is that ``self.separation(other)`` and ``other.separation(self)`` may not give the same answer in this case. Parameters ---------- other : `~astropy.coordinates.BaseCoordinateFrame` The coordinate to get the separation to. Returns ------- sep : `~astropy.coordinates.Angle` The on-sky separation between this and the ``other`` coordinate. Notes ----- The separation is calculated using the Vincenty formula, which is stable at all locations, including poles and antipodes [1]_. .. [1] https://en.wikipedia.org/wiki/Great-circle_distance r )angular_separationr)unit) angle_utilitiesranglesrr4rrrJrrrdegree)rrarr self_unit_sphother_transformedother_unit_sphseps r" separationzBaseCoordinateFrame.separations< 877777!!!!!!))!*GHH !..t44*778UVV!  }0.2DnFX  uSqx((((r$cDddlm}t|jjt jrtd||}t|jt jrtd|j t j }|j t j }||z }|j tjkr|S||S)a Computes three dimensional separation between this coordinate and another. Parameters ---------- other : `~astropy.coordinates.BaseCoordinateFrame` The coordinate system to get the distance to. Returns ------- sep : `~astropy.coordinates.Distance` The real-space distance between these two coordinates. Raises ------ ValueError If this or the other coordinate do not have distances. r )DistancezCThis object does not have a distance; cannot compute 3d separation.zHThe other object does not have a distance; cannot compute 3d separation.) distancesrrrr=rrrrJwithout_differentialsr4r2normrrone)rrarother_in_self_systemself_car other_cardists r" separation_3dz!BaseCoordinateFrame.separation_3d9s( (''''' di)1+H I I U  %11$77 *4a6S T T 0 92244AA %  )-CCEERR %  9$**,, 9  K8D>> !r$c0|ddS)ze Shorthand for a cartesian representation of the coordinates in this object. cartesianTrmr4rs r"rzBaseCoordinateFrame.cartesiank  T BBBr$c0|ddS)zg Shorthand for a cylindrical representation of the coordinates in this object. cylindricalTrmrrs r"rzBaseCoordinateFrame.cylindricalus  t DDDr$c0|ddS)ze Shorthand for a spherical representation of the coordinates in this object. sphericalTrmrrs r"rzBaseCoordinateFrame.sphericalrr$c2|dddS)z Shorthand for a spherical representation of the positional data and a `~astropy.coordinates.SphericalCosLatDifferential` for the velocity data in this object. rsphericalcoslatTrmrrs r"rz#BaseCoordinateFrame.sphericalcoslats!  .?PT UUUr$c`d|jjvrtd|jjdS)z Shorthand for retrieving the Cartesian space-motion as a `~astropy.coordinates.CartesianDifferential` object. This is equivalent to calling ``self.cartesian.differentials['s']``. rsAFrame has no associated velocity (Differential) data information.)rr.rrrs r"velocityzBaseCoordinateFrame.velocitys; di- - -S ~+C00r$c8d|jjvrtd|ddd}|jdj}|jdj}t j|j| |j jfd|j zS) a Shorthand for the two-dimensional proper motion as a `~astropy.units.Quantity` object with angular velocity units. In the returned `~astropy.units.Quantity`, ``axis=0`` is the longitude/latitude dimension so that ``.proper_motion[0]`` is the longitudinal proper motion and ``.proper_motion[1]`` is latitudinal. The longitudinal proper motion already includes the cos(latitude) term. rsrrrTrmr)axis) rr.rr4rrrDstackr!r5r)rsphpm_lonpm_lats r" proper_motionz!BaseCoordinateFrame.proper_motions di- - -S  ->tTT"3'4"3'- HflFIIfk$:$:$@A J J JV[ X r$cd|jjvrtd|dd}|jdjS)zs Shorthand for the radial or line-of-sight velocity as a `~astropy.units.Quantity` object. rsrrTrm)rr.rr4r)rrs r"rz#BaseCoordinateFrame.radial_velocitysT di- - -S  DAA %00r$r9)r*)Nr*)F)r*F)Fr>r?r@rArIrJrKr]rbrrurw classmethodrVrWr rrUrrrprrrrrcrrrrrlr1setterrrrrrrepresentation_component_unitsr!r$r'r)r4rJrNrQ staticmethodr_rZrkrhrgrrrrrrrrrrrrrrrrrBrCs@r"rrs$$L"*,&O&O&O&O&O&h  V;V;V;V;V;pKKK8b#b#b#HZZ[Zx;;;[;!!\!*  X &&X& IIXI ///X44X4KK[KZ - N   --[  -(((((AAAA"#( # #    00X0---3=3=[3=j//\/        &.X.P%Q%Q"%-X.P%Q%Q"&:&:&:&:P????::::::///.D7D7D7D7L?&?&?&B)))V888&@1@1\@1D###J D D DJJJX$$$$KKKKKZ333j      (+(+(+T ) ) ) ) ))))8---))))))V0"0"0"dCCXCEEXECCXCVVXV 1 1X 1  X * 1 1X 1 1 1 1 1r$rc6eZdZdZdZfdZdZfdZxZS)raS A frame object that can't store data but can hold any arbitrary frame attributes. Mostly useful as a utility for the high-level class to store intermediate frame attributes. Parameters ---------- frame_attrs : dict A dictionary of attributes to be used as the frame attributes for this frame. Nci|_|D]0\}}t||j|<t|d|z|1t ddS)Nrn)r]r+rrzr:r)rrhr0defaultr=s r"rzGenericFrame.__init__sv "(..00 / /MD'*3G*<*r?r@rAr0rrrrBrCs@r"rrsq   D/// ---------r$r)*rArXrr/ collectionsrrnumpyrDastropyrr astropy.utilsrrastropy.utils.decoratorsrr r astropy.utils.exceptionsr r rDrrrr attributesrtransformationsr__all__rr#r(r2_RepresentationMappingBaserbase_doc _componentsrrrTr$r"rs. ////////<<<<<<<<JIIIIIIIIINNNNNNNN!!!!!!!!!!!!++++++   '((   "'''T(ZE F F F F F6 F F F  <  HR888Y1Y1Y1Y1Y1+Y1Y198Y1x8!-!-!-!-!-&!-!-!-!-!-r$