def A(self, u):
s, a = self.dof.unzip(u)
# U"u = [S"s, 0a]
Uu = self.dof.zip(en.harm2map(en.map_mul(self.iS, en.map2harm(s))),
a * 0)
# P'N"P u
PNPu = self.PT(en.map_mul(self.iN, self.P(u)))
return Uu + PNPu
def calc_b(self):
PNd = self.PT(en.map_mul(self.iN, self.d))
Uw1_s = en.harm2map(
en.map_mul(self.hS,
en.rand_gauss_harm(self.d.shape[-3:], self.d.wcs)))
Uw1_a = np.zeros(self.T.shape[0])
Uw1 = self.dof.zip(Uw1_s, Uw1_a)
PNw2 = self.PT(
en.map_mul(self.hN, en.rand_gauss(self.d.shape, self.d.wcs)))
return PNd + Uw1 + PNw2
def M(x):
map = x[:area.size].reshape(area.shape)
junk = x[area.size:]
omap = map * 0
omap[:] = enmap.map_mul(idiv, map)
ojunk = junk / jdiv
return np.concatenate([omap.reshape(-1), ojunk], 0)
def M(x): map = x[:area.size].reshape(area.shape) junk = x[area.size:] omap = map*0 omap[:] = enmap.map_mul(idiv, map) ojunk= junk/jdiv return np.concatenate([omap.reshape(-1),ojunk],0)
def M(self, u):
# Multiplying things out, the full expression for A is:
# [ S" + sum(N") sum(N"T) ]
# [ sum(T'N") sum(T'T) ]
# A reasonable approximation for this is
# [ S" + sum(sigma^{-2}) 0 ]
# [ 0 sum(T'T) ]
# which can be directly inverted.
s, a = self.dof.unzip(u)
# Solve for the cmb signal component
res_s = en.harm2map(en.map_mul(self.S_prec, en.map2harm(s)))
res_a = np.linalg.solve(self.TT, a)
return self.dof.zip(res_s, res_a)
def noise_from_splits(splits, fourier_calc, nthread=0):
Nsplits = len(splits)
# Get fourier transforms of I,Q,U
ksplits = [
fourier_calc.iqu2teb(split,
nthread=nthread,
normalize=False,
rot=False) for split in splits
]
# Rotate I,Q,U to T,E,B for cross power (not necssary for noise)
kteb_splits = []
for ksplit in ksplits:
kteb_splits.append(ksplit.copy())
kteb_splits[-1][..., -2:, :, :] = enmap.map_mul(
fourier_calc.rot, kteb_splits[-1][..., -2:, :, :])
# get auto power of I,Q,U
auto = sum([fourier_calc.power2d(kmap=ksplit)[0]
for ksplit in ksplits]) / Nsplits
# do cross powers of I,Q,U
cross_splits = [y for y in itertools.combinations(ksplits, 2)]
Ncrosses = len(cross_splits)
assert Ncrosses == (Nsplits * (Nsplits - 1) / 2)
cross = sum([
fourier_calc.power2d(kmap=ksplit1, kmap2=ksplit2)[0]
for (ksplit1, ksplit2) in cross_splits
]) / Ncrosses
# do cross powers of T,E,B
cross_teb_splits = [y for y in itertools.combinations(kteb_splits, 2)]
cross_teb = sum([
fourier_calc.power2d(kmap=ksplit1, kmap2=ksplit2)[0]
for (ksplit1, ksplit2) in cross_teb_splits
]) / Ncrosses
# get noise model for I,Q,U
noise = (auto - cross) / Nsplits
# return I,Q,U noise model and T,E,B cross-power
return noise, cross_teb
rhs = enmap.zeros((ncomp,)+shape, area.wcs, dtype)
div = enmap.zeros((ncomp,ncomp)+shape, area.wcs, dtype)
junk = np.zeros(pcut.njunk, dtype)
with bench.show("rhs"):
tod *= ivar[:,None]
pcut.backward(tod, junk)
pmap.backward(tod, rhs)
with bench.show("hits"):
for i in range(ncomp):
div[i,i] = 1
pmap.forward(tod, div[i])
tod *= ivar[:,None]
pcut.backward(tod, junk)
div[i] = 0
pmap.backward(tod, div[i])
with bench.show("map"):
idiv = array_ops.eigpow(div, -1, axes=[0,1], lim=1e-5)
map = enmap.map_mul(idiv, rhs)
# Estimate central amplitude
c = np.array(map.shape[-2:])/2
crad = 50
mcent = map[:,c[0]-crad:c[0]+crad,c[1]-crad:c[1]+crad]
mcent = enmap.downgrade(mcent, 4)
amp = np.max(mcent)
print "%s amp %7.3f asens %7.3f" % (id, amp/1e6, asens)
with bench.show("write"):
enmap.write_map("%s%s_map.fits" % (prefix, bid), map)
enmap.write_map("%s%s_rhs.fits" % (prefix, bid), rhs)
enmap.write_map("%s%s_div.fits" % (prefix, bid), div)
del d, scan, pmap, pcut, tod, map, rhs, div, idiv, junk
rhs = enmap.zeros((ncomp,)+shape, area.wcs, dtype)
div = enmap.zeros((ncomp,ncomp)+shape, area.wcs, dtype)
junk = np.zeros(pcut.njunk, dtype)
with bench.show("rhs"):
tod *= ivar[:,None]
pcut.backward(tod, junk)
pmap.backward(tod, rhs)
with bench.show("hits"):
for i in range(ncomp):
div[i,i] = 1
pmap.forward(tod, div[i])
tod *= ivar[:,None]
pcut.backward(tod, junk)
div[i] = 0
pmap.backward(tod, div[i])
with bench.show("map"):
idiv = array_ops.eigpow(div, -1, axes=[0,1], lim=1e-5)
map = enmap.map_mul(idiv, rhs)
# Estimate central amplitude
c = np.array(map.shape[-2:])/2
crad = 50
mcent = map[:,c[0]-crad:c[0]+crad,c[1]-crad:c[1]+crad]
mcent = enmap.downgrade(mcent, 4)
amp = np.max(mcent)
print("%s amp %7.3f asens %7.3f" % (id, amp/1e6, asens))
with bench.show("write"):
enmap.write_map("%s%s_map.fits" % (prefix, bid), map)
enmap.write_map("%s%s_rhs.fits" % (prefix, bid), rhs)
enmap.write_map("%s%s_div.fits" % (prefix, bid), div)
del d, scan, pmap, pcut, tod, map, rhs, div, idiv, junk
t = np.zeros([scan.ndet, scan.nsamp], dtype)
scan.pmap.forward(t, (lam * scan.T)**-1 * map)
scan.pcut.forward(t, (lam * scan.T)**-1 *
junk[scan.cut_range[0]:scan.cut_range[1]])
if not args.precompute:
t += scan.Nbd
t = scan.iNbT.apply(t)
t /= scan.T
scan.pcut.backward(t, junk[scan.cut_range[0]:scan.cut_range[1]])
scan.pmap.backward(t, rhs)
rhs = utils.allreduce(rhs, comm)
if args.precompute:
rhs += prec_NNmap[lam]
junk += prec_NNjunk[lam]
junk /= jdiv
map[:] = enmap.map_mul(idiv, rhs)
if comm.rank == 0:
print "%4d %15.7e %8.1f" % (i + 1, np.std(map), lam)
if (i + 1) % args.ostep == 0:
enmap.write_map(args.odir + "/map%04d.fits" % (i + 1), map)
elif args.method == "cg":
def A(x):
map = x[:area.size].reshape(area.shape)
junk = x[area.size:]
omap = map * 0
ojunk = junk * 0
for scan in scans:
tod = np.zeros([scan.ndet, scan.nsamp], dtype)
scan.pmap.forward(tod, map)
for si, scan in enumerate(scans): t = np.zeros([scan.ndet,scan.nsamp],dtype) scan.pmap.forward(t, (lam*scan.T)**-1*map) scan.pcut.forward(t, (lam*scan.T)**-1*junk[scan.cut_range[0]:scan.cut_range[1]]) if not args.precompute: t += scan.Nbd t = scan.iNbT.apply(t) t /= scan.T scan.pcut.backward(t, junk[scan.cut_range[0]:scan.cut_range[1]]) scan.pmap.backward(t, rhs) rhs = utils.allreduce(rhs, comm) if args.precompute: rhs += prec_NNmap[lam] junk += prec_NNjunk[lam] junk /= jdiv map[:] = enmap.map_mul(idiv, rhs) if comm.rank == 0: print "%4d %15.7e %8.1f" % (i+1, np.std(map), lam) if (i+1) % args.ostep == 0: enmap.write_map(args.odir + "/map%04d.fits" % (i+1), map) elif args.method == "cg": def A(x): map = x[:area.size].reshape(area.shape) junk = x[area.size:] omap = map*0 ojunk= junk*0 for scan in scans: tod = np.zeros([scan.ndet,scan.nsamp],dtype) scan.pmap.forward(tod, map) scan.pcut.forward(tod, junk[scan.cut_range[0]:scan.cut_range[1]])
def solve(w, m):
if w.ndim == 2: return m / w[None]
elif w.ndim == 3: return m / w
elif w.ndim == 4: return enmap.map_mul(enmap.multi_pow(w, -1), m)
else: raise NotImplementedError("Only 2d, 3d or 4d weight maps understood")
def mul(w, m):
if w.ndim == 2: return m * w[None]
elif w.ndim == 3: return m * w
elif w.ndim == 4: return enmap.map_mul(w, m)
else: raise NotImplementedError("Only 2d, 3d or 4d weight maps understood")
