def aps(rlz, qobj, xobj, wfac, flens, fcib, **kwargs_ov):
Lmax = qobj.olmax
cl = np.zeros((len(rlz), 7, Lmax + 1))
for q in qobj.qlist:
for i, r in enumerate(
tqdm.tqdm(rlz,
ncols=100,
desc='aps (' + qobj.qtype + ',' + q + ')')):
if misctools.check_path(xobj.fcli[q][r], **kwargs_ov): continue
# load qlm
alm = quad_func.load_rec_alm(qobj, q, r, mean_sub=True)[0]
#alm = pickle.load(open(qobj.f[q].alm[r],"rb"))[0]
#mf = pickle.load(open(qobj.f[q].mfalm[r],"rb"))[0]
#alm -= mf
# auto spectrum
cl[i, 0, :] = csu.alm2cl(Lmax, alm) / qobj.wn[4]
if r > 0:
# load input klm
klm = hp.read_alm(flens['IN'][r])
klm = csu.lm_healpy2healpix(klm, 4096)[:Lmax + 1, :Lmax + 1]
# cross with input klm
cl[i, 1, :] = csu.alm2cl(Lmax, alm, klm) / qobj.wn[2]
# load reconstructed klm
klm = hp.read_alm(flens['MV'][r])
klm = csu.lm_healpy2healpix(klm, 4096)[:Lmax + 1, :Lmax + 1]
# cross with lens
cl[i, 2, :] = csu.alm2cl(Lmax, alm, klm) / wfac['ik']
# lens auto
cl[i, 3, :] = csu.alm2cl(Lmax, klm) / wfac['kk']
# load cib alm
Ilm = pickle.load(open(fcib[r], "rb"))
# cross with cib
cl[i, 4, :] = csu.alm2cl(Lmax, alm, Ilm) / wfac['iI']
# cib
cl[i, 5, :] = csu.alm2cl(Lmax, Ilm) / wfac['II']
# lens x cib
cl[i, 6, :] = csu.alm2cl(Lmax, Ilm, klm) / wfac['kI']
np.savetxt(xobj.fcli[q][r],
np.concatenate((qobj.l[None, :], cl[i, :, :])).T)
# save to files
if rlz[-1] >= 2 and not misctools.check_path(xobj.fmcl[q], **
kwargs_ov):
i0 = max(0, 1 - rlz[0])
np.savetxt(
xobj.fmcl[q],
np.concatenate(
(qobj.l[None, :], np.average(cl[i0:, :, :], axis=0),
np.std(cl[i0:, :, :], axis=0))).T)
def generate_map(aobj, overwrite=False, verbose=True):
# take lensed CMB alms and convert to map
for rlz in tqdm.tqdm(aobj.rlz, desc='signal map'):
if misctools.check_path(aobj.fmap['s'][rlz],
overwrite=overwrite,
verbose=verbose):
continue
iTlm = np.complex128(hp.fitsfunc.read_alm(aobj.fcmb[rlz],
hdu=(1))) / local.Tcmb
ilmax = hp.sphtfunc.Alm.getlmax(len(iTlm))
iTlm = cs.utils.lm_healpy2healpix(iTlm, ilmax)[:aobj.lmax +
1, :aobj.lmax + 1]
Tmap = cs.utils.hp_alm2map(aobj.nside, aobj.lmax, aobj.lmax, iTlm)
hp.fitsfunc.write_map(aobj.fmap['s'][rlz], Tmap, overwrite=True)
# generate random noise alm and covert to map
nl = np.ones(aobj.lmax + 1) * (aobj.sigma * np.pi / 10800. / local.Tcmb)**2
for rlz in tqdm.tqdm(aobj.rlz, desc='noise map'):
if misctools.check_path(aobj.fmap['n'][rlz],
overwrite=overwrite,
verbose=verbose):
continue
nlm = cs.utils.gauss1alm(aobj.lmax, nl)
nmap = cs.utils.hp_alm2map(aobj.nside, aobj.lmax, aobj.lmax, nlm)
hp.fitsfunc.write_map(aobj.fmap['n'][rlz], Tmap, overwrite=True)
def cinv(tqu,rlz,t,lmax,ntype,fmap,falm,cl,freqs=[],fmapsa='',overwrite=False,verbose=False,**kwargs):
# prepare objects for wiener filtering
if t == 'la':
wla = wiener_objects('la',tqu,freqs,ntype,kwargs['nsides'][0])
if t == 'co':
wla = wiener_objects('la',tqu,freqs,ntype,kwargs['nsides0'][0])
wiener_objects.load_invN(wla)
wsa = None
if t == 'co':
wsa = wiener_objects('sa',tqu,freqs,ntype,kwargs['nsides1'][0])
wiener_objects.load_invN(wsa)
# roll-off effect
roll = int(ntype[ntype.find('roll')+4:])
if roll > 2:
cl[:3,:roll] = 0.
# start loop for realizations
for i in tqdm.tqdm(rlz,ncols=100,desc='cinv'):
if misctools.check_path(falm['E'][i],overwrite=overwrite): continue
wiener_objects.load_maps(wla,fmap,i)
if t=='co':
wiener_objects.load_maps(wsa,fmapsa,i)
cinv_core(i,t,wla,wsa,lmax,falm,cl[:4,:lmax+1],verbose=verbose,**kwargs)
def map2alm(lmax, fmap, falm, mask, ibl, dtype, scale=1., tmap=None, **kwargs):
if misctools.check_path(falm, **kwargs): return
if tmap is None:
# standard map -> alm conversion
hpmap = reduc_map(dtype, fmap, scale=scale)
nside = hp.pixelfunc.get_nside(hpmap)
hpmap *= mask
# convert to alm
alm = curvedsky.utils.hp_map2alm(nside, lmax, lmax, hpmap)
# beam deconvolution
alm *= ibl[:, None] #/pfunc[:,None]
else:
# non-zero tau sim
# deconvolve beam first
hpmap = reduc_map(dtype, fmap, scale=scale)
nside = hp.pixelfunc.get_nside(hpmap)
alm = curvedsky.utils.hp_map2alm(nside, lmax, lmax, hpmap)
alm *= ibl[:, None]
# input signal amplitude modulation
alm = curvedsky.utils.mulwin(alm, mask * np.exp(-tmap))
# save to file
pickle.dump((alm), open(falm, "wb"), protocol=pickle.HIGHEST_PROTOCOL)
def quadxy(cy, lmax, rlz, qobj, fx, w3, w2, **kwargs_ov):
l = np.linspace(0, lmax, lmax + 1)
for i in tqdm.tqdm(rlz, ncols=100, desc='quad x y (' + qobj.qtype + ')'):
if misctools.check_path(fx.xl[i], **kwargs_ov): continue
# load tau
tlm = pickle.load(open(qobj.f['TT'].alm[i],
"rb"))[0][:lmax + 1, :lmax + 1]
mf = pickle.load(open(qobj.f['TT'].mfb[i],
"rb"))[0][:lmax + 1, :lmax + 1]
tlm -= mf
if qobj.qtype == 'tau': tlm = -tlm
# load yalm
ylm = {}
ylm[0], ylm[1], ylm[2] = pickle.load(open(cy.fyalm[i], "rb"))
# cross spectra
xl = np.zeros((3, lmax + 1))
for yn in range(3):
xl[yn, :] = curvedsky.utils.alm2cl(
lmax, tlm, ylm[yn][:lmax + 1, :lmax + 1]) / w3
np.savetxt(fx.xl[i], np.concatenate((l[None, :], xl)).T)
def gen_ptsr(rlz,
fcmb,
ibl,
fseed,
fcl,
fmap,
w,
olmax=2048,
ilmin=1000,
ilmax=3000,
overwrite=False,
verbose=True): # generating ptsr contributions
# difference spectrum with smoothing
scl = (np.loadtxt(fcmb.scl)).T[1][:ilmax + 1]
ncl = (np.loadtxt(fcmb.scl)).T[2][:ilmax + 1]
rcl = (np.loadtxt(fcmb.ocl)).T[1][:ilmax + 1]
# interpolate
dCL = rcl - scl - ncl
dcl = sp.savgol_filter(dCL, 101, 1)
dcl[dcl <= 0] = 1e-30
dcl[:ilmin] = 1e-30
np.savetxt(fcl, np.array((np.linspace(0, ilmax, ilmax + 1), dcl, dCL)).T)
dcl = np.sqrt(dcl)
# generating seed, only for the first run
for i in rlz:
if not os.path.exists(fseed[i]):
alm = curvedsky.utils.gauss1alm(ilmax, np.ones(ilmax + 1))
pickle.dump((alm),
open(fseed[i], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
# load beam function
bl = 1. / ibl[:ilmax + 1]
nside = hp.pixelfunc.get_nside(w)
#pfunc = hp.sphtfunc.pixwin(nside)[:lmax+1]
# multiply cl, transform to map and save it
for i in tqdm.tqdm(rlz, ncols=100, desc='gen ptsr:'):
if misctools.check_path(fcmb.alms['p']['T'][i],
overwrite=overwrite,
verbose=verbose):
continue
if i == 0: continue
palm = pickle.load(open(fseed[i], "rb"))[:ilmax + 1, :ilmax + 1]
palm *= dcl[:, None] * bl[:, None] #multiply beam-convolved cl
pmap = curvedsky.utils.hp_alm2map(nside, ilmax, ilmax, palm)
hp.fitsfunc.write_map(fmap['p'][i], pmap, overwrite=True)
palm = curvedsky.utils.hp_map2alm(nside, olmax, olmax,
w * pmap) #multiply window
palm /= bl[:olmax + 1, None] #beam deconvolution
pickle.dump((palm),
open(fcmb.alms['p']['T'][i], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
def alm_comb(rlz,
falm,
stype=['n'],
mtype=['T', 'E', 'B'],
overwrite=False,
verbose=True):
for i in tqdm.tqdm(rlz, ncols=100, desc='alm combine:'):
for m in mtype:
if misctools.check_path(falm['c'][m][i],
overwrite=overwrite,
verbose=verbose):
continue
salm = pickle.load(open(falm['s'][m][i], "rb"))
nalm, palm = 0. * salm, 0. * salm
if i > 0:
if 'n' in stype:
nalm = pickle.load(open(falm['n'][m][i], "rb"))
if 'p' in stype:
palm = pickle.load(open(falm['p'][m][i], "rb"))
pickle.dump((salm + nalm + palm),
open(falm['c'][m][i], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
def template_aps(rlz,
fdlm,
fBlm,
fcl,
W,
olmax=2048,
klist=['TT', 'TE', 'EE', 'EB'],
**kwargs_ov):
npix = len(W)
nside = int(np.sqrt(npix / 12.))
for k in tqdm.tqdm(klist, ncols=100, desc='template aps'):
for i in tqdm.tqdm(rlz,
ncols=100,
desc='each rlz (' + k + ')',
leave=False):
if misctools.check_path(fcl[k][i], **kwargs_ov): continue
dalm = pickle.load(open(fdlm[k][i], "rb"))[0:olmax + 1,
0:olmax + 1]
wdlm = curvedsky.utils.mulwin_spin(nside, olmax, olmax, 2,
0 * dalm, dalm, W)[1]
Balm = pickle.load(open(fBlm[i], "rb"))[:olmax + 1, :olmax + 1]
wBlm = curvedsky.utils.mulwin_spin(nside, olmax, olmax, 2,
0 * Balm, Balm, W)[1]
clbb = curvedsky.utils.alm2cl(olmax, wBlm)
cldd = curvedsky.utils.alm2cl(olmax, wdlm)
clbd = curvedsky.utils.alm2cl(olmax, wdlm, wBlm)
np.savetxt(fcl[k][i], np.array((clbb, cldd, clbd)).T)
def alm_comb_freq(rlz,fcmbfreq,fcmbcomb,verbose=True,overwrite=False,freqs=['93','145','225'],mtype=[(0,'T'),(1,'E'),(2,'B')],roll=2):
for i in tqdm.tqdm(rlz,ncols=100,desc='alm combine'):
for (mi, m) in mtype:
if misctools.check_path(fcmbcomb.alms['o'][m][i],overwrite=overwrite,verbose=verbose): continue
salm, nalm, Wl = 0., 0., 0.
for freq in freqs:
Nl = np.loadtxt(fcmbfreq[freq].scl['n'],unpack=True)[mi+1]
Nl[0:2] = 1.
Il = 1./Nl
salm += pickle.load(open(fcmbfreq[freq].alms['s'][m][i],"rb"))*Il[:,None]
nalm += pickle.load(open(fcmbfreq[freq].alms['n'][m][i],"rb"))*Il[:,None]
Wl += Il
salm /= Wl[:,None]
nalm /= Wl[:,None]
oalm = salm + nalm
# remove low-ell for roll-off effect
if roll > 2:
oalm[:roll,:] = 0.
pickle.dump((salm),open(fcmbcomb.alms['s'][m][i],"wb"),protocol=pickle.HIGHEST_PROTOCOL)
pickle.dump((nalm),open(fcmbcomb.alms['n'][m][i],"wb"),protocol=pickle.HIGHEST_PROTOCOL)
pickle.dump((oalm),open(fcmbcomb.alms['o'][m][i],"wb"),protocol=pickle.HIGHEST_PROTOCOL)
def interface(run=[], kwargs_cmb={}, kwargs_ov={}):
# define parameters, filenames and functions
aobj = local.init_analysis(**kwargs_cmb)
# read survey window
wind, M, wn = local.set_mask(aobj.famask)
if aobj.fltr == 'cinv': wn[:] = wn[0]
# generate ptsr
if 'fg' in run and aobj.biref == 0:
# compute signal and noise spectra but need to change file names
q = local.init_analysis(**kwargs_cmb)
q.fcmb.scl = q.fcmb.scl.replace('.dat', '_tmp.dat')
q.fcmb.ocl = q.fcmb.ocl.replace('.dat', '_tmp.dat')
if not misctools.check_path(q.fcmb.scl, **kwargs_ov):
# compute signal and noise alms
map2alm_all(aobj, wind, **kwargs_ov)
alm2aps(q, wn[2], stype=['s', 'n'], cli_out=False, **kwargs_ov)
# generate ptsr alm from obs - (sig+noi) spectrum
gen_ptsr(aobj.rlz,
q.fcmb,
aobj.ibl,
aobj.fpseed,
aobj.fptsrcl,
aobj.fimap,
wind,
olmax=aobj.lmax,
ilmin=ilmin,
ilmax=ilmax,
**kwargs_ov)
# use normal transform to alm
if aobj.freq == '857':
mtype = ['T']
else:
mtype = ['T', 'E', 'B']
if aobj.fltr == 'none':
if 'alm' in run: # combine signal, noise and ptsr
map2alm_all(aobj, wind, **kwargs_ov)
alm_comb(aobj.rlz, aobj.fcmb.alms, mtype=mtype, **kwargs_ov)
if 'aps' in run: # compute cl
alm2aps(aobj, wn[2], **kwargs_ov)
# map -> alm with cinv filtering
if aobj.fltr == 'cinv':
if 'alm' in run: # cinv filtering here
wiener_cinv(aobj, M, kwargs_ov=kwargs_ov)
if 'aps' in run: # aps of filtered spectrum
alm2aps(aobj, wn[0], stype=['c'], **kwargs_ov)
def sim_iamp(i, M, palm, lmax, rlmin, rlmax, Ag, ocl, lcl, nl, beta, freq):
fname = '/global/homes/t/toshiyan/scratch/plk_biref/test/glm_' + str(
freq) + '_' + str(i).zfill(3) + '.pkl'
if misctools.check_path(fname, verbose=False):
glm, Ealm, Balm = pickle.load(open(fname, "rb"))
else:
alms = hp.read_alm(
'/project/projectdirs/sobs/v4_sims/mbs/cmb/fullskyLensedUnabberatedCMB_alm_set00_'
+ str(i).zfill(5) + '.fits',
hdu=(1, 2, 3))
#Talm = cs.utils.lm_healpy2healpix( alms[0], 5100 ) [:lmax+1,:lmax+1] / CMB.Tcmb
Ealm = cs.utils.lm_healpy2healpix(
alms[1], 5100)[:lmax + 1, :lmax + 1] / CMB.Tcmb
Balm = cs.utils.lm_healpy2healpix(
alms[2], 5100)[:lmax + 1, :lmax + 1] / CMB.Tcmb
# biref
#print('birefringence')
Ealm, Balm = ana.ebrotate(beta, Ealm, Balm)
# add noise and filtering (temp)
#print('add noise')
#Talm += cs.utils.gauss1alm(lmax,nl[0,:])
Ealm += cs.utils.gauss1alm(lmax, nl[1, :])
Balm += cs.utils.gauss1alm(lmax, nl[2, :])
#print('mask')
#Talm = cs.utils.mulwin(Talm,M)
Ealm, Balm = cs.utils.mulwin_spin(Ealm, Balm, M)
# simple diagonal c-inverse
#print('reconstruction')
Fl = np.zeros((3, lmax + 1, lmax + 1))
for l in range(rlmin, rlmax):
Fl[:, l, 0:l + 1] = 1. / ocl[:3, l, None]
#Talm *= Fl[0,:,:]
fEalm = Ealm * Fl[1, :, :]
fBalm = Balm * Fl[2, :, :]
# compute unnormalized estiamtors
#glm['TE'], clm['TE'] = cs.rec_iamp.qte(lmax,rlmin,rlmax,lcl[3,:],Talm,Ealm)
#glm['TB'], clm['TB'] = cs.rec_iamp.qtb(lmax,rlmin,rlmax,lcl[3,:],Talm,Balm)
#glm['EE'], clm['EE'] = cs.rec_iamp.qee(lmax,rlmin,rlmax,lcl[1,:],Ealm,Ealm)
glm = cs.rec_iamp.qeb(lmax, rlmin, rlmax, ocl[1, :] - ocl[2, :], fEalm,
fBalm)
#glm['BB'], clm['BB'] = cs.rec_iamp.qbb(lmax,rlmin,rlmax,lcl[1,:],Balm,Balm)
#print('cross spec')
pickle.dump((glm, Ealm, Balm),
open(fname, "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
cl = cs.utils.alm2cl(lmax, Ag['EB'][:, None] * glm, palm)
W2 = np.mean(M**2)
EB = cs.utils.alm2cl(lmax, Ealm, Balm) / W2
return cl, EB
def alm2aps(aobj, overwrite=False, verbose=True):
cl = {
s: np.zeros((len(aobj.rlz), 6, aobj.lmax + 1))
for s in ['c', 'n', 's']
}
print('load W2')
W = hp.fitsfunc.read_map(aobj.amask, verbose=False)
wn = tools_cmb.get_wfactor(W)
for ii, rlz in enumerate(tqdm.tqdm(aobj.rlz, desc='alm2aps')):
if misctools.check_path(aobj.fcls['c'][rlz],
overwrite=overwrite,
verbose=verbose):
continue
alm = {}
for s in ['c', 'n']:
alm[s] = pickle.load(open(aobj.falm[s]['T'][rlz], "rb"))
cl[s][ii, 0, :] = cs.utils.alm2cl(lmax, alm[s]) / w2
cl['s'][ii, 0, :] = cs.utils.alm2cl(lmax, alm['c'] - alm['n']) / w2
# save cl for each rlz
np.savetxt(aobj.fcls['c'][rlz],
np.concatenate((aobj.l[None, :], cl['c'][ii, :, :])).T)
np.savetxt(aobj.fcls['s'][rlz],
np.concatenate((aobj.l[None, :], cl['s'][ii, :, :])).T)
np.savetxt(aobj.fcls['n'][rlz],
np.concatenate((aobj.l[None, :], cl['n'][ii, :, :])).T)
for s in ['c', 'n', 's']:
if misctools.check_path(aobj.fscl[s],
overwrite=overwrite,
verbose=verbose):
continue
np.savetxt(
aobj.fscl[s],
np.concatenate(
(aobj.l[None, :], np.mean(cl[s], axis=0), np.std(cl[s],
axis=0))).T)
def iso_noise(rlz,lmin,lmax,fslm,falm,ncls,mtype=['T','E','B'],**kwargs_ov):
for i in tqdm.tqdm(rlz,ncols=100,desc='iso noise'):
for mi, m in enumerate(mtype):
if misctools.check_path(falm[m][i],**kwargs_ov): continue
alm = pickle.load(open(fslm[m][i],"rb"))
alm += CS.utils.gauss1alm(lmax,ncls[mi,:])
pickle.dump((alm),open(falm[m][i],"wb"),protocol=pickle.HIGHEST_PROTOCOL)
def alm_comb(qids,
qidc,
overwrite=False,
verbose=True,
mtypes=['T', 'E', 'B'],
ep=1e-30,
**kwargs):
# qids = qid to be combined
# qidc = output qid
aobj = {
q: local.init_analysis_params(qid=q, **kwargs)
for q in qids + [qidc]
}
mid = {'T': 1, 'E': 2, 'B': 3}
ncl = {}
Ncl = {}
for mi, m in mtype:
# pre-computed noise spectra for inverse-variance weighting
ncl[m] = {q: (np.loadtxt(aobj[q].fscl['n'])).T[mid[m]] for q in qids}
# norm
Ncl[m] = comb_Nl(qids, ncl)
for rlz in tqdm.tqdm(aobj[qids[0]].rlz, desc='combine alms'):
for m in mtype:
if misctools.check_path(
[aobj[qidc].falm['c'][m][rlz], aobj[qidc].falm['n'][m][rlz]],
overwrite=overwrite,
verbose=verbose):
continue
walm = {}
for s in ['c', 'n']:
if rlz == 0 and s in ['n']: continue
walm[s, m] = 0.
for q in qids:
# walm = 1/N alm = 1/(N/r^2) alm/r
walm[s, m] += 1. / ncl[m][q][:, None] * pickle.load(
open(aobj[q].falm[s][m][rlz], "rb")) #/ w1[q]
#wTlm[s,m] += rcl[q][:,None]/(ncl[q][:,None]+ep) * pickle.load(open(aobj[q].falm[s]['T'][rlz],"rb")) #/ w1[q]
walm[s, m][:2, :] = 0.
walm[s, m] *= Ncl[m][:, None]
# save alm for each rlz
pickle.dump((walm[s, m]),
open(aobj[qidc].falm[s][m][rlz], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
def gen_tau(rlz, lmax, ftalm, **kwargs_ov):
for i in tqdm.tqdm(rlz, ncols=100, desc='generate tau alm:'):
if misctools.check_path(ftalm[i], **kwargs_ov): continue
if i == 0: continue
tt = prjlib.tau_spec(lmax)
alm = curvedsky.utils.gauss1alm(lmax, tt)
pickle.dump((alm),
open(ftalm[i], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
def output_hitmap(**kwargs_ov):
for telescope in ['LA','SA']:
nside, __ = prjlib.mapres(telescope)
f = prjlib.hitmap_filename(telescope,nside)
if misctools.check_path(f,**kwargs_ov): continue
s = noise.SONoiseSimulator(nside)
w = s.hitmap[telescope]
hp.fitsfunc.write_map(f,w,overwrite=kwargs_ov['overwrite'])
def alm2aps(rlz,
lmax,
fcmb,
w2,
stype=['s', 'n', 'p', 'c'],
cli_out=True,
**kwargs_ov): # compute aps
# output is ell, TT(s), TT(n), TT(p), TT(s+n+p)
if misctools.check_path(fcmb.scl, **kwargs_ov): return
eL = np.linspace(0, lmax, lmax + 1)
cl = np.zeros((len(rlz), 4, lmax + 1))
for ii, i in enumerate(tqdm.tqdm(rlz, ncols=100, desc='cmb alm2aps:')):
if 's' in stype: salm = pickle.load(open(fcmb.alms['s']['T'][i], "rb"))
if i > 0:
if 'n' in stype:
nalm = pickle.load(open(fcmb.alms['n']['T'][i], "rb"))
if 'p' in stype:
palm = pickle.load(open(fcmb.alms['p']['T'][i], "rb"))
if 'c' in stype:
oalm = pickle.load(open(fcmb.alms['c']['T'][i], "rb"))
#compute cls
if 's' in stype: cl[ii, 0, :] = curvedsky.utils.alm2cl(lmax, salm) / w2
if i > 0:
if 'n' in stype:
cl[ii, 1, :] = curvedsky.utils.alm2cl(lmax, nalm) / w2
if 'p' in stype:
cl[ii, 2, :] = curvedsky.utils.alm2cl(lmax, palm) / w2
if 'c' in stype:
cl[ii, 3, :] = curvedsky.utils.alm2cl(lmax, oalm) / w2
if cli_out:
np.savetxt(fcmb.cl[i],
np.concatenate((eL[None, :], cl[ii, :, :])).T)
# save to files
if rlz[-1] > 2:
if kwargs_ov['verbose']: print('cmb alm2aps: save sim')
i0 = max(0, 1 - rlz[0])
np.savetxt(
fcmb.scl,
np.concatenate((eL[None, :], np.mean(cl[i0:, :, :], axis=0),
np.std(cl[i0:, :, :], axis=0))).T)
if rlz[0] == 0:
if kwargs_ov['verbose']: print('cmb alm2aps: save real')
np.savetxt(fcmb.ocl, np.array((eL, cl[0, 0, :])).T)
def ymap2yalm(cy, Wy, rlz, lmax, w2, ftalm, **kwargs_ov):
nside = hp.pixelfunc.get_nside(Wy)
l = np.linspace(0, lmax, lmax + 1)
bl = CMB.beam(10., lmax)
for i in tqdm.tqdm(rlz,
ncols=100,
desc='ymap2alm (' + cy.ytype + ',' + str(cy.ymask) +
')'):
if misctools.check_path(cy.fyalm[i], **kwargs_ov): continue
yalm = {}
clyy = {}
for yn in [0, 1, 2]: #full, first, last
if i == 0: # real data
ymap = Wy * hp.fitsfunc.read_map(
cy.fymap, field=yn, verbose=False)
yalm[yn] = curvedsky.utils.hp_map2alm(nside, lmax, lmax,
ymap) * bl[:, None]
clyy[yn] = curvedsky.utils.alm2cl(lmax, yalm[yn]) / w2
else: # generate sim
clyy[yn] = np.loadtxt(cy.fclyy, unpack=True)[yn + 1]
if ftalm is None:
galm = curvedsky.utils.gauss1alm(lmax, clyy[yn][:lmax + 1])
else:
talm = pickle.load(open(ftalm[i], "rb"))
cltt = prjlib.tau_spec(lmax)
clty = np.sqrt(cltt * clyy[yn]) * .9
__, galm = curvedsky.utils.gauss2alm(lmax,
cltt,
clyy[yn],
clty,
flm=talm)
ymap = Wy * curvedsky.utils.hp_alm2map(nside, lmax, lmax, galm)
yalm[yn] = curvedsky.utils.hp_map2alm(nside, lmax, lmax, ymap)
if i == 0:
xlyy = curvedsky.utils.alm2cl(lmax, yalm[1], yalm[2]) / w2
np.savetxt(cy.fclyy,
np.array((l, clyy[0], clyy[1], clyy[2], xlyy)).T)
pickle.dump((yalm[0], yalm[1], yalm[2]),
open(cy.fyalm[i], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
def qrec_bh_tau(qtau,
qlen,
qsrc,
qtbh,
rlz,
q='TT',
est=['lens', 'tau', 'src'],
**kwargs_ov):
At = np.loadtxt(qtau.f[q].al, unpack=True)[1]
# calculate response function
Btt, Btg, Bts = quad_func.quad.coeff_bhe(qtau, est=est, qcomb=q, gtype='k')
# normalization for BH
if not misctools.check_path(qtbh.f[q].al, **kwargs_ov):
np.savetxt(qtbh.f[q].al, np.array((qtau.l, At * Btt, At)).T)
# calculate bh-estimator
for i in tqdm.tqdm(rlz, ncols=100, desc='forming bh-est'):
if misctools.check_path(qtbh.f[q].alm[i], **kwargs_ov): continue
tlm = pickle.load(open(qtau.f[q].alm[i], "rb"))[0]
glm = pickle.load(open(qlen.f[q].alm[i], "rb"))[0]
if 'src' in est:
slm = pickle.load(open(qsrc.f[q].alm[i], "rb"))[0]
else:
slm = 0. * glm
alm = Btt[:, None] * tlm + Btg[:, None] * glm + Bts[:, None] * slm
pickle.dump((alm, alm * 0.),
open(qtbh.f[q].alm[i], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
# calculate mean-field bias
quad_func.quad.mean_rlz(qtbh, rlz, **kwargs_ov)
def map2alm(i, s, aobj, wind, scale=1., mtype=['T', 'E', 'B'], **kwargs):
if aobj.freq == '857':
mtype = ['T']
for m in mtype:
if misctools.check_path(aobj.fcmb.alms[s][m][i], **kwargs): return
# convert to alm
alm = {}
if 'T' in mtype:
Tmap = wind * reduc_map(aobj.fimap[s][i], scale=scale, field=0)
nside = hp.pixelfunc.get_nside(Tmap)
alm['T'] = curvedsky.utils.hp_map2alm(nside, aobj.lmax, aobj.lmax,
Tmap)
if 'E' in mtype or 'B' in mtype:
Qmap = wind * reduc_map(aobj.fimap[s][i], scale=scale, field=1)
Umap = wind * reduc_map(aobj.fimap[s][i], scale=scale, field=2)
nside = hp.pixelfunc.get_nside(Qmap)
alm['E'], alm['B'] = curvedsky.utils.hp_map2alm_spin(
nside, aobj.lmax, aobj.lmax, 2, Qmap, Umap)
# isotropic rotation
if s == 's' and i != 0:
alm['E'], alm['B'] = analysis.ebrotate(aobj.biref, alm['E'],
alm['B'])
# get empirical beam
#ibl = {}
#if aobj.freq in ['smica']:
# ibl['T'] = 1./local.get_beam(aobj.fimap['s'][0],aobj.lmax,'INT')
# ibl['E'] = 1./local.get_beam(aobj.fimap['s'][0],aobj.lmax,'POL')
# ibl['B'] = ibl['E']*1.
#else:
# ibl['T'] = local.get_transfer(aobj.freq,aobj.lmax)
# ibl['E'] = ibl['I']*1.
# ibl['B'] = ibl['I']*1.
for m in mtype:
# beam deconvolution
alm[m] *= aobj.ibl[:, None]
# save to file
pickle.dump((alm[m]),
open(aobj.fcmb.alms[s][m][i], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
def aps(rlz,lmax,fcmb,w2,stype=['o','s','n'],mtype=['T','E','B'],**kwargs_ov):
# compute aps for each rlz
L = np.linspace(0,lmax,lmax+1)
for s in stype:
if misctools.check_path(fcmb.scl[s],**kwargs_ov): continue
if kwargs_ov['verbose']: print('stype =',s)
cl = cmb.aps(rlz,lmax,fcmb.alms[s],odd=False,mtype=mtype,**kwargs_ov,w2=w2,fname=fcmb.cl[s])
# save average to files
mcl = np.mean(cl,axis=0)
vcl = np.std(cl,axis=0)
np.savetxt(fcmb.scl[s],np.concatenate((L[None,:],mcl,vcl)).T)
def aps(rlz, qobj, fklm=None, q='TT', **kwargs_ov):
cl = np.zeros((len(rlz), 3, qobj.olmax + 1))
for i in tqdm.tqdm(rlz, ncols=100, desc='aps (' + qobj.qtype + ')'):
if misctools.check_path(qobj.f[q].cl[i], **kwargs_ov): continue
# load qlm
alm = pickle.load(open(qobj.f[q].alm[i], "rb"))[0]
mf = pickle.load(open(qobj.f[q].mfb[i], "rb"))[0]
alm -= mf
# flip sign as e^-tau ~ 1-tau
if qobj.qtype == 'tau':
alm = -alm
# auto spectrum
cl[i, 0, :] = curvedsky.utils.alm2cl(qobj.olmax, alm) / qobj.wn[4]
if fklm is not None and i > 0:
# load input klm
if qobj.qtype == 'lens':
iKlm = hp.fitsfunc.read_alm(fklm[i])
iklm = curvedsky.utils.lm_healpy2healpix(iKlm, 2048)
if qobj.qtype == 'tau':
iklm = pickle.load(open(fklm[i], "rb"))
if qobj.qtype == 'src':
iklm = 0. * alm
# cross with input
cl[i, 1, :] = curvedsky.utils.alm2cl(qobj.olmax, alm,
iklm) / qobj.wn[2]
# input
cl[i, 2, :] = curvedsky.utils.alm2cl(qobj.olmax, iklm)
np.savetxt(qobj.f[q].cl[i],
np.concatenate((qobj.l[None, :], cl[i, :, :])).T)
# save to files
if rlz[-1] >= 2:
i0 = max(0, 1 - rlz[0])
np.savetxt(
qobj.f[q].mcls,
np.concatenate((qobj.l[None, :], np.average(cl[i0:, :, :], axis=0),
np.std(cl[i0:, :, :], axis=0))).T)
def wiener_cinv(aobj, M, kwargs_ov={}):
# noise covariance
Nij = M / aobj.sigma**2
Nij = np.reshape((Nij, Nij / 2., Nij / 2.), (3, 1, len(M)))
# rlz
for i in tqdm.tqdm(aobj.rlz, ncols=100, desc='wiener cinv:'):
if aobj.biref != 0. and i == 0: continue # avoid real biref case
if misctools.check_path([
aobj.fcmb.alms['c']['T'][i], aobj.fcmb.alms['c']['E'][i],
aobj.fcmb.alms['c']['B'][i]
], **kwargs_ov):
continue
wiener_cinv_core(i, aobj, M, Nij, verbose=kwargs_ov['verbose'])
def map2alm(aobj, overwrite=False, verbose=True):
W = hp.fitsfunc.read_map(aobj.amask, verbose=False)
for rlz in tqdm.tqdm(aobj.rlz, desc='map2alm'):
if misctools.check_path(aobj.falm['c']['T'][rlz],
overwrite=overwrite,
verbose=verbose):
continue
smap = hp.fitsfunc.read_map(aobj.fmap['s'][rlz], verbose=False)
nmap = hp.fitsfunc.read_map(aobj.fmap['n'][rlz], verbose=False)
wslm = cs.utils.hp_map2alm(aobj.nside, aobj.lmax, aobj.lmax, W * smap)
wnlm = cs.utils.hp_map2alm(aobj.nside, aobj.lmax, aobj.lmax, W * nmap)
pickle.dump((wslm + wnlm),
open(aobj.falm['c']['T'][rlz], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
pickle.dump((wnlm),
open(aobj.falm['n']['T'][rlz], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
def wiener_cinv(rlz,
dtype,
M,
cl,
fbeam,
fmap,
falm,
sscale,
nscale,
ftalm=None,
kwargs_ov={},
kwargs_cinv={}):
lmin = 1
lmax = len(cl[0, :]) - 1
bl = np.reshape(np.loadtxt(fbeam)[:lmax + 1], (1, lmax + 1))
Nij = M * (30. * (np.pi / 10800.) / 2.726e6)**(-2)
Nij = np.reshape(Nij, (1, 1, len(M)))
for i in tqdm.tqdm(rlz, ncols=100, desc='wiener cinv:'):
if ftalm is not None and i == 0: continue # avoid real tau case
if misctools.check_path(falm[i], **kwargs_ov): continue
wiener_cinv_core(i,
dtype,
M,
cl,
bl,
Nij,
fmap,
falm,
sscale,
nscale,
ftalm=ftalm,
verbose=kwargs_ov['verbose'],
**kwargs_cinv)
def SOsim(self):
# Simulate CMB and noise maps
ch = SOChannel(self.telescope,self.band)
print(ch.center_frequency.value)
if self.verbose: print(self.mode,self.roll)
for i in tqdm.tqdm(self.rlz,ncols=100,desc='generate map'):
if misctools.check_path(self.fmap[i],overwrite=self.overwrite,verbose=self.verbose): continue
if self.verbose: misctools.progress(i,self.rlz,addtext='sim map for '+self.mode)
if self.ntype == '':
# signal simulation
sim = SOStandalonePrecomputedCMB(i,nside=self.nside,input_units='uK_CMB')
map = SOStandalonePrecomputedCMB.simulate(sim,ch)
else:
# noise simulation
sim = SONoiseSimulator(telescopes=[self.telescope],nside=self.nside,apply_beam_correction=False,sensitivity_mode=self.mode,rolloff_ell=self.roll)
map = SONoiseSimulator.simulate(sim,ch)
# save to file
hp.fitsfunc.write_map(self.fmap[i],map,overwrite=True)
#!/usr/bin/env python
import numpy as np, healpy as hp, curvedsky, misctools, prjlib
from matplotlib.pyplot import *
ascale = 1. # 1deg apodization to Galactic mask
nside = 2048
#for wtype, gal in [('Lmask',3),('G60',2),('G60Lmask',2)]: #index is G70 or G60
for wtype in ['LmaskN18']: #index is G70 or G60
p = prjlib.init_analysis(wtype=wtype, ascale=ascale)
if not misctools.check_path(p.famask, overwrite=True):
mask = hp.fitsfunc.read_map(p.fmask, verbose=True)
amask = curvedsky.utils.apodize(nside, mask,
ascale) # apodize original mask
hp.fitsfunc.write_map(p.famask, amask, overwrite=True)
p = prjlib.init_analysis(wtype=wtype, ascale=ascale)
mask = hp.fitsfunc.read_map(p.fmask)
print('effective sky area', np.mean(mask))
amask = hp.fitsfunc.read_map(p.famask, verbose=False)
print('effective sky area', np.mean(amask))
def wiener_cinv_core(qids,
wqid,
white=False,
kwargs_ov={
'overwrite': False,
'verbose': True
},
kwargs_cmb={},
kwargs_cinv={}):
# parameter
vb = kwargs_ov['verbose']
# specify output filename
aobj = local.init_analysis_params(qid=wqid, **kwargs_cmb)
# input CMB data
Aobj = {q: local.init_analysis_params(qid=q, **kwargs_cmb) for q in qids}
mn = len(qids)
bl = np.zeros((mn, aobj.lmax + 1))
Nij = np.zeros((1, mn, aobj.npix))
mask = {}
inl = np.ones((1, mn, aobj.lmax + 1))
for i, q in enumerate(qids):
# beam
bl[i, :] = beam_func(Aobj[q].lmax, Aobj[q].qid)
# binary mask
mask[q] = load_window_curvedsky(Aobj[q], with_ivar=False)
mask[q][mask[q] != 0] = 1.
# inv noise covariance
#os.system('echo "'+q+',constructing noise covariance" >> test.txt')
if vb: print(q, 'constructing noise covariance')
Nvar = load_ivar_curvedsky(Aobj[q])
if white:
Nij[0,
i, :] = mask[q] * Nvar / np.max(Nvar) / local.qid_wnoise(q)**2
else:
if q in local.boss_d:
# averaged noise spectrum at S16 region
bobj = local.init_analysis_params(qid=q,
fltr='none',
wind='com16',
ivar='base',
ptsr=aobj.ptsr)
if q in local.boss_n or q in local.s_16_d:
bobj = local.init_analysis_params(qid=q,
fltr='none',
wind='base',
ivar='base',
ptsr=aobj.ptsr)
Nl = np.loadtxt(bobj.fscl['n'], unpack=True)[1]
inl[0, i, 2:] = 1. / (Nl[2:] * bl[i, 2:]**2)
Nvar[Nvar <= 0] = 1e-60
Nij[0, i, :] = mask[q] * np.sqrt(
Nvar / np.max(Nvar)) #/ local.qid_wnoise(q)
del Nvar
# temperature map
T = np.zeros((1, mn, aobj.npix))
for rlz in aobj.rlz:
if misctools.check_path(aobj.falm['c']['T'][rlz], **kwargs_ov):
continue
#os.system('echo "'+str(rlz)+',loading temperature obs map" >> test.txt')
if rlz == 0:
for i, q in enumerate(qids):
if vb: print(rlz, q, 'loading temperature obs map')
Tc = enmap.read_map(Aobj[q].fmap['s'][rlz])[0]
T[0, i, :] = mask[q] * enmap.to_healpix(remove_lxly(
Tc, lmin=aobj.clmin, lmax=aobj.lmax),
nside=aobj.nside)
else:
for i, q in enumerate(qids):
if vb: print(rlz, q, 'loading temperature sim map')
Ts = enmap.read_map(Aobj[q].fmap['s'][rlz])[0]
Tn = enmap.read_map(Aobj[q].fmap['n'][rlz])[0]
T[0, i, :] = mask[q] * enmap.to_healpix(remove_lxly(
Ts + Tn, lmin=aobj.clmin, lmax=aobj.lmax),
nside=aobj.nside)
# cinv
if vb: print('cinv filtering')
#os.system('echo "cinv filter" >> test.txt')
if white:
Tlm = curvedsky.cninv.cnfilter_freq(1,
mn,
aobj.nside,
aobj.lmax,
aobj.lcl[0:1, :],
bl,
Nij,
T,
verbose=kwargs_ov['verbose'],
**kwargs_cinv)
else:
Tlm = curvedsky.cninv.cnfilter_freq(1,
mn,
aobj.nside,
aobj.lmax,
aobj.lcl[0:1, :],
bl,
Nij,
T,
verbose=kwargs_ov['verbose'],
inl=inl,
**kwargs_cinv)
pickle.dump((Tlm[0, :, :]),
open(aobj.falm['c']['T'][rlz], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
def diff_day_night(qid_d,
qid_n,
qid,
overwrite=False,
verbose=True,
mtype=['T'],
**kwargs):
aobj = {
q: local.init_analysis_params(qid=q, **kwargs)
for q in [qid_d, qid_n, qid]
}
cl = {
s: np.zeros((len(aobj[qid].rlz), 6, aobj[qid].lmax + 1))
for s in ['c', 's', 'n']
}
for ii, rlz in enumerate(tqdm.tqdm(aobj[qid_d].rlz, desc='day - night')):
if misctools.check_path(aobj[qid].falm['c']['T'][rlz],
overwrite=overwrite,
verbose=verbose):
continue
for s in ['c', 's', 'n']:
if rlz == 0 and s in ['s', 'n']: continue
# empirical Window correction from each day and night masks
if s in ['s']:
calm0 = pickle.load(open(aobj[qid_d].falm['c']['T'][rlz],
"rb"))
calm1 = pickle.load(open(aobj[qid_n].falm['c']['T'][rlz],
"rb"))
nalm0 = pickle.load(open(aobj[qid_d].falm['n']['T'][rlz],
"rb"))
nalm1 = pickle.load(open(aobj[qid_n].falm['n']['T'][rlz],
"rb"))
Talm0 = calm0 - nalm0
Talm1 = calm1 - nalm1
else:
Talm0 = pickle.load(open(aobj[qid_d].falm[s]['T'][rlz], "rb"))
Talm1 = pickle.load(open(aobj[qid_n].falm[s]['T'][rlz], "rb"))
dTalm = Talm0 - Talm1
if s == 'c':
pickle.dump(dTalm,
open(aobj[qid].falm[s]['T'][rlz], "wb"),
protocol=pickle.HIGHEST_PROTOCOL)
# aps
cl[s][ii, 0, :] = curvedsky.utils.alm2cl(aobj[qid].lmax, dTalm)
# save cl for each rlz
np.savetxt(
aobj[qid].fcls[s][rlz],
np.concatenate((aobj[qid].l[None, :], cl[s][ii, :, :])).T)
# save mean cl to files
if aobj[qid].rlz[-1] >= 2:
if verbose: print('save averaged diff day-night spectrum')
imin = max(0, 1 - aobj[qid].rlz[0])
for s in ['c', 's', 'n']:
np.savetxt(
aobj[qid].fscl[s],
np.concatenate(
(aobj[qid].l[None, :], np.mean(cl[s][imin:, :, :], axis=0),
np.std(cl[s][imin:, :, :], axis=0))).T)
def alm2aps(qids,
overwrite=False,
verbose=True,
mtype=['T', 'E', 'B'],
cns=['c', 'n', 's'],
W2=None,
**kwargs):
for qid in qids:
aobj = local.init_analysis_params(qid=qid, **kwargs)
if aobj.fltr == 'cinv': cns = ['c']
if W2 is None:
mask = load_window_curvedsky(aobj)
w2 = get_wfactor(mask)[2]
else:
if isinstance(W2, dict):
w2 = W2[qid]
else:
w2 = W2
cl = {s: np.zeros((len(aobj.rlz), 6, aobj.lmax + 1)) for s in cns}
for ii, rlz in enumerate(tqdm.tqdm(aobj.rlz, desc='alm -> aps')):
if misctools.check_path(aobj.fcls['c'][rlz],
overwrite=overwrite,
verbose=verbose):
continue
if rlz == 0:
alms = {
m: pickle.load(open(aobj.falm['c'][m][rlz], "rb"))
for m in mtype
}
cl['c'][ii, :, :] = alm2aps_core(aobj.lmax, alms, w2=w2)
else:
for s in cns:
if s == 's':
continue # signal part will be computed from combined - noise
alms = {
m: pickle.load(open(aobj.falm[s][m][rlz], "rb"))
for m in mtype
}
cl[s][ii, :, :] = alm2aps_core(aobj.lmax, alms, w2=w2)
# signal part
if 's' in cns:
# combined - noise = signal
alms = {
m: pickle.load(open(aobj.falm['c'][m][rlz], "rb")) -
pickle.load(open(aobj.falm['n'][m][rlz], "rb"))
for m in mtype
}
cl['s'][ii, :, :] = alm2aps_cor(aobj.lmax, alms, w2=w2)
# save cl for each rlz
np.savetxt(aobj.fcls['c'][rlz],
np.concatenate((aobj.l[None, :], cl['c'][ii, :, :])).T)
if rlz >= 1:
if 's' in cns:
np.savetxt(
aobj.fcls['s'][rlz],
np.concatenate((aobj.l[None, :], cl['s'][ii, :, :])).T)
if 'n' in cns:
np.savetxt(
aobj.fcls['n'][rlz],
np.concatenate((aobj.l[None, :], cl['n'][ii, :, :])).T)
# save mean cl to files
if aobj.rlz[-1] >= 2:
if verbose: print('save averaged spectrum over rlz')
imin = max(0, 1 - aobj.rlz[0])
for s in cns:
if misctools.check_path(aobj.fscl[s],
overwrite=overwrite,
verbose=verbose):
continue
np.savetxt(
aobj.fscl[s],
np.concatenate(
(aobj.l[None, :], np.mean(cl[s][imin:, :, :], axis=0),
np.std(cl[s][imin:, :, :], axis=0))).T)
