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)