def fts(result, lmin, lmax, deltal):
shape,wcs, delta, modlmap = list(result.values())
fc = omaps.FourierCalc(shape,wcs)
p2d,kgal,_ = fc.power2d(delta)
bin_edges = np.arange(lmin, lmax, deltal)
binner = stats.bin2D(modlmap,bin_edges)
cents, p1d = binner.bin(p2d)
result = OrderedDict([('cents', cents), ('p1d', p1d)])
return result
def init_geometry(ishape,iwcs):
modlmap = enmap.modlmap(ishape,iwcs)
bin_edges = np.arange(args.kellmin,args.kellmax,args.dell)
binner = stats.bin2D(modlmap,bin_edges)
if args.beam<1e-5:
kbeam = None
else:
kbeam = maps.gauss_beam(modlmap,args.beam)
lmax = modlmap.max()
ells = np.arange(2,lmax,1)
wnoise_TT = ells*0.+(args.noise*(np.pi/180./60.))**2.
wnoise_PP = 2.*wnoise_TT
nT = modlmap*0.+(args.noise*(np.pi/180./60.))**2.
nP = 2.*nT
ncomp = 3 if pol else 1
ps = np.zeros((ncomp,ncomp,ells.size))
ps[0,0] = wnoise_TT
if pol:
ps[1,1] = wnoise_PP
ps[2,2] = wnoise_PP
oshape = (3,)+ishape if pol else ishape
if not(args.flat) and args.noise_pad>1.e-5:
# Pad noise sim geometry
pad_width_deg = args.noise_pad
pad_width = pad_width_deg * np.pi/180.
res = maps.resolution(oshape[-2:],iwcs)
pad_pixels = int(pad_width/res)
template = enmap.zeros(oshape,iwcs)
btemplate = enmap.pad(template,pad_pixels)
bshape,bwcs = btemplate.shape,btemplate.wcs
del template
del btemplate
ngen = maps.MapGen(bshape,bwcs,ps)
else:
ngen = maps.MapGen(oshape,iwcs,ps)
tmask = maps.mask_kspace(ishape,iwcs,lmin=args.tellmin,lmax=args.tellmax)
pmask = maps.mask_kspace(ishape,iwcs,lmin=args.pellmin,lmax=args.pellmax)
kmask = maps.mask_kspace(ishape,iwcs,lmin=args.kellmin,lmax=args.kellmax)
qest = lensing.qest(ishape,iwcs,theory,noise2d=nT,beam2d=kbeam,kmask=tmask,noise2d_P=nP,kmask_P=pmask,kmask_K=kmask,pol=pol,grad_cut=None,unlensed_equals_lensed=True)
taper,w2 = maps.get_taper_deg(ishape,iwcs,taper_width_degrees = args.taper_width,pad_width_degrees = args.pad_width)
fc = maps.FourierCalc(oshape,iwcs,iau=args.iau)
purifier = maps.Purify(ishape,iwcs,taper) if args.purify else None
return qest,ngen,kbeam,binner,taper,fc,purifier
def __init__(self,
shape,
wcs,
beams,
rmss,
lknees,
alphas,
aniss,
inhoms,
nsplits,
plancks,
response_dict,
ps_dict,
ellmin=100):
"""
TODO: inhomogenity
noise cross covariance
"""
self.fc = maps.FourierCalc(shape, wcs)
self.narrays = len(beams)
self.modlmap = enmap.modlmap(shape, wcs)
self.beams = beams
self.inhoms = inhoms
self.nsplits = nsplits
self.plancks = plancks.astype(np.bool)
self.ngens = []
antemplate = covtools.get_anisotropic_noise_template(shape, wcs)
for rms, lknee, alpha, anis in zip(rmss, lknees, alphas, aniss):
if anis:
template = antemplate.copy()
else:
template = 1
p2d = covtools.rednoise(enmap.modlmap(shape, wcs), rms, lknee,
alpha) * template
p2d[self.modlmap < ellmin] = 0
self.ngens.append(maps.MapGen(shape, wcs, p2d[None, None, ...]))
self.fgens = {}
assert "cmb" in ps_dict.keys()
self.components = ps_dict.keys()
for key in ps_dict.keys():
self.fgens[key] = maps.MapGen(shape, wcs, ps_dict[key][None, None,
...])
self.shape = shape
self.wcs = wcs
self.rdict = response_dict
self.ellmin = ellmin
imap = mgen.get_map() bmap2 = maps.convolve_gaussian(imap.copy(),fwhm=fwhm,nsigma=5.0) print(bmap2.shape) bmap = maps.filter_map(imap.copy(),kbeam) taper,w2 = maps.get_taper(shape) io.plot_img(imap*taper,io.dout_dir+"bmap0.png",high_res=True) io.plot_img(bmap*taper,io.dout_dir+"bmap1.png",high_res=True) io.plot_img(bmap2*taper,io.dout_dir+"bmap2.png",high_res=True) bin_edges = np.arange(200,3000,100) binner = stats.bin2D(modlmap,bin_edges) fc = maps.FourierCalc(shape,wcs) p2d,_,_ = fc.power2d(imap*taper) cents,p1di = binner.bin(p2d/w2) p2d,_,_ = fc.power2d(bmap*taper) cents,p1db = binner.bin(p2d/w2) p2d,_,_ = fc.power2d(bmap2*taper) cents,p1db2 = binner.bin(p2d/w2) pl = io.Plotter(yscale='log') pl.add(ells,ps[0,0]*ells**2.) pl.add(ells,ps[0,0]*ells**2.*maps.gauss_beam(ells,fwhm)**2.) pl.add(cents,p1di*cents**2.) pl.add(cents,p1db*cents**2.,label="fourier") pl.add(cents,p1db2*cents**2.,label="real") pl._ax.set_xlim(2,3000) pl._ax.set_ylim(1e-12,1e-8)
args = parser.parse_args()
# Load dictionary of array specs from yaml file
config = tutils.Config(arrays=args.arrays.split(','))
narrays = len(arrays)
freqs = []
for i in range(narrays):
f = config.darrays[arrays[i]]['freq']
freqs.append(f)
# Get the common map geometry from the coadd map of the first array
shape, wcs = enmap.read_fits_geometry(coaddfname(0))
Ny, Nx = shape[-2:]
# Set up a fourier space calculator (for power spectra)
fc = maps.FourierCalc(shape[-2:], wcs)
modlmap = enmap.modlmap(shape, wcs)
lmax = 5000
ells = modlmap[modlmap < lmax].reshape(-1) # unraveled disk
nells = ells.size
Scov = np.zeros((narrays, narrays, nells))
Ncov = np.zeros((narrays, narrays, nells))
for aindex1 in range(narrays):
for aindex2 in range(aindex1, narrays):
print("Noise calc...")
scov, ncov, autos = ncalc(
aindex1, aindex2
out_dir = args.output_dir
mask = enmap.read_map(out_dir + args.field.upper() + "_mask_2arc.hdf")
# What is the geometry of this field?
shape, wcs = mask.shape, mask.wcs
shape = (3, ) + shape
# Set up a GRF generator
mg = maps.MapGen(shape, wcs, ps)
# Get wavenumbers
modlmap = enmap.modlmap(shape, wcs)
print("Lmax: ", modlmap.max())
print("Unmasked area sq.deg.: ", mask.area() * (180. / np.pi)**2.)
# Set up a power-spectrum-doer
fc = maps.FourierCalc(shape, wcs, iau=iau)
# And a binner
bin_edges = np.arange(40, 3000, 100)
binner = stats.bin2D(modlmap, bin_edges)
binit = lambda x: binner.bin(x)[1]
cents = binner.centers
#ells_coupled = cents
# === ENMAP TO NAMASTER ===
# get the extent and shape of our geometry
Ly, Lx = enmap.extent(shape, wcs)
Ny, Nx = shape[-2:]
if not (do_mask):
mask = mask * 0. + 1.
get_dimensionless=False)
ls, nls = np.loadtxt("nlkk.dat", usecols=[0, 1], unpack=True)
clkk = theory.gCl('kk', ls)
ellrange = np.arange(0, 6000, 1)
totcls = interp1d(ls, clkk + nls, bounds_error=False,
fill_value="extrapolate")(ellrange)
ps = totcls.reshape((1, 1, ellrange.size))
bshape, bwcs = maps.rect_geometry(width_deg=80.,
px_res_arcmin=2.0,
height_deg=15.)
tap_per = 1. / 40. * 100.
pad_per = 1. / 40. * 100.
mg = maps.MapGen(bshape, bwcs, ps)
fc = maps.FourierCalc(bshape, bwcs)
taper, w2 = maps.get_taper(bshape,
taper_percent=tap_per,
pad_percent=pad_per,
weight=None)
bmap = mg.get_map()
#io.plot_img(bmap*taper,"map.png",high_res=True)
# bin_edges = np.arange(100,5000,100)
# binner = stats.bin2D(enmap.modlmap(bshape,bwcs),bin_edges)
# cents, bp1d = binner.bin(fc.power2d(bmap*taper)[0]/w2)
# pl = io.Plotter(yscale='log')
def test_shear():
from orphics import lensing, io, cosmology, maps
deg = 20.
px = 2.0
tellmin = 30
tellmax = 3500
kellmin = 10
kellmax = 3000
bin_width = 20
beam_arcmin = 1.4
noise_uk_arcmin = 7.0
theory = cosmology.default_theory(lpad=30000)
shape, wcs = s.rect_geometry(width_deg=deg, px_res_arcmin=px)
flsims = lensing.FlatLensingSims(shape, wcs, theory, beam_arcmin,
noise_uk_arcmin)
kbeam = flsims.kbeam
modlmap = enmap.modlmap(shape, wcs)
fc = maps.FourierCalc(shape, wcs)
n2d = (noise_uk_arcmin * np.pi / 180. / 60.)**2. / flsims.kbeam**2.
tmask = s.mask_kspace(shape, wcs, lmin=tellmin, lmax=tellmax)
kmask = s.mask_kspace(shape, wcs, lmin=kellmin, lmax=kellmax)
bin_edges = np.arange(kellmin, kellmax, bin_width)
binner = s.bin2D(modlmap, bin_edges)
i = 0
unlensed, kappa, lensed, beamed, noise_map, observed = flsims.get_sim(
seed_cmb=(i, 1),
seed_kappa=(i, 2),
seed_noise=(i, 3),
lens_order=5,
return_intermediate=True)
_, kmap, _ = fc.power2d(observed)
pii2d, kinput, _ = fc.power2d(kappa)
feed_dict = {}
cltt = theory.lCl('TT', modlmap)
feed_dict['uC_T_T'] = theory.lCl('TT', modlmap)
feed_dict['tC_T_T'] = (cltt + n2d)
feed_dict['X'] = kmap / kbeam
feed_dict['Y'] = kmap / kbeam
ells = np.arange(0, 10000, 1)
ucltt = theory.lCl('TT', ells)
feed_dict['duC_T_T'] = s.interp(ells,
np.gradient(np.log(ucltt),
np.log(ells)))(modlmap)
sAl = s.A_l(shape, wcs, feed_dict, "shear", "TT", xmask=tmask, ymask=tmask)
sNl = s.N_l(shape,
wcs,
feed_dict,
"shear",
"TT",
xmask=tmask,
ymask=tmask,
Al=sAl)
sukappa = s.unnormalized_quadratic_estimator(shape,
wcs,
feed_dict,
"shear",
"TT",
xmask=tmask,
ymask=tmask)
snkappa = sAl * sukappa
pir2d3 = fc.f2power(snkappa, kinput)
cents, pir1d3 = binner.bin(pir2d3)
cents, pii1d = binner.bin(pii2d)
cents, prr1d = binner.bin(fc.f2power(snkappa, snkappa))
cents, Nlkk3 = binner.bin(sNl)
pl = io.Plotter(xyscale='loglog')
pl.add(ells, theory.gCl('kk', ells))
pl.add(cents, pii1d, color='k', lw=3)
pl.add(cents, pir1d3, label='shear')
pl.add(cents, prr1d)
pl.add(cents, Nlkk3, ls=":")
pl._ax.set_xlim(10, 3500)
pl.done("ncomp.png")
def test_lens_recon():
from orphics import lensing, io, cosmology, maps
from enlib import bench
deg = 10.
px = 2.0
tellmin = 100
tellmax = 3000
kellmin = 40
kellmax = 3000
grad_cut = None
bin_width = 80
beam_arcmin = 0.01
noise_uk_arcmin = 0.01
theory = cosmology.default_theory(lpad=30000)
shape, wcs = s.rect_geometry(width_deg=deg, px_res_arcmin=px)
flsims = lensing.FlatLensingSims(shape, wcs, theory, beam_arcmin,
noise_uk_arcmin)
kbeam = flsims.kbeam
modlmap = enmap.modlmap(shape, wcs)
fc = maps.FourierCalc(shape, wcs)
n2d = (noise_uk_arcmin * np.pi / 180. / 60.)**2. / flsims.kbeam**2.
tmask = s.mask_kspace(shape, wcs, lmin=tellmin, lmax=tellmax)
kmask = s.mask_kspace(shape, wcs, lmin=kellmin, lmax=kellmax)
with bench.show("orphics init"):
qest = lensing.qest(shape,
wcs,
theory,
noise2d=n2d,
kmask=tmask,
kmask_K=kmask,
pol=False,
grad_cut=grad_cut,
unlensed_equals_lensed=True,
bigell=30000)
bin_edges = np.arange(kellmin, kellmax, bin_width)
binner = s.bin2D(modlmap, bin_edges)
i = 0
unlensed, kappa, lensed, beamed, noise_map, observed = flsims.get_sim(
seed_cmb=(i, 1),
seed_kappa=(i, 2),
seed_noise=(i, 3),
lens_order=5,
return_intermediate=True)
kmap = enmap.fft(observed, normalize="phys")
# _,kmap,_ = fc.power2d(observed)
with bench.show("orphics"):
kkappa = qest.kappa_from_map("TT",
kmap / kbeam,
alreadyFTed=True,
returnFt=True)
pir2d, kinput = fc.f1power(kappa, kkappa)
pii2d = fc.f2power(kinput, kinput)
prr2d = fc.f2power(kkappa, kkappa)
cents, pir1d = binner.bin(pir2d)
cents, pii1d = binner.bin(pii2d)
cents, prr1d = binner.bin(prr2d)
feed_dict = {}
cltt = theory.lCl('TT', modlmap)
feed_dict['uC_T_T'] = theory.lCl('TT', modlmap)
feed_dict['tC_T_T'] = cltt + n2d
feed_dict['X'] = kmap / kbeam
feed_dict['Y'] = kmap / kbeam
with bench.show("symlens init"):
Al = s.A_l(shape,
wcs,
feed_dict,
"hdv",
"TT",
xmask=tmask,
ymask=tmask)
Nl = s.N_l_from_A_l_optimal(shape, wcs, Al)
with bench.show("symlens"):
ukappa = s.unnormalized_quadratic_estimator(shape,
wcs,
feed_dict,
"hdv",
"TT",
xmask=tmask,
ymask=tmask)
nkappa = Al * ukappa
pir2d2 = fc.f2power(nkappa, kinput)
cents, pir1d2 = binner.bin(pir2d2)
cents, Nlkk = binner.bin(qest.N.Nlkk['TT'])
cents, Nlkk2 = binner.bin(Nl)
pl = io.Plotter(xyscale='linlog')
pl.add(cents, pii1d, color='k', lw=3)
pl.add(cents, pir1d, label='orphics')
pl.add(cents, pir1d2, label='hdv symlens')
pl.add(cents, Nlkk, ls="--", label='orphics')
pl.add(cents, Nlkk2, ls="-.", label='symlens')
pl.done("ncomp.png")
def make_sim(self, seed):
with bench.show(
"Lensing operation...") if self.rank == 0 else ignore():
full, kappa = lensing.rand_map(
self.fshape,
self.fwcs,
self.ps,
lmax=self.lmax,
maplmax=self.lmax,
seed=seed,
verbose=True if self.rank == 0 else False,
dtype=self.dtype,
output="lk")
alms = curvedsky.map2alm(full, lmax=self.lmax)
ps_data = hp.alm2cl(alms.astype(np.complex128))
del alms
self.mpibox.add_to_stats("fullsky_ps", ps_data)
south = full.submap(self.pos_south)
equator = full.submap(self.pos_eq)
ksouth = kappa.submap(self.pos_south)
kequator = kappa.submap(self.pos_eq)
del full
del kappa
if self.count == 0:
self.shape['s'], self.wcs['s'] = south.shape, south.wcs
self.shape['e'], self.wcs['e'] = equator.shape, equator.wcs
for m in ['s', 'e']:
self.taper[m], self.w2[m] = fmaps.get_taper(self.shape[m],
taper_percent=18.0,
pad_percent=4.0,
weight=None)
self.w4[m] = np.mean(self.taper[m]**4.)
self.w3[m] = np.mean(self.taper[m]**3.)
self.rotator = fmaps.MapRotatorEquator(
self.shape['s'],
self.wcs['s'],
self.wdeg,
self.hdeg,
width_multiplier=0.6,
height_multiplier=1.2,
downsample=True,
verbose=True if self.rank == 0 else False,
pix_target_override_arcmin=self.pix_intermediate)
self.taper['r'] = self.rotator.rotate(self.taper['s'])
self.w2['r'] = np.mean(self.taper['r']**2.)
self.w4['r'] = np.mean(self.taper['r']**4.)
self.w3['r'] = np.mean(self.taper['r']**3.)
self.shape['r'], self.wcs[
'r'] = self.rotator.shape_final, self.rotator.wcs_final
self.fc = {}
self.binner = {}
self.modlmap = {}
for m in ['s', 'e', 'r']:
self.fc[m] = fmaps.FourierCalc(self.shape[m], self.wcs[m])
self.modlmap[m] = enmap.modlmap(self.shape[m], self.wcs[m])
self.binner[m] = bin2D(self.modlmap[m], self.bin_edges)
self.cents = self.binner['s'].centers
self._init_qests()
self.count += 1
south *= self.taper['s']
equator *= self.taper['e']
ksouth *= self.taper['s']
kequator *= self.taper['e']
return south, equator, ksouth, kequator
nsplits.astype(np.int),
lknees,
alphas,
ps,
nu0,
lmins=lmins,
lmaxs=lmaxs,
atmosphere=atmosphere,
lensing=lensing,
dust=dust,
do_fgs=fgs,
lpass=lpass,
aseed=aseed)
modlmap = tsim.modlmap
fc = maps.FourierCalc(tsim.shape, tsim.wcs)
narrays = len(tsim.arrays)
iells = modlmap[modlmap < lmax1].reshape(-1) # unraveled disk
nells = iells.size
Ny, Nx = shape[-2:]
tcmb = 2.726e6
yresponses = tfg.get_mix(tsim.freqs, "tSZ")
cresponses = tfg.get_mix(tsim.freqs, "CMB")
minell = maps.minimum_ell(tsim.shape, tsim.wcs)
bin_edges = np.arange(np.min(lmins), lmax - 50, 8 * minell)
binner = stats.bin2D(modlmap, bin_edges)
cents = binner.centers
# Only do hybrid treatment for arrays with more than 2 splits (ACT) -- now doing for Planck as well
anisotropic_pairs = []
