savePickledNormAndFilters=None)
lensedMapX = stamp.copy() * win
lensedMapY = stamp.copy() * win
try:
fotX = np.nan_to_num(
fft(lensedMapX, axes=[-2, -1]) / beamTemplate[:, :])
except:
print(("skipping ", i, ra, dec))
i -= 1
continue
fotY = np.nan_to_num(fft(lensedMapY, axes=[-2, -1]) / beamTemplate[:, :])
if i % 10 == 0: print(("Reconstructing", i, " ..."))
qest.updateTEB_X(fotX, alreadyFTed=True)
qest.updateTEB_Y(fotY, alreadyFTed=True)
kappa = qest.getKappa(polCombList[0]).real / w2
kappaStack += kappa
N = i
kappaStack /= N
saveMf = False
try:
if doMf:
np.savetxt("data/meanfield.dat", kappaStack)
print("saved meanfield")
saveMf = True
except:
theorySpectraForNorm=None,
noiseX2dTEB=[filt_noiseT, filt_noiseE, filt_noiseB],
noiseY2dTEB=[filt_noiseT, filt_noiseE, filt_noiseB],
fmaskX2dTEB=[fMaskCMB] * 3,
fmaskY2dTEB=[fMaskCMB] * 3,
fmaskKappa=fMask,
doCurl=False,
TOnly=tonly,
halo=True,
gradCut=cmbellmax,
verbose=True,
loadPickledNormAndFilters=loadFile,
savePickledNormAndFilters=saveFile)
print "Reconstructing", i, " ..."
qest.updateTEB_X(fot, foe, fob, alreadyFTed=True)
qest.updateTEB_Y(alreadyFTed=True)
for j, polComb in enumerate(polCombList):
kappa = qest.getKappa(polComb)
# pl = Plotter()
# pl.plot2d(fftshift(qest.AL[polComb]))
# pl.done("al.png")
# sys.exit()
reconLm = lensedTLm.copy()
reconLm.data[:, :] = kappa[:, :].real
print "crossing with input"
unlensed = parray_sim.get_unlensed_cmb(seed=index, scalar=False)
luteb, dummy = sverif_cmb.add_power("unlensed", unlensed)
kappa = parray_sim.get_kappa(ktype="grf", vary=False, seed=index + 1000000)
phi, fphi = lt.kappa_to_phi(kappa, parray_sim.modlmap, return_fphi=True)
grad_phi = enmap.grad(phi)
lensed = lensing.lens_map(unlensed.copy(), grad_phi, order=lens_order)
llteb, dummy = sverif_cmb.add_power("lensed", lensed)
pdelensed = lensing.delens_map(lensed,
grad_phi,
nstep=delens_steps,
order=lens_order)
lpteb, dummy = sverif_cmb.add_power("pdelensed", pdelensed)
qest.updateTEB_X(llteb[0], llteb[1], llteb[2], alreadyFTed=True)
qest.updateTEB_Y(alreadyFTed=True)
with io.nostdout():
rawkappa_TT = qest.getKappa("TT").real
rawkappa_EB = qest.getKappa("EB").real
kappa_recon_TT = enmap.ndmap(rawkappa_TT, wcs_dat)
kappa_recon_EB = enmap.ndmap(rawkappa_EB, wcs_dat)
if rank == 0 and k == 0:
io.quickPlot2d(kappa_recon_TT, out_dir + "rtt.png")
io.quickPlot2d(kappa_recon_EB, out_dir + "reb.png")
# rphitt, rfphitt = lt.kappa_to_phi(kappa_recon_TT,parray_dat.modlmap,return_fphi=True)
# rgrad_phitt = enmap.grad(rphitt)
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...")
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)
pl = io.Plotter()
pl.add(cents, bwf)
pl.done(out_dir + "bwfcmb.png")
kappa_start = modr_dat * 0. + model_uniform_kappa
kappa_model = enmap.samewcs(
fmaps.filter_map(kappa_start,
wfilter * 0. + 1.,
modlmap_dat,
lowPass=kellmax,
highPass=kellmin), measured)
io.quickPlot2d(kappa_model,
out_dir + "kappa_iter_" + str(k).zfill(3) + ".png")
qest_maxlike.updateTEB_X(fkmaps, alreadyFTed=True)
qest_maxlike.updateTEB_Y()
kappa_recon_single = enmap.samewcs(
qest_maxlike.getKappa(polcomb).real, measured)
io.quickPlot2d(kappa_recon_single, out_dir + "kappa_recon_single.png")
truek_filt = fmaps.filter_map(true_kappa_map_dat,
wfilter * 0. + 1.,
modlmap_dat,
lowPass=kellmax,
highPass=kellmin)
true_ksum = truek_filt[modr_dat < 10.].mean()
while k < 20:
if k == 0:
pl.add(cents, nee2 * cents**2., color="C4", ls="-.", alpha=0.4)
pl.add(cents, ntt * cents**2., color="C0", ls="-.", alpha=0.4)
pl.add(cents, nee * cents**2., color="C1", ls="-.", alpha=0.4)
pl.add(cents, nbb * cents**2., color="C2", ls="-.", alpha=0.4)
pl.done(out_dir + "lccomp.png")
pl = io.Plotter(scaleX='log')
pl.add(cents, lte * cents**2., color="C0", ls="-")
pl.add(fine_ells, lclte * fine_ells**2., color="C0", ls="--")
pl.done(out_dir + "lccompte.png")
measured = measured * taper
fkmaps = fftfast.fft(measured, axes=[-2, -1])
if pol:
qest.updateTEB_X(fkmaps[0], fkmaps[1], fkmaps[2], alreadyFTed=True)
else:
qest.updateTEB_X(fkmaps, alreadyFTed=True)
qest.updateTEB_Y()
for polcomb in pol_list:
print(("Reconstructing", polcomb, " for ", i, " ..."))
kappa_recon = enmap.samewcs(qest.getKappa(polcomb).real, measured)
if i == 0:
io.quickPlot2d(kappa_recon, out_dir + "kappa_recon_single.png")
kappa_recon -= kappa_recon.mean()
downk = enmap.downgrade(kappa_map, pixratio)
kpower = fmaps.get_simple_power_enmap(kappa_recon) / w4
cents_pwr, aclkk = dbinner_dat.bin(kpower)
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)
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")
