def solve(self, maxiter=100, cg_tol=1e-7, verbose=False, dump_dir=None):
if np.sum(self.highres_mask) == 0: return None
solver = cg.CG(self.A, self.rhs.reshape(-1), M=self.M)
for i in range(maxiter):
t1 = time.time()
solver.step()
t2 = time.time()
if verbose:
print "%5d %15.7e %5.2f" % (solver.i, solver.err, t2 - t1)
if dump_dir is not None and solver.i in [1, 2, 5, 10, 20, 50
] + range(
100, 10000, 100):
m = enmap.ndmap(solver.x.reshape(self.shape), self.wcs)
enmap.write_map(dump_dir + "/step%04d.fits" % solver.i, m)
if solver.err < cg_tol:
if dump_dir is not None:
m = enmap.ndmap(solver.x.reshape(self.shape), self.wcs)
enmap.write_map(dump_dir + "/step_final.fits", m)
break
tot_map = self.highres_mask * solver.x.reshape(self.shape)
tot_div = self.highres_mask * self.tot_div
# Get rid of the fourier padding
ny, nx = tot_map.shape[-2:]
tot_map = tot_map[..., :ny - self.ffpad[0], :nx - self.ffpad[1]]
tot_div = tot_div[..., :ny - self.ffpad[0], :nx - self.ffpad[1]]
return bunch.Bunch(map=tot_map, div=tot_div)
def read_sdata(ifile):
# Output thumb for this tod
with h5py.File(ifile, "r") as hfile:
sdata = [None for key in hfile]
for key in hfile:
ind = int(key)
g = hfile[key]
sdat = bunch.Bunch()
# First parse the wcs
hwcs = g["wcs"]
header = astropy.io.fits.Header()
for key in hwcs:
header[key] = hwcs[key].value
wcs = wcsutils.WCS(header).sub(2)
# Then get the site
sdat.site = bunch.Bunch(
**{key: g["site/" + key].value
for key in g["site"]})
# And the rest
for key in [
"map", "div", "srcpos", "sid", "vel", "fknee", "alpha",
"id", "ctime", "dur", "el", "az", "off"
]:
sdat[key] = g[key].value
sdat.map = enmap.ndmap(fixorder(sdat.map), wcs)
sdat.div = enmap.ndmap(fixorder(sdat.div), wcs)
sdata[ind] = sdat
return sdata
def l(cseed,kseed,returnk=False,index=None):
cname = fout_dir+"lensed_covseed_"+str(args.covseed).zfill(3)+"_cmbseed_"+str(cseed).zfill(5)+"_kseed_"+str(kseed).zfill(5)+".hdf"
if unlensed:
seedroot = (covseed)*Nsets*Nsims
lensedt = parray_dat.get_unlensed_cmb(seed=seedroot+cseed,scalar=False)
else:
lensedt = enmap.read_map(cname)[0] if polsims else enmap.read_map(cname)
# -- add beam and noise if you want --
if "noiseless" not in expf_name:
assert index is not None
if rank==0: print("Adding beam...")
flensed = fftfast.fft(lensedt,axes=[-2,-1])
flensed *= parray_dat.lbeam
lensedt = fftfast.ifft(flensed,axes=[-2,-1],normalize=True).real
if rank==0: print("Adding noise...")
seedroot = (covseed+1)*Nsets*Nsims # WARNING: noise sims will be correlated with CMB from the next covseed
nseed = seedroot+index
noise = parray_dat.get_noise_sim(seed=nseed)
if paper:
cents, noise1d = lbinner.bin(power(noise)[0])
mpibox.add_to_stats('noisett',noise1d)
lensedt += noise
lensedt = enmap.ndmap(lensedt,wcs_dat)
if returnk:
kname = fout_dir+"kappa_covseed_"+str(args.covseed).zfill(3)+"_kseed_"+str(kseed).zfill(5)+".hdf"
return lensedt,enmap.read_map(kname)
else:
return lensedt
def get_map(self,weights=None):
if self.verbose: print("Calculating histogram...")
if self.curved:
return np.histogram(self.pixs,bins=self.shape,weights=weights,range=[0,self.shape])[0].astype(np.float32)
else:
Ny,Nx = self.shape
return enmap.ndmap(np.histogram2d(self.pixs[0,:],self.pixs[1,:],bins=self.shape,weights=weights,range=[[0,Ny],[0,Nx]])[0],self.wcs)
def aberrate(imap,
dir,
beta,
mode="wrap",
order=3,
recenter=False,
modulation=True):
pol = imap.ndim > 2
pos = imap.posmap()
# The ::-1 stuff switches between dec,ra and ra,dec ordering.
# It is a bit confusing to have different conventions in enmap
# and coordinates.
pos = remap(pos[::-1],
dir,
beta,
pol=pol,
recenter=recenter,
modulation=modulation)
pos[:2] = pos[1::-1]
pix = imap.sky2pix(pos[:2], corner=True) # interpol needs corners
omap = en.ndmap(utils.interpol(imap, pix, mode=mode, order=order),
imap.wcs)
if pol:
c, s = np.cos(2 * pos[2]), np.sin(2 * pos[2])
omap[1] = c * omap[1] + s * omap[2]
omap[2] = -s * omap[1] + c * omap[2]
if modulation:
omap *= pos[2 + pol]
return omap
def get_map(self, weights=None):
Ny, Nx = self.shape
print("Calculating histogram...")
return enmap.ndmap(
np.histogram2d(self.pixs[0, :],
self.pixs[1, :],
bins=self.shape,
weights=weights,
range=[[0, Ny], [0, Nx]])[0], self.wcs)
def rotate(self, imap, **kwargs):
rotated = MapRotator.rotate(self, imap, **kwargs)
if self.downsample:
from enlib import resample
return enmap.ndmap(
resample.resample_fft(rotated, self.shape_final),
self.wcs_final)
else:
return rotated
def update_kappa(self, kappa):
# Converts kappa map to pixel displacements
import alhazen.lensTools as lt
fphi = lt.kappa_to_fphi(kappa, self.modlmap)
grad_phi = enmap.gradf(enmap.ndmap(fphi, self.wcs))
pos = self.posmap + grad_phi
self._displace_pix = enmap.sky2pix(self.shape,
self.wcs,
pos,
safe=False)
def sim(cseed, kseed, skip_kappa_verif=False):
if not (vonly):
unlensed = parray_sim.get_unlensed_cmb(seed=seedroot + cseed,
scalar=False)
kappa = aio.kappa_from_config(Config,
kappa_section,
parray_sim,
seed=seedroot + kseed)
lensed = parray_sim.get_lensed(unlensed,
order=lens_order,
mode="spline",
border="cyclic")
luteb, dummy = sverif_cmb.add_power("unlensed", unlensed)
llteb, dummy = sverif_cmb.add_power("lensed", lensed)
if not (skip_kappa_verif):
lk, dummy = sverif_kappa.add_power("kappa", kappa)
cname = fout_dir + "lensed_covseed_" + str(
args.covseed).zfill(3) + "_cmbseed_" + str(cseed).zfill(
5) + "_kseed_" + str(kseed).zfill(5) + ".hdf"
kname = fout_dir + "kappa_covseed_" + str(
args.covseed).zfill(3) + "_kseed_" + str(kseed).zfill(5) + ".hdf"
if vonly:
dlensed = enmap.read_map(cname)
dkappa = enmap.read_map(kname)
else:
dlensed = lensed if abs(pixratio - 1.) < 1.e-3 else enmap.ndmap(
resample.resample_fft(lensed, shape_dat), wcs_dat)
dkappa = kappa if abs(pixratio - 1.) < 1.e-3 else enmap.ndmap(
resample.resample_fft(kappa, shape_dat[-2:]), wcs_dat)
dlensed.write(cname)
dkappa.write(kname)
dllteb, dummy = sverif_dcmb.add_power("dlensed", dlensed)
if not (skip_kappa_verif):
dlk, dummy = sverif_dkappa.add_power("dkappa", dkappa)
def read_maps(fmt, n, ntot=4):
try:
maps = en.read_map(fmt)
if maps.ndim == ntot - 1: maps = en.enmap([maps] * n, maps.wcs)
if maps.ndim != ntot:
raise ValueError("Map %s must have %d dimensions" % (fmt, ntot))
return maps
except (IOError, OSError):
maps = [en.read_map(fmt % i) for i in range(n)]
maps = en.ndmap(maps, maps[0].wcs)
if maps.ndim != ntot:
maps = maps.reshape(maps.shape[:-2] + (1, ) * (maps.ndim - ntot) +
maps.shape[-2:])
return maps
def read_thumb_data(fname): res = bunch.Bunch() hdus = astropy.io.fits.open(fname) header = hdus[0].header with warnings.catch_warnings(): wcs = wcsutils.WCS(header).sub(2) res.rhs, res.div, res.corr = enmap.fix_endian(enmap.ndmap(hdus[0].data, wcs)) res.srcinfo = hdus[1].data res.detinfo = hdus[2].data res.id = header["id"] res.off = np.array([float(header["off_x"]),float(header["off_y"])])*utils.arcmin for key in ["bore_az1","bore_az2","bore_el"]: res[key] = float(header[key])*utils.degree res.ctime = float(header["ctime"]) return res
def read_sdata(ifile):
# Output thumb for this tod
with h5py.File(ifile, "r") as hfile:
sdata = [None for key in hfile]
for key in hfile:
ind = int(key)
g = hfile[key]
sdat = bunch.Bunch()
# First parse the wcs
hwcs = g["wcs"]
header = astropy.io.fits.Header()
for key in hwcs:
header[key] = hwcs[key].value
wcs = wcsutils.WCS(header).sub(2)
# Then get the site
sdat.site= bunch.Bunch(**{key:g["site/"+key].value for key in g["site"]})
# And the rest
for key in ["map","div","srcpos","sid","vel","fknee","alpha",
"id", "ctime", "dur", "el", "az", "off"]:
sdat[key] = g[key].value
sdat.map = enmap.ndmap(fixorder(sdat.map),wcs)
sdat.div = enmap.ndmap(fixorder(sdat.div),wcs)
sdata[ind] = sdat
return sdata
def read_thumb_data(fname): res = bunch.Bunch() hdus = astropy.io.fits.open(fname) header = hdus[0].header with warnings.catch_warnings(): wcs = wcsutils.WCS(header).sub(2) res.rhs, res.div, res.corr = enmap.fix_endian(enmap.ndmap(hdus[0].data, wcs)) res.srcinfo = hdus[1].data res.detinfo = hdus[2].data res.id = header["id"] res.off = np.array([float(header["off_x"]),float(header["off_y"])])*utils.arcmin for key in ["bore_az1","bore_az2","bore_el"]: res[key] = float(header[key])*utils.degree res.ctime = float(header["ctime"]) return res
def calc_precon(self):
datasets = self.datasets
# Build the preconditioner
self.tot_div = enmap.ndmap(
np.sum([
split.data.div for dataset in datasets
for split in dataset.splits
], 0), self.wcs)
self.tot_idiv = self.tot_div.copy()
self.tot_idiv[self.tot_idiv > 0] **= -1
# Find the part of the sky hit by high-res data
self.highres_mask = enmap.zeros(self.shape[-2:], self.wcs, np.bool)
for dataset in datasets:
if dataset.lowres: continue
for split in dataset.splits:
if split.data.empty or not split.active: continue
self.highres_mask |= split.data.div > 0
def project(self, hp_map, interpolate=True):
"""
hp_map -- array-like healpix map
interpolate -- boolean
"""
import healpy as hp
imap = enmap.zeros(self.shape, self.wcs)
# Not as slow as you'd expect
if interpolate:
imap[self.y, self.x] = hp.get_interp_val(hp_map, self.thOut,
self.phOut)
else:
ind = hp.ang2pix(hp.get_nside(hp_map), self.thOut, self.phOut)
imap[:] = 0.
imap[[self.y, self.x]] = hp_map[ind]
return enmap.ndmap(imap, self.wcs)
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)
#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)
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)
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)
# === ADD NOISE BEFORE 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(lensed,axes=[-2,-1])
# flensed *= parray_sim.lbeam
# lensed = fftfast.ifft(flensed,axes=[-2,-1],normalize=True).real
# if rank==0: print "Adding noise..."
# noise = parray_sim.get_noise_sim(seed=index+20000)
# lensed += noise
# 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)
hits = hfile["hits"].value
srate = hfile["srate"].value
speed = hfile["speed"].value * utils.degree
inspec = hfile["inspec"].value
offsets = hfile["offsets"].value * utils.degree
site = bunch.Bunch(
**{k: hfile["site"][k].value
for k in hfile["site"]})
pattern = hfile["pattern"].value * utils.degree
hwcs = hfile["wcs"]
header = astropy.io.fits.Header()
for key in hwcs:
header[key] = hwcs[key].value
wcs = wcsutils.WCS(header).sub(2)
# Set up our maps
rhs = enmap.ndmap(rhs, wcs)
hits = enmap.ndmap(hits, wcs)
rhs = prepare(rhs)
hits = prepare(hits, hitmap=True)
# Turn offsets into an average array offset and detector offsets relative to that,
# and use the array offset to set up the Unskew matrix.
offset_array = np.mean(offsets, 0)
offset_det = offsets - offset_array
ndet = len(offsets)
if args.unskew == "curved":
U = UnskewCurved(rhs.shape,
rhs.wcs,
pattern,
offset_array,
site,
with h5py.File(infofile, "r") as hfile:
rhs = hfile["rhs"].value
hits = hfile["hits"].value
srate = hfile["srate"].value
speed = hfile["speed"].value * utils.degree
inspec = hfile["inspec"].value
offsets = hfile["offsets"].value * utils.degree
site = bunch.Bunch(**{k:hfile["site"][k].value for k in hfile["site"]})
pattern = hfile["pattern"].value * utils.degree
hwcs = hfile["wcs"]
header = astropy.io.fits.Header()
for key in hwcs:
header[key] = hwcs[key].value
wcs = wcsutils.WCS(header).sub(2)
# Set up our maps
rhs = enmap.ndmap(rhs, wcs)
hits = enmap.ndmap(hits, wcs)
rhs = prepare(rhs)
hits = prepare(hits, hitmap=True)
# Turn offsets into an average array offset and detector offsets relative to that,
# and use the array offset to set up the Unskew matrix.
offset_array = np.mean(offsets,0)
offset_det = offsets - offset_array
ndet = len(offsets)
if args.unskew == "curved":
U = UnskewCurved(rhs.shape, rhs.wcs, pattern, offset_array, site, order=args.order)
elif args.unskew == "shift":
U = UnskewShift(rhs.shape, rhs.wcs, pattern, offset_array, site)
else: raise ValueError(args.unskew)
scale = calc_scale(inspec.size, srate, speed, enmap.pixshape(U.ushape, U.uwcs)[0])
if args.template:
templ = enmap.read_map(args.template)
shape, wcs = templ.shape, templ.wcs
else:
shape, wcs = pixie.fullsky_geometry(res=config.patch_res*utils.degree)
if args.apply_beam:
print "Applying beam"
for i, field in enumerate(fields):
print field.name
fields[i] = field.to_beam(beam)
print "Beam done"
posmap = enmap.posmap(shape, wcs)
maps = [[field.at(freq, posmap) for freq in freqs] for field in fields]
maps.insert(0, np.sum(maps,0))
maps = enmap.ndmap(np.array(maps), wcs)
# We now have [comp,freq,stokes,y,x]
if args.unit:
if args.unit == "cmb":
# CMB uK equivalent
scale = pixie.blackbody(freqs, pixie.Tcmb)
maps *= pixie.Tcmb * 1e6 / scale[:,None,None,None]
else:
raise ValueError("Unknown unit '%s'" % args.unit)
# And write our results
enmap.write_map(args.omap, maps)
assert kappa_file[-9:] == cmb_file[-9:]
k += 1
if rank == 0: print(("Rank ", rank, " doing cutout ", index))
if not (simulated_kappa):
if liu:
kappa = liucon.get_kappa(index + 1)
elif sigurd:
kappa = enmap.read_map(sigurd_kappa_file(index)) * taper
#phi = enmap.read_map(sigurd_phi_file(index))
#fkphi = fftfast.fft(phi*taper,axes=[-2,-1])
#lmap = parray_sim.modlmap
#fkkappa = fkphi * lmap * (lmap+1.)/2.
#kappa = fftfast.ifft(fkkappa,axes=[-2,-1],normalize=True)
else:
hikappa = enmap.ndmap(np.load(kappa_file), wcs_dat)
kappa = enmap.upgrade(
hikappa, pixratio) if abs(pixratio - 1.) > 1.e-3 else hikappa
# phi, fphi = lt.kappa_to_phi(kappa,parray_sim.modlmap,return_fphi=True)
# alpha_pix = enmap.grad_pixf(fphi)
else:
if k == 0:
if cluster:
from alhazen.halos import NFWkappa
massOverh = 2.e14
zL = 0.7
overdensity = 180.
critical = False
atClusterZ = False
def __init__(self,
splits=None,
wmap=None,
mask=None,
kmask=None,
directory=None,
spec_smooth_width=2.,
skip_beam=True,
skip_mask=True,
skip_kmask=True,
skip_cross=True,
iau_convention=False):
"""
shape, wcs for geometry
unmasked splits
hit counts wmap
real-space mask that must include a taper. Can be 3-dimensional if Q/U different from I.
k-space kmask
"""
if directory is not None:
self._load(directory, skip_beam, skip_mask, skip_kmask, skip_cross)
else:
shape = splits[0].shape
wcs = splits[0].wcs
if wmap is None: wmap = enmap.ones(shape[-2:], wcs)
if mask is None: mask = np.ones(shape[-2:])
if kmask is None: kmask = np.ones(shape[-2:])
wmap = enmap.ndmap(wmap, wcs)
osplits = [split * mask for split in splits]
fc = enmap.FourierCalc(shape, wcs, iau_convention)
n2d, p2d = noise_from_splits(osplits, fc)
w2 = np.mean(mask**2.)
n2d *= (1. / w2)
p2d *= (1. / w2)
n2d = enmap.smooth_spectrum(n2d,
kernel="gauss",
weight="mode",
width=spec_smooth_width)
self.spec_smooth_width = spec_smooth_width
ncomp = shape[0] if len(shape) > 2 else 1
self.cross2d = p2d
self.cross2d *= kmask
n2d *= kmask
self.noise2d = n2d.reshape((ncomp, ncomp, shape[-2], shape[-1]))
self.mask = mask
self.kmask = kmask
self.wmap = wmap
self.shape = shape
self.wcs = wcs
self.ngen = enmap.MapGen(self.shape, self.wcs, self.noise2d)
#self.noise_modulation = 1./np.sqrt(self.wmap)/np.sqrt(np.mean((1./self.wmap)))
wt = 1. / np.sqrt(self.wmap)
wtw2 = np.mean(1. / wt**2.)
self.noise_modulation = wt * np.sqrt(wtw2)
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)
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)
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")
io.quickPlot2d(kappa_recon, out_dir + "rtt.png")
lrtt, likk = sverif_kappa.add_power("rttXikk", kappa_recon, imap2=kappa)
# BEGIN ITERATIVE DELENSING
def get_model(s, area): pos = area.posmap().reshape(2,-1)[::-1].T model = np.rollaxis(s.get_model(pos),-1).reshape(-1,area.shape[1],area.shape[2]) return enmap.ndmap(model, area.wcs)[:area.shape[0]]
if args.template:
templ = enmap.read_map(args.template)
shape, wcs = templ.shape, templ.wcs
else:
shape, wcs = pixie.fullsky_geometry(res=config.patch_res * utils.degree)
if args.apply_beam:
print "Applying beam"
for i, field in enumerate(fields):
print field.name
fields[i] = field.to_beam(beam)
print "Beam done"
posmap = enmap.posmap(shape, wcs)
maps = [[field.at(freq, posmap) for freq in freqs] for field in fields]
maps.insert(0, np.sum(maps, 0))
maps = enmap.ndmap(np.array(maps), wcs)
# We now have [comp,freq,stokes,y,x]
if args.unit:
if args.unit == "cmb":
# CMB uK equivalent
scale = pixie.blackbody(freqs, pixie.Tcmb)
maps *= pixie.Tcmb * 1e6 / scale[:, None, None, None]
else:
raise ValueError("Unknown unit '%s'" % args.unit)
# And write our results
enmap.write_map(args.omap, maps)
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)
# rphieb, rfphieb = lt.kappa_to_phi(kappa_recon_EB,parray_dat.modlmap,return_fphi=True)
# rgrad_phieb = enmap.grad(rphieb)
lrtt, lreb = sverif_kappa.add_power("rttXreb",
kappa_recon_TT,
imap2=kappa_recon_EB)
px_dat = analysis_resolution
del fMask
del fMaskCMB_T
del fMaskCMB_P
del nT
del nP
k = -1
for index in my_tasks:
k += 1
if rank == 0: print(("Rank ", rank, " doing cutout ", index))
kappa = enmap.read_map(alex_kappa_file(index))
ucmb = enmap.ndmap(
enmap.read_map(alex_ucmb_file(index)) / 2.7255e6, wcs_dat)
utt2d = fmaps.get_simple_power_enmap(ucmb)
ccents, utt = lbinner_dat.bin(utt2d)
mpibox.add_to_stats("ucl", utt)
del ucmb
del utt2d
cmb = enmap.ndmap(enmap.read_map(alex_cmb_file(index)) / 2.7255e6, wcs_dat)
ltt2d = fmaps.get_simple_power_enmap(cmb)
ccents, ltt = lbinner_dat.bin(ltt2d)
mpibox.add_to_stats("lcl", ltt)
del ltt2d
if rank == 0: print("Reconstructing...")
measured = cmb
fkmaps = fftfast.fft(measured, axes=[-2, -1])
return kappa
cc = ClusterCosmology(lmax=8500,pickling=True)
widtharc = 50.
px = 0.5
shape,wcs = enmap.get_enmap_patch(widtharc,px)
modrmap = enmap.modrmap(shape,wcs)
modlmap = enmap.modlmap(shape,wcs)
rbins = np.arange(0.,10.,1.0)
rbinner = stats.bin2D(modrmap*60.*180./np.pi,rbins)
true_mass = 2.e14
true2d = get_nfw(true_mass)
kellmin = 200
kellmax = 8500
true2d = enmap.ndmap(fmaps.filter_map(true2d,true2d*0.+1.,modlmap,lowPass=kellmax,highPass=kellmin),wcs)
Nsims = 1000
cov = np.ones((1,1,8500))*0.00000001
ngen = enmap.MapGen(shape,wcs,cov)
out_dir = os.environ['WWW']+"plots/cgauss_"
# Efficiently distribute sims over MPI cores
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]
def get_model(s, area): pos = area.posmap().reshape(2,-1)[::-1].T model = np.rollaxis(s.get_model(pos),-1).reshape(-1,area.shape[1],area.shape[2]) return enmap.ndmap(model, area.wcs)[:area.shape[0]]
