def healpixellize(f_in, theta_in, phi_in, nside=16, verbose=False):
'''
A dumb method for converting data f sampled at points theta and phi
(not on a healpix grid)
into a healpix at resolution nside
Parameters
----------
f_in | array: square map
theta_in | array: latitude to grid to
phi_in | array in: longitude to grid to
nside | Optional[int]: healpix value (IONEX maps give nside=16 natively)
verbose | Optional[bool]: whether to print values and info or not
Returns
-------
array: healpixellized version of square map input
'''
# Input arrays are likely to be rectangular, but this is inconvenient
f = f_in.flatten()
theta = theta_in.flatten()
phi = phi_in.flatten()
pix = hp.ang2pix(nside, theta, phi)
hp_map = np.zeros(hp.nside2npix(nside))
hits = np.zeros(hp.nside2npix(nside))
for i, v in enumerate(f):
# Find the nearest pixels to the pixel in question
neighbours, weights = hp.get_interp_weights(nside, theta[i], phi[i])
# Add weighted values to hp_map
hp_map[neighbours] += v * weights
# Keep track of weights
hits[neighbours] += weights
hp_map = hp_map / hits
wh_no_hits = np.where(hits == 0)
if verbose:
print('pixels with no hits', wh_no_hits[0].shape)
hp_map[wh_no_hits[0]] = hp.UNSEEN
wh = np.where(hp_map == np.nan)[0]
for i, w in enumerate(wh):
neighbors = hp.get_interp_weights(nside, theta[i], phi[i])
hp_map[w] = np.median(neighbors)
return hp_map
def healpixellize(f_in, theta_in, phi_in, nside=16, verbose=False):
'''
A dumb method for converting data f sampled at points theta and phi
(not on a healpix grid)
into a healpix at resolution nside
Parameters
----------
f_in | array: square map
theta_in | array: latitude to grid to
phi_in | array in: longitude to grid to
nside | Optional[int]: healpix value (IONEX maps give nside=16 natively)
verbose | Optional[bool]: whether to print values and info or not
Returns
-------
array: healpixellized version of square map input
'''
# Input arrays are likely to be rectangular, but this is inconvenient
f = f_in.flatten()
theta = theta_in.flatten()
phi = phi_in.flatten()
pix = hp.ang2pix(nside, theta, phi)
hp_map = np.zeros(hp.nside2npix(nside))
hits = np.zeros(hp.nside2npix(nside))
for i, v in enumerate(f):
# Find the nearest pixels to the pixel in question
neighbours, weights = hp.get_interp_weights(nside, theta[i], phi[i])
# Add weighted values to hp_map
hp_map[neighbours] += v * weights
# Keep track of weights
hits[neighbours] += weights
hp_map = hp_map / hits
wh_no_hits = np.where(hits == 0)
if verbose:
print('pixels with no hits', wh_no_hits[0].shape)
hp_map[wh_no_hits[0]] = hp.UNSEEN
wh = np.where(hp_map == np.nan)[0]
for i, w in enumerate(wh):
neighbors = hp.get_interp_weights(nside, theta[i], phi[i])
hp_map[w] = np.median(neighbors)
return hp_map
def at(self, theta, phi, interp_pix=None, interp_weights=None):
"""
Use healpy bilinear interpolation to interpolate the
map. User must make sure that coordinate system used
for theta and phi matches the map coordinate system.
"""
if self._map is None:
raise RuntimeError("No temperature map to sample")
n = len(theta)
stepsize = self.buflen
signal = np.zeros(n, dtype=np.float32)
# DEBUG begin
if np.any(theta < 0) or np.any(theta > np.pi):
raise RuntimeError("bad theta")
if np.any(phi < 0) or np.any(phi > 2 * np.pi):
raise RuntimeError("bad phi")
# DEBUG end
for istart in range(0, n, stepsize):
istop = min(istart + stepsize, n)
ind = slice(istart, istop)
if interp_pix is None or interp_weights is None:
p, w = hp.get_interp_weights(self.nside,
theta[ind],
phi[ind],
nest=self.nest)
else:
p = np.ascontiguousarray(interp_pix[:, ind])
w = np.ascontiguousarray(interp_weights[:, ind])
buf = np.zeros(istop - istart, dtype=np.float64)
fast_scanning_float32(buf, p, w, self._map[:])
signal[ind] = buf
return signal
def _get_interp_weights(self, coords, idxs):
import healpy as hp
c = MapCoords.create(coords)
coords_ctr = list(coords[:2])
coords_ctr += [ax.pix_to_coord(t)
for ax, t in zip(self.geom.axes, idxs)]
pix_ctr = pix_tuple_to_idx(self.geom.coord_to_pix(coords_ctr))
pix_ctr = self.geom.global_to_local(pix_ctr)
if np.any(pix_ctr[0] == -1):
raise ValueError('HPX pixel index out of map bounds.')
theta = np.array(np.pi / 2. - np.radians(c.lat), ndmin=1)
phi = np.array(np.radians(c.lon), ndmin=1)
if self.geom.nside.size > 1:
nside = self.geom.nside[idxs]
else:
nside = self.geom.nside
pix, wts = hp.get_interp_weights(nside, theta,
phi, nest=self.geom.nest)
if self.geom.nside.size > 1:
pix_local = [self.geom.global_to_local([pix] + list(idxs))[0]]
else:
pix_local = [self.geom[pix]]
m = pix_local[0] == -1
pix_local[0][m] = (pix_ctr[0] * np.ones(pix.shape, dtype=int))[m]
return pix_local + list(idxs), wts
def probability(self, ra, dec, dist):
"""
returns probability density at given ra, dec, dist
p(ra,dec) * p(dist | ra,dec )
RA, dec : radians
dist : Mpc
"""
theta = np.pi / 2.0 - dec
# Step 1: find 4 nearest pixels
(pixnums, weights) = \
hp.get_interp_weights(self.nside, theta, ra,
nest=self.nested, lonlat=False)
dist_pdfs = [
scipy.stats.norm(loc=self.mean[i], scale=self.sigma[i])
for i in pixnums
]
# Step 2: compute p(ra,dec)
# p(ra, dec) = sum_i weight_i p(pixel_i)
probvals = np.array([
self.distnorm[i] * dist_pdfs[i].pdf(dist)
for i, pixel in enumerate(pixnums)
])
skyprob = self.prob[pixnums]
p_ra_dec = np.sum(weights * probvals * skyprob)
return (p_ra_dec)
def healpixellize(f_in,theta_in,phi_in,nside,fancy=True):
""" A dumb method for converting data f sampled at points theta and phi (not on a healpix grid) into a healpix at resolution nside """
# Input arrays are likely to be rectangular, but this is inconvenient
f = f_in.flatten()
theta = theta_in.flatten()
phi = phi_in.flatten()
pix = hp.ang2pix(nside,theta,phi)
map = np.zeros(hp.nside2npix(nside))
hits = np.zeros(hp.nside2npix(nside))
# Simplest gridding is map[pix] = val. This tries to do some
#averaging Better would be to do some weighting by distance from
#pixel center or something ...
if (fancy):
for i,v in enumerate(f):
# Find the nearest pixels to the pixel in question
neighbours,weights = hp.get_interp_weights(nside,theta[i],phi[i])
# Add weighted values to map
map[neighbours] += v*weights
# Keep track of weights
hits[neighbours] += weights
map = map/hits
wh_no_hits = np.where(hits == 0)
print 'pixels with no hits',wh_no_hits[0].shape
map[wh_no_hits[0]] = hp.UNSEEN
else:
for i,v in enumerate(f):
map[pix[i]] += v
hits[pix[i]] +=1
map = map/hits
return map
def interp_weights(self, coords, idxs=None):
"""Get interpolation weights for given coords
Parameters
----------
coords : `MapCoord` or dict
Input coordinates
idxs : `~numpy.ndarray`
Indices for non-spatial axes.
Returns
-------
weights : `~numpy.ndarray`
Interpolation weights
"""
import healpy as hp
coords = MapCoord.create(coords, frame=self.frame).broadcasted
if idxs is None:
idxs = self.coord_to_idx(coords, clip=True)[1:]
theta, phi = coords.theta, coords.phi
m = ~np.isfinite(theta)
theta[m] = 0
phi[m] = 0
if not self.is_regular:
nside = self.nside[tuple(idxs)]
else:
nside = self.nside
pix, wts = hp.get_interp_weights(nside, theta, phi, nest=self.nest)
wts[:, m] = 0
pix[:, m] = INVALID_INDEX.int
if not self.is_regular:
pix_local = [self.global_to_local([pix] + list(idxs))[0]]
else:
pix_local = [self.global_to_local(pix, ravel=True)]
# If a pixel lies outside of the geometry set its index to the center pixel
m = pix_local[0] == INVALID_INDEX.int
if m.any():
coords_ctr = [coords.lon, coords.lat]
coords_ctr += [
ax.pix_to_coord(t) for ax, t in zip(self.axes, idxs)
]
idx_ctr = self.coord_to_idx(coords_ctr)
idx_ctr = self.global_to_local(idx_ctr)
pix_local[0][m] = (idx_ctr[0] * np.ones(pix.shape, dtype=int))[m]
pix_local += [np.broadcast_to(t, pix_local[0].shape) for t in idxs]
return pix_local, wts
def crd2px(self, c1, c2, c3=None, interpolate=False):
"""Convert 1 dimensional arrays of input coordinates to pixel indices. If only c1,c2 provided, then read them as th,phi. If c1,c2,c3 provided, read them as x,y,z. If interpolate is False, return a single pixel coordinate. If interpolate is True, return px,wgts where each entry in px contains the 4 pixels adjacent to the specified location, and wgt contains the 4 corresponding weights of those pixels."""
is_nest = (self._scheme == 'NEST')
if not interpolate:
if c3 is None: # th/phi angle mode
px = healpy.ang2pix(self._nside, c1, c2, nest=is_nest)
else: # x,y,z mode
px = healpy.vec2pix(self._nside, c1, c2, c3, nest=is_nest)
return px
else:
if c3 is not None: # need to translate xyz to th/phi
c1,c2 = healpy.vec2ang(np.array([c1,c2,c3]).T)
px,wgts = healpy.get_interp_weights(self._nside, c1, c2, nest=is_nest)
return px.T, wgts.T
def crd2px(self, c1, c2, c3=None, interpolate=False):
"""Convert 1 dimensional arrays of input coordinates to pixel indices. If only c1,c2 provided, then read them as th,phi. If c1,c2,c3 provided, read them as x,y,z. If interpolate is False, return a single pixel coordinate. If interpolate is True, return px,wgts where each entry in px contains the 4 pixels adjacent to the specified location, and wgt contains the 4 corresponding weights of those pixels."""
is_nest = (self._scheme == 'NEST')
if not interpolate:
if c3 is None: # th/phi angle mode
px = healpy.ang2pix(self._nside, c1, c2, nest=is_nest)
else: # x,y,z mode
px = healpy.vec2pix(self._nside, c1, c2, c3, nest=is_nest)
return px
else:
if c3 is not None: # need to translate xyz to th/phi
c1, c2 = healpy.vec2ang(np.array([c1, c2, c3]).T)
px, wgts = healpy.get_interp_weights(self._nside,
c1,
c2,
nest=is_nest)
return px.T, wgts.T
def _get_interp_weights(self, coords, idxs):
import healpy as hp
c = MapCoord.create(coords)
coords_ctr = list(coords[:2])
coords_ctr += [
ax.pix_to_coord(t) for ax, t in zip(self.geom.axes, idxs)
]
idx_ctr = pix_tuple_to_idx(self.geom.coord_to_pix(coords_ctr))
idx_ctr = self.geom.global_to_local(idx_ctr)
theta = np.array(np.pi / 2. - np.radians(c.lat), ndmin=1)
phi = np.array(np.radians(c.lon), ndmin=1)
m = ~np.isfinite(theta)
theta[m] = 0.0
phi[m] = 0.0
if self.geom.nside.size > 1:
nside = self.geom.nside[idxs]
else:
nside = self.geom.nside
pix, wts = hp.get_interp_weights(nside,
theta,
phi,
nest=self.geom.nest)
wts[:, m] = 0.0
pix[:, m] = -1
if not self.geom.is_regular:
pix_local = [self.geom.global_to_local([pix] + list(idxs))[0]]
else:
pix_local = [self.geom[pix]]
# If a pixel lies outside of the geometry set its index to the
# center pixel
m = pix_local[0] == -1
pix_local[0][m] = (idx_ctr[0] * np.ones(pix.shape, dtype=int))[m]
pix_local += [np.broadcast_to(t, pix_local[0].shape) for t in idxs]
return pix_local, wts
def _get_interp_weights(self, coords, idxs=None):
import healpy as hp
if idxs is None:
idxs = self.geom.coord_to_idx(coords, clip=True)[1:]
theta, phi = coords.theta, coords.phi
m = ~np.isfinite(theta)
theta[m] = 0
phi[m] = 0
if not self.geom.is_regular:
nside = self.geom.nside[tuple(idxs)]
else:
nside = self.geom.nside
pix, wts = hp.get_interp_weights(nside,
theta,
phi,
nest=self.geom.nest)
wts[:, m] = 0
pix[:, m] = INVALID_INDEX.int
if not self.geom.is_regular:
pix_local = [self.geom.global_to_local([pix] + list(idxs))[0]]
else:
pix_local = [self.geom[pix]]
# If a pixel lies outside of the geometry set its index to the center pixel
m = pix_local[0] == INVALID_INDEX.int
if m.any():
coords_ctr = [coords.lon, coords.lat]
coords_ctr += [
ax.pix_to_coord(t) for ax, t in zip(self.geom.axes, idxs)
]
idx_ctr = self.geom.coord_to_idx(coords_ctr)
idx_ctr = self.geom.global_to_local(idx_ctr)
pix_local[0][m] = (idx_ctr[0] * np.ones(pix.shape, dtype=int))[m]
pix_local += [np.broadcast_to(t, pix_local[0].shape) for t in idxs]
return pix_local, wts
def _get_interp_weights(self, coords, idxs):
import healpy as hp
c = MapCoord.create(coords)
coords_ctr = list(coords[:2])
coords_ctr += [ax.pix_to_coord(t)
for ax, t in zip(self.geom.axes, idxs)]
idx_ctr = pix_tuple_to_idx(self.geom.coord_to_pix(coords_ctr))
idx_ctr = self.geom.global_to_local(idx_ctr)
theta = np.array(np.pi / 2. - np.radians(c.lat), ndmin=1)
phi = np.array(np.radians(c.lon), ndmin=1)
m = ~np.isfinite(theta)
theta[m] = 0.0
phi[m] = 0.0
if self.geom.nside.size > 1:
nside = self.geom.nside[idxs]
else:
nside = self.geom.nside
pix, wts = hp.get_interp_weights(nside, theta,
phi, nest=self.geom.nest)
wts[:, m] = 0.0
pix[:, m] = -1
if not self.geom.is_regular:
pix_local = [self.geom.global_to_local([pix] + list(idxs))[0]]
else:
pix_local = [self.geom[pix]]
# If a pixel lies outside of the geometry set its index to the
# center pixel
m = pix_local[0] == -1
pix_local[0][m] = (idx_ctr[0] * np.ones(pix.shape, dtype=int))[m]
pix_local += [np.broadcast_to(t, pix_local[0].shape) for t in idxs]
return pix_local, wts
def _get_interp_weights(self, coords, idxs):
import healpy as hp
c = MapCoords.create(coords)
coords_ctr = list(coords[:2])
coords_ctr += [
ax.pix_to_coord(t) for ax, t in zip(self.geom.axes, idxs)
]
pix_ctr = pix_tuple_to_idx(self.geom.coord_to_pix(coords_ctr))
pix_ctr = self.geom.global_to_local(pix_ctr)
if np.any(pix_ctr[0] == -1):
raise ValueError('HPX pixel index out of map bounds.')
theta = np.array(np.pi / 2. - np.radians(c.lat), ndmin=1)
phi = np.array(np.radians(c.lon), ndmin=1)
if self.geom.nside.size > 1:
nside = self.geom.nside[idxs]
else:
nside = self.geom.nside
pix, wts = hp.get_interp_weights(nside,
theta,
phi,
nest=self.geom.nest)
if self.geom.nside.size > 1:
pix_local = [self.geom.global_to_local([pix] + list(idxs))[0]]
else:
pix_local = [self.geom[pix]]
m = pix_local[0] == -1
pix_local[0][m] = (pix_ctr[0] * np.ones(pix.shape, dtype=int))[m]
return pix_local + list(idxs), wts
def healpixellize(f_in, theta_in, phi_in, nside, fancy=True, verbose=False):
""" A dumb method for converting data f sampled at points theta and phi (not on a healpix grid) into a healpix at resolution nside """
# Input arrays are likely to be rectangular, but this is inconvenient
f = f_in.flatten()
theta = theta_in.flatten()
phi = phi_in.flatten()
pix = hp.ang2pix(nside, theta, phi)
map = np.zeros(hp.nside2npix(nside))
hits = np.zeros(hp.nside2npix(nside))
# Simplest gridding is map[pix] = val. This tries to do some
#averaging Better would be to do some weighting by distance from
#pixel center or something ...
if (fancy):
for i, v in enumerate(f):
# Find the nearest pixels to the pixel in question
neighbours, weights = hp.get_interp_weights(
nside, theta[i], phi[i])
# Add weighted values to map
map[neighbours] += v * weights
# Keep track of weights
hits[neighbours] += weights
map = map / hits
wh_no_hits = np.where(hits == 0)
#print 'pixels with no hits',wh_no_hits[0].shape
map[wh_no_hits[0]] = hp.UNSEEN
else:
for i, v in enumerate(f):
map[pix[i]] += v
hits[pix[i]] += 1
map = map / hits
if verbose:
print 'Healpixellization successful.'
return map
def _get_interp_weights(self, coords, idxs=None):
import healpy as hp
if idxs is None:
idxs = self.geom.coord_to_idx(coords, clip=True)[1:]
theta, phi = coords.theta, coords.phi
m = ~np.isfinite(theta)
theta[m] = 0
phi[m] = 0
if not self.geom.is_regular:
nside = self.geom.nside[tuple(idxs)]
else:
nside = self.geom.nside
pix, wts = hp.get_interp_weights(nside, theta, phi, nest=self.geom.nest)
wts[:, m] = 0
pix[:, m] = INVALID_INDEX.int
if not self.geom.is_regular:
pix_local = [self.geom.global_to_local([pix] + list(idxs))[0]]
else:
pix_local = [self.geom[pix]]
# If a pixel lies outside of the geometry set its index to the center pixel
m = pix_local[0] == INVALID_INDEX.int
if m.any():
coords_ctr = [coords.lon, coords.lat]
coords_ctr += [ax.pix_to_coord(t) for ax, t in zip(self.geom.axes, idxs)]
idx_ctr = self.geom.coord_to_idx(coords_ctr)
idx_ctr = self.geom.global_to_local(idx_ctr)
pix_local[0][m] = (idx_ctr[0] * np.ones(pix.shape, dtype=int))[m]
pix_local += [np.broadcast_to(t, pix_local[0].shape) for t in idxs]
return pix_local, wts
def at(self, theta, phi, interp_pix=None, interp_weights=None):
"""
Use healpy bilinear interpolation to interpolate the
map. User must make sure that coordinate system used
for theta and phi matches the map coordinate system.
"""
autotimer = timing.auto_timer(type(self).__name__)
if self._map is None:
raise RuntimeError('No temperature map to sample')
n = len(theta)
stepsize = self.buflen
signal = np.zeros(n, dtype=np.float32)
# DEBUG begin
if np.any(theta < 0) or np.any(theta > np.pi):
raise RuntimeError('bad theta')
if np.any(phi < 0) or np.any(phi > 2 * np.pi):
raise RuntimeError('bad phi')
# DEBUG end
for istart in range(0, n, stepsize):
istop = min(istart + stepsize, n)
ind = slice(istart, istop)
if interp_pix is None or interp_weights is None:
p, w = hp.get_interp_weights(self.nside, theta[ind], phi[ind],
nest=self.nest)
else:
p = np.ascontiguousarray(interp_pix[:, ind])
w = np.ascontiguousarray(interp_weights[:, ind])
buf = np.zeros(istop - istart, dtype=np.float64)
fast_scanning32(buf, p, w, self._map[:])
signal[ind] = buf
del autotimer
return signal
hp.orthview(UT22,
rot=[0, 90],
max=2,
unit=r'rad m$^{-1}$',
title='SAST 00:00 2012-02-13',
half_sky=True)
#pylab.show()
print UT22
print 'Interpolating NaNs'
UT22_interp = np.zeros_like(UT22)
c = 0
for i, val in enumerate(UT22):
if np.isnan(val):
c += 1
theta, phi = hp.pix2ang(nside, i)
neybs = hp.get_interp_weights(nside, theta, phi=phi)
v = np.nanmean(UT22[neybs[0]])
UT22_interp[i] = v
else:
UT22_interp[i] = val
print c, 'NaN vals'
hp.orthview(UT22_interp,
rot=[0, 90],
min=0,
max=2,
unit=r'rad m$^{-1}$',
title='SAST 00:00 2012-02-13',
half_sky=True)
#pylab.show()
def atpol(
self,
theta,
phi,
IQUweight,
onlypol=False,
interp_pix=None,
interp_weights=None,
pol=True,
pol_deriv=False,
):
"""
Use healpy bilinear interpolation to interpolate the
map. User must make sure that coordinate system used
for theta and phi matches the map coordinate system.
IQUweight is an array of shape (nsamp,3) returned by the
pointing library that gives the weights of the I,Q, and U maps.
Args:
pol_deriv(bool): Return the polarization angle derivative
of the signal instead of the actual signal.
"""
if onlypol and not self.pol:
return None
if not self.pol or not pol:
return self.at(theta,
phi,
interp_pix=interp_pix,
interp_weights=interp_weights)
if np.shape(IQUweight)[1] != 3:
raise RuntimeError("Cannot sample polarized map with only "
"intensity weights")
n = len(theta)
stepsize = self.buflen
signal = np.zeros(n, dtype=np.float32)
for istart in range(0, n, stepsize):
istop = min(istart + stepsize, n)
ind = slice(istart, istop)
if interp_pix is None or interp_weights is None:
p, w = hp.get_interp_weights(self.nside,
theta[ind],
phi[ind],
nest=self.nest)
else:
p = np.ascontiguousarray(interp_pix[:, ind])
w = np.ascontiguousarray(interp_weights[:, ind])
weights = np.ascontiguousarray(IQUweight[ind].T)
buf = np.zeros(istop - istart, dtype=np.float64)
fast_scanning_float32(buf, p, w, self._map_Q[:])
if pol_deriv:
signal[ind] = -2 * weights[2] * buf
else:
signal[ind] = weights[1] * buf
buf[:] = 0
fast_scanning_float32(buf, p, w, self._map_U[:])
if pol_deriv:
signal[ind] += 2 * weights[1] * buf
else:
signal[ind] += weights[2] * buf
if not onlypol:
if self._map is None:
raise RuntimeError("No temperature map to sample")
buf[:] = 0
fast_scanning_float32(buf, p, w, self._map[:])
signal[ind] += weights[0] * buf
return signal
def atpol(self, theta, phi, IQUweight, onlypol=False,
interp_pix=None, interp_weights=None, pol=True,
pol_deriv=False):
"""
Use healpy bilinear interpolation to interpolate the
map. User must make sure that coordinate system used
for theta and phi matches the map coordinate system.
IQUweight is an array of shape (nsamp,3) returned by the
pointing library that gives the weights of the I,Q, and U maps.
Args:
pol_deriv(bool): Return the polarization angle derivative
of the signal instead of the actual signal.
"""
autotimer = timing.auto_timer(type(self).__name__)
if onlypol and not self.pol:
return None
if not self.pol or not pol:
return self.at(theta, phi, interp_pix=interp_pix,
interp_weights=interp_weights)
if np.shape(IQUweight)[1] != 3:
raise RuntimeError('Cannot sample polarized map with only '
'intensity weights')
n = len(theta)
stepsize = self.buflen
signal = np.zeros(n, dtype=np.float32)
for istart in range(0, n, stepsize):
istop = min(istart + stepsize, n)
ind = slice(istart, istop)
if interp_pix is None or interp_weights is None:
p, w = hp.get_interp_weights(self.nside, theta[ind], phi[ind],
nest=self.nest)
else:
p = np.ascontiguousarray(interp_pix[:, ind])
w = np.ascontiguousarray(interp_weights[:, ind])
weights = np.ascontiguousarray(IQUweight[ind].T)
buf = np.zeros(istop - istart, dtype=np.float64)
fast_scanning32(buf, p, w, self._map_Q[:])
if pol_deriv:
signal[ind] = -2 * weights[2] * buf
else:
signal[ind] = weights[1] * buf
buf[:] = 0
fast_scanning32(buf, p, w, self._map_U[:])
if pol_deriv:
signal[ind] += 2 * weights[1] * buf
else:
signal[ind] += weights[2] * buf
if not onlypol:
if self._map is None:
raise RuntimeError('No temperature map to sample')
buf[:] = 0
fast_scanning32(buf, p, w, self._map[:])
signal[ind] += weights[0] * buf
del autotimer
return signal
def convert_to_healpix(theta, phi, gains, nside=32, interp_method='spline', gainunit_in='dB', gainunit_out=None, angunits='radians'):
try:
theta, phi, gains
except NameError:
raise NameError('Inputs theta, phi and gains must be specified')
if not HP.isnsideok(nside):
raise ValueError('Specified nside invalid')
if not isinstance(interp_method, str):
raise TypeError('Input interp_method must be a string')
if interp_method not in ['spline', 'nearest', 'healpix']:
raise valueError('Input interp_method value specified is invalid')
if gains.shape == (theta.size, phi.size):
gridded = True
elif (gains.size == theta.size) and (gains.size == phi.size):
gridded = False
else:
raise ValueError('Inputs theta, phi and gains have incompatible dimensions')
if angunits.lower() == 'degrees':
theta = NP.radians(theta)
phi = NP.radians(phi)
phi = NP.angle(NP.exp(1j*phi)) # Bring all phi in [-pi,pi] range
phi[phi<0.0] += 2*NP.pi # Bring all phi in [0, 2 pi] range
hmap = NP.empty(HP.nside2npix(nside))
wtsmap = NP.empty(HP.nside2npix(nside))
hmap.fill(NP.nan)
wtsmap.fill(NP.nan)
if interp_method == 'spline':
if gainunit_in.lower() != 'db':
gains = 10.0 * NP.log10(gains)
hpxtheta, hpxphi = HP.pix2ang(nside, NP.arange(HP.nside2npix(nside)))
# Find the in-bound and out-of-bound indices to handle the boundaries
inb = NP.logical_and(NP.logical_and(hpxtheta>=theta.min(), hpxtheta<=theta.max()), NP.logical_and(hpxphi>=phi.min(), hpxphi<=phi.max()))
pub = hpxphi < phi.min()
pob = hpxphi > phi.max()
oob = NP.logical_not(inb)
inb_ind = NP.where(inb)[0]
oob_ind = NP.where(oob)[0]
pub_ind = NP.where(pub)[0]
pob_ind = NP.where(pob)[0]
# Perform regular interpolation in in-bound indices
if NP.any(inb):
if gridded:
interp_func = interpolate.RectBivariateSpline(theta, phi, gains)
hmap[inb_ind] = interp_func.ev(hpxtheta[inb_ind], hpxphi[inb_ind])
else:
# interp_func = interpolate.interp2d(theta, phi, gains, kind='cubic')
# hmap = interp_func(hpxtheta, hpxphi)
hmap[inb_ind] = interpolate.griddata(NP.hstack((theta.reshape(-1,1),phi.reshape(-1,1))), gains, NP.hstack((hpxtheta[inb_ind].reshape(-1,1),hpxphi[inb_ind].reshape(-1,1))), method='cubic')
if NP.any(pub): # Under bound at phi=0
phi[phi>NP.pi] -= 2*NP.pi # Bring oob phi in [-pi, pi] range
if gridded:
interp_func = interpolate.RectBivariateSpline(theta, phi, gains)
hmap[pub_ind] = interp_func.ev(hpxtheta[pub_ind], hpxphi[pub_ind])
else:
# interp_func = interpolate.interp2d(theta, phi, gains, kind='cubic')
# hmap = interp_func(hpxtheta, hpxphi)
hmap[pub_ind] = interpolate.griddata(NP.hstack((theta.reshape(-1,1),phi.reshape(-1,1))), gains, NP.hstack((hpxtheta[pub_ind].reshape(-1,1),hpxphi[pub_ind].reshape(-1,1))), method='cubic')
if NP.any(pob): # Over bound at phi=2 pi
phi[phi<0.0] += 2*NP.pi # Bring oob phi in [0, 2 pi] range
phi[phi<NP.pi] += 2*NP.pi # Bring oob phi in [pi, 3 pi] range
if gridded:
interp_func = interpolate.RectBivariateSpline(theta, phi, gains)
hmap[pob_ind] = interp_func.ev(hpxtheta[pob_ind], hpxphi[pob_ind])
else:
# interp_func = interpolate.interp2d(theta, phi, gains, kind='cubic')
# hmap = interp_func(hpxtheta, hpxphi)
hmap[pob_ind] = interpolate.griddata(NP.hstack((theta.reshape(-1,1),phi.reshape(-1,1))), gains, NP.hstack((hpxtheta[pob_ind].reshape(-1,1),hpxphi[pob_ind].reshape(-1,1))), method='cubic')
hmap -= NP.nanmax(hmap)
if gainunit_out.lower() != 'db':
hmap = 10**(hmap/10)
else:
if gainunit_in.lower() == 'db':
gains = 10**(gains/10.0)
if gridded:
phi_flattened, theta_flattened = NP.meshgrid(phi, theta)
theta_flattened = theta_flattened.flatten()
phi_flattened = phi_flattened.flatten()
gains = gains.flatten()
else:
theta_flattened = theta
phi_flattened = phi
if interp_method == 'healpix':
ngbrs, wts = HP.get_interp_weights(nside, theta_flattened, phi=phi_flattened)
gains4 = gains.reshape(1,-1) * NP.ones(ngbrs.shape[0]).reshape(-1,1)
wtsmap, be, bn, ri = OPS.binned_statistic(ngbrs.ravel(), values=wts.ravel(), statistic='sum', bins=NP.arange(HP.nside2npix(nside)+1))
hmap, be, bn, ri = OPS.binned_statistic(ngbrs.ravel(), values=(wts*gains4).ravel(), statistic='sum', bins=NP.arange(HP.nside2npix(nside)+1))
else: # nearest neighbour
ngbrs = HP.ang2pix(nside, theta_flattened, phi_flattened)
wtsmap, be, bn, ri = OPS.binned_statistic(ngbrs.ravel(), statistic='count', bins=NP.arange(HP.nside2npix(nside)+1))
hmap, be, bn, ri = OPS.binned_statistic(ngbrs.ravel(), values=gains.ravel(), statistic='sum', bins=NP.arange(HP.nside2npix(nside)+1))
ind_nan = NP.isnan(wtsmap)
other_nanind = wtsmap < 1e-12
ind_nan = ind_nan | other_nanind
wtsmap[ind_nan] = NP.nan
hmap /= wtsmap
hmap /= NP.nanmax(hmap)
if gainunit_out.lower() == 'db':
hmap = 10.0 * NP.log10(hmap)
ind_nan = NP.isnan(hmap)
hmap[ind_nan] = HP.UNSEEN
return hmap
