def test_synfast_flat_stats(self):
# Temperature only
m_t = nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl1, [0],
beam=np.array([self.beam]),
seed=1234)[0]
# Polarization
m_p1 = nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl12, [0, 2],
beam=np.array([self.beam, self.beam]),
seed=1234)
km, nk, ctt1 = self.anafast(m_t)
km, nk, [ctt2, cee2, cbb2, cte2, ceb2, ctb2] = self.anafast(m_p1)
lint = km.astype(int)
def get_diff(c_d, c_t, c11, c22, c12, nmodes, facsig=5):
diff = np.fabs(c_d - c_t[lint]) # Residuals
sig = np.sqrt((c11[lint] * c22[lint] + c12[lint]**2) / nmodes)
return diff < facsig * sig
# Check TT
self.assertTrue(
get_diff(ctt1, self.cltt, self.cltt, self.cltt, self.cltt,
nk).all())
self.assertTrue(
get_diff(ctt2, self.cltt, self.cltt, self.cltt, self.cltt,
nk).all())
# Check EE
self.assertTrue(
get_diff(cee2, self.clee, self.clee, self.clee, self.clee,
nk).all())
# Check BB
self.assertTrue(
get_diff(cbb2, self.clbb, self.clbb, self.clbb, self.clbb,
nk).all())
# Check TE
self.assertTrue(
get_diff(cte2, self.clte, self.cltt, self.clee, self.clte,
nk).all())
# Check EB
self.assertTrue(
get_diff(ceb2, self.cleb, self.clbb, self.clee, self.cleb,
nk).all())
# Check TB
self.assertTrue(
get_diff(ctb2, self.cltb, self.cltt, self.clbb, self.cltb,
nk).all())
def generate_maps(self):
"""
Generates a set of maps by computing correlated realisations of the
provided power spectra.
:return:
"""
logger.info('Generating Gaussian map realizations.')
np.random.seed(seed=None)
# Now create the maps with the correlations between both spin-0 and spin-2 fields
maps = nmt.synfast_flat(self.fsk.nx, self.fsk.ny, np.radians(self.fsk.lx), np.radians(self.fsk.ly), \
self.cls, spin_arr=self.params['spins'], seed=-1, beam=None)
logger.info('Gaussian maps done.')
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(fsk,mask,w_cont=False) :
"""
Generate a simulated field.
It returns two NmtField objects for a spin-0 and a spin-2 field.
:param fsk: a fm.FlatMapInfo object.
:param mask: a sky mask.
:param w_cont: deproject any contaminants? (not implemented yet)
"""
st,sq,su=nmt.synfast_flat(int(fsk.nx),int(fsk.ny),fsk.lx_rad,fsk.ly_rad,
[cltt+nltt,clte+nlte,0*cltt,clee+nlee,0*clee,clbb+nlbb],[0,2])
if w_cont :
if np.any(templates_all):
tst, tsq, tsu = templates_all.sum(axis=0)
st+=tst; sq+=tsq; su+=tsu;
if o.no_deproject :
ff0=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
[st])
ff2=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
[sq, su])
else :
ff0=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
[st],
templates=templates_all[:,0,None,:])
ff2=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
[sq,su],
templates=templates_all[:,1:, :])
else :
ff0=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
[st])
ff2=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
[sq,su])
return ff0,ff2
def create_templates_flat(nx, ny, lx_rad, ly_rad, l, clTT, clEE, clBB,
**kwards):
TT_cl = create_cl_templates(l, clTT, **kwards)
EE_cl = create_cl_templates(l, clEE, **kwards)
BB_cl = create_cl_templates(l, clBB, **kwards)
templates = []
for tt, ee, bb in zip(TT_cl, EE_cl, BB_cl):
templates.append(
nmt.synfast_flat(nx, ny, lx_rad, ly_rad,
[tt, 0 * tt, 0 * tt, ee, 0 * tt, bb], [0, 2]))
return np.array(templates)
def gaussnoisemap(self, probe, data):
"""
Generates a noise-only HEALPix map as a Gaussian realisation of a theoretical noise power spectrum
:param probe: string tag of desired probe
:param data: the power spectrum needed to generate the noisemap
:return noisemap: HEALPix map of the noise for the respective probe
"""
if probe == 'galaxy_shear':
# In the new healpy ordering the order of the power spectra is
# TT, EE, BB, TE, EB, TB
# and one needs to set at least 4 of those
# We set the E and B mode power spectra to the theoretical shape noise power spectrum
zeroarr = np.zeros(data['noisecls'].shape[0])
cl_inp = [data['noisecls'], zeroarr, data['noisecls']]
noisemap = nmt.synfast_flat(data['fsk'].nx, data['fsk'].ny, np.radians(data['fsk'].lx),
np.radians(data['fsk'].ly), cl_inp, spin_arr=[2], seed=-1, beam=None)
else:
noisemap = nmt.synfast_flat(data['fsk'].nx, data['fsk'].ny, np.radians(data['fsk'].lx),
np.radians(data['fsk'].ly), [data['noisecls']], spin_arr=[0],
seed=-1, beam=None)[0]
return noisemap
def get_fields() :
st,sq,su=nmt.synfast_flat(int(fmi.nx),int(fmi.ny),fmi.lx_rad,fmi.ly_rad,
np.array([cltt*beam**2+nltt,clte*beam**2+nlte,0*cltt,
clee*beam**2+nlee,0*clee,
clbb*beam**2+nlbb]),[0,2])
st=st.flatten(); sq=sq.flatten(); su=su.flatten()
if w_cont :
sq+=np.sum(fgp,axis=0)[0,:]; su+=np.sum(fgp,axis=0)[1,:];
ff2=nmt.NmtFieldFlat(fmi.lx_rad,fmi.ly_rad,mask.reshape([fmi.ny,fmi.nx]),
[sq.reshape([fmi.ny,fmi.nx]),su.reshape([fmi.ny,fmi.nx])],
templates=fgp.reshape([1,2,fmi.ny,fmi.nx]),beam=[l,beam],
purify_e=False,purify_b=w_pureb)
else :
ff2=nmt.NmtFieldFlat(fmi.lx_rad,fmi.ly_rad,mask.reshape([fmi.ny,fmi.nx]),
[sq.reshape([fmi.ny,fmi.nx]),su.reshape([fmi.ny,fmi.nx])],
beam=[l,beam],purify_e=False,purify_b=w_pureb)
return ff2
def get_fields(fsk_ar, mask_ar, w_cont=False) :
"""
Generate a simulated field.
It returns two NmtField objects for a spin-0 and a spin-2 field.
:param fsk: a fm.FlatMapInfo object.
:param mask: a sky mask.
:param w_cont: deproject any contaminants? (not implemented yet)
"""
nbins = 2
spins = [0,2] * nbins
fsk = fsk_ar[0] # They share fsk.nx, ny, etc.
# maps == [st1, sq1, su1, st2, sq2, su2, ...] (oredered as in spins)
maps = nmt.synfast_flat(int(fsk.nx),int(fsk.ny),fsk.lx_rad,fsk.ly_rad,
cls_ar + nls_ar, spins)
st1, sq1, su1, st2, sq2, su2 = maps
if w_cont :
raise ValueError('Contaminants not implemented yet')
# if np.any(templates_all):
# tst, tsq, tsu = templates_all.sum(axis=0)
# st+=tst; sq+=tsq; su+=tsu;
# if o.no_deproject :
# ff0=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
# [st])
# ff2=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
# [sq, su])
# else :
# ff0=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
# [st],
# templates=templates_all[:,0,None,:])
# ff2=nmt.NmtFieldFlat(fsk.lx_rad,fsk.ly_rad,mask.reshape([fsk.ny,fsk.nx]),
# [sq,su],
# templates=templates_all[:,1:, :])
else :
ff0_1=nmt.NmtFieldFlat(fsk.lx_rad, fsk.ly_rad, mask_ar[0].reshape([fsk.ny, fsk.nx]),
[st1])
ff0_2=nmt.NmtFieldFlat(fsk.lx_rad, fsk.ly_rad, mask_ar[1].reshape([fsk.ny, fsk.nx]),
[st2])
ff2_1=nmt.NmtFieldFlat(fsk.lx_rad, fsk.ly_rad, mask_ar[0].reshape([fsk.ny, fsk.nx]),
[sq1, su1])
ff2_2=nmt.NmtFieldFlat(fsk.lx_rad, fsk.ly_rad, mask_ar[1].reshape([fsk.ny, fsk.nx]),
[sq2, su2])
return (ff0_1,ff2_1), (ff0_2, ff2_2)
def get_fields():
mppt, mppq, mppu = nmt.synfast_flat(int(mi.nx),
int(mi.ny),
mi.lx * DTOR,
mi.ly * DTOR, [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.NmtFieldFlat(mi.lx * DTOR, mi.ly * DTOR, mask, [mppt],
[[fgt]])
ff2 = nmt.NmtFieldFlat(mi.lx * DTOR, mi.ly * DTOR, mask, [mppq, mppu],
[[fgq, fgu]])
else:
ff0 = nmt.NmtFieldFlat(mi.lx * DTOR, mi.ly * DTOR, mask, [mppt])
ff2 = nmt.NmtFieldFlat(mi.lx * DTOR, mi.ly * DTOR, mask, [mppq, mppu])
return mppt, mppq, mppu, ff0, ff2
def get_fields():
st, sq, su = nmt.synfast_flat(
int(fmi.nx),
int(fmi.ny),
fmi.lx_rad,
fmi.ly_rad, [cltt + nltt, clee + nlee, clbb + nlbb, clte + nlte],
pol=True)
st = st.flatten()
sq = sq.flatten()
su = su.flatten()
if w_cont:
st += np.sum(fgt, axis=0)[0, :]
sq += np.sum(fgp, axis=0)[0, :]
su += np.sum(fgp, axis=0)[1, :]
if o.no_deproject:
ff0 = nmt.NmtFieldFlat(fmi.lx_rad, fmi.ly_rad,
mask.reshape([fmi.ny, fmi.nx]),
[st.reshape([fmi.ny, fmi.nx])])
ff2 = nmt.NmtFieldFlat(
fmi.lx_rad, fmi.ly_rad, mask.reshape([fmi.ny, fmi.nx]),
[sq.reshape([fmi.ny, fmi.nx]),
su.reshape([fmi.ny, fmi.nx])])
else:
ff0 = nmt.NmtFieldFlat(
fmi.lx_rad,
fmi.ly_rad,
mask.reshape([fmi.ny, fmi.nx]), [st.reshape([fmi.ny, fmi.nx])],
templates=fgt.reshape([2, 1, fmi.ny, fmi.nx]))
ff2 = nmt.NmtFieldFlat(
fmi.lx_rad,
fmi.ly_rad,
mask.reshape([fmi.ny, fmi.nx]),
[sq.reshape([fmi.ny, fmi.nx]),
su.reshape([fmi.ny, fmi.nx])],
templates=fgp.reshape([2, 2, fmi.ny, fmi.nx]))
else:
ff0 = nmt.NmtFieldFlat(fmi.lx_rad, fmi.ly_rad,
mask.reshape([fmi.ny, fmi.nx]),
[st.reshape([fmi.ny, fmi.nx])])
ff2 = nmt.NmtFieldFlat(
fmi.lx_rad, fmi.ly_rad, mask.reshape([fmi.ny, fmi.nx]),
[sq.reshape([fmi.ny, fmi.nx]),
su.reshape([fmi.ny, fmi.nx])])
return ff0, ff2
def test_synfast_flat_errors():
with pytest.raises(ValueError): # Negative spin
nmt.synfast_flat(ST.nx,
ST.ny,
ST.lx,
ST.ly,
ST.cl1, [-1],
beam=ST.beam,
seed=1234)
with pytest.raises(ValueError): # Not enough power spectra
nmt.synfast_flat(ST.nx,
ST.ny,
ST.lx,
ST.ly,
ST.cl2, [0, 2],
beam=np.array([ST.beam, ST.beam]),
seed=1234)
with pytest.raises(ValueError): # Not enough beams
nmt.synfast_flat(ST.nx,
ST.ny,
ST.lx,
ST.ly,
ST.cl12, [0, 2],
beam=np.array([ST.beam]),
seed=1234)
with pytest.raises(ValueError): # Inconsistent beam
nmt.synfast_flat(ST.nx,
ST.ny,
ST.lx,
ST.ly,
ST.cl12, [0, 2],
beam=np.array([ST.beam[:15], ST.beam[:15]]),
seed=1234)
with pytest.raises(RuntimeError): # Negative dimensions
nmt.synfast_flat(ST.nx,
ST.ny,
-ST.lx,
ST.ly,
ST.cl2, [2],
beam=np.array([ST.beam]),
seed=1234)
m = nmt.synfast_flat(ST.nx,
ST.ny,
ST.lx,
ST.ly,
ST.cl12, [0, 2],
beam=None,
seed=-1)
assert m.shape == (3, ST.ny, ST.nx)
Nx = 602
Ny = 410
#Gaussian simulations:
#pymaster allows you to generate random realizations of both spherical and
#flat fields given a power spectrum. These are returned as 2D arrays with
#shape (Ny,Nx)
l, cl_tt, cl_ee, cl_bb, cl_te = np.loadtxt('cls.txt', unpack=True)
beam = np.exp(-(0.25 * np.pi / 180 * l)**2)
cl_tt *= beam
cl_ee *= beam
cl_bb *= beam
cl_te *= beam
mpt, mpq, mpu = nmt.synfast_flat(Nx,
Ny,
Lx,
Ly, [cl_tt, cl_ee, cl_bb, cl_te],
pol=True)
#You can have a look at the maps using matplotlib's imshow:
plt.figure()
plt.imshow(mpt, interpolation='nearest', origin='lower')
plt.colorbar()
plt.figure()
plt.imshow(mpq, interpolation='nearest', origin='lower')
plt.colorbar()
plt.figure()
plt.imshow(mpu, interpolation='nearest', origin='lower')
plt.colorbar()
plt.show()
# Gaussian simulations:
# pymaster allows you to generate random realizations of both spherical and
# flat fields given a power spectrum. These are returned as 2D arrays with
# shape (Ny,Nx)
l, cl_tt, cl_ee, cl_bb, cl_te = np.loadtxt(
'../data/cls_cmb.txt', unpack=True
) # this one goes plenty high enough: max(l) = 9134 corresponding to 1.2 arcmin, around the pixel scale
ell_max = np.pi / (pix * np.pi / 180) # max expected l based on pixel size
# Generate random realisation of the power spectrum, just in temperature (spin-0).
# Set random seed for repeatability - doesn't work?!
rseed = 10
np.random.seed(rseed)
mpt, = nmt.synfast_flat(Nx,
Ny,
Lx,
Ly,
np.expand_dims(cl_tt, 0), [0],
seed=rseed)
# Convolve with instrumental beam
x = np.arange(Nx) - Nx / 2 - 1
y = np.arange(Ny) - Ny / 2 - 1
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2) * pix # deg
Planck_res = 10. / 60 # deg
Planck_sig = Planck_res / 2. / np.sqrt(2 * np.log(2.)) # deg
PSF = np.exp(-R**2 / 2 / Planck_sig**2)
mpt_conv = convolve2d(mpt, PSF, mode='same') / np.sum(PSF)
# Check this method looks the same - can't check because random seed doesn't work!!
beam = np.exp(
def test_synfast_flat_errors(self):
with self.assertRaises(ValueError): #Single array for polarization
nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cltt,
pol=True,
seed=1234)
with self.assertRaises(
ValueError): #Inconsistent array for polarization
nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly, [self.cltt, self.clee],
pol=True,
seed=1234)
with self.assertRaises(
ValueError): #Inconsistent array for temperature-only
nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl4,
seed=1234)
with self.assertRaises(ValueError): #Inconsistent beam
nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl4,
pol=True,
beam=self.beam[:15],
seed=1234)
with self.assertRaises(RuntimeError): #Negative dimensions
nmt.synfast_flat(self.nx,
self.ny,
-self.lx,
self.ly,
self.cl4,
pol=True,
beam=self.beam,
seed=1234)
m = nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl4,
pol=True,
beam=self.beam,
seed=1234)
self.assertEqual(m.shape, (3, self.ny, self.nx))
def test_synfast_flat_stats(self):
#Temperature only
m_t = nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cltt,
beam=self.beam,
seed=1234)[0]
#Polarization (omitting EB and TB)
m_p1 = nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl4,
pol=True,
beam=self.beam,
seed=1234)
#Polarization (full monty)
m_p2 = nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl6,
pol=True,
beam=self.beam,
seed=1234)
km, nk, ctt1 = self.anafast(m_t)
km, nk, [ctt2, cee2, cbb2, cte2, ceb2, ctb2] = self.anafast(m_p1)
km, nk, [ctt3, cee3, cbb3, cte3, ceb3, ctb3] = self.anafast(m_p1)
lint = km.astype(int)
def get_diff(c_d, c_t, c11, c22, c12, nmodes, facsig=5):
diff = np.fabs(c_d - c_t[lint]) #Residuals
sig = np.sqrt((c11[lint] * c22[lint] + c12[lint]**2) / nmodes)
return diff < facsig * sig
#Check TT
self.assertTrue(
get_diff(ctt1, self.cltt, self.cltt, self.cltt, self.cltt,
nk).all())
self.assertTrue(
get_diff(ctt2, self.cltt, self.cltt, self.cltt, self.cltt,
nk).all())
self.assertTrue(
get_diff(ctt3, self.cltt, self.cltt, self.cltt, self.cltt,
nk).all())
#Check EE
self.assertTrue(
get_diff(cee2, self.clee, self.clee, self.clee, self.clee,
nk).all())
self.assertTrue(
get_diff(cee3, self.clee, self.clee, self.clee, self.clee,
nk).all())
#Check BB
self.assertTrue(
get_diff(cbb2, self.clbb, self.clbb, self.clbb, self.clbb,
nk).all())
self.assertTrue(
get_diff(cbb3, self.clbb, self.clbb, self.clbb, self.clbb,
nk).all())
#Check TE
self.assertTrue(
get_diff(cte2, self.clte, self.cltt, self.clee, self.clte,
nk).all())
self.assertTrue(
get_diff(cte3, self.clte, self.cltt, self.clee, self.clte,
nk).all())
#Check EB
self.assertTrue(
get_diff(ceb2, self.cleb, self.clbb, self.clee, self.cleb,
nk).all())
self.assertTrue(
get_diff(ceb3, self.cleb, self.clbb, self.clee, self.cleb,
nk).all())
#Check TB
self.assertTrue(
get_diff(ctb2, self.cltb, self.cltt, self.clbb, self.cltb,
nk).all())
self.assertTrue(
get_diff(ctb3, self.cltb, self.cltt, self.clbb, self.cltb,
nk).all())
def get_sample_field():
mpt = nmt.synfast_flat(Nx, Ny, Lx, Ly, clarr, pol=False)[0]
return nmt.NmtFieldFlat(Lx, Ly, mask, [mpt])
import numpy as np
import pymaster as nmt
import flatmaps as fm
import matplotlib.pyplot as plt
DTOR = np.pi / 180
#Create information for a flat-sky map covering the GAMA15H field with resolution ~1.2 arcmin
mi = fm.FlatMapInfo([212.5, 222.], [-2., 2.], nx=396, ny=168)
#Generate a map as a Gaussian random field
larr = np.arange(8000.)
clarr = ((larr + 1000.) / 1000.)**(-1.5)
mp = (nmt.synfast_flat(mi.nx, mi.ny, mi.lx * DTOR, mi.ly * DTOR,
clarr)[0]).flatten()
#Generate up-graded and de-graded versions (just for show)
mi_hi, mp_hi = mi.u_grade(mp, 2)
mi_lo, mp_lo = mi.d_grade(mp, 2)
mi.view_map(mp, title='normal')
mi_hi.view_map(mp_hi, title='u-grade')
mi_lo.view_map(mp_lo, title='d-grade')
#Generate a mask (just remove the edges of the field)
mask = np.ones([mi.ny, mi.nx])
mask[:mi.ny / 5, :] = 0
mask[4 * mi.ny / 5:, :] = 0
mask[:, :mi.nx / 11] = 0
mask[:, 10 * mi.nx / 11:] = 0
mask = mask.flatten()
mi.view_map(mask * mp)
#Read theory power spectra
nsims=10*n_cross*n_ell #Use 10 times as many simulations as there are data points
print("Computing covariance from %d Gaussian simulations"%nsims)
msk_binary=msk_t.reshape([fsk.ny,fsk.nx])
weights=(msk_t*mskfrac).reshape([fsk.ny,fsk.nx])
if temps is not None :
conts=[[t.reshape([fsk.ny,fsk.nx])] for t in temps]
else :
conts=None
cells_sims=[]
for isim in range(nsims) :
if isim%100==0 :
print(" %d-th isim"%isim)
#Generate random maps
mps=nmt.synfast_flat(fsk.nx,fsk.ny,np.radians(fsk.lx),np.radians(fsk.ly),clth,np.zeros(nbins),seed=1000+isim)
#Nmt fields
flds=[nmt.NmtFieldFlat(np.radians(fsk.lx),np.radians(fsk.ly),weights,[m],templates=conts) for m in mps]
#Compute power spectra (possibly with deprojection)
i_x=0
cells_this=[]
for i in range(nbins) :
for j in range(i,nbins) :
cells_this.append(wsp.decouple_cell(nmt.compute_coupled_cell_flat(flds[i],flds[j],bpws),
cl_bias=cl_deproj_all[i_x])[0])
i_x+=1
cells_sims.append(np.array(cells_this).flatten())
cells_sims=np.array(cells_sims)
#Save simulations for further analysis
np.savez(o.prefix_out+".cls",cl_sims=cells_sims)
def test_synfast_flat_errors(self):
with self.assertRaises(ValueError): # Spin != 0 or 2
nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl1, [1],
beam=self.beam,
seed=1234)
with self.assertRaises(ValueError): # Not enough power spectra
nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl2, [0, 2],
beam=np.array([self.beam, self.beam]),
seed=1234)
with self.assertRaises(ValueError): # Not enough beams
nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl12, [0, 2],
beam=np.array([self.beam]),
seed=1234)
with self.assertRaises(ValueError): # Inconsistent beam
nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl12, [0, 2],
beam=np.array([self.beam[:15], self.beam[:15]]),
seed=1234)
with self.assertRaises(RuntimeError): # Negative dimensions
nmt.synfast_flat(self.nx,
self.ny,
-self.lx,
self.ly,
self.cl2, [2],
beam=np.array([self.beam]),
seed=1234)
m = nmt.synfast_flat(self.nx,
self.ny,
self.lx,
self.ly,
self.cl12, [0, 2],
beam=np.array([self.beam, self.beam]),
seed=1234)
self.assertEqual(m.shape, (3, self.ny, self.nx))
mask_raw = mask.copy()
if aposize > 0:
mask = nmt.mask_apodization_flat(mask_raw.reshape([mi.ny, mi.nx]),
mi.lx * DTOR, mi.ly * DTOR, aposize)
mi.write_flat_map(fname_mask, mask.flatten())
mi, mask = fm.read_flat_map(fname_mask + '.npz')
mi = fm.FlatMapInfo([212.5, 222.], [-2., 2.], nx=792, ny=336)
mask = mask.reshape([mi.ny, mi.nx])
if plotres:
mi.view_map(mask.flatten(), addColorbar=False, colorMax=1, colorMin=0)
if w_cont:
if not os.path.isfile(prefix + "_contaminants.npz"):
fgt, fgq, fgu = nmt.synfast_flat(int(mi.nx),
int(mi.ny),
mi.lx * DTOR,
mi.ly * DTOR,
[clttfg, cleefg, clbbfg, cltefg],
pol=True)
mi.write_flat_map(
prefix + "_contaminants",
np.array([fgt.flatten(),
fgq.flatten(),
fgu.flatten()]))
else:
mii, fgs = fm.read_flat_map(prefix + "_contaminants.npz", i_map=-1)
fgt = fgs[0].reshape([mi.ny, mi.nx])
fgq = fgs[1].reshape([mi.ny, mi.nx])
fgu = fgs[2].reshape([mi.ny, mi.nx])
#Binning scheme
lx_rad = mi.lx * DTOR
hdul=fits.open(filename)
w=WCS(hdul[0].header)
maps=hdul[i_map].data
ny,nx=maps.shape
return w,maps
wcs,msk=read_flat_map("msk_flat.fits")
(ny,nx)=msk.shape
lx=np.fabs(nx*wcs.wcs.cdelt[0])*np.pi/180
ly=np.fabs(ny*wcs.wcs.cdelt[1])*np.pi/180
d_ell=20; lmax=500.; ledges=np.arange(int(lmax/d_ell)+1)*d_ell+2
b=nmt.NmtBinFlat(ledges[:-1],ledges[1:])
leff=b.get_effective_ells();
dt,dq,du=nmt.synfast_flat(int(nx),int(ny),lx,ly,
[cltt,cltt,0*cltt,cltt,0*cltt,0*cltt],[0,1])
write_flat_map("mps_sp1_flat.fits", np.array([dt,dq,du]),wcs,["T", "Q", "U"])
prefix = 'bm_f_sp1'
f0=nmt.NmtFieldFlat(lx,ly,msk,[dt])
f1=nmt.NmtFieldFlat(lx,ly,msk,[dq,du], spin=1)
w00=nmt.NmtWorkspaceFlat(); w00.compute_coupling_matrix(f0,f0,b);
w00.write_to(prefix+'_w00.fits')
c00=w00.decouple_cell(nmt.compute_coupled_cell_flat(f0,f0,b))
np.savetxt(prefix+'_c00.txt', np.transpose([leff, c00[0]]))
w01=nmt.NmtWorkspaceFlat(); w01.compute_coupling_matrix(f0,f1,b);
w01.write_to(prefix+'_w01.fits')
c01=w01.decouple_cell(nmt.compute_coupled_cell_flat(f0,f1,b))
np.savetxt(prefix+'_c01.txt', np.transpose([leff, c01[0], c01[1]]))
for tick in ax.yaxis.get_major_ticks():
tick.label.set_fontsize(12)
def read_cls(fname) :
l,ctt,cte,ctb,cee,ceb,cbe,cbb=np.loadtxt(fname,unpack=True);
return l,ctt,cte,ctb,cee,ceb,cbe,cbb
l_th,clTT_th,clTE_th,clTB_th,clEE_th,clEB_th,clBE_th,clBB_th=read_cls(prefix_clean+"_cl_th.txt")
ndof=len(l_th)
print("Plotting contamination figure")
l,cltt,clee,clbb,clte,nltt,nlee,nlbb,nlte=np.loadtxt("data/cls_lss.txt",unpack=True)
cltt[0]=0; clee[0]=0; clbb[0]=0; clte[0]=0;
nltt[0]=0; nlee[0]=0; nlbb[0]=0; nlte[0]=0;
fmi,mask_hsc=fm.read_flat_map("data/mask_lss_flat.fits")
dum,fgt=fm.read_flat_map("data/cont_lss_dust_flat.fits") #Dust
st,sq,su=nmt.synfast_flat(int(fmi.nx),int(fmi.ny),fmi.lx_rad,fmi.ly_rad,
[cltt+nltt,clte+nlte,0*cltt,clee+nlee,0*clee,clbb+nlbb],[0,2])
mask_hsc[:]=1
ff0=nmt.NmtFieldFlat(fmi.lx_rad,fmi.ly_rad,mask_hsc.reshape([fmi.ny,fmi.nx]),
[st+fgt.reshape([fmi.ny,fmi.nx])],
templates=fgt.reshape([1,1,fmi.ny,fmi.nx]))
plt.figure(figsize=(12,4.75))
fs_or=matplotlib.rcParams['font.size']
ax=plt.subplot(221,projection=fmi.wcs);
fmi.view_map(st.flatten(),ax=ax,addColorbar=False,title='Signal',
colorMin=np.amin(st),colorMax=np.amax(st))
ax=plt.subplot(222,projection=fmi.wcs);
fmi.view_map(4*fgt,ax=ax,addColorbar=False,title='Contaminant',
colorMin=np.amin(st),colorMax=np.amax(st))
ax=plt.subplot(223,projection=fmi.wcs);
fmi.view_map(st.flatten()+4*fgt,ax=ax,addColorbar=False,title='Contaminated map',
colorMin=np.amin(st),colorMax=np.amax(st))
plt.imshow(sl * mask, interpolation='nearest', origin='lower')
plt.figure()
plt.imshow(sw_q * mask, interpolation='nearest', origin='lower')
plt.figure()
plt.imshow(sw_u * mask, interpolation='nearest', origin='lower')
plt.show()
exit(1)
##########################
# Flat-sky stuff
wcs, msk = read_flat_map("msk_flat.fits")
(ny, nx) = msk.shape
lx = np.fabs(nx * wcs.wcs.cdelt[0]) * np.pi / 180
ly = np.fabs(ny * wcs.wcs.cdelt[1]) * np.pi / 180
dt, dq, du = nmt.synfast_flat(
int(nx), int(ny), lx, ly,
[cltt + nltt, clte + nlte, 0 * cltt, clee + nlee, 0 * clee, clbb + nlbb],
[0, 2])
write_flat_map("mps_flat.fits", np.array([dt, dq, du]), wcs, ["T", "Q", "U"])
d_ell = 20
lmax = 500.
ledges = np.arange(int(lmax / d_ell) + 1) * d_ell + 2
_, st = read_flat_map("tmp_flat.fits", 0)
_, sq = read_flat_map("tmp_flat.fits", 1)
_, su = read_flat_map("tmp_flat.fits", 2)
b = nmt.NmtBinFlat(ledges[:-1], ledges[1:])
leff = b.get_effective_ells()
#No contaminants
prefix = 'bm_f_nc_np'
f0 = nmt.NmtFieldFlat(lx, ly, msk, [dt])
def get_covar_gaussim(self, lth, clth, bpws, wsp, temps, cl_dpj_all):
"""
Estimate the power spectrum covariance from Gaussian simulations
:param lth: list of multipoles.
:param clth: list of guess power spectra sampled at the multipoles stored in `lth`.
:param bpws: NaMaster bandpowers.
:param wsp: NaMaster workspace.
:param temps: list of contaminatn templates.
:params cl_dpj_all: list of deprojection biases for each bin pair combination.
"""
#Create a dummy file for the covariance MCM
f = open(self.get_output_fname('cov_mcm', ext='dat'), "w")
f.close()
#Setup
nsims = 10 * self.ncross * self.nell
print("Computing covariance from %d Gaussian simulations" % nsims)
msk_binary = self.msk_bi.reshape([self.fsk.ny, self.fsk.nx])
weights = (self.msk_bi * self.mskfrac).reshape(
[self.fsk.ny, self.fsk.nx])
if temps is not None:
conts = [[t.reshape([self.fsk.ny, self.fsk.nx])] for t in temps]
cl_dpj = [[c] for c in cl_dpj_all]
else:
conts = None
cl_dpj = [None for i in range(self.ncross)]
#Iterate
cells_sims = []
for isim in range(nsims):
if isim % 100 == 0:
print(" %d-th sim" % isim)
#Generate random maps
mps = nmt.synfast_flat(self.fsk.nx,
self.fsk.ny,
np.radians(self.fsk.lx),
np.radians(self.fsk.ly),
clth,
np.zeros(self.nbins),
seed=1000 + isim)
#Nmt fields
flds = [
nmt.NmtFieldFlat(np.radians(self.fsk.lx),
np.radians(self.fsk.ly),
weights, [m],
templates=conts) for m in mps
]
#Compute power spectra (possibly with deprojection)
i_x = 0
cells_this = []
for i in range(self.nbins):
for j in range(i, self.nbins):
cl = nmt.compute_coupled_cell_flat(flds[i], flds[j], bpws)
cells_this.append(
wsp.decouple_cell(cl, cl_bias=cl_dpj[i_x])[0])
i_x += 1
cells_sims.append(np.array(cells_this).flatten())
cells_sims = np.array(cells_sims)
#Save simulations for further
np.savez(self.get_output_fname('gaucov_sims'), cl_sims=cells_sims)
#Compute covariance
covar = np.cov(cells_sims.T)
return covar
# - Nx and Ny: the number of pixels in the x and y dimensions
Nx = 602
Ny = 410
#Gaussian simulations:
#pymaster allows you to generate random realizations of both spherical and
#flat fields given a power spectrum. These are returned as 2D arrays with
#shape (Ny,Nx)
l, cl_tt, cl_ee, cl_bb, cl_te = np.loadtxt('cls.txt', unpack=True)
beam = np.exp(-(0.25 * np.pi / 180 * l)**2)
cl_tt *= beam
cl_ee *= beam
cl_bb *= beam
cl_te *= beam
mpt, mpq, mpu = nmt.synfast_flat(
Nx, Ny, Lx, Ly,
np.array([cl_tt, cl_te, 0 * cl_tt, cl_ee, 0 * cl_ee, cl_bb]), [0, 2])
#You can have a look at the maps using matplotlib's imshow:
plt.figure()
plt.imshow(mpt, interpolation='nearest', origin='lower')
plt.colorbar()
plt.figure()
plt.imshow(mpq, interpolation='nearest', origin='lower')
plt.colorbar()
plt.figure()
plt.imshow(mpu, interpolation='nearest', origin='lower')
plt.colorbar()
plt.show()
#Masks:
def get_sample_field():
mpt = nmt.synfast_flat(Nx, Ny, Lx, Ly, np.array([clarr]), [0])[0]
return nmt.NmtFieldFlat(Lx, Ly, mask, [mpt])
hdul = fits.open(filename)
w = WCS(hdul[0].header)
maps = hdul[i_map].data
ny, nx = maps.shape
return w, maps
wcs, msk = read_flat_map("msk_flat.fits")
(ny, nx) = msk.shape
lx = np.fabs(nx * wcs.wcs.cdelt[0]) * np.pi / 180
ly = np.fabs(ny * wcs.wcs.cdelt[1]) * np.pi / 180
dt, dq, du = nmt.synfast_flat(
int(nx),
int(ny),
lx,
ly, [cltt + nltt, clee + nlee, clbb + nlbb, clte + nlte],
pol=True)
write_flat_map("mps_flat.fits", np.array([dt, dq, du]), wcs, ["T", "Q", "U"])
d_ell = 20
lmax = 500.
ledges = np.arange(int(lmax / d_ell) + 1) * d_ell + 2
_, st = read_flat_map("tmp_flat.fits", 0)
_, sq = read_flat_map("tmp_flat.fits", 1)
_, su = read_flat_map("tmp_flat.fits", 2)
b = nmt.NmtBinFlat(ledges[:-1], ledges[1:])
leff = b.get_effective_ells()
#No contaminants
prefix = 'bm_f_nc_np'
