a ߙfbp|@sddlZddlmZddlmZddlZddlm Z ddl m Z m Z m Z mZddlmZddlmZmZddlmZdgZGd d d eZGd d d eZejejZe eZe gd eZdejZ dgZ!ddZ"ddZ#ddZ$dddZ%ddZ&ddZ'GdddeZ(dS)N)indent)c)ICRSCartesianDifferentialCartesianRepresentationSkyCoord)SpectralQuantity)BaseCoordinateFrameframe_transform_graph)AstropyUserWarning SpectralCoordc@s eZdZdS)NoVelocityWarningN__name__ __module__ __qualname__rrFlib/python3.9/site-packages/astropy/coordinates/spectral_coordinate.pyr sr c@s eZdZdS)NoDistanceWarningNrrrrrrsr)rrrg.AzSpectralCoord.*cCs"|t}td|d|dS)z8 Convert a velocity to a relativistic redshift. )C_KMSnpsqrt)velocitybetarrr_velocity_to_redshift%srcCs d|d}t|d|dS)z8 Convert a relativistic redshift to a velocity. r)r)redshiftZzponesqrrr_redshift_to_velocity-s rcCs|t}|t}td|d|}|jtjr>||S|jtj sl|jtj sl|jdtjrt||S|jt r| tj | |jSt d|jddS)a Given a `SpectralQuantity` and a velocity, return a new `SpectralQuantity` that is Doppler shifted by this amount. Note that the Doppler shift applied is the full relativistic one, so `SpectralQuantity` currently expressed in velocity and not using the relativistic convention will temporarily be converted to use the relativistic convention while the shift is applied. Positive velocities are assumed to redshift the spectral quantity, while negative velocities blueshift the spectral quantity. rz$Unexpected units in velocity shift: zM. This should not happen, so please report this in the astropy issue tracker!N)viewrrrrunit is_equivalentumZHzZeVKMSto RuntimeError)ZscoordrZ squantityrZdoppler_factorrrr!_apply_relativistic_doppler_shift5s   r'Fc Cs|jjstdd|jvr2t|dr2|j|jd}|t}|t}|j t t j}|j t  |}| |}|r||}n ||}|jt t dS)a Given an original coordinate object, update the differentials so that the final coordinate is at the same location as the original coordinate but co-moving with the velocity reference object. If preserve_original_frame is set to True, the resulting object will be in the frame of the original coordinate, otherwise it will be in the frame of the velocity reference. z!Reference frame has no velocitiesobstime)r(Zrepresentation_typeZdifferential_type)data differentials ValueErrorZframe_attributeshasattr replicater( transform_torZ represent_asrrwith_differentials realize_frame) ZoriginalZvelocity_referencepreserve_observer_frameZ original_icrsZvelocity_reference_icrsr+Zdata_with_differentialsZ final_icrsfinalrrrupdate_differentials_to_matchXs&       r4cCs|jt}||S)zH Set the differentials to be stationary on a coordinate object. ) cartesianr0ZERO_VELOCITIESr1)coordnew_datarrrattach_zero_velocitiess r9cCsd|jjvr|jStSdS)Ns)r*r+rr6)r7rrr_get_velocitiess r;c seZdZdZejejejdd'fdd ZfddZ e d(d d Z d)d d Z e ddZe ddZejddZe ddZejddZe ddZe ddZe d*ddZe ddZejejejdd+dd Zd,d!d"Zd#d$Zd%d&ZZS)-r a A spectral coordinate with its corresponding unit. .. note:: The |SpectralCoord| class is new in Astropy v4.1 and should be considered experimental at this time. Note that we do not fully support cases where the observer and target are moving relativistically relative to each other, so care should be taken in those cases. It is possible that there will be API changes in future versions of Astropy based on user feedback. If you have specific ideas for how it might be improved, please let us know on the `astropy-dev mailing list`_ or at http://feedback.astropy.org. Parameters ---------- value : ndarray or `~astropy.units.Quantity` or `SpectralCoord` Spectral values, which should be either wavelength, frequency, energy, wavenumber, or velocity values. unit : unit-like Unit for the given spectral values. observer : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`, optional The coordinate (position and velocity) of observer. If no velocities are present on this object, the observer is assumed to be stationary relative to the frame origin. target : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`, optional The coordinate (position and velocity) of target. If no velocities are present on this object, the target is assumed to be stationary relative to the frame origin. radial_velocity : `~astropy.units.Quantity` ['speed'], optional The radial velocity of the target with respect to the observer. This can only be specified if ``redshift`` is not specified. redshift : float, optional The relativistic redshift of the target with respect to the observer. This can only be specified if ``radial_velocity`` cannot be specified. doppler_rest : `~astropy.units.Quantity`, optional The rest value to use when expressing the spectral value as a velocity. doppler_convention : str, optional The Doppler convention to use when expressing the spectral value as a velocity. )radial_velocityNc  stj||fd|i|}|durB|durB|dus:|durBtd|dur|durZtdt|}|jtjs|tdt |}|durt |dd}|durt |dd}|dus|dur|durt |dd}||_ |j |dd|_ |j |dd|_|S) Nr zTCannot specify radial velocity or redshift if both target and observer are specifiedz.Cannot set both a radial velocity and redshiftz redshift should be dimensionlessobservertargetr<label)super__new__r,r"Quantityr r!one UnitsErrorrgetattr_radial_velocity_validate_coordinate _observer_target) clsvaluer r=r>r<rkwargsobj __class__rrrBs,      zSpectralCoord.__new__cs:t|t|dd|_t|dd|_t|dd|_dS)NrGrIrJ)rA__array_finalize__rFrGrIrJ)selfrNrOrrrQs z SpectralCoord.__array_finalize__cCs|dur dSt|jts8t|tr*|j}nt|dtjddt |dd}Wdn1sf0Y|dur|j j dkrt|t d}t dt d td |jjvrt d td tt|}|S) ad Checks the type of the frame and whether a velocity differential and a distance has been defined on the frame object. If no distance is defined, the target is assumed to be "really far away", and the observer is assumed to be "in the solar system". Parameters ---------- coord : `~astropy.coordinates.BaseCoordinateFrame` The new frame to be used for target or observer. label : str, optional The name of the object being validated (e.g. 'target' or 'observer'), which is then used in error messages. Nz0 must be a SkyCoord or coordinate frame instanceignore)alldistance dimensionless)rVzODistance on coordinate object is dimensionless, an arbitrary distance value of z will be set instead.r:z'No velocity defined on frame, assuming .) issubclassrPr isinstancerframe TypeErrorrZerrstaterFr physical_typeDEFAULT_DISTANCEwarningswarnrr*r+r6r r9)r7r@rVrrrrHs.  *   z"SpectralCoord._validate_coordinateFc Cst|tjr,|durtdn|j|j}}|dur8|n|j}|pF|j}||pV|j}||pf|j}|pp|j }|pz|j }| r| }|jdus|jdur|dur|dur|j }t 8t dt|j||||||||dd WdS1s0YdS)a Return a replica of the `SpectralCoord`, optionally changing the values or attributes. Note that no conversion is carried out by this method - this keeps all the values and attributes the same, except for the ones explicitly passed to this method which are changed. If ``copy`` is set to `True` then a full copy of the internal arrays will be made. By default the replica will use a reference to the original arrays when possible to save memory. Parameters ---------- value : ndarray or `~astropy.units.Quantity` or `SpectralCoord`, optional Spectral values, which should be either wavelength, frequency, energy, wavenumber, or velocity values. unit : unit-like Unit for the given spectral values. observer : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`, optional The coordinate (position and velocity) of observer. target : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord`, optional The coordinate (position and velocity) of target. radial_velocity : `~astropy.units.Quantity` ['speed'], optional The radial velocity of the target with respect to the observer. redshift : float, optional The relativistic redshift of the target with respect to the observer. doppler_rest : `~astropy.units.Quantity`, optional The rest value to use when expressing the spectral value as a velocity. doppler_convention : str, optional The Doppler convention to use when expressing the spectral value as a velocity. copy : bool, optional If `True`, and ``value`` is not specified, the values are copied to the new `SkyCoord` - otherwise a reference to the same values is used. Returns ------- sc : `SpectralCoord` object Replica of this object Nz8Cannot specify value as a Quantity and also specify unitrTF) rLr r=r>r<rdoppler_convention doppler_restcopy)rZr"rCr,rLr rHr=r>rarbrcr<r_catch_warnings simplefilterr rP) rRrLr r=r>r<rrarbrcrrrr.,s*.     $  zSpectralCoord.replicatecCs |tjS)a Convert the ``SpectralCoord`` to a `~astropy.units.Quantity`. Equivalent to ``self.view(u.Quantity)``. Returns ------- `~astropy.units.Quantity` This object viewed as a `~astropy.units.Quantity`. )rr"rCrRrrrquantityws zSpectralCoord.quantitycCs|jS)a> The coordinates of the observer. If set, and a target is set as well, this will override any explicit radial velocity passed in. Returns ------- `~astropy.coordinates.BaseCoordinateFrame` The astropy coordinate frame representing the observation. )rIrfrrrr=s zSpectralCoord.observercCs6|jdurtd|j|dd|_|jdur2d|_dS)Nzobserver has already been setr=r?)r=r,rHrIrJrGrRrLrrrr=s   cCs|jS)aI The coordinates of the target being observed. If set, and an observer is set as well, this will override any explicit radial velocity passed in. Returns ------- `~astropy.coordinates.BaseCoordinateFrame` The astropy coordinate frame representing the target. )rJrfrrrr>s zSpectralCoord.targetcCs6|jdurtd|j|dd|_|jdur2d|_dS)Nztarget has already been setr>r?)r>r,rHrJrIrGrhrrrr>s   cCsF|jdus|jdur.|jdur&dtS|jSn|j|j|jddSdS)a Radial velocity of target relative to the observer. Returns ------- `~astropy.units.Quantity` ['speed'] Radial velocity of target. Notes ----- This is different from the ``.radial_velocity`` property of a coordinate frame in that this calculates the radial velocity with respect to the *observer*, not the origin of the frame. NrT as_scalar)rIrJrGr$_calculate_radial_velocityrfrrrr<s  zSpectralCoord.radial_velocitycCs t|jS)z Redshift of target relative to observer. Calculated from the radial velocity. Returns ------- float Redshift of target. )rr<rfrrrrs zSpectralCoord.redshiftcCsN|t}|t}t||}|j|j}||}|rB|S||SdS)az Compute the line-of-sight velocity from the observer to the target. Parameters ---------- observer : `~astropy.coordinates.BaseCoordinateFrame` The frame of the observer. target : `~astropy.coordinates.BaseCoordinateFrame` The frame of the target. as_scalar : bool If `True`, the magnitude of the velocity vector will be returned, otherwise the full vector will be returned. Returns ------- `~astropy.units.Quantity` ['speed'] The radial velocity of the target with respect to the observer. N)r/rr _normalized_position_vectorrdot)r=r>rj observer_icrs target_icrspos_hatZd_velZvel_magrrrrks     z(SpectralCoord._calculate_radial_velocitycCs:|j|j}|}d|j||dk<||}|S)a Calculate the normalized position vector between two frames. Parameters ---------- observer : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord` The observation frame or coordinate. target : `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord` The target frame or coordinate. Returns ------- pos_hat : `BaseRepresentation` Position representation. rr)r5Zwithout_differentialsZnormr )r=r>Zd_posZdp_normrprrrrlsz)SpectralCoord._normalized_position_vector)rc Cs|jdus|jdurtdt|tr,|j}t|tr|js`|t dt j dt j dt j }|j j rz|durtdn(|durt}nt|}||j |}t|ttfrRt|tr|}nt|trt|}|durdt jt jdt jt jdt jt jf}n|jdkr$td|dt jdt jdt jg|Rddd}t|j||d }|j|j|jd d }|j||jd d }t|||} |j| |d } | S) aL A new `SpectralCoord` with the velocity of the observer altered, but not the position. If a coordinate frame is specified, the observer velocities will be modified to be stationary in the specified frame. If a coordinate instance is specified, optionally with non-zero velocities, the observer velocities will be updated so that the observer is co-moving with the specified coordinates. Parameters ---------- frame : str, `~astropy.coordinates.BaseCoordinateFrame` or `~astropy.coordinates.SkyCoord` The observation frame in which the observer will be stationary. This can be the name of a frame (e.g. 'icrs'), a frame class, frame instance with no data, or instance with data. This can optionally include velocities. velocity : `~astropy.units.Quantity` or `~astropy.coordinates.CartesianDifferential`, optional If ``frame`` does not contain velocities, these can be specified as a 3-element `~astropy.units.Quantity`. In the case where this is also not specified, the velocities default to zero. preserve_observer_frame : bool If `True`, the final observer frame class will be the same as the original one, and if `False` it will be the frame of the velocity reference class. Returns ------- new_coord : `SpectralCoord` The new coordinate object representing the spectral data transformed based on the observer's new velocity frame. NzZThis method can only be used if both observer and target are defined on the SpectralCoord.rz=frame already has differentials, cannot also specify velocity)z4velocity should be a Quantity vector with 3 elementsr5r))r2Tri)rLr=)r=r>r,rZrr[r Zhas_datar1rr"kmr*r+r6rr0typestrr Z lookup_namer#r:shaper4rkr'r.) rRr[rr2r+Z frame_clsr= init_obs_vel fin_obs_velr8Z new_coordrrr$with_observer_stationary_relative_to#sJ#  $     0 z2SpectralCoord.with_observer_stationary_relative_tocCs|dur$|jdus|jdur$tddd||fDD],}t|tjr6|jtjt fs6t dq6|dur|j dus|j dur| Sdt }nLt|}|jjdkrt|}|j dus|j dur|j t|||j|dS|durdt }n t|}|jjdkrt|}|j t}|j t}t||}t|||}t|||}t|j}t|j}||j||j } ||j||j } |j||d d } |j| | d d } t|| | } |j | | | d S) a  Apply a velocity shift to this spectral coordinate. The shift can be provided as a redshift (float value) or radial velocity (`~astropy.units.Quantity` with physical type of 'speed'). Parameters ---------- target_shift : float or `~astropy.units.Quantity` ['speed'] Shift value to apply to current target. observer_shift : float or `~astropy.units.Quantity` ['speed'] Shift value to apply to current observer. Returns ------- `SpectralCoord` New spectral coordinate with the target/observer velocity changed to incorporate the shift. This is always a new object even if ``target_shift`` and ``observer_shift`` are both `None`. NzMBoth an observer and target must be defined before applying a velocity shift.cSsg|]}|dur|qS)Nr).0xrrr z.zaArgument must have unit physical type 'speed' for radial velocty or 'dimensionless' for redshift.rrW)rLr<Tri)rLr=r>)r>r=r,rZr"rCr r!rDr$rErIrJr.r]rr'r<r/rr rlr;rZxyzr1r5r0rk)rRZ target_shiftZobserver_shiftargrornrpZtarget_velocityZobserver_velocity new_targetZ new_observerrvrwr8rrrwith_radial_velocity_shiftzs^            z(SpectralCoord.with_radial_velocity_shiftcCsB|jdur |jdur ||jSt||j }|j|dtddS)zA Transforms the spectral axis to the rest frame. Ng)rLr<r)r=r>rxr'r<r.r$)rRresultrrrto_rests zSpectralCoord.to_restcCsd|jjd}z|j}|j}Wnty:d}}Yn0|g}|jdurrtt|jd}| d||j durtt|j d}| d||j dur|j dus|j dur |jdur|j dur| dn | d | d || d ||jdus"|jdurF| d |j| d |jtj|tjddd}t|dkr|d||jd7<n)rPrr<rr,r=rreprlstripappendr>rIrJrGrbrarZ array2stringrZndarraylenZ_unitstrjoin)rRZ prefixstrr<rZ repr_itemsZ observer_reprZ target_reprZarrstrrrr__repr__s>       zSpectralCoord.__repr__)NNNNN)rS) NNNNNNNNF)F)NF)NN)rrr__doc__r"Zquantity_inputrrr:rBrQ staticmethodrHr.propertyrgr=setterr>r<rrkrlrxrrr __classcell__rrrOrr sL(5  4 K        $  V S )F))r_textwraprZ astropy.unitsZunitsr"ZnumpyrZastropy.constantsrZastropy.coordinatesrrrrZ%astropy.coordinates.spectral_quantityrZastropy.coordinates.baseframer r Zastropy.utils.exceptionsr __all__r rrrr:r$r%rr6Zkpcr^Z__doctest_skip__rrr'r4r9r;r rrrrs.        # +