def test_mask_errors():
with pytest.raises(RuntimeError): # Badly shaped input
nmt.mask_apodization(MT.msk[:13], MT.aposize, apotype="C1")
with pytest.raises(RuntimeError): # Negative apodization
nmt.mask_apodization(MT.msk, -MT.aposize, apotype="C1")
with pytest.raises(RuntimeError): # Wrong apodization type
nmt.mask_apodization(MT.msk, MT.aposize, apotype="C3")
with pytest.raises(RuntimeError): # Aposize too small
nmt.mask_apodization(MT.msk[:12 * 2**2], 1., apotype='C1')
with pytest.raises(RuntimeError):
nmt.mask_apodization(MT.msk[:12 * 2**2], 1., apotype='Smooth')
def _get_mask(self):
msk = hp.read_map(self.config['file_mask'], dtype=float)
msk = rotate_mask(msk, self.rot, binarize=True)
# Apodize
msk = nmt.mask_apodization(msk, self.mask_aposize, self.mask_apotype)
msk = hp.ud_grade(msk, nside_out=self.nside)
return msk
def so_mask_hits(nside, aposcale=20, gal_mask=None):
""" Function to return mask on which power spectra will be calculated. This
combines the SO hits map (passed as the hits map to each field, not square root)
with a Galactic mask from Planck (between 20 and 80 % of the sky unmasked) by
simply multiplying the two masks. The resulting mask then has an additional
tapering applied to ensure the second derivative is zero at the boundary.
Parameters
----------
nside: int
Resolution at which to calculate the mask.
aposcale: float
Parameter relevant to the additional tapering applied. This is the length
scale of the taper, and is defined in the NaMaster documentation. Note that
we use the 'C2' apodization scheme, which is outlined in Grain et al. 2009.
gal_mask: int
Field of the Planck mask fits file to use. This can be 0 - 6. Increasing
numbers refer to less masking.
Returns
-------
ndarray(float)
Scalar mask at resolution given by `nside`.
"""
mask = get_nhits(nside)
if gal_mask is not None:
# read planck mask at a given nside, and make binary by applying the
# numpy.ceil function.
mask *= np.ceil(
hp.ud_grade(hp.read_map(_GAL_MASK, field=gal_mask, verbose=False),
nside_out=nside))
# apply an additional C2 apodization to the nhits mask + galactic mask
return nmt.mask_apodization(mask, aposcale, apotype="C2")
def __init__(self, mask_in, nside, bin_w, lmin, lmax, beams, wsp = True):
'''
class for Band-Power-Estimation;
Define the **apodized mask**, **beam weights**, **nside**, **bin-scheme**, **ell**
------------------------
beams : a numpy array which include fwhms for every frequency. Deconvolve to ** lmax=2*nside **
'''
self.mask = nmt.mask_apodization(mask_in, 6, apotype='C2')
self.nside = nside; self.lmax = lmax; self.Nf = len(beams); self.beams = beams;
# self.beam = hp.gauss_beam(beams/60/180*np.pi, lmax = 3*self.nside);
# self.b = nmt.NmtBin(self.nside, nlb=bin_w, lmax=self.lmax, is_Dell = True)
self.b = self.bands(bin_w = bin_w, lmin = lmin, lmax = lmax);
self.ell_n = self.b.get_effective_ells(); self.lbin = len(self.ell_n)
# self.w00 = [];
# self.w02 = [];
self.w22 = [];
# - To construct a empty template with a mask to calculate the **coupling matrix**
if wsp is True:
qu = np.ones((2, 12*self.nside**2))
for i in range(self.Nf):
beam_i = hp.gauss_beam(beams[i]/60/180*np.pi, lmax = 3*self.nside - 1);
# m0 = nmt.NmtField(self.mask,[qu[0]],purify_e=False, purify_b=True, beam = beam_i);
# # construct a workspace that calculate the coupling matrix first.
# _w00 = nmt.NmtWorkspace()
# _w00.compute_coupling_matrix(m0, m0, self.b) ## spin-0 with spin-0
# self.w00.append(_w00);
for j in range(self.Nf):
beam_j = hp.gauss_beam(beams[j]/60/180*np.pi, lmax = 3*self.nside - 1);
m20 = nmt.NmtField(self.mask, qu, purify_e=False, purify_b=True, beam = beam_i);
m21 = nmt.NmtField(self.mask, qu, purify_e=False, purify_b=True, beam = beam_j);
# _w02 = nmt.NmtWorkspace()
# _w02.compute_coupling_matrix(m0, m21, self.b) ## spin-0 with spin-2
_w22 = nmt.NmtWorkspace()
_w22.compute_coupling_matrix(m20, m21, self.b) ## spin-2 with spin-2
# self.w02.append(_w02);
self.w22.append(_w22)
def main(cfg_path: Path, log_level: int):
logging.basicConfig(
stream=sys.stdout,
level=log_level,
datefmt='%Y-%m-%d %H:%M',
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
with open(cfg_path) as f:
cfg = yaml.load(f, Loader=yaml.FullLoader)
nside = cfg['nside']
outpath = cfg['hdf5_path']
mask_file = 'data/n0512.fits'
mask_data = old_np.nan_to_num(
hp.read_map(mask_file, verbose=False, dtype=np.float32))
mask_apodized = nmt.mask_apodization(mask_data, 5., apotype="C2")
mask_binary = old_np.where(mask_data > 0.0, 1.0, 0.0)
with h5py.File(outpath, 'w') as f:
ns0512 = f.require_group('ns0512')
data_dset = ns0512.require_dataset('binary',
shape=(hp.nside2npix(nside), ),
dtype=np.float32)
data_dset[...] = np.nan_to_num(mask_binary)
apodized = ns0512.require_group('apodized')
data_dset2 = apodized.require_dataset('basic',
shape=(hp.nside2npix(nside), ),
dtype=np.float32)
data_dset2[...] = np.nan_to_num(mask_apodized)
def __init__(self,cat,nside,theta_apo) :
""" Initializes Mask object from catalog and resolution parameters
Parameters
----------
cat : fc.Catalog
Catalog containing window information
nside : int
HEALPix resolution index
theta_apo : float
Apodization scale in degrees
"""
if cat.window.typestr=='decbcut':
npix=hp.nside2npix(nside)
ind_aux=np.arange(0,npix)
theta,phi=hp.pix2ang(nside,ind_aux)
self.weights=cat.window(phi*180/np.pi,90-theta*180/np.pi)
elif cat.window.typestr=='base':
self.weights=np.ones(12*nside**2)
else:
self.weights=cat.window.map.copy()
if debug:
hp.mollview(self.weights)
plt.show()
#Figure out which pixels are empty
self.ip_nomask=np.where(self.weights>0)[0]
#Generate sky mask and apply apodization
self.binary=np.zeros_like(self.weights)
self.binary[self.ip_nomask]=1.
if theta_apo>0 :
self.mask_apo=nmt.mask_apodization(self.binary,theta_apo,apotype='C1')
else :
self.mask_apo=self.binary.copy()
#Final weights are a combination of mask + depth fluctuations
self.total=self.mask_apo*self.weights
#Can't generate maps with pixels larger than the mask
if (cat.window.typestr!='decbcut') & (cat.window.typestr!='base'):
if nside<cat.window.nside:
#If mask pixelization is higher, upgrade output maps
self.nside=cat.window.nside
else :
#If mask pixelization is lower, upgrade mask
self.nside=nside
self.total =hp.ud_grade(self.total ,nside_out=nside)
self.binary =hp.ud_grade(self.binary ,nside_out=nside)
self.weights=hp.ud_grade(self.weights,nside_out=nside)
self.ip_nomask=np.where(self.weights>0)[0]
else:
self.nside=nside
self.total =hp.ud_grade(self.total ,nside_out=nside)
self.binary =hp.ud_grade(self.binary ,nside_out=nside)
self.weights=hp.ud_grade(self.weights,nside_out=nside)
self.ip_nomask=np.where(self.weights>0)[0]
#Pixel area
self.pixOmega=4*np.pi/hp.nside2npix(self.nside)
if debug:
hp.mollview(self.weights)
plt.show()
def mask(self, mask):
"""apply apodization during initialization"""
if mask is None:
self._mask = np.ones((1,self._npix),dtype=np.float64)
else:
assert isinstance(mask, np.ndarray)
assert (mask.shape == (1,self._npix))
self._mask = nmt.mask_apodization(mask[0], self._aposcale, apotype='C2').reshape(1,-1)
def apodize_mask(mask, apod_arcmin=60, apod_type='C2'):
"""
for pure-B formalism, must be differentiable at boundary : use 'C1' or 'C2' schemes
"""
apod_deg = apod_arcmin / 60.
mask_apod = nmt.mask_apodization(mask, apod_deg, apotype=apod_type)
return mask_apod
def mask(self, mask):
if mask is None:
self._mask = np.ones(self._npix,dtype=np.float64)
self._apomask = np.ones(self._npix,dtype=np.float64)
else:
assert isinstance(mask, np.ndarray)
assert (len(mask) == self._npix)
self._mask = mask.copy()
self._apomask = nmt.mask_apodization(self._mask, self._aposcale, apotype='C2')
def __init__(self, cat, nside, theta_apo):
""" Initializes Mask object from catalog and resolution parameters
Parameters
----------
cat : fc.Catalog
Catalog containing window information
nside : int
HEALPix resolution index
theta_apo : float
Apodization scale in degrees
"""
if cat.window.typestr == 'decbcut':
npix = hp.nside2npix(nside)
ind_aux = np.arange(0, npix)
theta, phi = hp.pix2ang(nside, ind_aux)
self.weights = cat.window(phi * 180 / np.pi,
90 - theta * 180 / np.pi)
else:
self.weights = cat.window.map.copy()
if debug:
hp.mollview(self.weights)
plt.show()
#Figure out which pixels are empty
self.ip_nomask = np.where(self.weights > 0)[0]
#Generate sky mask and apply apodization
self.binary = np.zeros_like(self.weights)
self.binary[self.ip_nomask] = 1.
if theta_apo > 0:
self.mask_apo = nmt.mask_apodization(self.binary,
theta_apo,
apotype='C1')
else:
self.mask_apo = self.binary.copy()
#Final weights are a combination of mask + depth fluctuations
self.total = self.mask_apo * self.weights
#Can't generate maps with pixels larger than the mask
if cat.window.typestr != 'decbcut':
if nside < cat.window.nside:
#If mask pixelization is higher, upgrade output maps
self.nside = cat.window.nside
else:
#If mask pixelization is lower, upgrade mask
self.nside = nside
self.total = hp.ud_grade(self.total, nside_out=nside)
self.binary = hp.ud_grade(self.binary, nside_out=nside)
self.weights = hp.ud_grade(self.weights, nside_out=nside)
self.ip_nomask = np.where(self.weights > 0)[0]
else:
self.nside = nside
self.total = hp.ud_grade(self.total, nside_out=nside)
self.binary = hp.ud_grade(self.binary, nside_out=nside)
self.weights = hp.ud_grade(self.weights, nside_out=nside)
self.ip_nomask = np.where(self.weights > 0)[0]
if debug:
hp.mollview(self.weights)
plt.show()
def calculate_apodizations(self, mask_in):
for value in self.masks['powerspectrum'].values():
apo_mask = nmt.mask_apodization(mask_in,
**value['nmt_apo']['args'])
with h5py.File(self.hdf5_path, 'a') as f:
dset = f.require_dataset(value['record'],
shape=apo_mask.shape,
dtype=apo_mask.dtype)
dset[...] = apo_mask
def get_apodized_mask(self):
"""
Make an apodized mask. The pure-B formalism requires the mask to be
differentiable along the edges. The 'C1' and 'C2' apodization types
supported by mask_apodization achieve this.
"""
mask_apo = nmt.mask_apodization(self.weight_mask,
aposize=self.aposize,
apotype=self.apotype)
return mask_apo
def mask(self, mask):
if mask is None:
self._mask = np.ones(self._npix,dtype=np.float64)
else:
assert isinstance(mask, np.ndarray)
assert (len(mask) == self._npix)
self._mask = mask.copy()
self._mask = nmt.mask_apodization(self._mask, self._aposcale, apotype='C2')
self._qml_mask=degrade_mask(self._qml_nside, self._mask)
self._fsky=np.mean(self._qml_mask)
self._qml_npix = sum(self._qml_mask)
def mask(self, mask):
if mask is None:
self._mask = np.ones(hp.nsdie2pix(self._qml_nside), dtype=np.bool)
else:
assert isinstance(mask, np.ndarray)
self._mask = mask.copy()
self._mask = nmt.mask_apodization(self._mask,
self._aposcale,
apotype='C2')
self._qml_mask = degrade_mask(self._qml_nside, self._mask)
self._fsky = np.mean(self._qml_mask)
self._qml_npix = sum(self._qml_mask)
def test_mask_errors(self):
with self.assertRaises(RuntimeError): # Badly shaped input
nmt.mask_apodization(self.msk[:13], self.aposize, apotype="C1")
with self.assertRaises(RuntimeError): # Negative apodization
nmt.mask_apodization(self.msk, -self.aposize, apotype="C1")
with self.assertRaises(RuntimeError): # Wrong apodization type
nmt.mask_apodization(self.msk, self.aposize, apotype="C3")
def test_mask_c2():
msk_apo = nmt.mask_apodization(MT.msk, MT.aposize, apotype="C2")
# Below transition
assert (msk_apo[MT.th > MT.th0] < 1E-10).all()
# Above transition
assert (np.fabs(msk_apo[MT.th < MT.th0 - np.radians(MT.aposize)] - 1.) <
1E-10).all()
# Within transition
x = np.sqrt((1 - np.cos(MT.th - MT.th0)) * MT.inv_x2thr)
f = 0.5 * (1 - np.cos(x * np.pi))
ind_transition = ((MT.th < MT.th0) &
(MT.th > MT.th0 - np.radians(MT.aposize)))
assert (np.fabs(msk_apo[ind_transition] - f[ind_transition]) < 2E-2).all()
def cross_teb(self, maps, mask=None, aposcale=None, binning=None):
"""
Cross PS,
apply NaMaster estimator to TQU maps with(out) masks,
requires NaMaster, healpy, numpy packages.
Parameters
----------
maps : numpy.ndarray
A six-row array of T, Q, U maps, arranged as {T,Q,U,T,Q,U},
with polarization in CMB convention.
mask : numpy.ndarray
mask map
Returns
-------
pseudo-PS results : tuple of numpy.ndarray
(ell, TT, EE, BB)
"""
assert isinstance(maps, np.ndarray)
assert (maps.shape[0] == 6)
# fix resolution and apodization
_nside = hp.get_nside(maps[0])
# apodization
if aposcale is None:
aposcale = 1.0
_apd_mask = nmt.mask_apodization(mask, aposcale, apotype='Smooth')
_mapI01 = maps[0]
_mapQ01 = maps[1]
_mapU01 = maps[2]
_mapI02 = maps[3]
_mapQ02 = maps[4]
_mapU02 = maps[5]
# assemble NaMaster fields
_f01 = nmt.NmtField(_apd_mask, [_mapI01])
_f21 = nmt.NmtField(_apd_mask, [_mapQ01, _mapU01])
_f02 = nmt.NmtField(_apd_mask, [_mapI02])
_f22 = nmt.NmtField(_apd_mask, [_mapQ02, _mapU02])
# initialize binning scheme with ? ells per bandpower
if binning is None:
binning = 16
else:
assert isinstance(binning, int)
_b = nmt.NmtBin(_nside, nlb=binning)
# MASTER estimator
_cl00 = nmt.compute_full_master(_f01, _f02, _b) # scalar - scalar
_cl22 = nmt.compute_full_master(_f21, _f22, _b) # tensor - tensor
return _b.get_effective_ells(), _cl00[0], _cl22[0], _cl22[3]
def get_apodized_mask(self):
"""
Make an apodized mask. The pure-B formalism requires the mask to be
differentiable along the edges. The 'C1' and 'C2' apodization types
supported by mask_apodization achieve this.
"""
resol = np.degrees(hp.nside2resol(hp.npix2nside(len(self.weight_mask))))
if resol < self.aposize:
mask_apo = nmt.mask_apodization(self.weight_mask,
aposize=self.aposize,
apotype=self.apotype)
else:
mask_apo = self.weight_mask.copy()
return mask_apo
def test_mask_c2(self):
msk_apo = nmt.mask_apodization(self.msk, self.aposize, apotype="C2")
# Below transition
self.assertTrue((msk_apo[self.th > self.th0] < 1E-10).all())
# Above transition
self.assertTrue(
(np.fabs(msk_apo[self.th < self.th0 - np.radians(self.aposize)] -
1.) < 1E-10).all())
# Within transition
x = np.sqrt((1 - np.cos(self.th - self.th0)) * self.inv_x2thr)
f = 0.5 * (1 - np.cos(x * np.pi))
ind_transition = ((self.th < self.th0) &
(self.th > self.th0 - np.radians(self.aposize)))
self.assertTrue((np.fabs(msk_apo[ind_transition] - f[ind_transition]) <
2E-2).all())
def __init__(self, mask_in, nside, bin_w, lmax, beam = None):
'''
Define the **apodized mask**, **beam weights**, **nside**, **bin-scheme**, **ell**
Needs to be revised for the beam correction
'''
self.mask = nmt.mask_apodization(mask_in, 6, apotype='C2')
self.nside = nside; self.lmax = lmax
# self.beam = hp.gauss_beam(beam/60/180*np.pi, lmax = 3*self.nside);
self.b = nmt.NmtBin(self.nside, nlb=bin_w, lmax=self.lmax, is_Dell = True)
self.ell_n = self.b.get_effective_ells(); self.lbin = len(self.ell_n)
def cross_t(self, maps, mask=None, aposcale=None, binning=None):
"""
Cross PS,
apply NaMaster estimator to T (scalar) map with(out) masks,
requires NaMaster, healpy, numpy packages.
Parameters
----------
maps : numpy.ndarray
A two-row array array of two T maps.
mask : numpy.ndarray
mask map
Returns
-------
pseudo-PS results : tuple of numpy.ndarray
(ell, TT)
"""
assert isinstance(maps, np.ndarray)
assert (maps.shape[0] == 2)
# fix resolution and apodization
_nside = hp.get_nside(maps[0])
# apodization
if aposcale is None:
aposcale = 1.0
_apd_mask = nmt.mask_apodization(mask, aposcale, apotype='Smooth')
_mapI01 = maps[0]
_mapI02 = maps[1]
# assemble NaMaster fields
_f01 = nmt.NmtField(_apd_mask, [_mapI01])
_f02 = nmt.NmtField(_apd_mask, [_mapI02])
# initialize binning scheme with ? ells per bandpower
if binning is None:
binning = 16
else:
assert isinstance(binning, int)
_b = nmt.NmtBin(_nside, nlb=binning)
# MASTER estimator
_cl00 = nmt.compute_full_master(_f01, _f02, _b) # scalar - scalar
return _b.get_effective_ells(), _cl00[0]
def auto_eb(self, maps, mask=None, aposcale=None, binning=None):
"""
Auto PS,
apply NaMaster estimator to QU (spin-2) maps with(out) masks,
requires NaMaster, healpy, numpy packages.
Parameters
----------
maps : numpy.ndarray
A two-row array of Q, U maps,
with polarization in CMB convention.
mask : numpy.ndarray
mask map
Returns
-------
pseudo-PS results : tuple of numpy.ndarray
(ell, EE, BB)
"""
assert isinstance(maps, np.ndarray)
assert (maps.shape[0] == 2)
# fix resolution and apodization
_nside = hp.get_nside(maps[0])
# apodization
if aposcale is None:
aposcale = 1.0
_apd_mask = nmt.mask_apodization(mask, aposcale, apotype='Smooth')
_mapQ = maps[0]
_mapU = maps[1]
# assemble NaMaster fields
_f2 = nmt.NmtField(_apd_mask, [_mapQ, _mapU])
# initialize binning scheme with ? ells per bandpower
if binning is None:
binning = 16
else:
assert isinstance(binning, int)
_b = nmt.NmtBin(_nside, nlb=binning)
# MASTER estimator
_cl22 = nmt.compute_full_master(_f2, _f2, _b) # tensor - tensor
return _b.get_effective_ells(), _cl22[0], _cl22[3]
def __init__(self, mask_in, nside, bin_w, lmax, beam = None, wsp = True):
'''
class for Band-Power-Estimation;
Define the **apodized mask**, **beam weights**, **nside**, **bin-scheme**, **ell**
Needs to be revised for the beam correction. Different frequency have different sigma,
which may lead to different wsp...
'''
self.mask = nmt.mask_apodization(mask_in, 6, apotype='C2')
self.nside = nside; self.lmax = lmax
# self.beam = hp.gauss_beam(beam/60/180*np.pi, lmax = 3*self.nside);
self.b = nmt.NmtBin(self.nside, nlb=bin_w, lmax=self.lmax, is_Dell = True)
self.ell_n = self.b.get_effective_ells(); self.lbin = len(self.ell_n)
# - To construct a empty template with a mask to calculate the **coupling matrix**
if wsp is True:
qu = np.ones((2, 12*self.nside**2))
m0 = nmt.NmtField(self.mask,[qu[0]],purify_e=False, purify_b=True)
m2 = nmt.NmtField(self.mask, qu, purify_e=False, purify_b=True)#, beam=bl)
# construct a workspace that calculate the coupling matrix first.
_w00 = nmt.NmtWorkspace()
_w00.compute_coupling_matrix(m0, m0, self.b) ## spin-0 with spin-0
_w02 = nmt.NmtWorkspace()
_w02.compute_coupling_matrix(m0, m2, self.b) ## spin-0 with spin-2
_w22 = nmt.NmtWorkspace()
_w22.compute_coupling_matrix(m2, m2, self.b) ## spin-2 with spin-2
self.w00 = _w00
self.w02 = _w02
self.w22 = _w22
def estimate_bandpowers(hmap,
maskval=hp.UNSEEN,
nest=True,
nside=2048,
apodize=True,
aposcale=0.1,
nbins=32,
work=None,
cache_maps=False,
key=None):
bins = nmt.NmtBin.from_nside_linear(nside, nbins)
# First, check whether map is NEST or RING. If NEST, re-order.
if nest:
print(
"Converting power spectrum from NEST to RING for pseudo-C_\ell estimation."
)
hmap = hp.pixelfunc.reorder(hmap, inp='NEST', out='RING')
mask = np.ones_like(hmap)
mask[hmap == maskval] = 0
# Apodize mask??
if apodize:
mask = nmt.mask_apodization(mask, aposcale)
# Convert to a fluctuation field.
hmap[mask > 0] = hmap[mask > 0] / np.average(hmap[mask > 0],
weights=mask[mask > 0]) - 1.
if cache_maps:
fitsio.write(f'map-{key}.fits', hmap_ngal, clobber=True)
fitsio.write(f'map-{key}.fits', mask, clobber=False)
field = nmt.NmtField(mask, hmap[np.newaxis, :])
if work == None:
w = nmt.NmtWorkspace()
w.compute_coupling_matrix(field, field, bins)
else:
w = work
cl = nmt.compute_full_master(field, field, bins, workspace=w)
l_eff = bins.get_effective_ells()
return l_eff, cl, w
def get_cmb_lensing_map(nside=None):
folder_path = os.path.join(DATA_PATH, 'Planck2018/COM_Lensing_2048_R2.00')
map_path = os.path.join(folder_path, 'dat_klm.fits')
mask_path = os.path.join(folder_path, 'mask.fits')
# Read
klm = hp.read_alm(map_path)
map = hp.alm2map(klm, nside)
mask = hp.read_map(mask_path)
# Rotate
rotator = Rotator(coord=['G', 'C'])
map = rotator.rotate_map_pixel(map)
mask = rotator.rotate_map_pixel(mask)
# Adjust
mask = nmt.mask_apodization(mask, 0.2, apotype='C1')
mask = hp.ud_grade(mask, nside_out=nside)
mask[mask < 0.1] = 0 # Visualization purpose
map = get_masked_map(map, mask)
mask = get_masked_map(mask, mask)
return map, mask
def load_maps(self):
import pymaster as nmt
import healpy
# Parameters that we need at this point
apod_size = self.config['apodization_size']
apod_type = self.config['apodization_type']
# Load the various input maps and their metadata
map_file = self.open_input('diagnostic_maps', wrapper=True)
pix_info = map_file.read_map_info('mask')
area = map_file.file['maps'].attrs["area"]
nbin_source = map_file.file['maps'].attrs['nbin_source']
nbin_lens = map_file.file['maps'].attrs['nbin_lens']
# Choose pixelization and read mask and systematics maps
pixel_scheme = choose_pixelization(**pix_info)
# Load the mask. It should automatically be the same shape as the
# others, based on how it was originally generated.
# We remove any pixels that are at or below our threshold (default=0)
mask = map_file.read_map('mask')
mask_threshold = self.config['mask_threshold']
mask[mask <= mask_threshold] = 0
mask[np.isnan(mask)] = 0
mask_sum = mask.sum()
f_sky = area / 41253.
if self.rank == 0:
print(f"Unmasked area = {area}, fsky = {f_sky}")
# Load all the maps in.
# TODO: make it possible to just do a subset of these
ngal_maps = [map_file.read_map(f'ngal_{b}') for b in range(nbin_lens)]
g1_maps = [map_file.read_map(f'g1_{b}') for b in range(nbin_source)]
g2_maps = [map_file.read_map(f'g2_{b}') for b in range(nbin_source)]
# Mask any pixels which have the healpix bad value
for m in g1_maps + g2_maps + ngal_maps:
mask[m == healpy.UNSEEN] = 0
if self.config['flip_g2']:
for g2 in g2_maps:
w = np.where(g2 != healpy.UNSEEN)
g2[w] *= -1
# TODO: load systematics maps here, once we are making them.
syst_nc = None
syst_wl = None
map_file.close()
# Cut out any pixels below the threshold,
# zeroing out any pixels there
cut = mask < mask_threshold
mask[cut] = 0
# We also apply this cut to the count maps,
# since otherwise the pixels below threshold would contaminate
# the mean calculation below.
for ng in ngal_maps:
ng[cut] = 0
# Convert the number count maps to overdensity maps.
# First compute the overall mean object count per bin.
# Maybe we should do this in the mapping code itself?
n_means = [ng.sum() / mask_sum for ng in ngal_maps]
# and then use that to convert to overdensity
d_maps = [(ng / mu) - 1 for (ng, mu) in zip(ngal_maps, n_means)]
d_fields = []
wl_fields = []
if pixel_scheme.name == 'gnomonic':
lx = np.radians(pixel_scheme.size_x)
ly = np.radians(pixel_scheme.size_y)
# Apodize the mask
if apod_size > 0:
if self.rank == 0:
print(
f"Apodizing mask with size {apod_size} deg and method {apod_type}"
)
mask = nmt.mask_apodization_flat(mask,
lx,
ly,
apod_size,
apotype=apod_type)
elif self.rank == 0:
print("Not apodizing mask.")
for i, d in enumerate(d_maps):
# Density for gnomonic maps
if self.rank == 0:
print(f"Generating gnomonic density field {i}")
field = nmt.NmtFieldFlat(lx, ly, mask, [d], templates=syst_nc)
d_fields.append(field)
for i, (g1, g2) in enumerate(zip(g1_maps, g2_maps)):
# Density for gnomonic maps
if self.rank == 0:
print(f"Generating gnomonic lensing field {i}")
field = nmt.NmtFieldFlat(lx,
ly,
mask, [g1, g2],
templates=syst_wl)
wl_fields.append(field)
elif pixel_scheme.name == 'healpix':
# Apodize the mask
if apod_size > 0:
if self.rank == 0:
print(
f"Apodizing mask with size {apod_size} deg and method {apod_type}"
)
mask = nmt.mask_apodization(mask, apod_size, apotype=apod_type)
elif self.rank == 0:
print("Not apodizing mask.")
for i, d in enumerate(d_maps):
# Density for gnomonic maps
print(f"Generating healpix density field {i}")
field = nmt.NmtField(mask, [d], templates=syst_nc)
d_fields.append(field)
for i, (g1, g2) in enumerate(zip(g1_maps, g2_maps)):
# Density for gnomonic maps
print(f"Generating healpix lensing field {i}")
field = nmt.NmtField(mask, [g1, g2], templates=syst_wl)
wl_fields.append(field)
else:
raise ValueError(
f"Pixelization scheme {pixel_scheme.name} not supported by NaMaster"
)
return pixel_scheme, d_fields, wl_fields, nbin_source, nbin_lens, f_sky
mpd1=hp.alm2map(hp.almxfl(hp.map2alm(mp),alpha1i),nside=ns,verbose=False)
mpd2=hp.alm2map(hp.almxfl(hp.map2alm(mp),alpha2i),nside=ns,verbose=False)
return mpd1,mpd2
ZER0=1E-3
APOSCALE=10.
nside=1024
nh=hp.ud_grade(hp.read_map("norm_nHits_SA_35FOV.fits"),nside_out=nside)
nhg=hp.smoothing(nh,fwhm=np.pi/180,verbose=False)
nhg[nhg<0]=0
nh/=np.amax(nh)
nhg/=np.amax(nhg)
mpb=np.zeros_like(nh); mpb[nh>ZER0]=1
mpbg=np.zeros_like(nhg); mpbg[nhg>ZER0]=1
print("Apodize 1")
msk=nmt.mask_apodization(mpb,APOSCALE,apotype='C1')
print("Apodize 2")
mskg=nmt.mask_apodization(mpbg,APOSCALE,apotype='C1')
print("Deriv")
mskd1,mskd2=get_deriv(nh*msk)
mskd1g,mskd2g=get_deriv(nhg*mskg)
hp.write_map("mask_apo%.1lf.fits"%APOSCALE,mskg*nhg)
hp.write_map("masks_SAT.fits",(mskg*nhg)[None,:]*np.ones(6)[:,None],overwrite=True)
hp.mollview(msk)
hp.mollview(mskd1)
hp.mollview(mskd2)
hp.mollview(mskg)
hp.mollview(mskd1g)
hp.mollview(mskd2g)
# Define the **apodized mask**, **beam weights**, **nside**, **bin-scheme**, **ell**
beam_low = 27.9435
nside = 512
lmax = 1000
b = nmt.NmtBin(nside, nlb=10, lmax=lmax)
ell_n = b.get_effective_ells()
eln2 = utils.l2(ell_n)
bl = hp.gauss_beam(beam_low / 60 / 180 * np.pi, lmax=3 * nside)
ali_ma_512 = hp.read_map("/smc/jianyao/Ali_maps/ali_mask_wo_edge_512.fits",
verbose=False)
mask = nmt.mask_apodization(ali_ma_512, 6, apotype='C2')
def compute_master(f_a, f_b, wsp):
cl_coupled = nmt.compute_coupled_cell(f_a, f_b)
cl_decoupled = wsp.decouple_cell(cl_coupled)
return cl_decoupled
# - To construct a empty template with a mask to calculate the **coupling matrix**
# > the template should have a shape (2, 12*nside^2)
map0 = np.ones((2, 12 * nside**2))
m0 = nmt.NmtField(mask, map0, purify_e=False, purify_b=True, beam=bl)
# compute apodization mask
lmin = 20
lmax = 3 * nside - 1
delta_ell = 20
racenter = 0.0
deccenter = -57.0
maxang = 20.
center = equ2gal(racenter, deccenter)
veccenter = hp.ang2vec(pi / 2 - np.radians(center[1]), np.radians(center[0]))
vecpix = hp.pix2vec(nside, np.arange(12 * nside ** 2))
cosang = np.dot(veccenter, vecpix)
maskok = np.degrees(np.arccos(cosang)) < maxang
msk_apo = nmt.mask_apodization(maskok, 1, apotype='C1')
# Select a binning scheme
b = nmt.NmtBin(nside, nlb=20, is_Dell=True)
leff = b.get_effective_ells()
# gaussian beam
beam = hp.gauss_beam(np.radians(0.39), lmax)
# initial maps and workspaces
mp_t, mp_q, mp_u = hp.synfast(spectra,
nside=nside,
fwhm=np.radians(0.39),
pixwin=True,
new=True,
verbose=False)
#We'll run this many simulations
nsim=10
#HEALPix map resolution
nside=256
#Let us first create a square mask:
msk=np.zeros(hp.nside2npix(nside))
th,ph=hp.pix2ang(nside,np.arange(hp.nside2npix(nside)))
ph[np.where(ph>np.pi)[0]]-=2*np.pi
msk[np.where((th<2.63) & (th>1.86) & (ph>-np.pi/4) & (ph<np.pi/4))[0]]=1.
#Now we apodize the mask. The pure-B formalism requires the mask to be differentiable
#along the edges. The 'C1' and 'C2' apodization types supported by mask_apodization
#achieve this.
msk_apo=nmt.mask_apodization(msk,10.0,apotype='C1')
#Select a binning scheme
b=nmt.NmtBin(nside,nlb=16)
leff=b.get_effective_ells()
#Read power spectrum and provide function to generate simulated skies
l,cltt,clee,clbb,clte=np.loadtxt('cls.txt',unpack=True);
def get_fields() :
mp_t,mp_q,mp_u=hp.synfast([cltt,clee,clbb,clte],nside=nside,new=True,verbose=False)
#This creates a spin-2 field without purifying either E or B
f2_np=nmt.NmtField(msk_apo,[mp_q,mp_u])
#This creates a spin-2 field with both pure E and B.
f2_yp=nmt.NmtField(msk_apo,[mp_q,mp_u],purify_e=True,purify_b=True)
#Note that generally it's not a good idea to purify both, since you'll lose sensitivity on E
return f2_np,f2_yp
N_side = 2048
Npix = 12 * N_side**2
Coords = 'G' #coordinate system
mask_dir = '/data/jch/RHT_QU/'
mask_name = 'allsky_GALFA_mask_nonzero_nchannels_edge200_hp_proj_plusbgt70_maskGal'
# apodization scale
apod_Arcmin = 60.
apod_Deg = apod_Arcmin / 60.
# mask file name
mask_file = mask_dir + mask_name + FITS_end
# read in mask and apodize
# to use the pure-B formalism, need the mask to be differentiable at the boundary; the "C1" and "C2" schemes in nmt satisfy this criterion
mask = hp.read_map(mask_file, verbose=False)
apod_Type = 'C2'
#print "apodizing mask"
mask_apod = nmt.mask_apodization(mask, apod_Deg, apotype=apod_Type)
#print "done apodizing"
#####
#####
# simulation directory, maps, and theory power spectra
sim_dir = '/data/jch/Planckdata/DustSims/'
sim_name = 'DustSim_BICEPamp_alpha-2.42_TQU_' #'+str(i)+'.fits'
Nsim = 10 #actually have 100
sim_theory = 'DustEEBB_BICEPamp_alpha-2.42'
EEDust = (np.loadtxt(sim_dir + sim_theory +
TXT_end))[:, 0] #ClEE -- extends to ell=4000
BBDust = (np.loadtxt(sim_dir + sim_theory +
TXT_end))[:, 1] #ClBB -- extends to ell=4000
ellmax = 1001
ell = np.arange(int(ellmax) + 1)
