def ones(geometry):
"""Return a new Dmap with the specified geometry, filled with ones."""
tiles = [
enmap.ones(ts, tw, dtype=geometry.dtype)
for ts, tw in geometry.loc_geometry
]
return Dmap(geometry, tiles, copy=False)
def mask_map(imap, iys, ixs, hole_arc, hole_frac=0.6):
shape, wcs = imap.shape, imap.wcs
Ny, Nx = shape[-2:]
px = maps.resolution(shape, wcs) * 60. * 180. / np.pi
hole_n = int(round(hole_arc / px))
hole_ny = hole_nx = hole_n
oshape, owcs = enmap.geometry(pos=(0., 0.),
shape=(2 * hole_n, 2 * hole_n),
res=px * np.pi / 180. / 60.)
modrmap = enmap.modrmap(oshape, owcs)
mask = enmap.ones(shape, wcs)
for iy, ix in zip(iys, ixs):
if iy <= hole_n or ix <= hole_n or iy >= (Ny - hole_n) or ix >= (
Nx - hole_n):
continue
vslice = imap[np.int(iy - hole_ny):np.int(iy + hole_ny),
np.int(ix - hole_nx):np.int(ix + hole_nx)]
vslice[modrmap < (hole_frac * hole_arc) * np.pi / 180. /
60.] = np.nan # !!!! could cause a bias
mask[np.int(iy - hole_ny):np.int(iy + hole_ny),
np.int(ix - hole_nx):np.int(ix + hole_nx)][modrmap < hole_arc *
np.pi / 180. / 60.] = 0
return mask
mgen, kgen = init_flat(shape[-2:],wcs)
inited = True
unlensed = mgen.get_map(iau=args.iau)
if not(args.save_meanfield is None):
cpatch = unlensed
else:
kpatch = kgen.get_map()
cpatch = lens(unlensed,kpatch)
# enmap.write_fits(filename("lensed"),cpatch)
# enmap.write_fits(filename("unlensed"),unlensed)
enmap.write_fits(filename("kappa"),kpatch)
if i==0:
qest, ngen, kbeam, binner, taper, fc, purifier = init_geometry(shape[-2:],wcs)
if args.flat and not(args.flat_taper): taper = enmap.ones(shape[-2:])
w4 = np.mean(taper**4.)
w3 = np.mean(taper**3.)
w2 = np.mean(taper**2.)
if args.save_meanfield is None: kpatch *= taper
nmaps = ngen.get_map(iau=args.iau)
if not(args.flat) and args.noise_pad>1.e-5:
nmaps = enmap.extract(nmaps,shape,wcs)
observed = maps.convolve_gaussian(cpatch,args.beam) + nmaps if args.beam>1e-5 and args.noise>1e-5 else cpatch
enmap.write_fits(filename("obs_I"),cpatch[0])
enmap.write_fits(filename("obs_Q"),cpatch[1])
enmap.write_fits(filename("obs_U"),cpatch[2])
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)