def __init__(self,
mpibox,
theory,
shape,
wcs,
lbinner=None,
bin_edges=None,
pol=False,
iau_convention=False):
self.mpibox = mpibox
self.theory = theory
self.shape = shape
self.pol = pol
self.wcs = wcs
self.modlmap = enmap.modlmap(shape, wcs)
self.fcalc = enmap.FourierCalc(shape,
wcs,
iau_convention=iau_convention)
if lbinner is None:
assert bin_edges is not None
import orphics.tools.stats as stats
self.lbinner = stats.bin2D(self.modlmap, bin_edges)
else:
self.lbinner = lbinner
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] = enmap.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
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 __init__(self, modlmap, bin_edges):
import orphics.tools.stats as stats
self.binner = stats.bin2D(modlmap, bin_edges)
lmap = lm.makeEmptyCEATemplate(raSizeDeg=20., decSizeDeg=20.)
ells = np.arange(2, 6000, 1)
Cell = cc.clttfunc(ells) #cc.theory.lCl('TT',ells)
lmap.fillWithGaussianRandomField(ells, Cell, bufferFactor=1)
io.highResPlot2d(lmap.data, out_dir + "map.png")
p2d = fmaps.get_simple_power(lmap, lmap.data * 0. + 1.)
lxMap, lyMap, modLMap, thetaMap, lx, ly = fmaps.getFTAttributesFromLiteMap(
lmap)
bin_edges = np.arange(20, 4000, 40)
b = stats.bin2D(modLMap, bin_edges)
cents, cdat = b.bin(p2d)
pl = io.Plotter(scaleX='log', scaleY='log')
pl.add(ells, Cell * ells**2.)
pl.add(cents, cdat * cents**2.)
# pl.done(out_dir+"cls.png")
lmap.fillWithGaussianRandomField(ells, Cell, bufferFactor=3)
p2d = fmaps.get_simple_power(lmap, lmap.data * 0. + 1.)
cents, cdat = b.bin(p2d)
pl.add(cents, cdat * cents**2., ls="--")
pl.done(out_dir + "cls.png")
deg = 20.
px = 1.0
shape, wcs = maps.rect_geometry(width_deg=deg,px_res_arcmin=px,pol=True)
pa = fmaps.PatchArray(shape,wcs,cc=cc,orphics_is_dimensionless=False)
ulensed = pa.get_unlensed_cmb()
kappa = pa.get_grf_kappa()
cmb = pa.get_lensed(ulensed,order=5)
# io.highResPlot2d(cmb[0],out_dir+"t.png")
# io.highResPlot2d(cmb[1],out_dir+"q.png")
# io.highResPlot2d(cmb[2],out_dir+"u.png")
modlmap = enmap.modlmap(shape,wcs)
fc = maps.FourierCalc(shape,wcs)
lbin_edges = np.arange(200,6000,40)
lbinner = stats.bin2D(modlmap,lbin_edges)
def plot_powers(cmb,suffix,power=None,w2=1.):
if power is None:
power,lteb1,lteb2 = fc.power2d(cmb,pixel_units=False,skip_cross=True)
power /= w2
cents,dtt = lbinner.bin(power[0,0])
cents,dee = lbinner.bin(power[1,1])
cents,dbb = lbinner.bin(power[2,2])
pl = io.Plotter(scaleY='log')
ellrange = np.arange(200,6000,1)
cltt = theory.lCl('TT',ellrange)
clee = theory.lCl('EE',ellrange)
# === COSMOLOGY ===
theory, cc, lmax = aio.theory_from_config(Config,
cosmology_section,
dimensionless=False)
parray_dat.add_theory(cc, theory, lmax, orphics_is_dimensionless=False)
parray_sim.add_theory(cc, theory, lmax, orphics_is_dimensionless=False)
lxmap_dat, lymap_dat, modlmap_dat, angmap_dat, lx_dat, ly_dat = fmaps.get_ft_attributes_enmap(
shape_dat, wcs_dat)
lxmap_sim, lymap_sim, modlmap_sim, angmap_sim, lx_sim, ly_sim = fmaps.get_ft_attributes_enmap(
shape_sim, wcs_sim)
kellmin = args.kellmin
kellmax = args.kellmax
lbin_edges = np.arange(kellmin, kellmax, 200)
lbinner_dat = stats.bin2D(modlmap_dat, lbin_edges)
lbinner_sim = stats.bin2D(modlmap_sim, lbin_edges)
sverif_cmb = SpectrumVerification(mpibox,
theory,
shape_sim,
wcs_sim,
lbinner=lbinner_sim,
pol=pol)
sverif_dcmb = SpectrumVerification(mpibox,
theory,
shape_dat,
wcs_dat,
lbinner=lbinner_dat,
pol=pol)
sverif_kappa = SpectrumVerification(mpibox,
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")
# let's define the bin edges for this test
ellmin = 2
ellmax = 4000
bin_width = 200
bin_edges = np.arange(ellmin, ellmax, bin_width)
# a typical map might be 400sq.deg. with 0.5 arcmin pixels
shape, wcs = enmap.get_enmap_patch(width_arcmin=20 * 60., px_res_arcmin=0.5)
# let's get the "mod ell" or |ell| map, which tells us the magnitude of
# the angular wavenumbers in each fourier pixel
modlmap = enmap.modlmap(shape, wcs)
# this let's us create a 2D fourier space binner
binner2d = stats.bin2D(modlmap, bin_edges)
# the 1d binner just needs to know about the bin edges
binner1d = stats.bin1D(bin_edges)
# initialize a cosmology; make sure you have an "output" directory
# for pickling to work
cc = Cosmology(lmax=6000, pickling=True)
theory = cc.theory
# the fine ells we will use
fine1d_ells = np.arange(ellmin, ellmax, 1)
# let's test on TT and kk, lCl for TT and gCl for kk
for spec in ['TT', 'kk']:
try:
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)
shape_dat, wcs_dat)
taper_percent = 15.0
Ny, Nx = shape_dat
taper = fmaps.cosineWindow(Ny,
Nx,
lenApodY=taper_percent * min(Ny, Nx) / 100.,
lenApodX=taper_percent * min(Ny, Nx) / 100.,
padY=0,
padX=0)
tapered = measured * taper
w2 = np.mean(taper**2.)
w4 = np.mean(taper**4.)
debug_edges = np.arange(400, 8000, 150)
dbinner_dat = stats.bin2D(modlmap_dat, debug_edges)
nT = parray_dat.nT
nP = parray_dat.nP
kbeam_dat = parray_dat.lbeam
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)
parray_sim.add_theory(theory=theory, lmax=lmax, orphics_is_dimensionless=False)
lb = aio.ellbounds_from_config(Config, recon_section, min_ell)
tellmin = lb['tellminY']
tellmax = lb['tellmaxY']
pellmin = lb['pellminY']
pellmax = lb['pellmaxY']
kellmin = lb['kellmin']
kellmax = lb['kellmax']
lxmap_dat, lymap_dat, modlmap_dat, angmap_dat, lx_dat, ly_dat = fmaps.get_ft_attributes_enmap(
shape_dat, wcs_dat)
lxmap_sim, lymap_sim, modlmap_sim, angmap_sim, lx_sim, ly_sim = fmaps.get_ft_attributes_enmap(
shape_sim, wcs_sim)
lbin_edges = np.arange(kellmin, kellmax, 200)
lbinner_dat = stats.bin2D(modlmap_dat, lbin_edges)
lbinner_sim = stats.bin2D(modlmap_sim, lbin_edges)
bin_edges = np.arange(0., 20., analysis_resolution * 2.)
binner_dat = stats.bin2D(parray_dat.modrmap * 60. * 180. / np.pi, bin_edges)
sverif_cmb = SpectrumVerification(mpibox,
theory,
shape_sim,
wcs_sim,
lbinner=lbinner_sim,
pol=pol)
sverif_kappa = SpectrumVerification(mpibox,
theory,
shape_dat,
wcs_dat,
lbinner=lbinner_dat,
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
def getKappa(self, XY, weightedFt=False):
assert self._hasX and self._hasY
assert XY in ['TT', 'TE', 'ET', 'EB', 'TB', 'EE']
X, Y = XY
WXY = self.N.WXY(XY)
WY = self.N.WY(Y + Y)
import orphics.tools.io as io
io.quickPlot2d(np.fft.fftshift((WXY.real)), "wxy_" + XY + ".png")
io.quickPlot2d(np.fft.fftshift((WY.real)), "wyy_" + Y + Y + ".png")
io.quickPlot2d(np.fft.fftshift((self.N.Nlkk[XY])),
"nxy_" + XY + ".png")
lx = self.N.lxMap
ly = self.N.lyMap
if Y in ['E', 'B']:
phaseY = self.phaseY
else:
phaseY = 1.
phaseB = (int(Y == 'B') * 1.j) + (int(Y != 'B'))
fmask = self.N.modLMap * 0. + 1.
#fmask[self.N.modLMap>6000]=0.
HighMapStar = ifft(self.kHigh[Y] * WY * phaseY * phaseB * fmask,
axes=[-2, -1],
normalize=True).conjugate()
kPx = fft(
ifft(self.kGradx[X] * WXY * phaseY, axes=[-2, -1],
normalize=True) * HighMapStar,
axes=[-2, -1]) * fmask
kPy = fft(
ifft(self.kGrady[X] * WXY * phaseY, axes=[-2, -1],
normalize=True) * HighMapStar,
axes=[-2, -1]) * fmask
rawKappa = ifft(1.j * lx * kPx + 1.j * ly * kPy,
axes=[-2, -1],
normalize=True).real
AL = np.nan_to_num(self.AL[XY] * fmask)
kappaft = -AL * fft(rawKappa, axes=[-2, -1]) * fmask
self.kappa = ifft(kappaft, axes=[-2, -1], normalize=True).real
try:
#raise
assert not (np.any(np.isnan(self.kappa)))
except:
import orphics.tools.io as io
import orphics.tools.stats as stats
io.quickPlot2d(self.kappa.real, "nankappa.png")
debug_edges = np.arange(20, 20000, 100)
dbinner = stats.bin2D(self.N.modLMap, debug_edges)
cents, bclkk = dbinner.bin(self.N.clkk2d)
cents, nlkktt = dbinner.bin(self.N.Nlkk['TT'])
try:
cents, nlkkeb = dbinner.bin(self.N.Nlkk['EB'])
except:
pass
pl = io.Plotter(scaleY='log', scaleX='log')
pl.add(cents, bclkk)
pl.add(cents, nlkktt, label="TT")
try:
pl.add(cents, nlkkeb, label="EB")
except:
pass
pl.legendOn()
pl.done("clkk.png")
sys.exit()
# from orphics.tools.io import Plotter
# pl = Plotter()
# #pl.plot2d(np.nan_to_num(self.kappa))
# pl.plot2d((self.kappa.real))
# pl.done("output/nankappa.png")
# sys.exit(0)
# try:
# assert not(np.any(np.isnan(self.kappa)))
# except:
# from orphics.tools.io import Plotter
# pl = Plotter()
# pl.plot2d(np.nan_to_num(self.kappa))
# pl.done("output/nankappa.png")
# sys.exit(0)
if self.doCurl:
OmAL = self.OmAL[XY]
rawCurl = ifft(1.j * lx * kPy - 1.j * ly * kPx,
axes=[-2, -1],
normalize=True).real
self.curl = -ifft(OmAL * fft(rawCurl, axes=[-2, -1]),
axes=[-2, -1],
normalize=True)
return self.kappa, self.curl
return self.kappa
modLMap,
kellmax,
ellMin=stepmin)
# filtSim = fmaps.stepFunctionFilterLiteMap(simKappa,modLMap,kellmax)
pl = Plotter()
pl.plot2d(filtInput)
pl.done(outDir + "filtinput.png")
# pl = Plotter()
# pl.plot2d(filtInput)
# pl.done(outDir+"filtsim.png")
dt = 0.2
thetaRange = np.arange(0., arcmax, dt)
breal = bin2D(thetaMapDown * 180. * 60. / np.pi, thetaRange)
#cents,inps = breal.bin(trueKappaStack)
cents, inpsFilt = breal.bin(filtInput)
cents, recons = breal.bin(kappaStack)
# cents,reconsfix = breal.bin(kappaFix)
# cents,simFilt = breal.bin(filtSim)
pl = Plotter()
#pl.add(cents,inps,ls="--")
pl.add(cents, inpsFilt)
# pl.add(cents,simFilt,ls="-.")
pl.add(cents, recons)
# pl.add(cents,reconsfix,ls="-.")
pl._ax.axhline(y=0., ls="--", alpha=0.5)
pl.done(outDir + "profiles.png")
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)
mpibox.add_to_stack("cut", p1d)
if rank == 0: print((k + 1, " / ", len(my_tasks), " done."))
def getDLnMCMB(ells,Nls,clusterCosmology,log10Moverh,z,concentration,arcStamp,pxStamp,arc_upto,bin_width,expectedSN,Nclusters=1000,numSims=30,saveId=None,numPoints=1000,nsigma=8.,overdensity=500.,critical=True,atClusterZ=True):
import flipper.liteMap as lm
if saveId is not None: from orphics.tools.output import Plotter
M = 10.**log10Moverh
cc = clusterCosmology
stepfilter_ellmax = max(ells)
lmap = lm.makeEmptyCEATemplate(raSizeDeg=arcStamp/60., decSizeDeg=arcStamp/60.,pixScaleXarcmin=pxStamp,pixScaleYarcmin=pxStamp)
xMap,yMap,modRMap,xx,xy = fmaps.getRealAttributes(lmap)
lxMap,lyMap,modLMap,thetaMap,lx,ly = fmaps.getFTAttributesFromLiteMap(lmap)
kappaMap,retR500 = NFWkappa(cc,M,concentration,z,modRMap*180.*60./np.pi,winAtLens,overdensity,critical,atClusterZ)
finetheta = np.arange(0.01,arc_upto,0.01)
finekappa,retR500 = NFWkappa(cc,M,concentration,z,finetheta,winAtLens,overdensity,critical,atClusterZ)
kappaMap = fmaps.stepFunctionFilterLiteMap(kappaMap,modLMap,stepfilter_ellmax)
generator = fmaps.GRFGen(lmap,ells,Nls)
bin_edges = np.arange(0.,arc_upto,bin_width)
binner = bin2D(modRMap*180.*60./np.pi, bin_edges)
centers, thprof = binner.bin(kappaMap)
if saveId is not None:
pl = Plotter()
pl.plot2d(kappaMap)
pl.done("output/"+saveId+"kappa.png")
expectedSNGauss = expectedSN*np.sqrt(numSims)
sigma = 1./expectedSNGauss
amplitudeRange = np.linspace(1.-nsigma*sigma,1.+nsigma*sigma,numPoints)
lnLikes = 0.
bigStamp = 0.
for i in range(numSims):
profiles,totstamp = getProfiles(generator,stepfilter_ellmax,kappaMap,binner,Nclusters)
bigStamp += totstamp
stats = getStats(profiles)
if i==0 and (saveId is not None):
pl = Plotter()
pl.add(centers,thprof,lw=2,color='black')
pl.add(finetheta,finekappa,lw=2,color='black',ls="--")
pl.addErr(centers,stats['mean'],yerr=stats['errmean'],lw=2)
pl._ax.set_ylim(-0.01,0.3)
pl.done("output/"+saveId+"profile.png")
pl = Plotter()
pl.plot2d(totstamp)
pl.done("output/"+saveId+"totstamp.png")
Likes = getAmplitudeLikelihood(stats['mean'],stats['covmean'],amplitudeRange,thprof)
lnLikes += np.log(Likes)
width = amplitudeRange[1]-amplitudeRange[0]
Likes = np.exp(lnLikes)
Likes = Likes / (Likes.sum()*width) #normalize
ampBest,ampErr = cfit(norm.pdf,amplitudeRange,Likes,p0=[1.0,0.5])[0]
sn = ampBest/ampErr/np.sqrt(numSims)
snAll = ampBest/ampErr
if snAll<5.: print "WARNING: ", saveId, " run with mass ", M , " and redshift ", z , " has overall S/N<5. \
Consider re-running with a greater numSims, otherwise estimate of per Ncluster S/N will be noisy."
if saveId is not None:
Fit = np.array([np.exp(-0.5*(x-ampBest)**2./ampErr**2.) for x in amplitudeRange])
Fit = Fit / (Fit.sum()*width) #normalize
pl = Plotter()
pl.add(amplitudeRange,Likes,label="like")
pl.add(amplitudeRange,Fit,label="fit")
pl.legendOn(loc = 'lower left')
pl.done("output/"+saveId+"like.png")
pl = Plotter()
pl.plot2d(bigStamp/numSims)
pl.done("output/"+saveId+"bigstamp.png")
np.savetxt("data/"+saveId+"_m"+str(log10Moverh)+"_z"+str(z)+".txt",np.array([log10Moverh,z,1./sn]))
return 1./sn
hdeg,
width_multiplier=0.6,
height_multiplier=1.2,
downsample=True,
pix_target_override_arcmin=pxover)
rotmap = r.rotate(map_south)
if k == 0:
rottap = r.rotate(taper)
#tmg = enmap.MapGen(r.shape_final,r.wcs_final,ps)
w2 = np.mean(rottap**2.)
fc = enmap.FourierCalc(r.shape_final, r.wcs_final)
modlmap = enmap.modlmap(r.shape_final, r.wcs_final)
bin_edges = np.arange(100, lmax, 40)
binner = bin2D(modlmap, bin_edges)
map_test = fullsky.submap(enmap.box(r.shape_final, r.wcs_final))
del fullsky
if k == 0:
rect_taper, rw2 = fmaps.get_taper(map_test.shape,
taper_percent=18.0,
pad_percent=4.0,
weight=None)
rfc = enmap.FourierCalc(map_test.shape, map_test.wcs)
rmodlmap = enmap.modlmap(map_test.shape, map_test.wcs)
rbinner = bin2D(rmodlmap, bin_edges)
map_test *= rect_taper
#map_test = tmg.get_map(seed=index+int(1e6))*rottap
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
cents, dcltt = dbinner.bin(nT)
pl.add(cents, dcltt * cents**2., label="binned 2d power from pa")
cov = np.zeros((3, 3, modlmap.shape[0], modlmap.shape[1]))
cov[0, 0] = nT
cov[1, 1] = nT
cov[2, 2] = nT
zL,
modr_sim,
winAtLens,
overdensity=overdensity,
critical=critical,
atClusterZ=atClusterZ)
else:
grad_cut = None
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:
i).zfill(2) + ".fits"
lmap_file = "/gpfs01/astro/workarea/msyriac/data/sims/sigurd/cori/v61600/equator_curved_lensed_car_" + str(
i).zfill(2) + ".fits"
imap = enmap.read_map(map_file)[0]
lmap = enmap.read_map(lmap_file)[0]
smap = imap.submap(bbox)
if k == 0:
shape = smap.shape
wcs = smap.wcs
fc = enmap.FourierCalc(shape, wcs)
taper, w2 = fmaps.get_taper(shape,
taper_percent=12.0,
pad_percent=3.0,
weight=None)
binner = stats.bin2D(enmap.modlmap(shape, wcs), bin_edges)
shape2 = lmap.shape
wcs2 = lmap.wcs
fc2 = enmap.FourierCalc(shape2, wcs2)
taper2, w22 = fmaps.get_taper(shape2,
taper_percent=12.0,
pad_percent=3.0,
weight=None)
binner2 = stats.bin2D(enmap.modlmap(shape2, wcs2), bin_edges)
ells = np.arange(0, 5000, 1)
ps = theory.lCl('TT', ells).reshape((1, 1, 5000))
shapeN, wcsN = enmap.rect_geometry(1.2 * deg * 60., px, proj="car")
mg = enmap.MapGen(shapeN, wcsN, ps)
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
Nlmvinv = 0.
pl = Plotter(scaleY='log')
for polComb in ['TT','TE','EE','EB']:
kmax = getMax(polComb,tellmaxY,pellmaxY)
bin_edges = np.arange(kmin,kmax,dell)+dell
lmap = lm.makeEmptyCEATemplate(raSizeDeg=deg, decSizeDeg=deg,pixScaleXarcmin=px,pixScaleYarcmin=px)
myNls = NlGenerator(lmap,theory,bin_edges,gradCut=gradCut)
myNls.updateBins(bin_edges)
nTX,nPX,nTY,nPY = myNls.updateNoise(beamX,noiseTX,noisePX,tellminX,tellmaxX, \
pellminX,pellmaxX,beamY=beamY,noiseTY=noiseTY, \
noisePY=noisePY,tellminY=tellminY,tellmaxY=tellmaxY, \
pellminY=pellminY,pellmaxY=pellmaxY,lkneesX=(lkneeTX,lkneePX),alphasX=(alphaTX,alphaPX), \
lkneesY=(lkneeTY,lkneePY),alphasY=(alphaTY,alphaPY),lxcutTX=lxcutTX, \
lxcutTY=lxcutTY,lycutTX=lycutTX,lycutTY=lycutTY, \
lxcutPX=lxcutPX,lxcutPY=lxcutPY,lycutPX=lycutPX,lycutPY=lycutPY, \
fgFileX=fgFileX,beamFileX=beamFileX,fgFileY=fgFileY,beamFileY=beamFileY )
cbinner = bin2D(myNls.N.modLMap,cmb_bin_edges)
ells, Nells = cbinner.bin(nTX)
pl = Plotter(scaleY='log')
pl.add(ells,Nells*ells**2.*TCMB**2.)
pl.add(ells,Nells*ells**2.*TCMB**2.)
tells,tnlstt = np.loadtxt('data/louisCls.dat',delimiter=',',unpack=True)
pl.add(tells,tnlstt)
pl.done("output/compnl.png")
sys.exit()
comS = cc.results.comoving_radial_distance(cc.cmbZ)*cc.h
comL = cc.results.comoving_radial_distance(zL)*cc.h
winAtLens = (comS-comL)/comS
kappa,r500 = NFWkappa(cc,massOverh,concentration,zL,modrmap* 180.*60./np.pi,winAtLens,
overdensity=overdensity,critical=critical,atClusterZ=atClusterZ)
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)
for nstep in range(1, 8):
iter_delensed = lensing.delens_map(lensed.copy(),
grad_phi,
nstep=nstep,
order=lens_order,
mode="spline",
border="cyclic")
# Check residual
iter_residual = iter_delensed - unlensed
iters.append(iter_residual)
#io.quickPlot2d(iter_residual,out_dir+"iterres_"+str(nstep).zfill(2)+".png")
bin_edges = np.arange(0., 20., 0.5)
binner = stats.bin2D(modr_sim, bin_edges)
cents, prof = binner.bin(lens_residual)
pl.add(cents,
np.abs(prof),
ls="--",
label=("no delensing" if k == 0 else None),
alpha=alpha,
color="C0")
cents, prof = binner.bin(simple_residual)
pl.add(cents,
np.abs(prof),
ls="--",
label=("anti-lensing" if k == 0 else None),
alpha=alpha,
color="C1")
if not (saveMf):
try:
mf = np.loadtxt("data/meanfield.dat")
kappaStack -= mf
print("subtracted meanfield")
except:
pass
stepmin = kellmin
kappaStack = fmaps.stepFunctionFilterLiteMap(kappaStack,
modLMap,
kellmax,
ellMin=stepmin)
pl = Plotter()
pl.plot2d(kappaStack)
pl.done(outDir + "recon.png")
dt = pixScale
arcmax = 20.
thetaRange = np.arange(0., arcmax, dt)
breal = bin2D(modRMap * 180. * 60. / np.pi, thetaRange)
cents, recons = breal.bin(kappaStack)
pl = Plotter()
pl.add(cents, recons)
pl._ax.axhline(y=0., ls="--", alpha=0.5)
pl.done(outDir + "profiles.png")
template_dat = fmaps.simple_flipper_template_from_enmap(measured.shape,measured.wcs)
lxmap_dat,lymap_dat,modlmap_dat,angmap_dat,lx_dat,ly_dat = fmaps.get_ft_attributes_enmap(shape_dat,wcs_dat)
taper_percent = 15.0
Ny,Nx = shape_dat
taper = fmaps.cosineWindow(Ny,Nx,lenApodY=taper_percent*min(Ny,Nx)/100.,lenApodX=taper_percent*min(Ny,Nx)/100.,padY=0,padX=0)
tapered = measured*taper
# io.quickPlot2d(tapered,"map.png")
w2 = np.mean(taper**2.)
w4 = np.mean(taper**4.)
debug_edges = np.arange(400,8000,150)
dbinner_dat = stats.bin2D(modlmap_dat,debug_edges)
# p2d = fmaps.get_simple_power_enmap(tapered)/w2
# cents,dcltt = dbinner_dat.bin(p2d)
# cltt = theory.lCl("TT",fine_ells)
# ucltt = theory.uCl("TT",fine_ells)
# pl = io.Plotter(scaleY='log')
# pl.add(cents,dcltt*cents**2.)
# pl.add(fine_ells,cltt*fine_ells**2.)
# pl.add(fine_ells,ucltt*fine_ells**2.)
# pl.done("cls.png")
nT = modlmap_dat*0.
