io.quickPlot2d(taper, out_dir + "taper.png")
print(("w2 : ", w2))
px_dat = analysis_resolution
k = -1
for index in my_tasks:
k += 1
if rank == 0: print(("Rank ", rank, " doing cutout ", index))
kappa = enmap.read_map(sigurd_kappa_file(index)) * taper
cmb = enmap.read_map(sigurd_cmb_file(index))[0] #/2.7255e6
ltt2d = fmaps.get_simple_power_enmap(cmb * taper)
ccents, ltt = lbinner_dat.bin(ltt2d) / w2
mpibox.add_to_stats("lcl", ltt)
if rank == 0: print("Reconstructing...")
measured = cmb * taper
fkmaps = fftfast.fft(measured, axes=[-2, -1])
qest.updateTEB_X(fkmaps, alreadyFTed=True)
qest.updateTEB_Y()
with io.nostdout():
rawkappa = qest.getKappa("TT").real
kappa_recon = enmap.ndmap(rawkappa, wcs_dat) - mf
if save_meanfield: mpibox.add_to_stack("meanfield", kappa_recon)
#if save is not None: enmap.write_fits(save_func(index),kappa_recon)
if rank == 0: print("Calculating kappa powers and binning...")
num_each,each_tasks = mpi_distribute(Nsims,numcores)
# Initialize a container for stats and stacks
mpibox = MPIStats(comm,num_each,tag_start=333)
if rank==0: print(("At most ", max(num_each) , " tasks..."))
# What am I doing?
my_tasks = each_tasks[rank]
for k,index in enumerate(my_tasks):
noise = ngen.get_map()
mkappa = true2d+noise
if k==0 and rank==0: io.quickPlot2d(noise,out_dir+"nstamp.png")
print(k)
cents, prof = rbinner.bin(mkappa)
mpibox.add_to_stats('prof',prof)
mpibox.add_to_stack('mkappa',mkappa)
mpibox.get_stacks()
mpibox.get_stats()
if rank==0:
io.quickPlot2d(mpibox.stacks['mkappa'],out_dir+"stack.png")
mean = mpibox.stats['prof']['mean']
cov = mpibox.stats['prof']['covmean']
siginv = np.linalg.inv(cov)
chisq = np.dot(np.dot(mean,siginv),mean)
print((np.sqrt(chisq)))
# if rank==0: print "Downsampling..."
# cmb = lensed if abs(pixratio-1.)<1.e-3 else resample.resample_fft(lensed,shape_dat)
# === ADD NOISE AFTER DOWNSAMPLE
if rank == 0: print "Beam convolving..."
olensed = enmap.ndmap(
lensed.copy() if abs(pixratio - 1.) < 1.e-3 else resample.resample_fft(
lensed.copy(), shape_dat), wcs_dat)
flensed = fftfast.fft(olensed, axes=[-2, -1])
flensed *= parray_dat.lbeam
lensed = fftfast.ifft(flensed, axes=[-2, -1], normalize=True).real
if rank == 0: print "Adding noise..."
noise = parray_dat.get_noise_sim(seed=index + 20000)
lcents, noise1d = lbinner_dat.bin(fmaps.get_simple_power_enmap(noise))
mpibox.add_to_stats('noisett', noise1d)
lensed += noise
if rank == 0: print "Downsampling..."
cmb = lensed
cmb = enmap.ndmap(cmb, wcs_dat)
if rank == 0: print "Calculating powers for diagnostics..."
utt2d = fmaps.get_simple_power_enmap(
enmap.ndmap(
unlensed if abs(pixratio - 1.) < 1.e-3 else resample.resample_fft(
unlensed, shape_dat), wcs_dat))
ltt2d = fmaps.get_simple_power_enmap(olensed)
ccents, utt = lbinner_dat.bin(utt2d)
ccents, ltt = lbinner_dat.bin(ltt2d)
mpibox.add_to_stats("ucl", utt)
("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)
qest.updateTEB_X(llteb, alreadyFTed=True)
qest.updateTEB_Y(alreadyFTed=True)
with io.nostdout():
rawkappa = qest.getKappa("TT").real
kappa_recon = enmap.ndmap(rawkappa, wcs_dat)
rcents, recon1d = binner_dat.bin(kappa_recon)
mpibox.add_to_stats("kapparecon1d", recon1d)
mpibox.add_to_stack("kapparecon", kappa_recon)
if rank == 0 and k == 0:
io.quickPlot2d(kappa, out_dir + "kappa.png")
io.quickPlot2d(kappa_model, out_dir + "kappamodel.png")
io.quickPlot2d(unlensed, out_dir + "unlensed.png")
io.quickPlot2d(lensed - unlensed, out_dir + "difflensed.png")
# io.quickPlot2d(pdelensed-unlensed,out_dir+"diffpdelensed.png")
io.quickPlot2d(kappa_recon, out_dir + "rtt.png")
lrtt, likk = sverif_kappa.add_power("rttXikk", kappa_recon, imap2=kappa)
# BEGIN ITERATIVE DELENSING
kappa_iter_recon = kappa_model.copy()
S0,inpk = l(4*Nsims+i,5*Nsims+i,returnk=True,index=i)
if doN1:
# === N1 calculation ===
if rank==0: print("N0MC ... ")
n1 = 0.
S = l(i,Nsims+i,index=i)
Sp = l(2*Nsims+i,3*Nsims+i,index=i)
# S and Sp have different unlensed CMB and different kappa
kappa = qe(S,Sp)
kappap = qe(Sp,S)
pwr,k1,k1 = power(kappa,kappa)
pwrp,kp = powerf1(kappap,k1)
n0mc2d = pwr+pwrp
cents, p1d = lbinner.bin(n0mc2d)
mpibox.add_to_stats('n0mc',p1d)
n1 += -n0mc2d
if rank==0: print("N1MC ... ")
# ALREADY DONE ABOVE: S0,inpk = l(4*Nsims+i,5*Nsims+i,returnk=True,index=i)
Sp,inpk2 = l(6*Nsims+i,5*Nsims+i,returnk=True,index=i)
assert np.all(np.isclose(inpk,inpk2))
# S and Sp have different unlensed CMB but same kappa
kappa = qe(S0,Sp)
kappap = qe(Sp,S0)
pwr,k1,k1 = power(kappa,kappa)
pwrp,kp = powerf1(kappap,k1)
n1 += (pwr+pwrp)
mpibox.add_to_stack('n1',n1)
# === N1 calculation done ===
# kappa verification
else:
kappa = parray_sim.get_kappa(ktype="grf", vary=False)
if simulated_cmb:
phi, fphi = lt.kappa_to_phi(kappa,
parray_sim.modlmap,
return_fphi=True)
#alpha_pix = enmap.grad_pixf(fphi)
grad_phi = enmap.grad(phi)
if not (simulated_cmb):
if sigurd:
cmb = enmap.read_map(sigurd_cmb_file(index))[0] / 2.7255e6
ltt2d = fmaps.get_simple_power_enmap(cmb * taper)
ccents, ltt = lbinner_dat.bin(ltt2d) / w2
mpibox.add_to_stats("lcl", ltt)
else:
cmb = np.load(cmb_file) / 1.072480e+09
else:
if rank == 0: print("Generating unlensed CMB...")
unlensed = parray_sim.get_unlensed_cmb(seed=index)
if random and simulated_kappa:
lensed = unlensed
else:
if rank == 0: print("Lensing...")
#lensed = lensing.lens_map_flat_pix(unlensed.copy(), alpha_pix.copy(),order=lens_order)
lensed = lensing.lens_map(unlensed.copy(),
grad_phi,
order=lens_order,
mode="spline",
border="cyclic",
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)
lensedt += noise
cmb = lensedt
if rank==0: print("Filtering and binning input kappa...")
dkappa = enmap.ndmap(fmaps.filter_map(kappa,kappa*0.+1.,parray_sim.modlmap,lowPass=kellmax,highPass=kellmin),wcs_sim)
dkappa = dkappa if abs(pixratio-1.)<1.e-3 else enmap.ndmap(resample.resample_fft(dkappa,shape_dat),wcs_dat)
cents,kappa1d = binner_dat.bin(dkappa)
mpibox.add_to_stats("input_kappa1d",kappa1d)
mpibox.add_to_stack("input_kappa2d",dkappa)
if rank==0: print("Reconstructing...")
measured = enmap.ndmap(cmb,wcs_dat)
fkmaps = fftfast.fft(measured,axes=[-2,-1])
qest.updateTEB_X(fkmaps,alreadyFTed=True)
qest.updateTEB_Y()
rawkappa = qest.getKappa("TT").real
if args.fake: rawkappa += dkappa
kappa_recon = enmap.ndmap(np.nan_to_num(rawkappa),wcs_dat)
kappa_recon = enmap.ndmap(fmaps.filter_map(kappa_recon,kappa_recon*0.+1.,parray_dat.modlmap,lowPass=kellmax,highPass=kellmin),wcs_dat)
mpibox.add_to_stack("recon_kappa2d",kappa_recon)
cents,kapparecon1d = binner_dat.bin(kappa_recon)