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
noise_uK_rad = args.noise*np.pi/180./60.
normfact = np.sqrt(np.prod(enmap.pixsize(shape,wcs)))
kbeam = maps.gauss_beam(args.beam,modlmap)
# Simulate
lmax = int(modlmap.max()+1)
ells = np.arange(0,lmax,1)
ps = theory.uCl('TT',ells).reshape((1,1,lmax))
~ps_noise = np.array([(noise_uK_rad)**2.]*ells.size).reshape((1,1,ells.size))
mg = maps.MapGen(shape,wcs,ps)
ng = maps.MapGen(shape,wcs,ps_noise)
kamp_true = args.Amp
kappa = lensing.nfw_kappa(kamp_true*1e15,modrmap,cc,overdensity=200.,critical=True,atClusterZ=True)
phi,_ = lensing.kappa_to_phi(kappa,modlmap,return_fphi=True)
grad_phi = enmap.grad(phi)
posmap = enmap.posmap(shape,wcs)
pos = posmap + grad_phi
alpha_pix = enmap.sky2pix(shape,wcs,pos, safe=False)
lens_order = 5
if rank==0: print("Starting sims...")
# Stats
Nsims = args.Nclusters
Njobs = Nsims
num_each,each_tasks = mpi.mpi_distribute(Njobs,numcores)
if rank==0: print ("At most ", max(num_each) , " tasks...")
my_tasks = each_tasks[rank]
mstats = stats.Stats(comm)
np.random.seed(rank)
highPass=kellmin)
true_ksum = truek_filt[modr_dat < 10.].mean()
while k < 20:
if k == 0:
delensed = maps.copy()
else:
kappa_model_filtered = enmap.samewcs(
fmaps.filter_map(kappa_model,
wfilter,
modlmap_dat,
lowPass=kellmax,
highPass=kellmin), init_kappa_model)
phi_model = lt.kappa_to_phi(kappa_model_filtered, modlmap_dat)
grad_phi = enmap.grad(phi_model)
delensed = lensing.delens_map(maps.copy(),
grad_phi,
nstep=nstep_delens,
order=lens_order,
mode="spline",
border="cyclic")
if k == 0:
io.quickPlot2d(delensed - maps,
out_dir + "firstdiff.png",
verbose=True)
fkmaps_update = enmap.samewcs(fftfast.fft(delensed, axes=[-2, -1]),
measured) * kbeam_dat
qest_maxlike.updateTEB_X(fkmaps_update, alreadyFTed=True)
qest_maxlike.updateTEB_Y()
# === DEFLECTION MAP ===
a = alphaMaker(thetaMap)
alpha = a.kappaToAlpha(kappaMap,test=False)
pos = thetaMap.posmap() + alpha
pix = thetaMap.sky2pix(pos, safe=False)
gradfit = 2.*np.pi/180./60.
from scipy.ndimage.interpolation import rotate
N = 100
avgrot = 0.
for i in range(N):
map = enmap.rand_map(shape, wcs, ps)/TCMB
gmap = enmap.grad(map)
angle = np.arctan2(gmap[0][np.where(thetaMap<gradfit)].mean(),gmap[1][np.where(thetaMap<gradfit)].mean())*180./np.pi
lensedTQU = lensing.displace_map(map, pix,order=5)+0.j
diffmap = (lensedTQU-map).real
rotmap = rotate(diffmap, angle,reshape=False)
avgrot += rotmap
print((i,angle))
#io.highResPlot2d(map,out_dir+"unl"+str(i)+".png")
#io.highResPlot2d(rotmap,out_dir+"rot"+str(i)+".png")
avgrot /= N
comS = cc.results.comoving_radial_distance(cc.cmbZ) * cc.h
comL = cc.results.comoving_radial_distance(zL) * cc.h
winAtLens = (comS - comL) / comS
kappa_map, r500 = NFWkappa(cc,
massOverh,
concentration,
zL,
modr_sim,
winAtLens,
overdensity=overdensity,
critical=critical,
atClusterZ=atClusterZ)
phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True)
alpha_pix = enmap.grad_pixf(fphi)
grad_phi_true = enmap.grad(phi)
res_stack = 0.
fMaskCMB_T = fmaps.fourierMask(lx_sim,
ly_sim,
modlmap_sim,
lmin=tellmin,
lmax=tellmax)
# io.quickPlot2d(np.fft.fftshift(fMaskCMB_T),out_dir+"presmooth.png")
# fMaskCMB_T = fmaps.smooth(fMaskCMB_T,modlmap_sim,gauss_sigma_arcmin=0.1)
# io.quickPlot2d(np.fft.fftshift(fMaskCMB_T),out_dir+"postsmooth.png")
# fMaskCMB_T[modlmap_sim<2]=0.
def f(rmap):
for k, lens_order in enumerate(range(5, 0, -1)):
alpha = (lens_order - 2 + 1. + 1) / (5 - 2 + 1. + 1)
print((lens_order, alpha))
# Lens with kappa1
lensed = lensing.lens_map_flat_pix(unlensed,
alpha_pix,
order=lens_order)
# Delens with kappa1
simple_delensed = lensing.lens_map_flat_pix(lensed.copy(),
-alpha_pix,
order=lens_order)
grad_phi = enmap.grad(phi)
lens_residual = lensed - unlensed
#io.quickPlot2d(lens_residual,out_dir+"lensres.png")
simple_residual = simple_delensed - unlensed
#io.quickPlot2d(simple_residual,out_dir+"simpleres.png")
iters = []
for nstep in range(1, 8):
iter_delensed = lensing.delens_map(lensed.copy(),
grad_phi,
nstep=nstep,
order=lens_order,
mode="spline",
border="cyclic")
# Check residual
# io.quickPlot2d(alpha_pix2[0],out_dir+"alpha_pixx2.png")
# io.quickPlot2d(alpha_pix2[1],out_dir+"alpha_pixy2.png")
TCMB = 2.7255e6
ps = powspec.read_spectrum("../alhazen/data/cl_lensinput.dat")
cmb_map = old_div(enmap.rand_map(shape, wcs, ps), TCMB)
lensed = lensing.lens_map_flat_pix(cmb_map, alpha_pix, order=5)
#lensed = lensing.lens_map_flat(cmb_map, phi)
io.quickPlot2d(cmb_map, out_dir + "unlensed.png")
io.quickPlot2d(lensed, out_dir + "lensed.png")
io.quickPlot2d(lensed - cmb_map, out_dir + "diff.png")
alpha = enmap.gradf(fphi)
io.quickPlot2d(alpha[0], out_dir + "alphax.png")
io.quickPlot2d(alpha[1], out_dir + "alphay.png")
io.quickPlot2d(np.sum(alpha**2, 0)**0.5, out_dir + "alpha.png")
kappa_inverted = -0.5 * enmap.div(alpha, normalize=False)
io.quickPlot2d(kappa_inverted, out_dir + "kappainv.png")
diffper = np.nan_to_num((kappaMap - kappa_inverted) * 100. / kappa_inverted)
diffper[kappaMap < 0.005] = 0.
io.quickPlot2d(diffper, out_dir + "kappadiff.png")
#delensed = lensing.lens_map_flat_pix(lensed, -alpha_pix,order=5)
alpha = enmap.grad(phi)
delensed = lensing.delens_map(lensed, alpha, nstep=5, order=5)
io.quickPlot2d(delensed, out_dir + "delensed.png")
io.quickPlot2d(delensed - cmb_map, out_dir + "delensdiff.png")
fmaskKappa=fMask,
kBeamX=kbeampass,
kBeamY=kbeampass,
doCurl=False,
TOnly=not (pol),
halo=True,
uEqualsL=False,
gradCut=gradCut,
verbose=False,
bigell=lmax,
lEqualsU=False)
kappa = get_nfw(5.e14)
#+ parray_sim.get_grf_kappa(seed=10,skip_update=False)
phi, fphi = lt.kappa_to_phi(kappa, parray_sim.modlmap, return_fphi=True)
grad_phi = enmap.grad(phi)
kappa_model = kappa.copy() / 5.
#kappa_model = kappa.copy()# /5.
for k, index in enumerate(my_tasks):
if rank == 0:
print(
("Rank ", rank, " doing job ", k + 1, " / ", len(my_tasks), "..."))
unlensed = parray_sim.get_unlensed_cmb(seed=index, scalar=False)
luteb, dummy = sverif_cmb.add_power("unlensed", unlensed)
lensed = lensing.lens_map(unlensed.copy(), grad_phi, order=lens_order)
lensed += parray_dat.get_noise_sim(seed=index + 100000)
llteb, dummy = sverif_cmb.add_power("lensed", lensed)
pixratio = analysis_resolution/Config.getfloat(sim_section,"pixel_arcmin")
px_dat = analysis_resolution
lens_order = Config.getint(sim_section,"lens_order")
k = -1
for index in my_tasks:
k += 1
if k==0:
from alhazen.halos import nfw_kappa
kappa = nfw_kappa(cluster_mass,parray_sim.modrmap,cc)
#kappa = parray_sim.get_grf_kappa(seed=1)
phi, fphi = lt.kappa_to_phi(kappa,parray_sim.modlmap,return_fphi=True)
grad_phi = enmap.grad(phi)
if rank==0: print(("Generating unlensed CMB for ", k, "..."))
unlensed = parray_sim.get_unlensed_cmb(seed=index)
if rank==0: print("Lensing...")
lensed = unlensed if nolens else lensing.lens_map(unlensed.copy(), grad_phi, order=lens_order, mode="spline", border="cyclic", trans=False, deriv=False, h=1e-7)
#lensed = lensing.lens_map_flat(unlensed.copy(), phi, order=lens_order)
if rank==0: print("Downsampling...")
cmb = lensed if abs(pixratio-1.)<1.e-3 else resample.resample_fft(lensed,shape_dat)
cmb = enmap.ndmap(cmb,wcs_dat)
if rank==0: print("Adding noise...")
flensed = fftfast.fft(cmb,axes=[-2,-1])
flensed *= parray_dat.lbeam
lensedt = fftfast.ifft(flensed,axes=[-2,-1],normalize=True).real
noise = parray_dat.get_noise_sim(seed=index+10000000)
