def stat_analysis(cutouts, binsize, arcmax, cents, modRMaps):
profiles = []
for i in range(0, len(cutouts)):
thetaRange = np.arange(0., arcmax, binsize)
breali = bin2D(modRMaps[i] * 180. * 60. / np.pi, thetaRange)
a = breali.bin(cutouts[i])[1]
profiles.append(a)
statistics = stats.getStats(profiles)
mean = statistics['mean']
error = statistics['errmean']
covmat = statistics['cov']
corrcoef = stats.cov2corr(covmat)
io.quickPlot2d(corrcoef, 'corrcoef.png')
pl = Plotter(labelX='Distance from Center (arcminutes)',
labelY='Temperature Fluctuation ($\mu K$)',
ftsize=10)
pl.add(cents, mean)
pl.addErr(cents, mean, yerr=error)
pl._ax.axhline(y=0., ls="--", alpha=0.5)
pl.done(out_dir + "error.png")
def main():
arcsec = 20.
px_arcsec = 0.5
a = 8.
b = np.random.uniform(0., 1.) * a
angle = np.random.uniform(0., 360.) * np.pi / 180.
print(a, b)
shape, wcs = enmap.rect_geometry(arcsec / 60.,
px_arcsec / 60.,
proj="car",
pol=False)
sec2rad = lambda x: x * np.pi / 180. / 3600.
gell = gauss_ellipse(shape,
wcs,
amajor=sec2rad(a),
bminor=sec2rad(b),
angle=angle)
io.quickPlot2d(gell, "gal.png")
def test():
arcsec = 20.
px_arcsec = 0.5
shape, wcs = enmap.rect_geometry(arcsec / 60.,
px_arcsec / 60.,
proj="car",
pol=False)
sec2rad = lambda x: x * np.pi / 180. / 3600.
N = 10000
arange = [sec2rad(3), sec2rad(9)]
brange = [sec2rad(3), sec2rad(9)]
angle_range = [0, 2. * np.pi]
esim = EllipseSim(shape, wcs)
mat = esim.get_sims(N, arange, brange, angle_range)
print("Megabytes : ", mat.nbytes / 1024. / 1024.)
print(mat.shape)
io.quickPlot2d(mat[0, :, :], "gal0.png")
io.quickPlot2d(mat[1, :, :], "gal1.png")
def stack_on_map(lite_map,
width_stamp_arcminute,
pix_scale,
ra_range,
dec_range,
catalog=None,
n_random_points=None):
from skimage.transform import resize
import orphics.tools.stats as stats
width_stamp_degrees = width_stamp_arcminute / 60.
Np = np.int(width_stamp_arcminute / pix_scale + 0.5)
pad = np.int(Np / 2 + 0.5)
print("Expected width in pixels = ", Np)
lmap = lite_map
stack = 0
N = 0
if catalog is not None:
looprange = goodobjects
print(looprange)
assert n_random_points is None
random = False
else:
assert n_random_points is not None
assert len(ra_range) == 2
assert len(dec_range) == 2
looprange = range(0, n_random_points)
random = True
for i in looprange:
if random:
ra = np.random.uniform(*ra_range)
dec = np.random.uniform(*dec_range)
if random == False:
ra = catalog[i][1] #1 for ACT catalog 2 for SDSS and redmapper
dec = catalog[i][2] #2 for ACT catalog 3 for SDSS and redmapper
ix, iy = lmap.skyToPix(ra, dec)
if ix >= pad and ix < lmap.Nx - pad and iy >= pad and iy < lmap.Ny - pad:
print(i)
smap = lmap.selectSubMap(ra - width_stamp_degrees / 2.,
ra + width_stamp_degrees / 2.,
dec - width_stamp_degrees / 2.,
dec + width_stamp_degrees / 2.)
#cutout = zoom(smap.data.copy(),zoom=(float(Np)/smap.data.shape[0],float(Np)/smap.data.shape[1]))
cutout = resize(smap.data.copy(), output_shape=(Np, Np))
cutouts.append(cutout - randomstack)
stack = stack + cutout
xMap, yMap, modRMap, xx, yy = fmaps.getRealAttributes(smap)
N = N + 1.
ixs.append(ix)
iys.append(iy)
modRMaps.append(modRMap)
else:
print("skip")
stack = stack / N - randomstack
print(N)
if catalog is not None:
io.quickPlot2d(stack, out_dir + "stack.png")
else:
np.save('randomstamp', stack)
dt = pix_scale
arcmax = 20.
thetaRange = np.arange(0., arcmax, dt)
breal = stats.bin2D(modRMap * 180. * 60. / np.pi, thetaRange)
cents, recons = breal.bin(stack)
pl = Plotter(labelX='Distance from Center (arcminutes)',
labelY='Temperature Fluctuation ($\mu K$)',
ftsize=10)
pl.add(cents, recons)
pl._ax.axhline(y=0., ls="--", alpha=0.5)
pl.done(out_dir + "profiles.png")
return stack, cents, recons
beta = 0.01
mini_batch_size = 128
learning_rate = 0.001
num_epochs = int(1e9)
pca = 500
Npix = pca if pca else ny * nx
alpha_scale = 2
optimal_hidden = int(m * 1. / (alpha_scale * (num_outputs + Npix)))
print("Optimal number of hidden layers : ", optimal_hidden)
#training_images,Y_train, Ytrain_bayes = sim(m,ny,nx,num_outputs)
training_images, Y_train, Ytrain_bayes = sim_gal(m, ny, nx, seed=100)
img = training_images[:, :, 0]
io.quickPlot2d(img, "img.png")
my_net = FeedForward(num_features=Npix,
num_outputs=num_outputs,
num_nodes=num_nodes,
activations=activations)
X_train = prepare(training_images, pca)
my_net.train(X_train,
Y_train,
learning_rate=learning_rate,
num_epochs=num_epochs,
minibatch_size=mini_batch_size,
beta=beta)
theory,
shape_sim,
wcs_sim,
lbinner=lbinner_sim,
pol=True)
sverif_kappa = SpectrumVerification(mpibox,
theory,
shape_dat,
wcs_dat,
lbinner=lbinner_dat,
pol=False)
template_dat = fmaps.simple_flipper_template_from_enmap(shape_dat, wcs_dat)
nT = parray_dat.nT
nP = parray_dat.nP
if rank == 0: io.quickPlot2d(nT, out_dir + "nt.png")
kbeam_dat = parray_dat.lbeam
kbeampass = kbeam_dat
if rank == 0: io.quickPlot2d(kbeampass, out_dir + "kbeam.png")
fMaskCMB_T = fmaps.fourierMask(lx_dat,
ly_dat,
modlmap_dat,
lmin=tellmin,
lmax=tellmax)
fMaskCMB_P = fmaps.fourierMask(lx_dat,
ly_dat,
modlmap_dat,
lmin=pellmin,
lmax=pellmax)
fMask = fmaps.fourierMask(lx_dat,
ly_dat,
clkk = theory.gCl("kk", fine_ells)
clkk.resize((1, 1, clkk.size))
kappa_map = enmap.rand_map(shape_sim[-2:], wcs_sim, cov=clkk, scalar=True)
pkk = fmaps.get_simple_power_enmap(kappa_map)
debug_edges = np.arange(2, 12000, 80)
dbinner = stats.bin2D(modlmap_sim, debug_edges)
cents, bclkk = dbinner.bin(pkk)
clkk.resize((clkk.shape[-1]))
pl = io.Plotter(scaleY='log', scaleX='log')
pl.add(fine_ells, clkk)
pl.add(cents, bclkk)
pl.done(out_dir + "clkk.png")
phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True)
io.quickPlot2d(kappa_map, out_dir + "kappa_map.png")
io.quickPlot2d(phi, out_dir + "phi.png")
alpha_pix = enmap.grad_pixf(fphi)
# === SIM AND RECON LOOP ===
kappa_stack = {}
if cluster:
profiles = {}
else:
apowers = {}
cpowers = {}
for polcomb in pol_list:
kappa_stack[polcomb] = 0.
if cluster:
profiles[polcomb] = []
print((ix, iy))
c += 1
ixs.append(ix)
iys.append(iy)
print(c)
#sys.exit()
holeArc = 10.
holeFrac = 1.
ra_range = [lmap.x1 - 360., lmap.x0]
dec_range = [lmap.y0, lmap.y1]
stack, cents, recons = fmaps.stack_on_map(lmap, 60., 0.5, ra_range, dec_range,
ras, decs)
io.quickPlot2d(stack, out_dir + "stack.png")
pl = io.Plotter(labelX='Distance from Center (arcminutes)',
labelY='Temperature Fluctuation ($\mu K$)',
ftsize=10)
pl.add(cents, recons)
pl._ax.axhline(y=0., ls="--", alpha=0.5)
pl.done(out_dir + "profiles.png")
mask = inp.maskLiteMap(lmap, iys, ixs, holeArc, holeFrac)
io.highResPlot2d(mask.data, out_dir + "mask.png")
def stack_on_map(lite_map,
width_stamp_arcminute,
pix_scale,
ra_range,
dec_range,
catalog=None,
n_random_points=None):
width_stamp_degrees = width_stamp_arcminute / 60.
Np = np.int(width_stamp_arcminute / pix_scale + 0.5)
pad = np.int(Np / 2 + 0.5)
print("Expected width in pixels = ", Np)
lmap = lite_map
stack = 0
N = 0
if catalog is not None:
looprange = range(0, len(catalog))
assert n_random_points is None
random = False
else:
assert n_random_points is not None
assert len(ra_range) == 2
assert len(dec_range) == 2
looprange = range(0, n_random_points)
random = True
print(looprange)
for i in looprange:
banana = True
mass = catalog[i][10]
if random:
ra = np.random.uniform(*ra_range)
dec = np.random.uniform(*dec_range)
if random == False:
ra = catalog[i][1] #1 for ACT catalog 2 for SDSS
dec = catalog[i][2] #2 for ACT catalog 3 for SDSS
for j in range(0, 2130):
distance = np.sqrt((ra - RAps[j])**2 + (dec - DECps[j])**2)
crit = 0.25
if distance < crit:
banana = False
print('too close')
ix, iy = lmap.skyToPix(ra, dec)
if ix >= pad and ix < lmap.Nx - pad and iy >= pad and iy < lmap.Ny - pad and banana == True and mass > 8:
print(i)
#print(ra,dec)
smap = lmap.selectSubMap(ra - width_stamp_degrees / 2.,
ra + width_stamp_degrees / 2.,
dec - width_stamp_degrees / 2.,
dec + width_stamp_degrees / 2.)
#print (smap.data.shape)
#cutout = zoom(smap.data.copy(),zoom=(float(Np)/smap.data.shape[0],float(Np)/smap.data.shape[1])
cutout = resize(smap.data.copy(),
output_shape=(Np, Np)) - randomstack
xMap, yMap, modRMap, xx, yy = fmaps.getRealAttributes(smap)
dt = pix_scale
arcmax = 20.
thetaRange = np.arange(0., arcmax, dt)
breali = bin2D(modRMap * 180. * 60. / np.pi, thetaRange)
a = breali.bin(cutout)[1]
profiles.append(a)
io.quickPlot2d(cutout, str(i) + "cutout.png")
#print (cutout.shape)
stack = stack + cutout
N = N + 1
else:
print("skip")
stack = stack / N #-randomstack
#print(stack.shape())
#print(smap.data.shape)
# print(stack)
print(N)
statistics = stats.getStats(profiles)
mean = statistics['mean']
error = statistics['errmean']
corrcoef = statistics['corr']
covmat = statistics['covmat']
print(mean / error)
np.save('statistics', statistics)
#np.save('newrandomstamp',stack)
# io.quickPlot2d(stack,out_dir+"newACTstack.png")
dt = pix_scale
arcmax = 20.
thetaRange = np.arange(0., arcmax, dt)
breal = bin2D(modRMap * 180. * 60. / np.pi, thetaRange)
cents, recons = breal.bin(stack)
pl = Plotter(labelX='Distance from Center (arcminutes)',
labelY='Temperature Fluctuation ($\mu K$)',
ftsize=10)
pl.add(cents, mean)
pl.addErr(cents, mean, yerr=error)
pl._ax.axhline(y=0., ls="--", alpha=0.5)
pl.done(out_dir + "error.png")
print(covmat)
io.quickPlot2d(covmat, 'covmat.png')
return (stack, cents, recons)
parray_dat.add_theory(cc, theory, lmax)
taper_percent = 14.0
pad_percent = 2.0
Ny, Nx = shape_dat
taper = fmaps.cosineWindow(Ny,
Nx,
lenApodY=int(taper_percent * min(Ny, Nx) / 100.),
lenApodX=int(taper_percent * min(Ny, Nx) / 100.),
padY=int(pad_percent * min(Ny, Nx) / 100.),
padX=int(pad_percent * min(Ny, Nx) / 100.))
w2 = np.mean(taper**2.)
w3 = np.mean(taper**3.)
w4 = np.mean(taper**4.)
if rank == 0:
io.quickPlot2d(taper, out_dir + "taper.png")
print(("w2 : ", w2))
px_dat = analysis_resolution
Nsims = 10
avg = 0.
for i in range(Nsims):
print(i)
cmb = parray_dat.get_unlensed_cmb(seed=i)
ltt2d = fmaps.get_simple_power_enmap(cmb * taper)
ccents, ltt = lbinner_dat.bin(ltt2d) / w2
avg += ltt
ltt = avg / Nsims
iltt2d = theory.uCl("TT", parray_dat.modlmap)
ks,zs,Pkz = getPkz(pkzfile) from scipy.interpolate import RectBivariateSpline pkint = RectBivariateSpline(ks,zs,Pkz,kx=3,ky=3) ks2,zs2,Pkz2 = getPkz(pkzfile2) kseval = ks zseval = zs io.quickPlot2d(Pkz,"pkz.png") io.quickPlot2d(pkint(kseval,zseval),"pkzint.png") lc = LimberCosmology(lmax=8000,pickling=True,kmax=400.,pkgrid_override=pkint) from alhazen.shear import dndz step = 0.01 zedges = np.arange(0.,3.0+step,step) zcents = (zedges[1:]+zedges[:-1])/2. dndzs = dndz(zcents) pkz_camb = lc.PK.P(zseval, kseval, grid=True).T io.quickPlot2d(pkz_camb,"pkz_camb.png")
maps, z, kappa, szMapuK, projectedM500, trueM500, trueR500, pixScaleX, pixScaleY = sim.getMaps(
snap, massIndex, freqGHz=150., sourceZ=1100.)
print((z, projectedM500, trueM500, trueR500, pixScaleX, pixScaleY))
kappaMap, szMap, projectedM500, z = sim.getKappaSZ(snap,
massIndex,
shape,
wcs,
apodWidth=500)
print((projectedM500, z))
print("done")
out_dir = os.environ['WWW']
io.quickPlot2d(kappaMap, out_dir + "kappa.png") #,crange=[-0.1,0.1])
io.highResPlot2d(szMap, out_dir + "sz.png", crange=[-50, 0])
B = fft_gen(kappaMap, axes=[-2, -1], flags=['FFTW_MEASURE'])
modlmap = get_modlmap(kappaMap)
io.quickPlot2d(modlmap, out_dir + "modlmap.png") #,crange=[-0.1,0.1])
phi, fphi = kappa_to_phi(kappaMap, modlmap, return_fphi=True)
io.quickPlot2d(phi, out_dir + "phi.png")
alpha_pix = enmap.grad_pixf(fphi)
# alpha_pix2 = enmap.grad_pix(phi)
print((alpha_pix.shape))
# print alpha_pix2.shape
decs = np.random.uniform(bbox[0, 0], bbox[1, 0], size=N)
ras = np.random.uniform(bbox[0, 1], bbox[1, 1], size=N)
print((ras.min() * 180. / np.pi, ras.max() * 180. / np.pi))
print((decs.min() * 180. / np.pi, decs.max() * 180. / np.pi))
# coords = np.vstack((decs,ras))
# print "getting pixels..."
# pixs = gal_map.sky2pix(coords)
# print "binning..."
# dat,xedges,yedges = np.histogram2d(pixs[1,:],pixs[0,:],bins=shape)
mapper = CatMapper(shape, wcs, ras * 180. / np.pi, decs * 180. / np.pi)
gal_map = mapper.get_map()
print((gal_map.sum()))
print((gal_map.sum() - N))
gal_map = enmap.smooth_gauss(gal_map, 2.0 * np.pi / 180. / 60.)
#gal_map = enmap.smooth_gauss(enmap.ndmap(dat.astype(np.float32),wcs),2.0*np.pi/180./60.)
print("plotting...")
io.highResPlot2d(gal_map, out_dir + "galmap.png")
fc = enmap.FourierCalc(shape, wcs)
p2d, d, d = fc.power2d(gal_map)
io.quickPlot2d(np.fft.fftshift(np.log10(p2d)), out_dir + "logp2d.png")
io.quickPlot2d(np.fft.fftshift((p2d)), out_dir + "p2d.png")
else:
pol_list = ['TT']
debug = False
out_dir = os.environ['WWW'] + "plots/halotest/smallpatch_"
# === COSMOLOGY ===
cc = ClusterCosmology(lmax=lmax, pickling=True)
parray_sim.add_cosmology(cc)
parray_dat.add_cosmology(cc)
theory = cc.theory
kappa_map = parray_sim.get_kappa(ktype="grf", vary=False)
phi, fphi = lt.kappa_to_phi(kappa_map, parray_sim.modlmap, return_fphi=True)
io.quickPlot2d(kappa_map, out_dir + "kappa_map.png")
io.quickPlot2d(phi, out_dir + "phi.png")
alpha_pix = enmap.grad_pixf(fphi)
# === EXPERIMENT ===
fine_ells = parray_dat.fine_ells
kbeam_sim = parray_sim.lbeam
# === SIM AND RECON LOOP ===
kappa_stack = {}
apowers = {}
cpowers = {}
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
kappa_iter_recon = kappa_model.copy()
niter = 10
# if rank==0 and k==0:
# pl = io.Plotter(scaleY='log')
shape,wcs = enmap.rect_geometry(deg*60.,px,proj="car",pol=False)
modlmap = enmap.modlmap(shape,wcs)
lxmap,lymap,modlmap,angmap,lx,ly = fmaps.get_ft_attributes_enmap(shape,wcs)
amajor = 3000
bminor = 100
angle = np.pi/4.
r_square = ((lxmap)*np.cos(angle)+(lymap)*np.sin(angle))**2./amajor**2.+((lxmap)*np.sin(angle)-(lymap)*np.cos(angle))**2./bminor**2.
elfact = (1.+1.e3*np.exp(-r_square))
#elfact = 1.
p2d = elfact * cmb.white_noise_with_atm_func(modlmap,uk_arcmin=10.0,lknee=4000,alpha=-4.5,dimensionless=False,TCMB=2.7255e6)
p2d[modlmap<90]=0.
p2d[modlmap>4000]=0.
io.quickPlot2d(np.fft.fftshift(np.log10(p2d)),io.dout_dir+"p2d.png")
mg = enmap.MapGen(shape,wcs,p2d.reshape(1,1,modlmap.shape[0],modlmap.shape[1]))
imap = mg.get_map()
io.quickPlot2d(imap,io.dout_dir+"cmb.png")
# imap2 = mg.get_map()
# io.quickPlot2d(imap2,io.dout_dir+"cmb2.png")
dtype = np.complex128
rtype = np.zeros([0],dtype=dtype).real.dtype
print("alms...")
alm = curvedsky.map2alm(imap,lmax=4000)
powfac = 0.5
ps_data = enmap.multi_pow(alm*alm.conj()[None,None],powfac).astype(rtype)
print(alm)
print((alm.shape))
for k, i in enumerate(my_tasks):
with io.nostdout():
hpmap, alm = hp.synfast(cls, nside, alm=True, pol=False)
lmap.loadDataFromHealpixMap(hpmap, interpolate=False, hpCoords="J2000")
del hpmap
if k == 0:
taper, w2 = fmaps.get_taper(lmap.data.shape,
taper_percent=12.0,
pad_percent=3.0,
weight=None)
lmap.data *= taper
if rank == 0 and k == 0:
io.quickPlot2d(lmap.data, io.dout_dir + "flipper_map.png")
p = ft.powerFromLiteMap(lmap)
if k == 0:
binner = stats.bin2D(p.modLMap, bin_edges)
#pwin = hp.pixwin(nside)
#pells = np.arange(0,pwin.size)
#from scipy.interpolate import interp1d
pwin2d = 1. #interp1d(pells,pwin,bounds_error=False,fill_value=0.)(p.modLMap)
p2d = np.nan_to_num(p.powerMap / w2 / pwin2d**2.)
cents, p1d = binner.bin(p2d)
cls = hp.alm2cl(alm)
mpibox.add_to_stack("full", cls)
cov = ps
width_deg = 20.
pix = 2.0
shape, wcs = enmap.get_enmap_patch(width_deg * 60., pix, proj="CAR", pol=True)
m1 = enmap.rand_map(shape,
wcs,
cov,
scalar=True,
seed=None,
power2d=False,
pixel_units=False)
modlmap = m1.modlmap()
io.quickPlot2d(m1[0], out_dir + "m1.png")
cltt = ps[0, 0]
ells = np.arange(0, cltt.size)
pl = io.Plotter(scaleY='log')
pl.add(ells, cltt * ells**2.)
debug_edges = np.arange(200, 2000, 80)
dbinner = stats.bin2D(modlmap, debug_edges)
powermap = fmaps.get_simple_power_enmap(m1[0])
cents, dcltt = dbinner.bin(powermap)
pl.add(cents, dcltt * cents**2., label="power of map")
pa = fmaps.PatchArray(shape, wcs, skip_real=True)
pa.add_noise_2d(powermap)
nT = pa.nT
padY=0,
padX=0)
w2 = np.mean(taper**2.)
w4 = np.mean(taper**4.)
modlmap = imap.modlmap()
ellmax = 6000
ellmin = 200
ellwidth = 40
bin_edges = np.arange(ellmin, ellmax, ellwidth)
binner = stats.bin2D(modlmap, bin_edges)
imap = imap * taper
phi = phi * taper
if i == 0:
io.quickPlot2d(phi, os.environ['WORK'] + "/web/plots/phimap.png")
print("IQU to TEB...")
teb = enmap.ifft(enmap.map2harm(imap)).real
print("Powers...")
t = teb[0, :, :]
e = teb[1, :, :]
b = teb[2, :, :]
spec2d = {}
spec2d['tt'] = np.nan_to_num(fmaps.get_simple_power_enmap(t)) / w2
spec2d['ee'] = np.nan_to_num(fmaps.get_simple_power_enmap(e)) / w2
spec2d['bb'] = np.nan_to_num(fmaps.get_simple_power_enmap(b)) / w2
spec2d['te'] = np.nan_to_num(fmaps.get_simple_power_enmap(t,
enmap2=e)) / w2
p2d, _, _ = fc.power2d(nmap * taper) / w2
cents, p1d3 = binner.bin(p2d)
nmap = mg.get_map().submap(enmap.box(shape, wcs))
fc4 = enmap.FourierCalc(nmap.shape, nmap.wcs)
taper4, w24 = fmaps.get_taper(nmap.shape,
taper_percent=12.0,
pad_percent=3.0,
weight=None)
binner4 = stats.bin2D(nmap.modlmap(), bin_edges)
p2d, _, _ = fc4.power2d(nmap * taper4) / w24
shape4 = nmap.shape
wcs4 = nmap.wcs
cents, p1d4 = binner4.bin(p2d)
if rank == 0 and k == 0:
io.quickPlot2d(nmap * taper4, io.dout_dir + "nptapered.png")
nmap = mgP.get_map()
p2d, _, _ = fc.power2d(nmap * taper) / w2
cents, p1d5 = binner.bin(p2d)
alm = curvedsky.map2alm(imap.astype(np.float64), lmax=4000)
del imap
cls = hp.alm2cl(alm)
mpibox.add_to_stack("full", cls)
mpibox.add_to_stack("cut", p1d)
mpibox.add_to_stack("cut2", p1d2)
mpibox.add_to_stack("cut3", p1d3)
mpibox.add_to_stack("cut4", p1d4)
mpibox.add_to_stack("cut5", p1d5)
else:
clkk = theory.gCl("kk", fine_ells)
clkk.resize((1, 1, clkk.size))
kappa_map = enmap.rand_map(shape_sim[-2:], wcs_sim, cov=clkk, scalar=True)
if debug:
pkk = fmaps.get_simple_power_enmap(kappa_map)
debug_edges = np.arange(kellmin, 8000, 80)
dbinner = stats.bin2D(modlmap_sim, debug_edges)
cents, bclkk = dbinner.bin(pkk)
clkk.resize((clkk.shape[-1]))
pl = io.Plotter(scaleY='log', scaleX='log')
pl.add(fine_ells, clkk)
pl.add(cents, bclkk)
pl.done(out_dir + "clkk.png")
phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True)
io.quickPlot2d(kappa_map, out_dir + "kappa_map.png")
io.quickPlot2d(phi, out_dir + "phi.png")
alpha_pix = enmap.grad_pixf(fphi)
# === EXPERIMENT ===
if deconvolve_beam:
ntfunc = cmb.get_noise_func(beam_arcmin,
noise_T_uK_arcmin,
ellmin=tellmin,
ellmax=tellmax,
TCMB=TCMB)
npfunc = cmb.get_noise_func(beam_arcmin,
noise_P_uK_arcmin,
ellmin=pellmin,
ellmax=pellmax,
alpha=alpha,
color="C" + str(i + 2))
pl.legendOn(labsize=10)
pl.done(out_dir + "iter_profs.png")
lens_order = 5
nstep = 9
iters = 2
unlensed = unlensed * TCMB
lensed = lensing.lens_map_flat_pix(unlensed, alpha_pix, order=lens_order)
iter_delensed = lensed
phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True)
grad_phi = enmap.grad(phi) / (iters)
for i in range(1, iters + 1):
print(i)
iter_delensed = lensing.delens_map(iter_delensed,
grad_phi,
nstep=nstep,
order=lens_order,
mode="spline",
border="cyclic")
iter_residual = iter_delensed - unlensed
lens_residual = lensed - unlensed
io.quickPlot2d(lens_residual, out_dir + "lensres.png")
io.quickPlot2d(iter_residual, out_dir + "iterres.png")
if rank == 0: print("Binners...")
lbin_edges = np.arange(kellmin, kellmax, 200)
lbinner_dat = stats.bin2D(modlmap_dat, lbin_edges)
if rank == 0: print("Cosmology...")
# === COSMOLOGY ===
theory, cc, lmax = aio.theory_from_config(Config,
cosmology_section,
dimensionless=False)
parray_dat.add_theory(cc, theory, lmax, orphics_is_dimensionless=False)
template_dat = fmaps.simple_flipper_template_from_enmap(shape_dat, wcs_dat)
nT = parray_dat.nT
nP = parray_dat.nP
if rank == 0: io.quickPlot2d(nT, out_dir + "nt.png")
kbeam_dat = parray_dat.lbeam
kbeampass = kbeam_dat
if rank == 0: io.quickPlot2d(kbeampass, out_dir + "kbeam.png")
fMaskCMB_T = fmaps.fourierMask(lx_dat,
ly_dat,
modlmap_dat,
lmin=tellmin,
lmax=tellmax)
fMaskCMB_P = fmaps.fourierMask(lx_dat,
ly_dat,
modlmap_dat,
lmin=pellmin,
lmax=pellmax)
fMask = fmaps.fourierMask(lx_dat,
ly_dat,
cosmology_section,
dimensionless=False)
parray_dat.add_theory(cc, theory, lmax, orphics_is_dimensionless=False)
taper_percent = 14.0
pad_percent = 6.0
Ny, Nx = shape_dat[-2:]
taper = fmaps.cosineWindow(Ny,
Nx,
lenApodY=int(taper_percent * min(Ny, Nx) / 100.),
lenApodX=int(taper_percent * min(Ny, Nx) / 100.),
padY=int(pad_percent * min(Ny, Nx) / 100.),
padX=int(pad_percent * min(Ny, Nx) / 100.))
w2 = np.mean(taper**2.)
if rank == 0:
io.quickPlot2d(taper, pout_dir + "taper.png")
print(("w2 : ", w2))
px_dat = analysis_resolution
sverif_cmb = SpectrumVerification(mpibox,
theory,
shape_dat,
wcs_dat,
lbinner=lbinner_dat,
pol=pol,
iau_convention=iau_convention)
k = -1
for index in my_tasks:
def debug():
teb = enmap.ifft(enmap.map2harm(unlensed)).real
lteb = enmap.ifft(klteb).real
if pol:
io.quickPlot2d(unlensed[0], out_dir + "tmap.png")
io.quickPlot2d(unlensed[1], out_dir + "qmap.png")
io.quickPlot2d(unlensed[2], out_dir + "umap.png")
io.quickPlot2d(teb[1], out_dir + "emap.png")
io.quickPlot2d(teb[2], out_dir + "bmap.png")
io.quickPlot2d(lensed[0], out_dir + "ltmap.png")
io.quickPlot2d(lensed[1], out_dir + "lqmap.png")
io.quickPlot2d(lensed[2], out_dir + "lumap.png")
io.quickPlot2d(lteb[1], out_dir + "lemap.png")
io.quickPlot2d(lteb[2], out_dir + "lbmap.png")
else:
io.quickPlot2d(unlensed, out_dir + "tmap.png")
io.quickPlot2d(lensed, out_dir + "ltmap.png")
t = teb[0, :, :]
e = teb[1, :, :]
b = teb[2, :, :]
nt = noise[0, :, :]
ne = noise[1, :, :]
nb = noise[2, :, :]
ntt2d = np.nan_to_num(fmaps.get_simple_power_enmap(nt) / kbeam_sim**2.)
nee2d = np.nan_to_num(fmaps.get_simple_power_enmap(ne) / kbeam_sim**2.)
nbb2d = np.nan_to_num(fmaps.get_simple_power_enmap(nb) / kbeam_sim**2.)
utt2d = fmaps.get_simple_power_enmap(t)
uee2d = fmaps.get_simple_power_enmap(e)
ute2d = fmaps.get_simple_power_enmap(enmap1=t, enmap2=e)
ubb2d = fmaps.get_simple_power_enmap(b)
debug_edges = np.arange(2, 12000, 80)
dbinner = stats.bin2D(modlmap_sim, debug_edges)
cents, utt = dbinner.bin(utt2d)
cents, uee = dbinner.bin(uee2d)
cents, ute = dbinner.bin(ute2d)
cents, ntt = dbinner.bin(ntt2d)
cents, nee = dbinner.bin(nee2d)
cents, nbb = dbinner.bin(nbb2d)
#cents, ubb = dbinner.bin(ubb2d)
tl = lteb[0, :, :]
el = lteb[1, :, :]
bl = lteb[2, :, :]
ltt2d = fmaps.get_simple_power_enmap(tl)
lee2d = fmaps.get_simple_power_enmap(el)
lte2d = fmaps.get_simple_power_enmap(enmap1=tl, enmap2=el)
lbb2d = fmaps.get_simple_power_enmap(bl)
cents, ltt = dbinner.bin(ltt2d)
cents, lee = dbinner.bin(lee2d)
cents, lte = dbinner.bin(lte2d)
cents, lbb = dbinner.bin(lbb2d)
lcltt, lclee, lclte, lclbb = (
x for x in cmb.unpack_cmb_theory(theory, fine_ells, lensed=True))
cltt, clee, clte, clbb = (
x for x in cmb.unpack_cmb_theory(theory, fine_ells, lensed=False))
pl = io.Plotter(scaleY='log', scaleX='log')
pl.add(cents, utt * cents**2., color="C0", marker="o", ls="none")
pl.add(cents, uee * cents**2., color="C1", marker="o", ls="none")
#pl.add(cents,ubb*cents**2.,color="C2",ls="-")
pl.add(fine_ells, cltt * fine_ells**2., color="C0", ls="--")
pl.add(fine_ells, clee * fine_ells**2., color="C1", ls="--")
#pl.add(fine_ells,clbb*fine_ells**2.,color="C2",ls="--")
pl.done(out_dir + "ccomp.png")
pl = io.Plotter(scaleX='log')
pl.add(cents, ute * cents**2., color="C0", marker="o", ls="none")
pl.add(fine_ells, clte * fine_ells**2., color="C0", ls="--")
pl.done(out_dir + "ccompte.png")
# sells,stt,see,sbb,ste = np.loadtxt("data/cl_lensed.dat",unpack=True)
# stt *= 2.*np.pi/TCMB**2./sells/(sells+1.)
# see *= 2.*np.pi/TCMB**2./sells/(sells+1.)
# sbb *= 2.*np.pi/TCMB**2./sells/(sells+1.)
pl = io.Plotter(scaleY='log') #,scaleX='log')
# pl.add(sells,stt*sells**2.,color="C0",ls="-")
# pl.add(sells,see*sells**2.,color="C1",ls="-")
# pl.add(sells,sbb*sells**2.,color="C2",ls="-")
pl.add(cents, ltt * cents**2., color="C0", marker="o", ls="none")
pl.add(cents, lee * cents**2., color="C1", marker="o", ls="none")
pl.add(cents, lbb * cents**2., color="C2", marker="o", ls="none")
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.add(fine_ells, lcltt * fine_ells**2., color="C0", ls="--")
pl.add(fine_ells, lclee * fine_ells**2., color="C1", ls="--")
pl.add(fine_ells, lclbb * fine_ells**2., color="C2", ls="--")
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")
unlensed = enmap.rand_map(shape_sim, wcs_sim, ps)
lensed = lensing.lens_map_flat_pix(unlensed, alpha_pix, order=lens_order)
if noiseless_cmb:
measured = lensed
else:
klteb = enmap.map2harm(lensed)
klteb_beam = klteb * kbeam_sim
lteb_beam = enmap.ifft(klteb_beam).real
noise = enmap.rand_map(shape_sim, wcs_sim, ps_noise, scalar=True)
observed = lteb_beam + noise
fkmaps = fftfast.fft(observed, axes=[-2, -1])
fkmaps = np.nan_to_num(fkmaps / kbeam_sim) * fMaskCMB_T
measured = enmap.samewcs(
fftfast.ifft(fkmaps, axes=[-2, -1], normalize=True).real, observed)
if i == 0: io.quickPlot2d((measured - lensed), out_dir + "test2.png")
grad_phi = grad_phi_true
delensed = lensing.delens_map(measured.copy(),
grad_phi,
nstep=nstep,
order=lens_order,
mode="spline",
border="cyclic")
residual = delensed - unlensed
res_stack += residual
res_stack /= Nstack
p = res_stack * 100. / unlensed
p[np.abs(p) > 100] = np.nan
def stack_on_map(lite_map,
width_stamp_arcminute,
pix_scale,
ra_range,
dec_range,
catalog=None,
n_random_points=None):
width_stamp_degrees = width_stamp_arcminute / 60.
Np = np.int(width_stamp_arcminute / pix_scale + 0.5)
pad = np.int(Np / 2 + 0.5)
print("Expected width in pixels = ", Np)
lmap = lite_map
stack = 0
N = 0
if catalog is not None:
looprange = range(0, len(catalog))
assert n_random_points is None
random = False
else:
assert n_random_points is not None
assert len(ra_range) == 2
assert len(dec_range) == 2
looprange = range(0, n_random_points)
random = True
for i in looprange:
if random:
ra = np.random.uniform(*ra_range)
dec = np.random.uniform(*dec_range)
else:
ra = catalog[i][1]
dec = catalog[i][2]
ix, iy = lmap.skyToPix(ra, dec)
if ix >= pad and ix < lmap.Nx - pad and iy >= pad and iy < lmap.Ny - pad:
print(i)
#print(ra,dec)
smap = lmap.selectSubMap(ra - width_stamp_degrees / 2.,
ra + width_stamp_degrees / 2.,
dec - width_stamp_degrees / 2.,
dec + width_stamp_degrees / 2.)
#print (smap.data.shape)
#cutout = zoom(smap.data.copy(),zoom=(float(Np)/smap.data.shape[0],float(Np)/smap.data.shape[1]))
cutout = resize(smap.data.copy(), output_shape=(Np, Np))
#print (cutout.shape)
stack = stack + cutout
xMap, yMap, modRMap, xx, yy = fmaps.getRealAttributes(smap)
N = N + 1.
else:
print("skip")
stack = stack / N
#print(stack.shape())
#print(smap.data.shape)
print(stack)
print(N)
io.quickPlot2d(stack, out_dir + "stackrandom.png")
dt = pix_scale
arcmax = 20.
thetaRange = np.arange(0., arcmax, dt)
breal = bin2D(modRMap * 180. * 60. / np.pi, thetaRange)
cents, recons = breal.bin(stack)
pl = Plotter(labelX='Distance from Center (arcminutes)',
labelY='Temperature Fluctuation ($\mu K$)',
ftsize=10)
pl.add(cents, recons)
pl._ax.axhline(y=0., ls="--", alpha=0.5)
pl.done(out_dir + "randomprofiles.png")
return stack, cents, recons
shape, wcs = enmap.geometry(pos=[[-hwidth * arcmin, -hwidth * arcmin],
[hwidth * arcmin, hwidth * arcmin]],
res=px * arcmin,
proj="car")
shape = (3, ) + shape
np.random.seed(100)
ps2d = enmap.spec2flat(shape, wcs, ps)
ps2dtest = ps2d[0, 0]
psfunc = interp1d(ells, cctt, fill_value=0., bounds_error=False)
modlmap = enmap.modlmap(shape, wcs)
ps2dalt = psfunc(modlmap)
io.quickPlot2d(np.log(ps2dtest), out_dir + "ps1.png")
io.quickPlot2d(np.log(ps2dalt), out_dir + "ps2.png")
#io.quickPlot2d(np.nan_to_num(ps2dtest/ps2dalt),out_dir+"psrat.png")
ellbin_edges = np.arange(2, 3000, 60)
binner = stats.bin2D(modlmap, ellbin_edges)
cents, ps1dtest = binner.bin(ps2dtest)
cents, ps1dalt = binner.bin(ps2dalt)
pl = io.Plotter(scaleY='log', scaleX='log')
pl.add(ells, cctt * ells**2., color="C1", ls="-")
pl.add(cents, ps1dtest * cents**2., color="C0", ls="-")
pl.add(cents, ps1dalt * cents**2., color="C0", ls="--")
pl.done(out_dir + "ccomp1d.png")
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]
for k,index in enumerate(my_tasks):
noise = ngen.get_map()
mkappa = true2d+noise
if k==0 and rank==0: io.quickPlot2d(noise,out_dir+"nstamp.png")
print(k)
cents, prof = rbinner.bin(mkappa)
mpibox.add_to_stats('prof',prof)
mpibox.add_to_stack('mkappa',mkappa)
mpibox.get_stacks()
mpibox.get_stats()
if rank==0:
io.quickPlot2d(mpibox.stacks['mkappa'],out_dir+"stack.png")
mean = mpibox.stats['prof']['mean']
cov = mpibox.stats['prof']['covmean']
siginv = np.linalg.inv(cov)
rxr = mpibox.stats['rxr']
sdn0 = mpibox.stats['superdumbs']
area = S0.area()*(180./np.pi)**2.
print(("area: ", area, " sq.deg."))
fsky = area/41250.
print(("fsky: ",fsky))
diagraw = np.sqrt(np.diagonal(rxr_raw['cov'])*cents*np.diff(lbin_edges)*fsky)
diagn0sub = np.sqrt(np.diagonal(rxr['cov'])*cents*np.diff(lbin_edges)*fsky)
idiag = np.sqrt(np.diagonal(ixr['cov'])*cents*np.diff(lbin_edges)*fsky)
cents,clkk1d = lbinner.bin(clkk2d)
idiag_est = clkk1d+(3.*(idiag**2.-clkk1d**2.)/clkk1d)
io.quickPlot2d(stats.cov2corr(rxr['covmean']),pout_dir+"rcorr.png")
io.quickPlot2d(stats.cov2corr(rxr_raw['covmean']),pout_dir+"corr.png")
# if paper and not(unlensed):
# np.save(pout_dir+"covmat_"+str(area)+"sqdeg.npy",rxr['cov'])
# np.save(pout_dir+"lbin_edges_"+str(area)+"sqdeg.npy",lbin_edges)
# import cPickle as pickle
# pickle.dump((cents,mpibox.stats['noisett']['mean']),open(pout_dir+"noise.pkl",'wb'))
ellrange = np.arange(2,kellmax,1)
clkk = theory.gCl('kk',ellrange)
pl = io.Plotter(scaleY='log',labelX="$L$",labelY="$C^{\\kappa\\kappa}_L$")#,scaleX='log')
pl.add(ellrange,clkk,color="k",lw=3)
io.save_cols(pout_dir+"_plot_clkk_theory.txt",(ellrange,clkk))
pl.addErr(cents-140,ixr['mean'],yerr=ixr['errmean'],ls="none",marker="o",label='Input x Reconstruction')
io.save_cols(pout_dir+"_plot_inputXrecon.txt",(cents,ixr['mean'],ixr['errmean']))
