# 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)))
mass_range = np.linspace(1.e14,5.e14,300)
io.quickPlot2d(lmap.data, io.dout_dir + "flipper_map.png")
p = ft.powerFromLiteMap(lmap)
if k == 0:
binner = stats.bin2D(p.modLMap, bin_edges)
#pwin = hp.pixwin(nside)
#pells = np.arange(0,pwin.size)
#from scipy.interpolate import interp1d
pwin2d = 1. #interp1d(pells,pwin,bounds_error=False,fill_value=0.)(p.modLMap)
p2d = np.nan_to_num(p.powerMap / w2 / pwin2d**2.)
cents, p1d = binner.bin(p2d)
cls = hp.alm2cl(alm)
mpibox.add_to_stack("full", cls)
mpibox.add_to_stack("cut", p1d)
if rank == 0: print((k + 1, " / ", len(my_tasks), " done."))
mpibox.get_stacks()
if rank == 0:
fineells = np.arange(0, cls.size, 1)
fulltt = theory.lCl('TT', fineells)
fulldiff = (mpibox.stacks['full'] - fulltt) / fulltt
cents, cuttt = binner.bin(theory.lCl('TT', p.modLMap))
cutdiff = (mpibox.stacks['cut'] - cuttt) / cuttt
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...")
apower = fmaps.get_simple_power_enmap(enmap1=kappa_recon) / w4
data_power_2d_TT = fmaps.get_simple_power_enmap(measured)
sd = qest.N.super_dumb_N0_TTTT(data_power_2d_TT) / w2**2.
lcents, sdp = lbinner_dat.bin(sd)
#np.savetxt(save_func(index,"superdumbn0"),np.vstack((lcents,sdp)).T)
mpibox.add_to_stats("superdumbs", sdp)
n0subbed = apower - sd
lcents, rclkk = lbinner_dat.bin(n0subbed)
#np.savetxt(save_func(index,"auto_n0_subbed"),np.vstack((lcents,rclkk)).T)
p2d, _, _ = fc4.power2d(nmap * taper4) / w24
shape4 = nmap.shape
wcs4 = nmap.wcs
cents, p1d4 = binner4.bin(p2d)
if rank == 0 and k == 0:
io.quickPlot2d(nmap * taper4, io.dout_dir + "nptapered.png")
nmap = mgP.get_map()
p2d, _, _ = fc.power2d(nmap * taper) / w2
cents, p1d5 = binner.bin(p2d)
alm = curvedsky.map2alm(imap.astype(np.float64), lmax=4000)
del imap
cls = hp.alm2cl(alm)
mpibox.add_to_stack("full", cls)
mpibox.add_to_stack("cut", p1d)
mpibox.add_to_stack("cut2", p1d2)
mpibox.add_to_stack("cut3", p1d3)
mpibox.add_to_stack("cut4", p1d4)
mpibox.add_to_stack("cut5", p1d5)
print((k, i))
mpibox.get_stacks()
if rank == 0:
fineells = np.arange(0, cls.size, 1)
fulltt = theory.lCl('TT', fineells)
fulldiff = (mpibox.stacks['full'] - fulltt) / fulltt
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()
niter = 10
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
if rank==0: print("Kappa verification ... ")
kappa = qe(S0)
if rank==0: print("Powers ... ")
ixi,ki,ki = power(inpk)
ixr,kr = powerf1(kappa,ki)
rxr_raw = powerf1f2(kr,kr)
if rank==0: print("Binning ... ")
cents, ixi1d = lbinner.bin(ixi)
cents, ixr1d = lbinner.bin(ixr)
cents, rxr_raw1d = lbinner.bin(rxr_raw)
mpibox.add_to_stats('ixi',ixi1d)
mpibox.add_to_stats('ixr',ixr1d)
mpibox.add_to_stats("hucl", hutt)
mpibox.add_to_stats("hlcl", hltt)
if rank == 0: print("Filtering and binning input kappa...")
#if not(sigurd):
kappa = enmap.ndmap(
fmaps.filter_map(kappa,
kappa * 0. + 1.,
parray_sim.modlmap,
lowPass=kellmax,
highPass=kellmin), wcs_sim)
if cluster:
cents, kappa1d = binner_sim.bin(kappa)
mpibox.add_to_stats("input_kappa1d", kappa1d)
#if not(sigurd):
mpibox.add_to_stack("input_kappa2d", kappa)
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
tapnorm = taper**2. if cluster else 1.
kappa_recon = enmap.ndmap(
np.nan_to_num(rawkappa / tapnorm) - meanfield, wcs_dat)
if cluster: kappa_recon[parray_dat.modrmap * 180. * 60. / np.pi > 40.] = 0.
kappa_recon = enmap.ndmap(
fmaps.filter_map(kappa_recon,
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)
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)
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)
clkk2d = theory.gCl('kk', modlmap_dat)
nlkk2d = qest.N.Nlkk['TT']
wiener2d = clkk2d / (clkk2d + nlkk2d)