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)
