def Method1():
l = np.arange(lmax + 1)
m = l.copy()
#----------------------------------------
# Vij(m), for beamlm ('AlmDS')
idxBp = self.LM2Index('AlmDS', lmax, l, -m, '2D')[0]
# Vij^{*}(-m)
idxBn = self.LM2Index('AlmDS', lmax, l, m, '2D')[0]
valid = 1 - Invalid(idxBp).mask # 01, not TrueFalse
''' row-l, col-m '''
#----------------------------------------
idxBp = Invalid(idxBp, 0).data.astype(int)
idxBn = Invalid(idxBn, 0).data.astype(int)
''' row-l, col-m '''
#----------------------------------------
m = m[None, :]
alm4pinv1 = (-1)**m * alm[idxBp] * valid
alm4pinv2 = np.conj(alm[idxBn]) * valid
alm4pinv = np.array([alm4pinv1, alm4pinv2])
# alm4pinv.shape =(2, l(lmax+1), m(lmax+1))
# => [0]:for m>=0, [1]:for m<=0
#----------------------------------------
if (flat): # healpy order
alm4pinv = alm4pinv.T[valid.T > 0.5].T
return alm4pinv
def ArrayRotation(self, bound, array, **kwargs):
'''
bound:
True | False
For 1D/2D/3D array
array[0,0,0] is the original point
ax: axis-0 of array: array.shape[0]
ay: axis-1 of array: array.shape[1]
az: axis-2 of array: array.shape[2]
'''
from jizhipy.Array import Invalid
import numpy as np
shape0 = array.shape
r = max(shape0) * 2**0.5 / 2 + 2
for i in range(len(shape0)):
d = int(r - shape0[i] / 2)
if (i == 0): halfshape = (d, ) + shape0[1:]
elif (i == 1): halfshape = (shape0[0], d, shape0[2])
elif (i == 2): halfshape = shape0[:-1] + (d, )
half = np.nan + np.zeros(halfshape)
array = np.concatenate([half, array, half], i)
shape = array.shape
#----------------------------------------
xyzAfter = [array * 0. for i in range(3)]
axis = 0
for xyz in xyzAfter:
if (len(shape) >= 1 and axis == 0):
for i in range(1, shape[0]):
xyz[i] = i
elif (len(shape) >= 1 and axis == 1):
for i in range(1, shape[1]):
xyz[:, i] = i
elif (len(shape) >= 1 and axis == 2):
for i in range(1, shape[2]):
xyz[:, :, i] = i
axis += 1
xyzBefore = self.xyzRotationPoint(xyzAfter, **kwargs)
#----------------------------------------
xyzBefore = xyzBefore.astype(int)
n = xyzBefore[-1]
for i in range(-2, -len(shape) - 1, -1):
n += xyzBefore[i] * np.prod(shape[:i + 1])
array = array.flatten(n.astype(int)).reshape(shape)
#----------------------------------------
mask = Invalid(array, None).mask
n = []
for i in range(len(shape)):
s = range(len(shape)).remove(i)
if (bound): tf = mask.prod(axis=s)
else: tf = mask.sum(axis=s)
n.append(np.arange(tf.size)[tf > 0])
for i in range(len(n)):
if (i == 0): array = array[n[i]]
elif (i == 1): array = array[:, n[i]]
elif (i == 2): array = array[:, :, n[i]]
return array
def _DoMultiprocess_Ylm(iterable):
import scipy.special as spsp
from jizhipy.Array import Invalid
import numpy as np
m, l, phi, theta = iterable[1]
ylm = np.zeros(m.size, np.dtype(iterable[2]))
for i in range(m.size):
ylmi = spsp.sph_harm(m[i], l[i], phi[i], theta[i])
if (Invalid(ylmi).mask == True): break
ylm[i] = ylmi.take(0)
return ylm
def _DoMultiprocess_Ylm_special(iterable):
import scipy.special as spsp
from jizhipy.Array import Invalid
import numpy as np
m, l = iterable[1]
theta, phi, dtypename = iterable[2]
ylm = np.zeros((m.size, ) + phi.shape, np.dtype(dtypename))
for i in range(m.size):
ylmi = spsp.sph_harm(m[i], l[i], np.pi / 1.5, np.pi / 2.5)
if (Invalid(ylmi).mask == True): continue
ylmi = spsp.sph_harm(m[i], l[i], phi, theta)
ylm[i] = ylmi
return ylm
def Smoothing(self, hpmap, fwhm, verbose=False):
'''
hpmap:
np.array(), with or without np.nan/np.inf
np.ma.MaskedArray()
'''
from jizhipy.Array import Invalid
import healpy as hp
import numpy as np
hpmap = Invalid(hpmap, True)
hpmap, mask = hpmap.data, hpmap.mask
hpmap = hp.smoothing(hpmap, fwhm, verbose=verbose)
hpmap[mask] = np.nan
return hpmap
def Graticule(hpmapORdlat=None, dlon=None, **kwargs):
'''
(1) Graticule( dlat, dlon ):
dlat, dlon in degree
(2) Graticule( hpmap ):
hpmap is healpix map
Example:
a = np.log10(jp.GSM2016(example=True))
nside = hp.get_nside(a)
hp.mollview(a, title='diffuse')
b = np.zeros(12*nside**2)
theta, phi = np.array(hp.pix2ang(nside, np.arange(12*nside**2)))*180/np.pi
b[(89.5<theta)*(theta<90.5)] = 1
b=jp.CoordTrans.HealpixRotation(b, ax=40)[-1]
jp.Plt.Graticule(b, color='r', ls='--', lw=3)
plt.show(), exit()
(3) Graticule( border=True, **kwargs )
plot border
'''
import matplotlib.pyplot as plt
import numpy as np
import healpy as hp
from jizhipy.Basic import IsType
from jizhipy.Array import Invalid
from jizhipy.Plot import GetSize, Scf, Sca, Zoom, Axes
fig0, ax0 = plt.gcf(), plt.gca()
if ('border' in kwargs.keys()):
theta_border = np.arange(0, 181) * np.pi / 180
border = bool(kwargs['border'])
kwargs.pop('border')
else:
border = False
#----------------------------------------
if (IsType.isnum(hpmapORdlat) and IsType.isnum(dlon)):
kwargs['verbose'] = False
hp.graticule(hpmapORdlat, dlon, **kwargs)
if (border):
ax0.projplot(theta_border,
theta_border * 0 - np.pi,
direct=True,
color='k',
ls='-',
lw=2)
ax0.projplot(theta_border,
theta_border * 0 + 0.9999 * np.pi,
direct=True,
color='k',
ls='-',
lw=2)
return ax0
#----------------------------------------
elif (hpmapORdlat is not None):
figsize, axsize = GetSize(fig0, ax0)
fig = plt.figure(figsize=(figsize['width'], figsize['height']))
hpmap = hp.mollview(hpmapORdlat,
fig=fig.number,
return_projected_map=True)
plt.close(fig)
del fig
hpmap = Invalid(hpmap)
hpmap.data[hpmap.mask] = 0
hpmap = hpmap.data
#----------------------------------------
drow = (1. * axsize['top'] - axsize['bottom']) / hpmap.shape[0]
dcol = (1. * axsize['right'] - axsize['left']) / hpmap.shape[1]
x, y = [], []
for i in range(1, hpmap.shape[1]):
b = hpmap[:, i]
n = np.arange(b.size)[b > 0.5]
if (n.size > 0):
x.append(axsize['left'] + dcol * i)
y.append(axsize['bottom'] + drow * n.mean())
Scf(fig0)
Sca(ax0)
Zoom(axsize)
plt.plot(x, y, **kwargs)
plt.xlim(axsize['left'], axsize['right'])
plt.ylim(axsize['bottom'], axsize['top'])
Axes.Frameoff()
plt.sca(ax0)
if (border):
ax0.projplot(theta_border,
theta_border * 0 - np.pi,
direct=True,
color='k',
ls='-',
lw=2)
ax0.projplot(theta_border,
theta_border * 0 + 0.9999 * np.pi,
direct=True,
color='k',
ls='-',
lw=2)
return ax0
#----------------------------------------
elif (border):
key = kwargs.keys()
if ('color' not in key): kwargs['color'] = 'k'
if ('lw' not in key and 'linewidth' not in key): kwargs['lw'] = 2
ax0.projplot(theta_border,
theta_border * 0 - np.pi,
direct=True,
**kwargs)
ax0.projplot(theta_border,
theta_border * 0 + 0.9999 * np.pi,
direct=True,
**kwargs)
return ax0
def Bins(self, array, nbins, weight=None, wmax2a=None, nsigma=None):
'''
nbins:
(1) ==list/ndarray with .size==3
** nbins, bmin, bmax = bins
nbins: number of bins
bmin, bmax: min and max of bins, NOT use the whole bin
(2) ==int_number:
** Then use weight and wmax2a
Give the total number of the bins, in this case, x.size=bins+1, xc.size=bins
nsigma:
float | None
When generate the bins, won't use the whole range of array, set nsigma, will use |array| <= nsigma*array.std()
weight:
** Use this only when bins==int_number
'G?', 'K?' | None | ndarray with size=bins
(1) ==None: each bin has the same weight => uniform bins
(2) ==ndarray: give weights to each bins
(3) =='G?':
'?' should be an value, for example, 'G1', 'G2.3', 'G5.4', 'G12', use Gaussian weight, and obtain it from np.linspace(-?, +?, bins)
=='K?':
'?' should be an value, for example, 'K1', 'K2.3', 'K5.4', 'K12', use modified Bessel functions of the second kind, and obtain it from np.linspace(-?, +?, bins)
wmax2a:
Use it when weight is not None
float | None
(1) ==float: weight.max() corresponds to which bin, the bin which value wmax2a is in
'''
import numpy as np
from jizhipy.Basic import IsType
from jizhipy.Array import Invalid, Asarray
from jizhipy.Math import Gaussian
#---------------------------------------------
array = Asarray(array)
if (nsigma is not None):
mean, sigma = array.mean(), array.std()
array = array[(mean - nsigma * sigma <= array) *
(array <= mean + nsigma * sigma)]
amin, amax = array.min(), array.max()
#---------------------------------------------
if (Asarray(nbins).size == 3): nbins, bmin, bmax = nbins
else: bmin, bmax = amin, amax
#---------------------------------------------
# First uniform bins
bins = np.linspace(bmin, bmax, nbins + 1)
bstep = bins[1] - bins[0]
#---------------------------------------------
# weight
if (weight is not None):
if (IsType.isstr(weight)):
w, v = str(weight[0]).lower(), abs(float(weight[1:]))
if (v == 0): v = 1
x = np.linspace(-v, v, nbins)
if (w == 'k'):
import scipy.special as spsp
weight = spsp.k0(abs(x))
weight = Invalid(weight)
weight.data[weight.mask] = 2 * weight.max()
else: # Gaussian
weight = Gaussian.GaussianValue1(x, 0, 0.4)
#--------------------
# wmax2a
if (wmax2a is not None):
nmax = int(round(np.where(weight == weight.max())[0].mean()))
nb = abs(bins - wmax2a)
nb = np.where(nb == nb.min())[0][0]
for i in range(bins.size - 1):
if (bins[i] <= wmax2a < bins[i + 1]):
nb = i
break
d = abs(nmax - nb)
if (nmax < nb): weight = np.append(weight[-d:], weight[:-d])
elif (nmax > nb): weight = np.append(weight[d:], weight[:d])
#--------------------
weight = weight[:nbins]
if (weight.size < nbins):
weight = np.concatenate([weight] +
(nbins - weight.size) * [weight[-1:]])
weight = weight.max() - weight + weight.min()
weight /= weight.sum()
weight = weight.cumsum()
#--------------------
c = bins[0] + (bmax - bmin) * weight
bins[1:-1] = c[:-1]
#--------------------
bins = list(bins)
n = 1
while (n < len(bins)):
if (bins[n] - bins[n - 1] < bstep / 20.):
bins = bins[:n] + bins[n + 1:]
else:
n += 1
bins = Asarray(bins)
#---------------------------------------------
return bins
def LM2Index(self, which, lmax, l, m, order=None, symmetry=True):
'''
Usage:
See MapMaking.py
lmax:
int, must be one
l, m:
Can be one or 1D array
order:
'2D': return 2D matrix with np.nan
None: remove np.nan and return 1D(flatten) ndarray
'l': return 1D array ordered by l from small to large
'm': return 1D array ordered by m from small to large
'i': return 1D array ordered by index from small to large
which == 'Alm' :
if (self.fgsymm) : index = (m*lmax - m*(m-1)/2 + l)
else :
if (m >= 0) : index = (m*lmax - m*(m-1)/2 + l)
else :
m = -m
index = (m-1)*self.lmax-m*(m-1)/2+l+self.offnm-1
which == 'AlmDS' :
index = l*(l+1) + m
return:
[index, morder, lorder]
'2D': index.shape=(l.size, m.size), lorder=l[:,None], morder=m[None,:]
Others: 1D with index.size==lorder.size==morder.size
'''
import numpy as np
from jizhipy.Array import Asarray, Invalid, Sort
from jizhipy.Basic import Raise
l, m = Asarray(l).flatten(), Asarray(m).flatten()
if (l[l > lmax].size > 0):
Raise(
Exception, 'l=[' + str(l.min()) + ', ..., ' + str(l.max()) +
'] > lmax=' + str(lmax))
if (abs(m)[abs(m) > lmax].size > 0):
Raise(
Exception, 'm=[' + str(m.min()) + ', ..., ' + str(m.max()) +
'] > lmax=' + str(lmax))
#--------------------------------------------------
#--------------------------------------------------
if (str(which).lower() == 'alm'):
if (symmetry):
index = lmax * m[None, :] - m[None, :] * (m[None, :] -
1) / 2. + l[:, None]
else:
morder = np.append(
np.arange(m.size)[m >= 0],
np.arange(m.size)[m < 0])
mpos, mneg = m[m >= 0], abs(m[m < 0])
indexpos = lmax * mpos[None, :] - mpos[None, :] * (
mpos[None, :] - 1) / 2. + l[:, None]
indexneg = lmax * (mneg[None, :] - 1) - mneg[None, :] * (
mneg[None, :] - 1) / 2. + l[:, None] + self.offnm - 1
index = np.append(indexpos, indexneg, 1)
indexpos = indexneg = mpos = mneg = 0 #@
index = index[:, morder]
#--------------------------------------------------
elif (str(which).lower() == 'almds'):
index = l[:, None] * (l[:, None] + 1) + m[None, :] + 0.
#--------------------------------------------------
#--------------------------------------------------
for i in range(l.size):
index[i, abs(m) > l[i]] = np.nan
#--------------------------------------------------
if (order == '2D'): return [index, m[None, :], l[:, None]]
#--------------------------------------------------
lorder = (index * 0 + 1) * l[:, None]
morder = (index * 0 + 1) * m[None, :]
lorder = Invalid(lorder, False).astype(int)
morder = Invalid(morder, False).astype(int)
index = Invalid(index, False).astype(int)
#--------------------------------------------------
if (order is not None):
if (str(order).lower() == 'i'): along = '[0,:]'
elif (str(order).lower() == 'l'): along = '[1,:]'
elif (str(order).lower() == 'm'): along = '[2,:]'
index = np.array([index, lorder, morder])
index, lorder, morder = Sort(index, along)
if (index.size == 1):
index, lorder, morder = index[0], lorder[0], morder[0]
return [index, morder, lorder]
def RemoveSource(inmap,
lb0,
lb1,
fwhm,
times=2,
same=False,
onebyone=True,
verbose=False):
'''
return:
(npix_source, inmap[npix_source])
Remove bright source from the healpix map
inmap:
input healpix map, 1D
lb0:
[degree], the center of the sources to be removed
l is longitude, b is latitude (theta=90-b)
(1) 2D: l0, b0 = lb0[:,0], lb0[:,1]
(2) .size==2: l0, b0 = lb0
lb1:
[degree], the center of the pixels which are used to fill the hole from sources removing
lb1.shape == lb0.shape
fwhm:
[degree]
isnum | islist
fwhm size of the sources
times:
fwhm*times to smooth the filling pixels
same:
(1) ==False: fill the hole of sources by the same shape regions centering at lb1
(2) ==True: use one value at lb1 to fill the hole for each sources
onebyone:
(1) ==True: handle the sources one by one, the result must be correct, but slower
(2) ==False: hand all sources together at once. The result is correct when all holes don't overlap. If they overlap, the result may be not correct
'''
import numpy as np
import healpy as hp
from jizhipy.Array import Invalid
from jizhipy.Process import ProgressBar
from jizhipy.Basic import IsType
if (verbose is True): pstr = 'jizhipy.RemoveSource:'
elif (verbose == '123'): pstr, verbose = ' ', True
if (same): onebyone = True
lb0, lb1 = np.array(lb0, float) * np.pi / 180, np.array(
lb1, float) * np.pi / 180
if (lb0.size == 2):
lb0 = lb0.flatten()[None, :]
lb1 = lb1.flatten()[None, :]
if (IsType.isnum(fwhm)): fwhm = fwhm + np.zeros(len(lb0))
fwhm = np.array(fwhm) * np.pi / 180
same, onebyone = bool(same), bool(onebyone)
inmap = np.array(inmap)
nside = hp.get_nside(inmap)
#--------------------------------------------------
def OneByOne(lb0, lb1, fwhm, nside, same):
l0, b0 = lb0
l1, b1 = lb1
# center of source
n0 = hp.ang2pix(nside, np.pi / 2 - b0, l0)
n1 = hp.ang2pix(nside, np.pi / 2 - b1, l1)
# source's region
a0 = np.zeros(12 * nside**2)
a0[n0] = 1000
a0 = hp.smoothing(a0, fwhm, verbose=False)
a0 /= a0.max()
pix = np.arange(12 * nside**2)
pix0 = pix[a0 > 0.4]
if (same): pix1 = n1 + 0 * pix0
else:
a1 = a0.copy()
a1[n1] = 1000
a1 = hp.smoothing(a1, fwhm, verbose=False)
a1 = a1 / a1.max()
pix1 = pix[a1 > 0.4][:pix0.size]
if (pix1.size < pix0.size):
pix1 = np.append(pix1, pix1[(pix1.size - pix0.size):][::-1])
return np.array([pix0, pix1])
#--------------------------------------------------
if (onebyone):
if (verbose): progressbar = ProgressBar(pstr, len(lb0))
pix = []
for i in range(len(lb0)):
if (verbose): progressbar.Progress()
pix.append(OneByOne(lb0[i], lb1[i], fwhm[i], nside, same))
pix = np.concatenate(pix, 1)
else:
pix = OneByOne(lb0.T, lb1.T, fwhm.mean(), nside, same)
#--------------------------------------------------
inmap[pix[0]] = inmap[pix[1]]
inmap = Invalid(inmap, True).data
inmap = hp.smoothing(inmap, fwhm.mean() * times, verbose=False)
return (pix[0], inmap[pix[0]])
def _Multiprocess_Smooth(iterable):
'''
nlr:
If reduceshape==False, large times will make the left and right edge worse and worse
(1) ==None: append first/last element
(2) ==True: set nlr=[len(array)/100, len(array)/100]
(3) ==[int, int]: set nlr=[int, int]
(4) isnum (float or int): as the outside value
(5) =='periodic': append right end to the left head, left head to right end
(6) ==False
(7) =='mirror': append mirror
'''
import numpy as np
from jizhipy.Optimize import Interp1d
import matplotlib.pyplot as plt
from jizhipy.Array import Invalid
array = iterable[1].T # smooth along axis-0
weight, nla, nra, sigma, nlr, case, fft = iterable[2]
N0, N1 = array.shape
#---------------------------------------------
if (case == 1): # nlr=None, append the first/last element
aleft = np.zeros((nla, N1), array.dtype)
if (nla != 0): aleft = aleft + array[:1]
aright = np.zeros((nra, N1), array.dtype) + array[-1:]
#---------------------------------------------
elif (case in [2, 3]): # nlr=True | (nl,nr), interp1d
nlr = np.array(nlr, int)
nlr[nlr > int(len(array) / 2)] = int(len(array) / 2)
nlr[nlr < 2] = 2
aleft0 = np.array([
array[:int(nlr[0] / 2)].mean(0),
array[int(nlr[0] / 2):nlr[0]].mean(0)
])
xl0 = np.array([nlr[0] / 4., nlr[0] * 3 / 4.])
aright0 = np.array([
array[-nlr[1]:-int(nlr[1] / 2)].mean(0),
array[-int(nlr[1] / 2):].mean(0)
])
xr0 = np.array([-nlr[1] * 3 / 4., -nlr[1] / 4.]) + len(array)
xl = np.arange(-nla, 0)
xr = np.arange(N0, N0 + nra)
aleft, aright = [], []
for i in range(N1):
if (nla == 0): aleft.append(np.zeros([0, N1], array.dtype))
else: aleft.append(Interp1d(xl0, aleft0[:, i], xl))
aright.append(Interp1d(xr0, aright0[:, i], xr))
aleft, aright = np.array(aleft).T, np.array(aright).T
#---------------------------------------------
elif (case in [4, 6]): # nlr=isnum | False
aleft = nlr + np.zeros((nla, N1), array.dtype)
aright = nlr + np.zeros((nra, N1), array.dtype)
#---------------------------------------------
elif (case == 5): # nlr='periodic'
if (nla == 0): aleft = np.zeros((nla, N1), array.dtype)
else: aleft = array[-nla:]
aright = array[:nra]
elif (case == 7): # nlr='mirror'
if (nla == 0): aleft = np.zeros((nla, N1), array.dtype)
else: aleft = array[:nla][::-1]
aright = array[-nra:][::-1]
#---------------------------------------------
#---------------------------------------------
if (not fft):
array = np.concatenate([aleft, array, aright], 0)
if (sigma is True): arrstd = array * 0
n1, n2, n = nla, len(array) - nra, len(weight)
arr = array * 0
weight = weight[:, None] # 2D
if (case != 6): w = weight
for i in range(n1, n2):
a = array[i - nla:i - nla + n]
if (case == 6):
tf = (1 - Invalid(a[:, 0]).mask).astype(bool)
if (tf.sum() < tf.size):
w = weight.copy()
w, a = w[tf], a[tf]
w /= w.sum()
else:
w = weight
arr[i] = (a * w).sum(0)
if (sigma is True): arrstd[i] = ((a - arr[i]) * w).std(0)
arr = arr[n1:n2]
if (sigma is True):
arrstd = arrstd[n1:n2]
arr = np.concatenate([arr, arrstd], 0)
#---------------------------------------------
#---------------------------------------------
else:
from jizhipy.Math import Convolve
if (case != 6):
array = np.concatenate([aleft, array, aright], 0)
n1, n2 = nla, len(array) - nra
if (sigma is True): arrstd = array * 0
n = weight.size - array.shape[0]
nl, nr = int(abs(n) / 2), int(abs(n) - abs(n) / 2)
if (n > 0): weight = weight[nl:-nr]
elif (n < 0):
weight = np.concatenate([np.zeros(nl), weight, np.zeros(nr)])
for i in range(array.shape[1]):
array[:, i] = Convolve(array[:, i], weight, 'linear')
if (case != 6):
array = array[n1:n2]
if (sigma is True): arrstd = arrstd[n1:n2]
arr = array
#---------------------------------------------
#---------------------------------------------
return arr
def Healpix2Flat(self,
lon=None,
lat=None,
dlon=None,
dlat=None,
Nlon=None,
Nlat=None,
hpmap=None,
nside=None,
ordering='RING'):
'''
npix, rehpmap = Healpix2Flat( hpmap=inhpmap )
rehpmap == inhpmap[npix]
(1) Healpix2Flat(lon, lat, dlon, dlat, Nlon, Nlat, hpmap)
(2) Healpix2Flat(lon, lat, None, dlat, None, Nlat, hpmap)
(3) Healpix2Flat(lon, lat, dlon, dlat, Nlon, Nlat, nside)
(4) Healpix2Flat(lon, lat, None, dlat, None, Nlat, nside)
(5) Healpix2Flat(hpmap): Nrow*Ncol = 4*12*nside**2
(6) Healpix2Flat(nside)
(7) Healpix2Flat( hpmap=remap, nside= ):
give 2D flat map, return healpixmap
return: npix | (npix, hpmap[npix])
****** Order of maps:
hp.mollview():
left -> right (RA) : 180 -> 0 -> -180
bottom -> top (Dec): -90 -> 0 -> 90
plt.pcolormesh():
left -> right (RA) : 180 -> 0 -> -180
bottom -> top (Dec): -90 -> 0 -> 90
np.array( hpmap[npix] ):
col[0] -> col[N-1] (RA) : 180 -> 0 -> -180
row[0] -> row[N-1] (Dec): -90 -> 0 -> 90
(RA+180, Dec-90) ... (RA-180, Dec-90)
(RA+180, Dec-80) ... (RA-180, Dec-80)
array = ...
(RA+180, Dec+90) ... (RA-180, Dec+90)
****************************************
lon, lat:
in degree
lon=RA or l, lat=Dec or b
Center of the region
dlon, dlat:
in degree
size of the region
(1) dlon !=None, dlat !=None
(2) dlon ==None, dlat !=None
Nlon, Nlat:
if (is None) : N = 2*int((12*nside**2)**0.5)
if (is str):
'2' : N = 2 * int((12*nside**2)**0.5)
'5.3': N = 5.3 * int((12*nside**2)**0.5)
hpmap, nside:
One of them must be !=None
return: npix | (npix, hpmap[npix])
NOTE THAT maybe not all npix are valid, use
mask = Invalid(theta).mask
'''
import numpy as np
import healpy as hp
from jizhipy.Astro import Beam
from jizhipy.Array import Invalid
from jizhipy.Basic import IsType
if (lon is None and lat is None and nside is not None
and hpmap is not None and len(hpmap.shape) == 2):
# case 7
NDec, NRA = hpmap.shape
Dec0, RA0 = -np.pi / 2, np.pi
dDec, dRA = np.pi / NDec, -2 * np.pi / NRA
theta, phi = hp.pix2ang(nside, np.arange(12 * nside**2))
theta = np.pi / 2 - theta
phi[phi > np.pi] -= 2 * np.pi
ntheta, nphi = ((theta - Dec0) /
dDec).astype(int), ((phi - RA0) / dRA).astype(int)
n = NRA * ntheta + nphi
hpmap = hpmap.flatten()[n]
return [n, hpmap]
#---------------------------------------------
#---------------------------------------------
if (hpmap is None):
hpmap, isnside = np.arange(12 * nside**2), True
else:
nside, isnside = hp.get_nside(hpmap), False
nest = False if (str(ordering).lower() == 'ring') else True
#---------------------------------------------
# Flat full sky
if (lon is None and lat is None):
N0 = 2 * int(12**0.5 * nside)
if (Nlon is None): Nlon = N0
elif (IsType.isstr(Nlon)): Nlon = int(float(Nlon) * N0)
if (Nlat is None): Nlat = N0
elif (IsType.isstr(Nlat)): Nlat = int(float(Nlat) * N0)
theta = np.linspace(0, np.pi, Nlat)
phi = np.linspace(-np.pi, np.pi, Nlon)
theta = theta[:, None] + 0 * phi[None, :]
phi = phi[None, :] + 0 * theta
npix = hp.ang2pix(nside, theta, phi, nest=nest)
npix = npix[::-1, ::-1]
if (isnside): return npix
else: return [npix, hpmap[npix]]
#--------------------------------------------------
#--------------------------------------------------
elif (lon is not None and lat is not None and dlon
is not None): # Healpix2Flat(lon, lat, dlon, dlat, Nlon, Nlat)
lon, lat, dlon, dlat = np.array([lon, lat, dlon, dlat
]) * np.pi / 180 # rad
if (Nlat is None): Nlat = Nlon
# left -> right (RA) : 180 -> 0 -> -180
# bottom -> top (Dec): -90 -> 0 -> 90
lat = np.linspace(lat - dlat / 2, lat + dlat / 2, Nlat)
lat[lat > np.pi / 2] = np.pi - lat[lat > np.pi / 2]
lat[lat < -np.pi / 2] = -np.pi - lat[lat < -np.pi / 2]
lon = np.linspace(lon - dlon / 2, lon + dlon / 2, Nlon)
lon %= 2 * np.pi
lon[lon > np.pi] -= 2 * np.pi
if ((lon[:-1] - lon[1:]).sum() < 0): lon = lon[::-1]
lon = lon[None, :] + 0 * lat[:, None]
lat = lat[:, None] + 0 * lon
npix = hp.ang2pix(nside, np.pi / 2 - lat, lon)
if (isnside): return npix
else: return [npix, hpmap[npix]]
#--------------------------------------------------
#--------------------------------------------------
elif (lon is not None and lat is not None
and dlon is None): # Healpix2Flat(lon, lat, dlat, Nlat)
thetawidth, Npix = dlat * np.pi / 180, Nlat
theta, phi = Beam.ThetaPhiMatrix(
thetawidth, Npix) # rad, np.nan may in theta,phi
#---------------------------------------------
mask = Invalid(theta).mask
theta[mask], phi[mask] = 0, 0
thetar, phir = self.thetaphiRotation([theta, phi],
ax=-(90 - lat),
az=-(lon + 90))
npix = hp.ang2pix(nside, thetar, phir, nest=nest)
npix = npix[::-1, ::-1]
#---------------------------------------------
if (isnside):
npix[mask] = -1
return npix
else:
rehpmap = hpmap[npix]
rehpmap[mask] = np.nan
npix[mask] = -1
return [npix, rehpmap]