def get_maps(self, seed=None): # SKY fgs = [] for i, comp in enumerate(self.components): fgs.append(self.fgens[comp].get_map(seed=(1, i, seed))) arrays = [] for k, (beam, inhom, nsplit) in enumerate(zip(self.beams, self.inhoms, self.nsplits)): # SKY sky = 0. for i, comp in enumerate(self.components): sky += (fgs[i] * self.rdict[comp][i]) kbeam = maps.gauss_beam(self.modlmap, beam) kbeam[self.modlmap < self.ellmin] = 0 sky_convolved = maps.filter_map(sky, kbeam) # NOISE nmaps = [] for j in range(nsplit): nmap = self.ngens[k].get_map(seed=(2, j, seed)) * nsplit nmaps.append(nmap.copy()) nmaps = np.stack(nmaps) observed = enmap.enmap(sky_convolved + nmaps, self.wcs) arrays.append(observed.copy()) return arrays
def process(kouts, name="default", ellmax=None, y=False, y_ellmin=400): ellmax = lmax if ellmax is None else ellmax ksilc = enmap.zeros((Ny, Nx), wcs, dtype=np.complex128).reshape(-1) ksilc[modlmap.reshape(-1) < lmax] = np.nan_to_num(kouts.copy()) ksilc = enmap.enmap(ksilc.reshape((Ny, Nx)), wcs) ksilc[modlmap > ellmax] = 0 if y: ksilc[modlmap < y_ellmin] = 0 msilc = np.nan_to_num( fft.ifft(ksilc, axes=[-2, -1], normalize=True).real * bmask) enmap.write_map(proot + "outmap_%s.fits" % name, enmap.enmap(msilc, wcs)) p2d = fc.f2power(ksilc, ksilc) bin_edges = np.arange(100, 3000, 40) binner = stats.bin2D(modlmap, bin_edges) cents, p1d = binner.bin(p2d) try: # io.plot_img(np.log10(np.fft.fftshift(p2d)),proot+"ksilc_%s.png" % name,aspect='auto') # io.plot_img(msilc,proot+"msilc_%s.png" % name) # io.plot_img(msilc,proot+"lmsilc_%s.png" % name,lim=300) tmask = maps.mask_kspace(shape, wcs, lmin=300, lmax=5000 if not (y) else 1500) fmap = maps.filter_map(msilc, tmask) * bmask io.plot_img(fmap, proot + "hmsilc_%s.png" % name, high_res=True) except: pass return cents, p1d
def lens(ulensed,convergence): posmap = ulensed.posmap() kmask = maps.mask_kspace(ulensed.shape,ulensed.wcs,lmin=10,lmax=8000) phi,_ = lensing.kappa_to_phi(enmap.enmap(maps.filter_map(enmap.enmap(convergence,wcs),kmask),wcs),ulensed.modlmap(),return_fphi=True) grad_phi = enmap.grad(phi) pos = posmap + grad_phi alpha_pix = ulensed.sky2pix(pos, safe=False) lensed = enlensing.displace_map(ulensed, alpha_pix, order=5) return lensed
def get_sim(cmb, task, expid): if expid == 'planck': nid = 1 fwhm = pfwhm nlevel = pnlevel elif expid == 'act': nid = 2 fwhm = afwhm nlevel = anlevel seed = (nid, task) npower = (nlevel * np.pi / 180. / 60.)**2. nmap = enmap.rand_map((1, ) + shape, wcs, np.ones(shape)[None, None] * npower, seed=seed) return maps.filter_map(cmb, maps.gauss_beam(modlmap, fwhm)) + nmap
dm.get_coadd("s15", region, array, srcfree=True, ncomp=1)[0] * mask) # Get pixel window correction pwin = tutils.get_pixwin(mask.shape[-2:]) bpfile = "data/" + dm.get_bandpass_file_name(array) # Apply a filter that converts array map to Compton Y units (Eq 8) f = tfg.get_mix_bandpassed([bpfile], 'tSZ', ccor_cen_nus=[freqs[array]], ccor_beams=[lbeam])[0] f2d = maps.interp(ells, f)(modlmap) filt = kmask / pwin / f2d filt[~np.isfinite(filt)] = 0 imap = enmap.ifft(kmap * filt).real # Reconvolve Y map ymap = maps.filter_map(enmap.read_map(yfile), beam_ratio * kmask) # Get CMB maps smap = enmap.read_map(yfile2) cmap = enmap.read_map(yfile3) # Width in pixels of stamp cutout pix = 60 # Initialize stacks i = 0 istack = 0 ystack = 0 sstack = 0 cstack = 0
kappa = lensing.nfw_kappa(kamp_true*1e15,bmodrmap,cc,overdensity=200.,critical=True,atClusterZ=True) phi,_ = lensing.kappa_to_phi(kappa,bmodlmap,return_fphi=True) grad_phi = enmap.grad(phi) posmap = enmap.posmap(bshape,bwcs) pos = posmap + grad_phi alpha_pix = enmap.sky2pix(bshape,bwcs,pos, safe=False) lens_order = 5 ### FG PROFS famps = np.linspace(fmin,fmax,fnum) fg = kappa * 50. fg_true = maps.filter_map(fg.copy()*ftrue,kbeam) # Load covs bkamps = np.loadtxt(GridName+"/amps.txt",unpack=True) #[:1] # !!! if rank==0: print("Amplitudes: ",bkamps) cov_file = lambda x: GridName+"/cov_"+str(x)+".npy" cinvs = [] logdets = [] for k in range(len(bkamps)): if rank==0: print("Loading cov",k," / ",len(bkamps),"...") cov = np.load(cov_file(k))
def filter_map(imap): modlmap = imap.modlmap() ells = np.arange(0, 8000, 1) fcurve = np.exp(-(ells - 4000)**2. / 2. / 200**2.) return maps.filter_map(imap, maps.interp(ells, fcurve)(modlmap))
import tilec.utils as tutils random = False cversion = 'joint' #region = 'boss' region = 'deep56' mask = sints.get_act_mr3_crosslinked_mask(region) dm = sints.ACTmr3(region=mask, calibrated=True) modlmap = mask.modlmap() lmin = 2000 kmask = maps.mask_kspace(mask.shape, mask.wcs, lmin=lmin, lmax=30000) kbeam150 = dm.get_beam(modlmap, "s15", region, "pa3_f150", sanitize=True) kbeam090 = dm.get_beam(modlmap, "s15", region, "pa3_f090", sanitize=True) m150 = maps.filter_map( dm.get_coadd("s15", region, "pa3_f150", srcfree=True, ncomp=1)[0] * mask, kmask * kbeam150) m090 = maps.filter_map( dm.get_coadd("s15", region, "pa3_f090", srcfree=True, ncomp=1)[0] * mask, kmask * kbeam090) m1502 = maps.filter_map( dm.get_coadd("s15", region, "pa2_f150", srcfree=True, ncomp=1)[0] * mask, kmask * kbeam150) m1503 = maps.filter_map( dm.get_coadd("s15", region, "pa1_f150", srcfree=True, ncomp=1)[0] * mask, kmask * kbeam150) m1504 = maps.filter_map( dm.get_coadd("s14", region, "pa2_f150", srcfree=True, ncomp=1)[0] * mask, kmask * kbeam150) m1505 = maps.filter_map( dm.get_coadd("s15", region, "pa1_f150", srcfree=True, ncomp=1)[0] * mask,
mstats = stats.Stats(comm) np.random.seed(rank) # QE tellmin = modlmap[modlmap>2].min(); tellmax = 8000; kellmin = tellmin ; kellmax = 8096 tmask = maps.mask_kspace(shape,wcs,lmin=tellmin,lmax=tellmax) kmask = maps.mask_kspace(shape,wcs,lmin=kellmin,lmax=kellmax) qest = lensing.qest(shape,wcs,theory,noise2d=kbeam*0.+(noise_uK_rad)**2.,beam2d=kbeam,kmask=tmask,kmask_K=kmask,pol=False,grad_cut=2000,unlensed_equals_lensed=False) for i,task in enumerate(my_tasks): if (i+1)%10==0 and rank==0: print(i+1) unlensed = mg.get_map() noise_map = ng.get_map() lensed = maps.filter_map(enlensing.displace_map(unlensed, alpha_pix, order=lens_order),kbeam) stamp = lensed + noise_map if task==0: io.plot_img(stamp,pout_dir+"cmb_noisy.png") recon = qest.kappa_from_map("TT",stamp) cents, recon1d = binner.bin(recon) mstats.add_to_stats("recon1d",recon1d) mstats.add_to_stack("recon",recon) mstats.get_stats() mstats.get_stacks() if rank==0: stack = mstats.stacks['recon']
def _beam(self,imap,ai): return maps.filter_map(imap,self.kbeams[ai])
kappa = kamp * np.exp(-modrmap**2. / 2. / ksigma**2.) tkmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=6000) kkmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=7000) qest = lensing.qest(shape, wcs, theory, kmask=tkmask, kmask_K=kkmask) phi, _ = lensing.kappa_to_phi(kappa, modlmap, return_fphi=True) grad_phi = enmap.grad(phi) lens_order = 5 N = 1000 bin_edges = np.arange(0, 10., 1.0) binner = stats.bin2D(modrmap * 180. * 60 / np.pi, bin_edges) mystats = stats.Stats() fkappa = maps.filter_map(kappa, kkmask) cents, yt = binner.bin(fkappa) for i in range(N): unlensed = mg.get_map() lensed = enlensing.lens_map(unlensed, grad_phi, order=lens_order, mode="spline", border="cyclic", trans=False, deriv=False, h=1e-7) recon = qest.kappa_from_map("TT", lensed) cents, recon1d = binner.bin(recon)
arrays.s16_01.rms = 40. arrays.s16_02.freq = 148 arrays.s16_02.fwhm = 1.4 arrays.s16_02.rms = 60. arrays.s16_03.freq = 93 arrays.s16_03.fwhm = 1.4 * (148. / 93.) arrays.s16_03.rms = 60. np.random.seed((1, seed)) ras, decs = catalogs.random_catalog(shape, wcs, Nclusters, edge_avoid_deg=0.) for qind, qid in enumerate(arrays.keys()): fwhm = arrays[qid].fwhm freq = arrays[qid].freq rms = arrays[qid].rms amps = get_amps(freq) srcs = np.stack((decs * putils.degree, ras * putils.degree, amps)).T szmap = sim_srcs(shape, wcs, srcs, beam=fwhm * putils.arcmin) kbeam = maps.gauss_beam(modlmap, fwhm) signal = maps.filter_map(cmb, kbeam) + szmap # io.hplot(signal,os.environ['WORK'] + '/tiling/signal_%s' % qid) for i in range(nsplits): noise = maps.white_noise(shape, wcs, rms, seed=(2, qind, seed, i)) omap = signal + noise fname = os.environ['WORK'] + '/sim_tiling/%s_split_%d.fits' % (qid, i) enmap.write_map(fname, omap) io.hplot(omap, os.environ['WORK'] + '/tiling/total_%s_%d' % (qid, i))
srcfree=False)[0, :, :, ...] cmap = dm.get_coadd(season=season, patch=apatch, array=array, ncomp=3, srcfree=False) except: continue io.hplot(splits, os.environ['WORK'] + "/new_mr3f/splits_%s" % fname, min=-300, max=600, grid=True) # ivars = dm.get_splits_ivar(season=season,patch=apatch,arrays=[array],ncomp=None)[0,:,0,...] # cmap,_ = noise.get_coadd(splits,ivars,axis=0) rmap = maps.filter_map(cmap * mask, mfilter) io.hplot(rmap, os.environ['WORK'] + "/new_mr3f/coadd_filtered_%s" % fname, grid=True) rmap = maps.filter_map(splits * mask, mfilter) io.hplot(rmap, os.environ['WORK'] + "/new_mr3f/splits_filtered_%s" % fname, grid=True) io.hplot(cmap, os.environ['WORK'] + "/new_mr3f/coadd_%s" % fname, min=-300, max=600, grid=True)
lmin=ylmin, lmax=ylmax, lxcut=ylcut, lycut=ylcut) kmask = maps.mask_kspace(shape, wcs, lmin=klmin, lmax=klmax) # get theory spectrum and build interpolated 2D Fourier CMB from theory and maps theory = cosmology.default_theory() ucltt2d = theory.lCl('TT', modlmap) # total spectrum includes beam-deconvolved noise npower = (nlevel * np.pi / 180. / 60.)**2. tcltt2d = ucltt2d + npower / beam2d**2. # apply beam k_stamp = maps.filter_map(kstamp, beam2d) l_stamp = maps.filter_map(lstamp, beam2d) # same filter as the post-reconstuction fk_stamp = maps.filter_map(k_stamp, kmask) s.add_to_stack('kstamp', fk_stamp) tapered_stamp = l_stamp * taper # get a beam deconvolved Fourier stamp k_map = enmap.fft(tapered_stamp, normalize="phys") / beam2d assert np.all(np.isfinite(k_map)) # build symlens dictionary feed_dict = { 'uC_T_T': ucltt2d,
bin_edges = np.arange(40, 4000, 40) taper, w2 = maps.get_taper(shape) st = stats.Stats() for i in range(nsims): print(i) imap = mgen.get_map() omap1 = maps.convolve_profile(imap.copy(), rs, brs, fwhm_test, nsigma=200.0) omap2 = maps.filter_map(imap.copy(), kbeam) omap3 = maps.convolve_gaussian(imap.copy(), fwhm=fwhm_test, nsigma=5.0) omap4 = maps.filter_map(imap.copy(), kbeam_test) if i == 0: io.plot_img(omap1, io.dout_dir + "drbeam.png", high_res=True) io.plot_img(omap2, io.dout_dir + "dfbeam.png", high_res=True) io.plot_img(omap3, io.dout_dir + "grbeam.png", high_res=True) io.plot_img(omap4, io.dout_dir + "gfbeam.png", high_res=True) cents, p0 = maps.binned_power(imap * taper, bin_edges=bin_edges, fc=fc, modlmap=modlmap) cents, p1 = maps.binned_power(omap1 * taper, bin_edges=bin_edges,
def reconvolve(x, ybname, fwhm): if not (do_reconvolve): return x ls, bells = np.loadtxt(ybname, unpack=True) beam_rat = maps.gauss_beam(modlmap, fwhm) / maps.interp(ls, bells)(modlmap) beam_rat[~np.isfinite(beam_rat)] = 0 return maps.filter_map(x, beam_rat)
lmin = 200 lmax = 3000 Lmin = 40 Lmax = 3000 xmask = maps.mask_kspace(shape,wcs,lmin=lmin,lmax=lmax) ymask = xmask kmask = maps.mask_kspace(shape,wcs,lmin=Lmin,lmax=Lmax) feed_dict['uC_T_T'] = cov feed_dict['tC_T_T'] = cov + (wnoise*np.pi/180/60)**2 / kbeam**2 qe = symlens.QE(shape,wcs,feed_dict,'hu_ok','TT',xmask=xmask,ymask=ymask,kmask=kmask) s = stats.Stats() for task in my_tasks: cmb = maps.filter_map(mgen.get_map(seed=(1,task))[0],kbeam) nseed = (2,task) nmap = maps.white_noise(shape,wcs,noise_muK_arcmin=None,seed=nseed,ipsizemap=pmap,div=ivar) obs = cmb + nmap kobs = enmap.fft(obs,normalize='phys')/kbeam kobs[~np.isfinite(kobs)] = 0 feed_dict['X'] = kobs feed_dict['Y'] = kobs krecon = qe.reconstruct(feed_dict) print(cmb.shape,nmap.shape,krecon.shape) s.add_to_stack('kreal',krecon.real) s.add_to_stack('kimag',krecon.imag)
aprior = 0.5 aprior_sigma = 0.5 lnprior = (kamps - aprior)**2. / aprior_sigma pl = io.Plotter(xlabel="$A$", ylabel="$\\mathrm{ln}\\mathcal{L}$") totlikes = 0. np.random.seed(2) for i in range(Nclusters): if (i + 1) % 10 == 0: print(i + 1) unlensed = mg.get_map() noise_map = ng.get_map() #noise_map -= noise_map.mean() lensed = maps.filter_map( enlensing.displace_map(unlensed, alpha_pix, order=lens_order), kbeam) stamp = lensed + noise_map #np.random.multivariate_normal(np.zeros(np.prod(shape)),Ncov).reshape(shape[0],shape[1]) #noise_map # io.plot_img(lensed) # io.plot_img(stamp) if mean_sub: stamp -= stamp.mean() totlnlikes = [] for k, kamp in enumerate(kamps): lnlike = maps.get_lnlike(Cinvs[k], stamp) + logdets[k] totlnlike = lnlike #+ lnprior[k] totlnlikes.append(totlnlike) nlnlikes = -0.5 * np.array(totlnlikes) #nlnlikes -= nlnlikes.max()
def _filter(self,imap,ai): kmask = maps.mask_kspace(self.shape,self.wcs,lmin=self.ellmins[ai],lmax=self.ellmaxes[ai]) return maps.filter_map(imap,kmask)
lsy1, by1 = np.loadtxt(ybfile1, unpack=True) by12d = maps.interp(lsy1, by1)(modlmap1) lsc1, bc1 = np.loadtxt(cbfile1, unpack=True) bc12d = maps.interp(lsc1, bc1)(modlmap1) beam_ratio1 = bc12d / by12d beam_ratio1[~np.isfinite(beam_ratio1)] = 0 lsy2, by2 = np.loadtxt(ybfile2, unpack=True) by22d = maps.interp(lsy2, by2)(modlmap2) # ls,bc2 = np.loadtxt(cbfile2,unpack=True) bc22d = maps.interp(lsc1, bc1)(modlmap2) beam_ratio2 = bc22d / by22d beam_ratio2[~np.isfinite(beam_ratio2)] = 0 ymap1 = maps.filter_map(enmap.read_map(yfile1), beam_ratio1) ymap2 = maps.filter_map(enmap.read_map(yfile2), beam_ratio2) arcmin = 40. pix = 0.5 def get_cuts(mask, ymap, cmap, dmap, wtmap, ra, dec, arcmin, pix): mcut = reproject.cutout(mask, ra=np.deg2rad(ra), dec=np.deg2rad(dec), npix=int(arcmin / pix)) if mcut is None: return None, None, None, None, None if np.any(mcut) <= 0: return None, None, None, None, None
ells = np.arange(0,lmax,1) ps = cc.theory.lCl('TT',ells).reshape((1,1,ells.size)) mgen = maps.MapGen(shape,wcs,ps) fwhm = 5. kbeam = maps.gauss_beam(modlmap,fwhm) imap = mgen.get_map() bmap2 = maps.convolve_gaussian(imap.copy(),fwhm=fwhm,nsigma=5.0) print(bmap2.shape) bmap = maps.filter_map(imap.copy(),kbeam) taper,w2 = maps.get_taper(shape) io.plot_img(imap*taper,io.dout_dir+"bmap0.png",high_res=True) io.plot_img(bmap*taper,io.dout_dir+"bmap1.png",high_res=True) io.plot_img(bmap2*taper,io.dout_dir+"bmap2.png",high_res=True) bin_edges = np.arange(200,3000,100) binner = stats.bin2D(modlmap,bin_edges) fc = maps.FourierCalc(shape,wcs) p2d,_,_ = fc.power2d(imap*taper) cents,p1di = binner.bin(p2d/w2) p2d,_,_ = fc.power2d(bmap*taper) cents,p1db = binner.bin(p2d/w2) p2d,_,_ = fc.power2d(bmap2*taper)
def compute_map(self,oshape,owcs,qid,pixwin_taper_deg=0.3,pixwin_pad_deg=0.3, include_cmb=True,include_tsz=True,include_fgres=True,sht_beam=True): """ 1. get total alm 2. apply beam, and pixel window if Planck 3. ISHT 4. if ACT, apply a small taper and apply pixel window in Fourier space """ # pad to a slightly larger geometry tot_pad_deg = pixwin_taper_deg + pixwin_pad_deg res = maps.resolution(oshape,owcs) pix = np.deg2rad(tot_pad_deg)/res omap = enmap.pad(enmap.zeros((3,)+oshape,owcs),pix) ishape,iwcs = omap.shape[-2:],omap.wcs # get data model dm = sints.models[sints.arrays(qid,'data_model')](region_shape=ishape,region_wcs=iwcs,calibrated=True) # 1. get total alm array_index = self.qids.index(qid) tot_alm = int(include_cmb)*self.alms['cmb'] if include_tsz: try: assert self.tsz_fnu.ndim==2 tot_alm[0] = tot_alm[0] + hp.almxfl(self.alms['comptony'][0] ,self.tsz_fnu[array_index]) except: tot_alm[0] = tot_alm[0] + self.alms['comptony'][0] * self.tsz_fnu[array_index] if self.cfgres is not None: tot_alm[0] = tot_alm[0] + int(include_fgres)*self.alms['fgres'][array_index] assert tot_alm.ndim==2 assert tot_alm.shape[0]==3 ells = np.arange(self.lmax+1) # 2. get beam, and pixel window for Planck if sht_beam: beam = tutils.get_kbeam(qid,ells,sanitize=False,planck_pixwin=False) # NEVER SANITIZE THE BEAM IN A SIMULATION!!! for i in range(3): tot_alm[i] = hp.almxfl(tot_alm[i],beam) if dm.name=='planck_hybrid': pixwint,pixwinp = hp.pixwin(nside=tutils.get_nside(qid),lmax=self.lmax,pol=True) tot_alm[0] = hp.almxfl(tot_alm[0],pixwint) tot_alm[1] = hp.almxfl(tot_alm[1],pixwinp) tot_alm[2] = hp.almxfl(tot_alm[2],pixwinp) # 3. ISHT omap = curvedsky.alm2map(np.complex128(tot_alm),omap,spin=[0,2]) assert omap.ndim==3 assert omap.shape[0]==3 if not(sht_beam): taper,_ = maps.get_taper_deg(ishape,iwcs,taper_width_degrees=pixwin_taper_deg,pad_width_degrees=pixwin_pad_deg) modlmap = omap.modlmap() beam = tutils.get_kbeam(qid,modlmap,sanitize=False,planck_pixwin=True) kmap = enmap.fft(omap*taper,normalize='phys') kmap = kmap * beam # 4. if ACT, apply a small taper and apply pixel window in Fourier space if dm.name=='act_mr3': if sht_beam: taper,_ = maps.get_taper_deg(ishape,iwcs,taper_width_degrees=pixwin_taper_deg,pad_width_degrees=pixwin_pad_deg) pwin = tutils.get_pixwin(ishape[-2:]) if sht_beam: omap = maps.filter_map(omap*taper,pwin) else: kmap = kmap * pwin if not(sht_beam): omap = enmap.ifft(kmap,normalize='phys').real return enmap.extract(omap,(3,)+oshape[-2:],owcs)