B z‹dÝã%@s²dZddlZddlmZddlZe d¡Zddlm Z dZ yddl m Z e j Z Wne d¡YnXd Zd d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.g%Zd/d0„Zd1d2„Zd3d4„Zd5d-„Zd6d.„Zd7d8„Zd9d:„Ze d;dd„Ze d;dzTHETA is out of range [0,pi]N)ÚnpÚasarrayÚallÚpiÚ ValueError)Útheta©r1ú]/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/healpy/pixelfunc.pyÚcheck_theta_valid™s r3cCstjdt |¡t |¡fS)aQTransform longitude and latitude (deg) into co-latitude and longitude (rad) Parameters ---------- lon : int or array-like Longitude in degrees lat : int or array-like Latitude in degrees Returns ------- theta, phi : float, scalar or array-like The co-latitude and longitude in radians g@)r+r.Úradians)ÚlonÚlatr1r1r2Úlonlat2thetaphi sr7cCst |¡dt |¡fS)aQTransform co-latitude and longitude (rad) into longitude and latitude (deg) Parameters ---------- theta : int or array-like Co-latitude in radians phi : int or array-like Longitude in radians Returns ------- lon, lat : float, scalar or array-like The longitude and latitude in degrees g€V@)r+Údegrees)r0Úphir1r1r2Úthetaphi2lonlat²sr:cCsÀt|dƒstdƒ‚t|ƒdkr&tdƒ‚yt|dƒ}Wntk rNd}YnX|dk r¤x(|dd…D]}t|ƒ|krftdƒ‚qfWtt|dƒƒršt|ƒStdƒ‚ntt|ƒƒr´dStdƒ‚dS) aDescribe the type of the map (valid, single, sequence of maps). Checks : the number of maps, that all maps have same length and that this length is a valid map size (using :func:`isnpixok`). Parameters ---------- m : sequence the map to get info from Returns ------- info : int -1 if the given object is not a valid map, 0 if it is a single map, *info* > 0 if it is a sequence of maps (*info* is then the number of maps) Examples -------- >>> import healpy as hp >>> hp.pixelfunc.maptype(np.arange(12)) 0 >>> hp.pixelfunc.maptype([np.arange(12), np.arange(12)]) 2 Ú__len__zinput map is a scalarrzinput map has length zeroNrzinput maps have different npixzbad number of pixels)ÚhasattrÚ TypeErrorÚlenr%)ÚmÚnpixÚmmr1r1r2r)Äs$       c CsLy| ¡Stk rFyt dd„|Dƒ¡Stk r@YnXYnX|S)aƒConverts a masked array or a list of masked arrays to filled numpy arrays Parameters ---------- m : a map (may be a sequence of maps) Returns ------- m : filled map or tuple of filled maps Examples -------- >>> import healpy as hp >>> m = hp.ma(np.array([2., 2., 3, 4, 5, 0, 0, 0, 0, 0, 0, 0])) >>> m.mask = np.array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=np.bool_) >>> print(m.data[1]) # data is not affected by mask 2.0 >>> print(m[1]) # shows that the value is masked -- >>> print(ma_to_array(m)[1]) # filled array, masked values replace by UNSEEN -1.6375e+30 cSsg|] }| ¡‘qSr1)Úfilled)Ú.0rAr1r1r2ú szma_to_array..)rBÚAttributeErrorr+Úarray)r?r1r1r2r*ös cCst|dƒpt|ddƒS)zïConverts a masked array or a list of masked arrays to filled numpy arrays Parameters ---------- m : a map (may be a sequence of maps) Returns ------- is_ma : bool whether the input map was a ma or not rBr)r<)r?r1r1r2Úis_mas rGcstˆƒ‡fdd„ƒ}|S)z¥Wraps a function in order to convert the input map from a masked to a regular numpy array, and convert back the output from a regular array to a masked arraycs0t|ƒ}t|ƒ}ˆ|f|ž|Ž}|r,t|ƒS|S)N)rGr*r)Úmap_inÚargsÚkwdsZ return_mar?Úout)Úfr1r2Úwrapper,szaccept_ma..wrapper)r)rLrMr1)rLr2Ú accept_ma'srNgñh㈵øä>g:Œ0âŽyE>cCs>t |¡}t |¡}t |¡}t ||¡||t |¡kS)aSReturns a bool array with ``True`` where m is close to badval. Parameters ---------- m : a map (may be a sequence of maps) badval : float, optional The value of the pixel considered as bad (:const:`UNSEEN` by default) rtol : float, optional The relative tolerance atol : float, optional The absolute tolerance Returns ------- mask a bool array with the same shape as the input map, ``True`` where input map is close to badval, and ``False`` elsewhere. See Also -------- mask_good, ma Examples -------- >>> import healpy as hp >>> import numpy as np >>> m = np.arange(12.) >>> m[3] = hp.UNSEEN >>> hp.mask_bad(m) array([False, False, False, True, False, False, False, False, False, False, False, False], dtype=bool) )r+r,Úabsolute)r?ÚbadvalÚrtolÚatolr1r1r2r6s!   cCs>t |¡}t |¡}t |¡}t ||¡||t |¡kS)a,Returns a bool array with ``False`` where m is close to badval. Parameters ---------- m : a map (may be a sequence of maps) badval : float, optional The value of the pixel considered as bad (:const:`UNSEEN` by default) rtol : float, optional The relative tolerance atol : float, optional The absolute tolerance Returns ------- a bool array with the same shape as the input map, ``False`` where input map is close to badval, and ``True`` elsewhere. See Also -------- mask_bad, ma Examples -------- >>> import healpy as hp >>> m = np.arange(12.) >>> m[3] = hp.UNSEEN >>> hp.mask_good(m) array([ True, True, True, False, True, True, True, True, True, True, True, True], dtype=bool) )r+r,rO)r?rPrQrRr1r1r2r]s   TcCstjjt |¡||||dS)aåReturn map as a masked array, with ``badval`` pixels masked. Parameters ---------- m : a map (may be a sequence of maps) badval : float, optional The value of the pixel considered as bad (:const:`UNSEEN` by default) rtol : float, optional The relative tolerance atol : float, optional The absolute tolerance copy : bool, optional If ``True``, a copy of the input map is made. Returns ------- a masked array with the same shape as the input map, masked where input map is close to badval. See Also -------- mask_good, mask_bad, numpy.ma.masked_values Examples -------- >>> import healpy as hp >>> m = np.arange(12.) >>> m[3] = hp.UNSEEN >>> hp.ma(m) masked_array(data = [0.0 1.0 2.0 -- 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0], mask = [False False False True False False False False False False False False], fill_value = -1.6375e+30) )rQrRÚcopy)r+rZ masked_valuesrF)r?rPrQrRrSr1r1r2r‚s#FcCsVt||d|rt||ƒ\}}t|ƒt||d|rDt |||¡St |||¡SdS)aSang2pix : nside,theta[rad],phi[rad],nest=False,lonlat=False -> ipix (default:RING) Parameters ---------- nside : int, scalar or array-like The healpix nside parameter, must be a power of 2, less than 2**30 theta, phi : float, scalars or array-like Angular coordinates of a point on the sphere nest : bool, optional if True, assume NESTED pixel ordering, otherwise, RING pixel ordering lonlat : bool If True, input angles are assumed to be longitude and latitude in degree, otherwise, they are co-latitude and longitude in radians. Returns ------- pix : int or array of int The healpix pixel numbers. Scalar if all input are scalar, array otherwise. Usual numpy broadcasting rules apply. See Also -------- pix2ang, pix2vec, vec2pix Examples -------- Note that some of the test inputs below that are on pixel boundaries such as theta=pi/2, phi=pi/2, have a tiny value of 1e-15 added to them to make them reproducible on i386 machines using x87 floating point instruction set (see https://github.com/healpy/healpy/issues/528). >>> import healpy as hp >>> hp.ang2pix(16, np.pi/2, 0) 1440 >>> print(hp.ang2pix(16, [np.pi/2, np.pi/4, np.pi/2, 0, np.pi], [0., np.pi/4, np.pi/2 + 1e-15, 0, 0])) [1440 427 1520 0 3068] >>> print(hp.ang2pix(16, np.pi/2, [0, np.pi/2 + 1e-15])) [1440 1520] >>> print(hp.ang2pix([1, 2, 4, 8, 16], np.pi/2, 0)) [ 4 12 72 336 1440] >>> print(hp.ang2pix([1, 2, 4, 8, 16], 0, 0, lonlat=True)) [ 4 12 72 336 1440] )ÚnestN)Ú check_nsider7r3ÚpixlibZ _ang2pix_nestZ _ang2pix_ring)Únsider0r9rTÚlonlatr1r1r2r¨s1  cCsLt||d|r"t ||¡\}}nt ||¡\}}|r@t||ƒS||fSdS)aÁpix2ang : nside,ipix,nest=False,lonlat=False -> theta[rad],phi[rad] (default RING) Parameters ---------- nside : int or array-like The healpix nside parameter, must be a power of 2, less than 2**30 ipix : int or array-like Pixel indices nest : bool, optional if True, assume NESTED pixel ordering, otherwise, RING pixel ordering lonlat : bool, optional If True, return angles will be longitude and latitude in degree, otherwise, angles will be co-latitude and longitude in radians (default) Returns ------- theta, phi : float, scalar or array-like The angular coordinates corresponding to ipix. Scalar if all input are scalar, array otherwise. Usual numpy broadcasting rules apply. See Also -------- ang2pix, vec2pix, pix2vec Examples -------- >>> import healpy as hp >>> hp.pix2ang(16, 1440) (1.5291175943723188, 0.0) >>> hp.pix2ang(16, [1440, 427, 1520, 0, 3068]) (array([ 1.52911759, 0.78550497, 1.57079633, 0.05103658, 3.09055608]), array([ 0. , 0.78539816, 1.61988371, 0.78539816, 0.78539816])) >>> hp.pix2ang([1, 2, 4, 8], 11) (array([ 2.30052398, 0.84106867, 0.41113786, 0.2044802 ]), array([ 5.49778714, 5.89048623, 5.89048623, 5.89048623])) >>> hp.pix2ang([1, 2, 4, 8], 11, lonlat=True) (array([ 315. , 337.5, 337.5, 337.5]), array([-41.8103149 , 41.8103149 , 66.44353569, 78.28414761])) )rTN)rUrVZ _pix2ang_nestZ _pix2ang_ringr:)rWÚipixrTrXr0r9r1r1r2rås(  cCs4t||d|r t ||||¡St ||||¡SdS)aOxyf2pix : nside,x,y,face,nest=False -> ipix (default:RING) Parameters ---------- nside : int, scalar or array-like The healpix nside parameter, must be a power of 2 x, y : int, scalars or array-like Pixel indices within face face : int, scalars or array-like Face number nest : bool, optional if True, assume NESTED pixel ordering, otherwise, RING pixel ordering Returns ------- pix : int or array of int The healpix pixel numbers. Scalar if all input are scalar, array otherwise. Usual numpy broadcasting rules apply. See Also -------- pix2xyf Examples -------- >>> import healpy as hp >>> hp.xyf2pix(16, 8, 8, 4) 1440 >>> print(hp.xyf2pix(16, [8, 8, 8, 15, 0], [8, 8, 7, 15, 0], [4, 0, 5, 0, 8])) [1440 427 1520 0 3068] )rTN)rUrVZ _xyf2pix_nestZ _xyf2pix_ring)rWÚxÚyZfacerTr1r1r2Úxyf2pixs! r\cCs,t||d|rt ||¡St ||¡SdS)ahpix2xyf : nside,ipix,nest=False -> x,y,face (default RING) Parameters ---------- nside : int or array-like The healpix nside parameter, must be a power of 2 ipix : int or array-like Pixel indices nest : bool, optional if True, assume NESTED pixel ordering, otherwise, RING pixel ordering Returns ------- x, y : int, scalars or array-like Pixel indices within face face : int, scalars or array-like Face number See Also -------- xyf2pix Examples -------- >>> import healpy as hp >>> hp.pix2xyf(16, 1440) (8, 8, 4) >>> hp.pix2xyf(16, [1440, 427, 1520, 0, 3068]) (array([ 8, 8, 8, 15, 0]), array([ 8, 8, 7, 15, 0]), array([4, 0, 5, 0, 8])) >>> hp.pix2xyf([1, 2, 4, 8], 11) (array([0, 1, 3, 7]), array([0, 0, 2, 6]), array([11, 3, 3, 3])) )rTN)rUrVZ _pix2xyf_nestZ _pix2xyf_ring)rWrYrTr1r1r2Úpix2xyfAs#  r]cCs(|rt ||||¡St ||||¡SdS)a€vec2pix : nside,x,y,z,nest=False -> ipix (default:RING) Parameters ---------- nside : int or array-like The healpix nside parameter, must be a power of 2, less than 2**30 x,y,z : floats or array-like vector coordinates defining point on the sphere nest : bool, optional if True, assume NESTED pixel ordering, otherwise, RING pixel ordering Returns ------- ipix : int, scalar or array-like The healpix pixel number corresponding to input vector. Scalar if all input are scalar, array otherwise. Usual numpy broadcasting rules apply. See Also -------- ang2pix, pix2ang, pix2vec Examples -------- >>> import healpy as hp >>> hp.vec2pix(16, 1, 0, 0) 1504 >>> print(hp.vec2pix(16, [1, 0], [0, 1], [0, 0])) [1504 1520] >>> print(hp.vec2pix([1, 2, 4, 8], 1, 0, 0)) [ 4 20 88 368] N)rVZ _vec2pix_nestZ _vec2pix_ring)rWrZr[ÚzrTr1r1r2r ks"cCs,t||d|rt ||¡St ||¡SdS)a2pix2vec : nside,ipix,nest=False -> x,y,z (default RING) Parameters ---------- nside : int, scalar or array-like The healpix nside parameter, must be a power of 2, less than 2**30 ipix : int, scalar or array-like Healpix pixel number nest : bool, optional if True, assume NESTED pixel ordering, otherwise, RING pixel ordering Returns ------- x, y, z : floats, scalar or array-like The coordinates of vector corresponding to input pixels. Scalar if all input are scalar, array otherwise. Usual numpy broadcasting rules apply. See Also -------- ang2pix, pix2ang, vec2pix Examples -------- >>> import healpy as hp >>> hp.pix2vec(16, 1504) (0.99879545620517241, 0.049067674327418015, 0.0) >>> hp.pix2vec(16, [1440, 427]) (array([ 0.99913157, 0.5000534 ]), array([ 0. , 0.5000534]), array([ 0.04166667, 0.70703125])) >>> hp.pix2vec([1, 2], 11) (array([ 0.52704628, 0.68861915]), array([-0.52704628, -0.28523539]), array([-0.66666667, 0.66666667])) )rTN)rUrVZ _pix2vec_nestZ _pix2vec_ring)rWrYrTr1r1r2r“s"  cCsP|rt||ƒ\}}t|ƒt |¡}t |t |¡|t |¡t |¡g¡jS)aÆang2vec : convert angles to 3D position vector Parameters ---------- theta : float, scalar or arry-like colatitude in radians measured southward from north pole (in [0,pi]). phi : float, scalar or array-like longitude in radians measured eastward (in [0, 2*pi]). lonlat : bool If True, input angles are assumed to be longitude and latitude in degree, otherwise, they are co-latitude and longitude in radians. Returns ------- vec : float, array if theta and phi are vectors, the result is a 2D array with a vector per row otherwise, it is a 1D array of shape (3,) See Also -------- vec2ang, rotator.dir2vec, rotator.vec2dir )r7r3r+ÚsinrFÚcosÚT)r0r9rXZsinthetar1r1r2r ¼s  cCs˜| dd¡}t tjt |¡dd¡}t |dd…df|¡}t |dd…df|dd…df¡}||dkdtj7<|rŒt||ƒS||fSdS)avec2ang: vectors [x, y, z] -> theta[rad], phi[rad] Parameters ---------- vectors : float, array-like the vector(s) to convert, shape is (3,) or (N, 3) lonlat : bool, optional If True, return angles will be longitude and latitude in degree, otherwise, angles will be co-latitude and longitude in radians (default) Returns ------- theta, phi : float, tuple of two arrays the colatitude and longitude in radians See Also -------- ang2vec, rotator.vec2dir, rotator.dir2vec éÿÿÿÿér)ÚaxisNér) Úreshaper+ÚsqrtÚsumZsquareZarccosZarctan2r.r:)ZvectorsrXZdnormr0r9r1r1r2r Ús $ cCst|ddt ||¡S)aConvert pixel number from RING ordering to NESTED ordering. Parameters ---------- nside : int, scalar or array-like the healpix nside parameter ipix : int, scalar or array-like the pixel number in RING scheme Returns ------- ipix : int, scalar or array-like the pixel number in NESTED scheme See Also -------- nest2ring, reorder Examples -------- >>> import healpy as hp >>> hp.ring2nest(16, 1504) 1130 >>> print(hp.ring2nest(2, np.arange(10))) [ 3 7 11 15 2 1 6 5 10 9] >>> print(hp.ring2nest([1, 2, 4, 8], 11)) [ 11 13 61 253] T)rT)rUrVZ _ring2nest)rWrYr1r1r2rùs cCst|ddt ||¡S)aConvert pixel number from NESTED ordering to RING ordering. Parameters ---------- nside : int, scalar or array-like the healpix nside parameter ipix : int, scalar or array-like the pixel number in NESTED scheme Returns ------- ipix : int, scalar or array-like the pixel number in RING scheme See Also -------- ring2nest, reorder Examples -------- >>> import healpy as hp >>> hp.nest2ring(16, 1130) 1504 >>> print(hp.nest2ring(2, np.arange(10))) [13 5 4 0 15 7 6 1 17 9] >>> print(hp.nest2ring([1, 2, 4, 8], 11)) [ 11 2 12 211] T)rT)rUrVZ _nest2ring)rWrYr1r1r2rs cCsæt|ƒ}|dkrt|ƒ}n t|dƒ}t|ƒ}|dkr@|d}n|}|rPd}d}|r\d}d}t|ƒ ¡dd…}t|ƒ ¡dd…}|dks”|dkrœtdƒ‚|dkr¬|g} n|} g} x| D]} ||krÖ|  | ¡q¼|dkrNtj|t | dƒd } xJt ||ƒD]:} t  | || d |¡}t ||ƒ}t  | ¡|| |<qW|  | ¡q¼|dkr¼tj|t | dƒd } xJt ||ƒD]:} t  | || d |¡}t||ƒ}t  | ¡|| |<qzW|  | ¡q¼W|dkrØ| dSt | ¡Sd S) aáReorder a healpix map from RING/NESTED ordering to NESTED/RING Parameters ---------- map_in : array-like the input map to reorder, accepts masked arrays inp, out : ``'RING'`` or ``'NESTED'`` define the input and output ordering r2n : bool if True, reorder from RING to NESTED n2r : bool if True, reorder from NESTED to RING Returns ------- map_out : array-like the reordered map, as masked array if the input was a masked array Notes ----- if ``r2n`` or ``n2r`` is defined, override ``inp`` and ``out``. See Also -------- nest2ring, ring2nest Examples -------- >>> import healpy as hp >>> hp.reorder(np.arange(48), r2n = True) array([13, 5, 4, 0, 15, 7, 6, 1, 17, 9, 8, 2, 19, 11, 10, 3, 28, 20, 27, 12, 30, 22, 21, 14, 32, 24, 23, 16, 34, 26, 25, 18, 44, 37, 36, 29, 45, 39, 38, 31, 46, 41, 40, 33, 47, 43, 42, 35]) >>> hp.reorder(np.arange(12), n2r = True) array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) >>> hp.reorder(hp.ma(np.arange(12.)), n2r = True) masked_array(data = [ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], mask = False, fill_value = -1.6375e+30) >>> m = [np.arange(12.), np.arange(12.), np.arange(12.)] >>> m[0][2] = hp.UNSEEN >>> m[1][2] = hp.UNSEEN >>> m[2][2] = hp.UNSEEN >>> m = hp.ma(m) >>> hp.reorder(m, n2r = True) masked_array(data = [[0.0 1.0 -- 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0] [0.0 1.0 -- 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0] [0.0 1.0 -- 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0]], mask = [[False False True False False False False False False False False False] [False False True False False False False False False False False False] [False False True False False False False False False False False False]], fill_value = -1.6375e+30) ré€éÚRINGÚNESTé)rkrlz'inp and out must be either RING or NEST)ÚdtyperN)r)r>rÚstrÚupperr/Úappendr+ÚzerosÚtypeÚrangeÚarangerr,rrF)rHZinprKÚr2nÚn2rÚtypr@rWÚ bunchsizeZmapinÚmapoutÚm_inZm_outÚibunchZipix_nZipix_rr1r1r2r?sT<         cCs d||S)aËGive the number of pixels for the given nside. Parameters ---------- nside : int healpix nside parameter Returns ------- npix : int corresponding number of pixels Examples -------- >>> import healpy as hp >>> import numpy as np >>> hp.nside2npix(8) 768 >>> np.all([hp.nside2npix(nside) == 12 * nside**2 for nside in [2**n for n in range(12)]]) True >>> hp.nside2npix(7) 588 é r1)rWr1r1r2r«scCst|ddtd |¡ƒdS)aíGive the resolution order for a given nside. Parameters ---------- nside : int healpix nside parameter; an exception is raised if nside is not valid (nside must be a power of 2, less than 2**30) Returns ------- order : int corresponding order where nside = 2**(order) Notes ----- Raise a ValueError exception if nside is not valid. Examples -------- >>> import healpy as hp >>> import numpy as np >>> hp.nside2order(128) 7 >>> np.all([hp.nside2order(2**o) == o for o in range(30)]) True >>> hp.nside2order(7) Traceback (most recent call last): ... ValueError: 7 is not a valid nside parameter (must be a power of 2, less than 2**30) T)rTz{0:b}r)rUr>Úformat)rWr1r1r2rÈs! cCs$t t|ƒ¡}|r t |¡d}|S)a4Give approximate resolution (pixel size in radian or arcmin) for nside. Resolution is just the square root of the pixel area, which is a gross approximation given the different pixel shapes Parameters ---------- nside : int healpix nside parameter, must be a power of 2, less than 2**30 arcmin : bool if True, return resolution in arcmin, otherwise in radian Returns ------- resol : float approximate pixel size in radians or arcmin Notes ----- Raise a ValueError exception if nside is not valid. Examples -------- >>> import healpy as hp >>> hp.nside2resol(128, arcmin = True) # doctest: +FLOAT_CMP 27.483891294539248 >>> hp.nside2resol(256) 0.0039973699529159707 >>> hp.nside2resol(7) 0.1461895297066412 é<)r+rgr#Úrad2deg)rWZarcminZresolr1r1r2r"ís#cCs*dtjt|ƒ}|r&t t |¡¡}|S)aÍGive pixel area given nside in square radians or square degrees. Parameters ---------- nside : int healpix nside parameter, must be a power of 2, less than 2**30 degrees : bool if True, returns pixel area in square degrees, in square radians otherwise Returns ------- pixarea : float pixel area in square radian or square degree Notes ----- Raise a ValueError exception if nside is not valid. Examples -------- >>> import healpy as hp >>> hp.nside2pixarea(128, degrees = True) # doctest: +FLOAT_CMP 0.2098234113027917 >>> hp.nside2pixarea(256) 1.5978966540475428e-05 >>> hp.nside2pixarea(7) 0.021371378595848933 rm)r+r.rr€)rWr8Zpixarear1r1r2r#s cCs"t|ƒstdƒ‚tt |d¡ƒS)aµGive the nside parameter for the given number of pixels. Parameters ---------- npix : int the number of pixels Returns ------- nside : int the nside parameter corresponding to npix Notes ----- Raise a ValueError exception if number of pixel does not correspond to the number of pixel of a healpix map. Examples -------- >>> import healpy as hp >>> hp.npix2nside(768) 8 >>> np.all([hp.npix2nside(12 * nside**2) == nside for nside in [2**n for n in range(12)]]) True >>> hp.npix2nside(1000) Traceback (most recent call last): ... ValueError: Wrong pixel number (it is not 12*nside**2) z*Wrong pixel number (it is not 12*nside**2)g(@)r%r/Úintr+rg)r@r1r1r2r@s cCsd|>}t|dd|S)aGive the nside parameter for the given resolution order. Parameters ---------- order : int the resolution order Returns ------- nside : int the nside parameter corresponding to order Notes ----- Raise a ValueError exception if order produces an nside out of range. Examples -------- >>> import healpy as hp >>> hp.order2nside(7) 128 >>> print(hp.order2nside(np.arange(8))) [ 1 2 4 8 16 32 64 128] >>> hp.order2nside(31) Traceback (most recent call last): ... ValueError: 2147483648 is not a valid nside parameter (must be a power of 2, less than 2**30) rT)rT)rU)ÚorderrWr1r1r2res cCst|ƒ}t|ƒ}|S)aºGive the number of pixels for the given resolution order. Parameters ---------- order : int the resolution order Returns ------- npix : int corresponding number of pixels Notes ----- A convenience function that successively applies order2nside then nside2npix to order. Examples -------- >>> import healpy as hp >>> hp.order2npix(7) 196608 >>> print(hp.order2npix(np.arange(8))) [ 12 48 192 768 3072 12288 49152 196608] >>> hp.order2npix(31) Traceback (most recent call last): ... ValueError: 2147483648 is not a valid nside parameter (must be a power of 2, less than 2**30) )rr)r‚rWr@r1r1r2r ‰scCst|ƒ}t|ƒ}|S)a€Give the resolution order for the given number of pixels. Parameters ---------- npix : int the number of pixels Returns ------- order : int corresponding resolution order Notes ----- A convenience function that successively applies npix2nside then nside2order to npix. Examples -------- >>> import healpy as hp >>> hp.npix2order(768) 3 >>> np.all([hp.npix2order(12 * 4**order) == order for order in range(12)]) True >>> hp.npix2order(1000) Traceback (most recent call last): ... ValueError: Wrong pixel number (it is not 12*nside**2) )rr)r@rWr‚r1r1r2r!­scCs¬t|dƒrdt|tjƒs t |¡}|| t¡k|dk@|tk@}|r¨|| t¡| t¡d@dkM}nD|t|ƒko†d|ko‚tkn}|r¨|o¦t|ƒt|ƒd@dk}|S)a·Returns :const:`True` if nside is a valid nside parameter, :const:`False` otherwise. NSIDE needs to be a power of 2 only for nested ordering Parameters ---------- nside : int, scalar or array-like integer value to be tested Returns ------- ok : bool, scalar or array-like :const:`True` if given value is a valid nside, :const:`False` otherwise. Examples -------- >>> import healpy as hp >>> hp.isnsideok(13, nest=True) False >>> hp.isnsideok(13, nest=False) True >>> hp.isnsideok(32) True >>> hp.isnsideok([1, 2, 3, 4, 8, 16], nest=True) array([ True, True, False, True, True, True], dtype=bool) r;rr)r<Ú isinstancer+Zndarrayr,ÚastyperÚ max_nside)rWrTZ is_nside_okr1r1r2r$Ñs   "$cCs&t t||d¡s"tdt|ƒƒ‚dS)z&Raises exception is nside is not valid)rTzI%s is not a valid nside parameter (must be a power of 2, less than 2**30)N)r+r-r$r/ro)rWrTr1r1r2rUÿsrUcCs"t t |¡d¡}|t |¡kS)a*Return :const:`True` if npix is a valid value for healpix map size, :const:`False` otherwise. Parameters ---------- npix : int, scalar or array-like integer value to be tested Returns ------- ok : bool, scalar or array-like :const:`True` if given value is a valid number of pixel, :const:`False` otherwise Examples -------- >>> import healpy as hp >>> hp.isnpixok(12) True >>> hp.isnpixok(768) True >>> hp.isnpixok([12, 768, 1002]) array([ True, True, False], dtype=bool) g(@)r+rgr,Úfloor)r@rWr1r1r2r%sc Cs€| ¡}t|jƒ}|r$t||ƒ\}}|r8t |||¡}nt |||¡}t |dd…¡}t |dd…¡} ~t  ||| d¡S)a­Return the bi-linear interpolation value of a map using 4 nearest neighbours. Parameters ---------- m : array-like a healpix map, accepts masked arrays theta, phi : float, scalar or array-like angular coordinates of point at which to interpolate the map nest : bool if True, the is assumed to be in NESTED ordering. lonlat : bool If True, input angles are assumed to be longitude and latitude in degree, otherwise, they are co-latitude and longitude in radians. Returns ------- val : float, scalar or arry-like the interpolated value(s), usual numpy broadcasting rules apply. See Also -------- get_interp_weights, get_all_neighbours Examples -------- >>> import healpy as hp >>> hp.get_interp_val(np.arange(12.), np.pi/2, 0) 4.0 >>> hp.get_interp_val(np.arange(12.), np.pi/2, np.pi/2) 5.0 >>> hp.get_interp_val(np.arange(12.), np.pi/2, np.pi/2 + 2*np.pi) 5.0 >>> hp.get_interp_val(np.arange(12.), np.linspace(0, np.pi, 10), 0) array([ 1.5 , 1.5 , 1.5 , 2.20618428, 3.40206143, 5.31546486, 7.94639458, 9.5 , 9.5 , 9.5 ]) >>> hp.get_interp_val(np.arange(12.), 0, np.linspace(90, -90, 10), lonlat=True) array([ 1.5 , 1.5 , 1.5 , 2.20618428, 3.40206143, 5.31546486, 7.94639458, 9.5 , 9.5 , 9.5 ]) rrmé) ZravelrÚsizer7rVÚ_get_interpol_nestÚ_get_interpol_ringr+rFrh) r?r0r9rTrXÚm2rWÚrÚpÚwr1r1r2r %s( cCsˆt||d|dkr(t|||d\}}n|r:t||ƒ\}}|rNt |||¡}nt |||¡}t |dd…¡}t |dd…¡}||fS)aReturn the 4 closest pixels on the two rings above and below the location and corresponding weights. Weights are provided for bilinear interpolation along latitude and longitude Parameters ---------- nside : int the healpix nside theta, phi : float, scalar or array-like if phi is not given, theta is interpreted as pixel number, otherwise theta[rad],phi[rad] are angular coordinates nest : bool if ``True``, NESTED ordering, otherwise RING ordering. lonlat : bool If True, input angles are assumed to be longitude and latitude in degree, otherwise, they are co-latitude and longitude in radians. Returns ------- res : tuple of length 2 contains pixel numbers in res[0] and weights in res[1]. Usual numpy broadcasting rules apply. See Also -------- get_interp_val, get_all_neighbours Examples -------- Note that some of the test inputs below that are on pixel boundaries such as theta=pi/2, phi=pi/2, have a tiny value of 1e-15 added to them to make them reproducible on i386 machines using x87 floating point instruction set (see https://github.com/healpy/healpy/issues/528). >>> import healpy as hp >>> pix, weights = hp.get_interp_weights(1, 0) >>> print(pix) [0 1 4 5] >>> weights array([ 1., 0., 0., 0.]) >>> pix, weights = hp.get_interp_weights(1, 0, 0) >>> print(pix) [1 2 3 0] >>> weights array([ 0.25, 0.25, 0.25, 0.25]) >>> pix, weights = hp.get_interp_weights(1, 0, 90, lonlat=True) >>> print(pix) [1 2 3 0] >>> weights array([ 0.25, 0.25, 0.25, 0.25]) >>> pix, weights = hp.get_interp_weights(1, [0, np.pi/2 + 1e-15], 0) >>> print(pix) [[ 1 4] [ 2 5] [ 3 11] [ 0 8]] >>> np.testing.assert_allclose( ... weights, ... np.array([[ 0.25, 1. ], ... [ 0.25, 0. ], ... [ 0.25, 0. ], ... [ 0.25, 0. ]]), rtol=0, atol=1e-14) )rTNrrmr‡)rUrr7rVr‰rŠr+rF)rWr0r9rTrXrŒrrŽr1r1r2r [sC cCsZt||d|dk r&t|||||d}|r8t ||¡}n t ||¡}t |dd…¡}|S)aÜReturn the 8 nearest pixels. Parameters ---------- nside : int the nside to work with theta, phi : scalar or array-like if phi is not given or None, theta is interpreted as pixel number, otherwise, theta[rad],phi[rad] are angular coordinates nest : bool if ``True``, pixel number will be NESTED ordering, otherwise RING ordering. lonlat : bool If True, input angles are assumed to be longitude and latitude in degree, otherwise, they are co-latitude and longitude in radians. Returns ------- ipix : int, array pixel number of the SW, W, NW, N, NE, E, SE and S neighbours, shape is (8,) if input is scalar, otherwise shape is (8, N) if input is of length N. If a neighbor does not exist (it can be the case for W, N, E and S) the corresponding pixel number will be -1. See Also -------- get_interp_weights, get_interp_val Examples -------- >>> import healpy as hp >>> print(hp.get_all_neighbours(1, 4)) [11 7 3 -1 0 5 8 -1] >>> print(hp.get_all_neighbours(1, np.pi/2, np.pi/2)) [ 8 4 0 -1 1 6 9 -1] >>> print(hp.get_all_neighbours(1, 90, 0, lonlat=True)) [ 8 4 0 -1 1 6 9 -1] )rTN)rTrXrr‡)rUrrVZ_get_neighbors_nestZ_get_neighbors_ringr+rF)rWr0r9rTrXrŒÚresr1r1r2r¬s(  cCs*t|dd|r t t |¡¡St |¡S)aÎMaximum angular distance between any pixel center and its corners Parameters ---------- nside : int the nside to work with degrees : bool if True, returns pixel radius in degrees, in radians otherwise Returns ------- rads: double angular distance (in radians or degrees) Examples -------- >>> '%.14f' % max_pixrad(1) '0.84106867056793' >>> '%.14f' % max_pixrad(16) '0.06601476143251' F)rT)rUr+r€rVZ _max_pixrad)rWr8r1r1r2rßs cCsÐt|ƒ}t |¡}|j}t|ƒ}|dkr2|d}n|}tjdtjd}tjdtjd}xþt||ƒD]ì} t | || d|¡} | |j | |kt  |j | ¡@} t || |ƒ\} } } |dkrt  | ¡t  |tjd¡k}| |} | |} | |} | |} ~|d | j7<|d |  ¡7<|d |  ¡7<|d |  ¡7<|d | d ¡7<|d| |  ¡7<|d| |  ¡7<|d| d ¡7<|d| |  ¡7<|d| d ¡7<|d|j |  ¡7<|d|j | |  ¡7<|d|j | |  ¡7<|d|j | |  ¡7<qfW|d |d<|d |d<|d |d<|d|d<|d|d<|d|d<t tj |¡|¡}|d}|dd…}||fS)a¨Fit a dipole and a monopole to the map, excluding bad pixels. Parameters ---------- m : float, array-like the map to which a dipole is fitted and subtracted, accepts masked maps nest : bool if ``False`` m is assumed in RING scheme, otherwise map is NESTED bad : float bad values of pixel, default to :const:`UNSEEN`. gal_cut : float [degrees] pixels at latitude in [-gal_cut;+gal_cut] degrees are not taken into account Returns ------- res : tuple of length 2 the monopole value in res[0] and the dipole vector (as array) in res[1] See Also -------- remove_dipole, fit_monopole, remove_monopole rirj)rmrm)rnrmrré´)rr)rr)rer)rcr)rrre)rer)rcr)rere)rcre)rcrcrc)rr)rre)rrc)rre)rrc)rerc)r*r+r,rˆrrrZfloat64rtruÚflatÚisfiniterÚabsr_r.rhÚdotZlinalgÚinv)r?rTÚbadÚgal_cutr@rWryÚaaÚvr|rYrZr[r^rŽrÚmonoÚdipoler1r1r2rýsX  " "       Úverbosez1.15.0cCs€t|ƒ}t|ƒ}tj||d}|j}t|ƒ} | dkr>|d} n|} t||||d\} } xÀt|| ƒD]°} t | | | d| ¡}||j ||kt  |j |¡@}t | ||ƒ\}}}|j || d|8<|j || d|8<|j || d|8<|j || 8<qdWddl m }|j| d d \}}t | |  ¡¡}t d | |||¡trht|ƒ}|rx|| | fS|Sd S) aûFit and subtract the dipole and the monopole from the given map m. Parameters ---------- m : float, array-like the map to which a dipole is fitted and subtracted, accepts masked arrays nest : bool if ``False`` m is assumed in RING scheme, otherwise map is NESTED bad : float bad values of pixel, default to :const:`UNSEEN`. gal_cut : float [degrees] pixels at latitude in [-gal_cut;+gal_cut] are not taken into account fitval : bool whether to return or not the fitted values of monopole and dipole copy : bool whether to modify input map or not (by default, make a copy) verbose : bool deprecated, no effect Returns ------- res : array or tuple of length 3 if fitval is False, returns map with monopole and dipole subtracted, otherwise, returns map (array, in res[0]), monopole (float, in res[1]), dipole_vector (array, in res[2]) See Also -------- fit_dipole, fit_monopole, remove_monopole )rSrirj)rTr–r—rrre)ÚrotatorT)rXz9monopole: %.2g dipole: lon: %.2g}, lat: %.2g}, amp: %.2gN)rGr*r+rFrˆrrrtrur‘r’rÚrZvec2dirrgrhÚlogÚinfor)r?rTr–r—ÚfitvalrSrœÚinput_mar@rWryršr›r|rYrZr[r^ÚRr5r6Úampr1r1r2rCs6" "  cCst|ƒ}t |¡}|j}t|ƒ}|dkr2|d}n|}d}}xÄt||ƒD]´} t | || d|¡} | |j| |kt |j| ¡@} t || |ƒ\} } } |dkrät  | ¡t  |tj d¡k}| |} | |} | |} | |} ~|| j7}||j|   ¡7}qLW||}|S)aaFit a monopole to the map, excluding unseen pixels. Parameters ---------- m : float, array-like the map to which a dipole is fitted and subtracted, accepts masked arrays nest : bool if ``False`` m is assumed in RING scheme, otherwise map is NESTED bad : float bad values of pixel, default to :const:`UNSEEN`. gal_cut : float [degrees] pixels at latitude in [-gal_cut;+gal_cut] degrees are not taken into account Returns ------- res: float fitted monopole value See Also -------- fit_dipole, remove_monopole, remove_monopole rirjgrrr)r*r+r,rˆrrtrur‘r’rr“r_r.rh)r?rTr–r—r@rWryr˜r™r|rYrZr[r^rŽršr1r1r2rˆs.  " cCsòt|ƒ}t|ƒ}tj||d}|j}t|ƒ} | dkr>|d} n|} t||||d} xrt|| ƒD]b} t | | | d| ¡} | |j | |kt  |j | ¡@} t | | |ƒ\}}}|j | | 8<q`Wt   d| ¡|rÞt|ƒ}|rê|| fS|SdS)a˜Fit and subtract the monopole from the given map m. Parameters ---------- m : float, array-like the map to which a monopole is fitted and subtracted nest : bool if ``False`` m is assumed in RING scheme, otherwise map is NESTED bad : float bad values of pixel, default to :const:`UNSEEN`. gal_cut : float [degrees] pixels at latitude in [-gal_cut;+gal_cut] are not taken into account fitval : bool whether to return or not the fitted value of monopole copy : bool whether to modify input map or not (by default, make a copy) verbose: bool deprecated, no effect Returns ------- res : array or tuple of length 3 if fitval is False, returns map with monopole subtracted, otherwise, returns map (array, in res[0]) and monopole (float, in res[1]) See Also -------- fit_dipole, fit_monopole, remove_dipole )rSrirj)rTr–r—rzmonopole: %.3gN)rGr*r+rFrˆrrrtrur‘r’rrŸr r)r?rTr–r—r¡rSrœr¢r@rWryršr|rYrZr[r^r1r1r2r¹s(! " cCspt|tƒrPd|krt|dƒSttdƒr2t|jƒStt| ¡ƒdƒ}t|ƒSnt t |ƒƒrdt |ƒSt dƒ‚dS)aÎReturns the npix of a given map (implicit or explicit pixelization). If map is a dict type, assumes explicit pixelization: use nside key if present, or use nside attribute if present, otherwise use the smallest valid npix given the maximum key value. otherwise assumes implicit pixelization and returns len(m). Parameters ---------- m : array-like or dict-like a map with implicit (array-like) or explicit (dict-like) pixellization Returns ------- npix : int a valid number of pixel Notes ----- In implicit pixellization, raise a ValueError exception if the size of the input is not a valid pixel number. Examples -------- >>> import healpy as hp >>> m = {0: 1, 1: 1, 2: 1, 'nside': 1} >>> print(hp.get_map_size(m)) 12 >>> m = {0: 1, 767: 1} >>> print(hp.get_map_size(m)) 768 >>> print(hp.get_map_size(np.zeros(12 * 8 ** 2))) 768 rWrz*Wrong pixel number (it is not 12*nside**2)N) rƒÚdictrr<rrWr'ÚmaxÚkeysr%r>r/)r?rWr1r1r2r&òs$      cCs$dt |d¡}dtt |¡ƒ>S)ažReturns the minimum acceptable nside so that npix <= nside2npix(nside). Parameters ---------- npix : int a minimal number of pixel Returns ------- nside : int a valid healpix nside so that 12 * nside ** 2 >= npix Examples -------- >>> import healpy as hp >>> hp.pixelfunc.get_min_valid_nside(355) 8 >>> hp.pixelfunc.get_min_valid_nside(768) 8 gà?g(@r)r+Úlog2rÚceil)r@r‚r1r1r2r'%scCs0t|ƒ}|dkrtt|ƒƒStt|dƒƒSdS)a»Return the nside of the given map. Parameters ---------- m : sequence the map to get the nside from. Returns ------- nside : int the healpix nside parameter of the map (or sequence of maps) Notes ----- If the input is a sequence of maps, all of them must have same size. If the input is not a valid map (not a sequence, unvalid number of pixels), a TypeError exception is raised. rN)r)rr>)r?rxr1r1r2r(>s rkc CsÜt||dkdt|ƒ}|dkr(tdƒ‚|dkr8|g}n|}g} |dkrL|}xp|D]h} t|ƒ ¡dd…dkrzt| dd} t| ||||d } t|ƒ ¡dd…dkr°t| dd } |  | ¡qRW|dkrÎ| dSt  | ¡SdS) aUpgrade or degrade resolution of a map (or list of maps). in degrading the resolution, ud_grade sets the value of the superpixel as the mean of the children pixels. Parameters ---------- map_in : array-like or sequence of array-like the input map(s) (if a sequence of maps, all must have same size) nside_out : int the desired nside of the output map(s) pess : bool if ``True``, in degrading, reject pixels which contains a bad sub_pixel. Otherwise, estimate average with good pixels order_in, order_out : str pixel ordering of input and output ('RING' or 'NESTED') power : float if non-zero, divide the result by (nside_in/nside_out)**power Examples: power=-2 keeps the sum of the map invariant (useful for hitmaps), power=2 divides the mean by another factor of (nside_in/nside_out)**2 (useful for variance maps) dtype : type the type of the output map Returns ------- map_out : array-like or sequence of array-like the upgraded or degraded map(s) Examples -------- >>> import healpy as hp >>> hp.ud_grade(np.arange(48.), 1) array([ 5.5 , 7.25, 9. , 10.75, 21.75, 21.75, 23.75, 25.75, 36.5 , 38.25, 40. , 41.75]) rk)rTrz Invalid mapNrmT)rv)ÚpessÚpowerrn)rw) rUr)r=rorprÚ_ud_grade_corerqr+rF) rHÚ nside_outrªZorder_inZ order_outr«rnrxr{rzr?Zmoutr1r1r2rXs(/   cCstt|ƒ}|r|}n t|dƒ}t|ddt|ƒ}t|ƒ}|r\t|ƒ}t|ƒt|ƒ|} nd} ||kr–||} tj| |d| } t || ¡ |¡} nÔ||krf||} | || ¡} t | ƒt  | ¡B}tj | |dd  |¡} |j dd}|rt  || k¡}nt  |dk¡}|r || }| |dk||dk| |dk<y t| |<Wntk rbYnXn|} |   |¡S)zmInternal routine used by ud_grade. It assumes that the map is NESTED and single (not a list of maps) rT)rTr)rn)rd)r(rsrUrÚfloatr+ZonesÚouterrfrr’rhr„ÚwhererÚ OverflowError)r?r­rªr«rnZnside_inZtype_outZnpix_inZnpix_outÚratioZrat2ZfactZmap_outÚmrZgoodsZnhitZbadoutr1r1r2r¬ŸsB       r¬)FF)FF)F)F)F)F)F)F)NNNN)F)F)F)F)FF)NFF)NFF)F)FrkNNN)FNN)>Ú__doc__Únumpyr+Ú functoolsrÚloggingÚ getLoggerrŸZastropy.utils.decoratorsrrržrrVÚwarningr…Ú__all__r3r7r:r)r*rGrNrrrrrr\r]r rr r rrrrrr"r#rrr r!r$rUr%r r rrrrrrr&r'r(rr¬r1r1r1r2ÚWsÌ     2"'%& = 4 ( * ( )  ## k% + (%$$$ .  6 Q 3 F C1 73 ?