def test_synfast_stats(self):
#Temperature only
m_t = nmt.synfast_spherical(self.nside,
self.cltt,
beam=self.beam,
seed=1234)
#Polarization (omitting EB and TB)
m_p1 = nmt.synfast_spherical(self.nside,
self.cl4,
pol=True,
beam=self.beam,
seed=1234)
#Polarization (full monty)
m_p2 = nmt.synfast_spherical(self.nside,
self.cl6,
pol=True,
beam=self.beam,
seed=1234)
ctt1 = self.anafast(m_t)
ctt2, cee2, cbb2, cte2, ceb2, ctb2 = self.anafast(m_p1)
ctt3, cee3, cbb3, cte3, ceb3, ctb3 = self.anafast(m_p2)
def get_diff(c_d, c_t, c11, c22, c12, facsig=5):
diff = np.fabs(c_d - c_t) #Residuals
sig = np.sqrt((c11 * c22 + c12**2) /
(2 * self.larr + 1.)) #1-sigma expected errors
return diff < facsig * sig
#Check TT
self.assertTrue(
get_diff(ctt1, self.cltt, self.cltt, self.cltt, self.cltt).all())
self.assertTrue(
get_diff(ctt2, self.cltt, self.cltt, self.cltt, self.cltt).all())
self.assertTrue(
get_diff(ctt3, self.cltt, self.cltt, self.cltt, self.cltt).all())
#Check EE
self.assertTrue(
get_diff(cee2, self.clee, self.clee, self.clee, self.clee).all())
self.assertTrue(
get_diff(cee3, self.clee, self.clee, self.clee, self.clee).all())
#Check BB
self.assertTrue(
get_diff(cbb2, self.clbb, self.clbb, self.clbb, self.clbb).all())
self.assertTrue(
get_diff(cbb3, self.clbb, self.clbb, self.clbb, self.clbb).all())
#Check TE
self.assertTrue(
get_diff(cte2, self.clte, self.cltt, self.clee, self.clte).all())
self.assertTrue(
get_diff(cte3, self.clte, self.cltt, self.clee, self.clte).all())
#Check EB
self.assertTrue(
get_diff(ceb2, self.cleb, self.clbb, self.clee, self.cleb).all())
self.assertTrue(
get_diff(ceb3, self.cleb, self.clbb, self.clee, self.cleb).all())
#Check TB
self.assertTrue(
get_diff(ctb2, self.cltb, self.clbb, self.cltt, self.cltb).all())
self.assertTrue(
get_diff(ctb3, self.cltb, self.clbb, self.cltt, self.cltb).all())
def synfast_stats(self, spin):
# Temperature only
m_t = nmt.synfast_spherical(self.nside,
self.cl1, [0],
beam=np.array([self.beam]),
seed=1234)
# Polarization
m_p1 = nmt.synfast_spherical(self.nside,
self.cl12, [0, spin],
beam=np.array([self.beam, self.beam]),
seed=1234)
ctt1 = self.anafast(m_t, 0)[0]
ctt2 = self.anafast([m_p1[0]], 0)[0]
cte2, ctb2 = self.anafast([m_p1[0]], 0, m_p1[1:], spin)
cee2, ceb2, _, cbb2 = self.anafast(m_p1[1:], spin, m_p1[1:], spin)
def get_diff(c_d, c_t, c11, c22, c12, facsig=5):
diff = np.fabs(c_d - c_t) # Residuals
# 1-sigma expected errors
sig = np.sqrt((c11 * c22 + c12**2) / (2 * self.larr + 1.))
return diff[2 * self.nside] < facsig * sig[2 * self.nside]
# Check TT
assert (get_diff(ctt1, self.cltt, self.cltt, self.cltt,
self.cltt).all())
assert (get_diff(ctt2, self.cltt, self.cltt, self.cltt,
self.cltt).all())
# Check EE
assert (get_diff(cee2, self.clee, self.clee, self.clee,
self.clee).all())
# Check BB
assert (get_diff(cbb2, self.clbb, self.clbb, self.clbb,
self.clbb).all())
# Check TE
assert (get_diff(cte2, self.clte, self.cltt, self.clee,
self.clte).all())
# Check EB
assert (get_diff(ceb2, self.cleb, self.clbb, self.clee,
self.cleb).all())
# Check TB
assert (get_diff(ctb2, self.cltb, self.clbb, self.cltt,
self.cltb).all())
def test_synfast_errors():
with pytest.raises(ValueError): # Negative spin
nmt.synfast_spherical(ST.nside, ST.cl1, [-1], seed=1234)
with pytest.raises(ValueError): # Not enough power spectra
nmt.synfast_spherical(ST.nside, ST.cl2, [0, 2], seed=1234)
with pytest.raises(ValueError): # Not enough beams
nmt.synfast_spherical(ST.nside,
ST.cl12, [0, 2],
beam=np.array([ST.beam]),
seed=1234)
with pytest.raises(ValueError): # Inconsistent beam
nmt.synfast_spherical(ST.nside,
ST.cl12, [0, 2],
beam=np.array([ST.beam[:15], ST.beam[:15]]),
seed=1234)
m = nmt.synfast_spherical(ST.nside, ST.cl12, [0, 2], beam=None, seed=-1)
assert m.shape == (3, hp.nside2npix(ST.nside))
def test_synfast_stats(self):
# Temperature only
m_t = nmt.synfast_spherical(self.nside,
self.cl1, [0],
beam=np.array([self.beam]),
seed=1234)
# Polarization
m_p1 = nmt.synfast_spherical(self.nside,
self.cl12, [0, 2],
beam=np.array([self.beam, self.beam]),
seed=1234)
ctt1 = self.anafast(m_t)
ctt2, cee2, cbb2, cte2, ceb2, ctb2 = self.anafast(m_p1)
def get_diff(c_d, c_t, c11, c22, c12, facsig=5):
diff = np.fabs(c_d - c_t) # Residuals
# 1-sigma expected errors
sig = np.sqrt((c11 * c22 + c12**2) / (2 * self.larr + 1.))
return diff < facsig * sig
# Check TT
self.assertTrue(
get_diff(ctt1, self.cltt, self.cltt, self.cltt, self.cltt).all())
self.assertTrue(
get_diff(ctt2, self.cltt, self.cltt, self.cltt, self.cltt).all())
# Check EE
self.assertTrue(
get_diff(cee2, self.clee, self.clee, self.clee, self.clee).all())
# Check BB
self.assertTrue(
get_diff(cbb2, self.clbb, self.clbb, self.clbb, self.clbb).all())
# Check TE
self.assertTrue(
get_diff(cte2, self.clte, self.cltt, self.clee, self.clte).all())
# Check EB
self.assertTrue(
get_diff(ceb2, self.cleb, self.clbb, self.clee, self.cleb).all())
# Check TB
self.assertTrue(
get_diff(ctb2, self.cltb, self.clbb, self.cltt, self.cltb).all())
def get_fields():
mppt, mppq, mppu = nmt.synfast_spherical(nside, [cltt, clee, clbb, clte],
pol=True)
if w_cont: #Not ready yet
mppq += alpha_cont_2 * fgq
mppu += alpha_cont_2 * fgu
ff2 = nmt.NmtField(mask, [mppq, mppu], [[fgq, fgu]])
else:
ff2 = nmt.NmtField(mask, [mppq, mppu],
purify_e=ispure_e,
purify_b=ispure_b,
n_iter_mask_purify=10)
return mppq, mppu, ff2
def get_fields():
mppt, mppq, mppu = nmt.synfast_spherical(nside, [cltt, clee, clbb, clte],
pol=True)
if w_cont:
mppt += alpha_cont_0 * fgt
mppq += alpha_cont_2 * fgq
mppu += alpha_cont_2 * fgu
ff0 = nmt.NmtField(mask, [mppt], templates=[[fgt]])
ff2 = nmt.NmtField(mask, [mppq, mppu], [[fgq, fgu]])
else:
ff0 = nmt.NmtField(mask, [mppt])
ff2 = nmt.NmtField(mask, [mppq, mppu])
return mppt, mppq, mppu, ff0, ff2
def test_synfast_errors(self):
with self.assertRaises(ValueError): # Spin != 0 or 2
nmt.synfast_spherical(self.nside, self.cl1, [1], seed=1234)
with self.assertRaises(ValueError): # Not enough power spectra
nmt.synfast_spherical(self.nside, self.cl2, [0, 2], seed=1234)
with self.assertRaises(ValueError): # Not enough beams
nmt.synfast_spherical(self.nside,
self.cl12, [0, 2],
beam=np.array([self.beam]),
seed=1234)
with self.assertRaises(ValueError): # Inconsistent beam
nmt.synfast_spherical(self.nside,
self.cl12, [0, 2],
beam=np.array(
[self.beam[:15], self.beam[:15]]),
seed=1234)
m = nmt.synfast_spherical(self.nside,
self.cl12, [0, 2],
beam=np.array([self.beam, self.beam]),
seed=1234)
self.assertEqual(m.shape, (3, hp.nside2npix(self.nside)))
def test_synfast_errors(self):
with self.assertRaises(ValueError): #Single array for polarization
nmt.synfast_spherical(self.nside, self.cltt, pol=True, seed=1234)
with self.assertRaises(
ValueError): #Inconsistent array for polarization
nmt.synfast_spherical(self.nside, [self.cltt, self.clee],
pol=True,
seed=1234)
with self.assertRaises(
ValueError): #Inconsistent array for temperature-only
nmt.synfast_spherical(self.nside, self.cl4, seed=1234)
with self.assertRaises(ValueError): #Inconsistent beam
nmt.synfast_spherical(self.nside,
self.cl4,
pol=True,
beam=self.beam[:15],
seed=1234)
m = nmt.synfast_spherical(self.nside,
self.cl4,
pol=True,
beam=self.beam,
seed=1234)
self.assertEqual(m.shape, (3, hp.nside2npix(self.nside)))
def generate_maps(self):
"""
Generates a set of maps by computing correlated realisations of the
provided power spectra.
:return:
"""
logger.info('Generating Gaussian maps for one realization')
np.random.seed(seed=None)
# Now create the maps with the correlations between both spin-0 and spin-2 fields
# print("tests")
# print("nside", self.params['nside'])
# print("cl shape", self.cls.shape)
# print("spins", self.params['spins'])
# print("pixwinarr shape", self.pixwinarr.shape)
#
# print('Cl = '+str(self.cls))
# print('min/max Cl = '+str(np.min(self.cls))+', '+str(np.max(self.cls)))
#
maps = nmt.synfast_spherical(self.params['nside'], self.cls, spin_arr=self.params['spins'], seed=-1, \
beam=self.pixwinarr)
# maps = nmt.synfast_spherical(self.params['nside'], self.cls, spin_arr=self.params['spins'], seed=-1, \
# beam=None)
print('Mean of all map values' + str(np.mean(maps)))
logger.info('Gaussian maps done for one realization')
if self.params['nspin2'] > 0:
logger.info('Spin 2 fields present. Reordering maps.')
reordered_maps = self.reorder_maps(maps)
if self.params['nspin2'] == 1:
assert np.sum([np.all(maps[i] == reordered_maps[i]) for i in range(len(maps))]) == len(maps), \
'Something went wrong with map reordering.'
else:
logger.info('No spin 2 fields. Keeping map ordering.')
reordered_maps = copy.deepcopy(maps)
return reordered_maps
def get_fields(mask_ar, w_cont=False):
"""
Generate a simulated field.
It returns two NmtField objects for a spin-0 and a spin-2 field.
:param mask: a sky mask.
:param w_cont: deproject any contaminants? (not implemented yet)
"""
nbins = 2
spins = [0, 2] * nbins
# maps == [st1, sq1, su1, st2, sq2, su2, ...] (oredered as in spins)
maps = nmt.synfast_spherical(nside, clTh_all, spins)
st1, sq1, su1, st2, sq2, su2 = maps
if w_cont:
raise ValueError('Contaminants not implemented yet')
else:
ff0_1 = nmt.NmtField(mask_ar[0], [st1])
ff0_2 = nmt.NmtField(mask_ar[1], [st2])
ff2_1 = nmt.NmtField(mask_ar[0], [sq1, su1])
ff2_2 = nmt.NmtField(mask_ar[1], [sq2, su2])
return (ff0_1, ff2_1), (ff0_2, ff2_2)
mask_apo = mask_apo.reshape([w._naxis2, w._naxis1])
return mask_apo
dra = 1.
ddec = -1.
nx = 360
ny = 181
wcs = WCS(naxis=2)
wcs.wcs.cdelt = [dra, ddec]
wcs.wcs.crval = [0, 0]
wcs.wcs.ctype = ['RA---CAR', 'DEC--CAR']
wcs.wcs.crpix = [1 + 180 / dra, 1 + 90 / np.fabs(ddec)]
dl, dw_q, dw_u = nmt.synfast_spherical(
-1,
[cltt + nltt, clte + nlte, 0 * cltt, clee + nlee, 0 * clee, clbb + nlbb],
[0, 2],
wcs=wcs)
sl, sw_q, sw_u = nmt.synfast_spherical(-1, [
cltt / (l + 1.)**1.5, 0 * clte, 0 * cltt, clee /
(l + 1.)**1.5, 0 * clee, 0.5 * clee / (l + 1.)**1.5
], [0, 2],
wcs=wcs)
wcs._naxis2, wcs._naxis1 = dl.shape
mask = getmaskapoana_car(wcs, 20., 0.4, dec0=90.)
write_flat_map("mps_car_small.fits", np.array([dl, dw_q, dw_u]), wcs,
["T", "Q", "U"])
write_flat_map("tmp_car_small.fits", np.array([sl, sw_q, sw_u]), wcs,
["T", "Q", "U"])
write_flat_map("msk_car_small.fits", mask, wcs, "mask")
np.random.seed(1001)
fsky = 0.2
rholes = 1.
if not os.path.isfile(fname_mask + '.fits'):
print "Generating mask"
mask = getmaskapoana(nside, aposize, fsk=fsky)
hp.write_map(fname_mask + ".fits", mask)
mask = hp.read_map(fname_mask + ".fits")
if plotres:
hp.mollview(mask)
if w_cont: #Not ready yet
if not os.path.isfile(prefix + "_contaminants.fits"):
fgt, fgq, fgu = nmt.synfast_spherical(nside,
[clttfg, cleefg, clbbfg, cltefg],
pol=True)
hp.write_map(prefix + "_contaminants.fits", [fgt, fgq, fgu])
else:
fgt, fgq, fgu = hp.read_map(prefix + "_contaminants.fits",
field=[0, 1, 2],
verbose=False)
#Binning scheme
d_ell = int(1. / fsky)
b = nmt.NmtBin(nside, nlb=d_ell)
#Generate some initial fields
print " - Res: %.3lf arcmin. " % (np.sqrt(
4 * np.pi * (180 * 60 / np.pi)**2 / hp.nside2npix(nside)))
