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)