def plot(self,
spec,
keys,
out_dir=None,
scaleY='log',
scaleX='log',
scale_spectrum=True,
xlim=None,
ylim=None,
skip_uzero=True,
pl=None,
skip_labels=True):
if pl is None: pl = io.Plotter(scaleY=scaleY, scaleX=scaleX)
if scale_spectrum:
scalefac = self.cents**2.
else:
scalefac = 1.
cmb_specs = ['TT', 'EE', 'BB', 'TE', 'ET', 'EB', 'BE', 'TB', 'BT']
uspecs = ['BB', 'EB', 'BE', 'TB', 'BT']
done_spec = []
suffspec = ""
if (spec in cmb_specs) and self.pol:
suffspec = spec
for key in keys:
if ("unlensed" in key) and (spec in uspecs) and skip_uzero:
continue
st = self.mpibox.stats[key + suffspec]
if ("unlensed" in key) or ("delensed" in key):
spec_key = "u" + spec
else:
if (spec in cmb_specs):
spec_key = "l" + spec
else:
spec_key = spec
if spec_key not in done_spec:
done_spec.append(spec_key)
th2d = self.theory.gCl(spec_key, self.modlmap)
cents, th1d = self.lbinner.bin(th2d)
pl.add(cents, th1d * scalefac)
pl.addErr(cents,
st['mean'] * scalefac,
yerr=st['errmean'] * scalefac,
marker="x",
ls="none",
label=key)
if xlim is not None: pl._ax.set_xlim(xlim[0], xlim[1])
if ylim is not None: pl._ax.set_ylim(ylim[0], ylim[1])
if not (skip_labels): pl.legendOn(labsize=10)
if pl is None: pl.done(out_dir)
def plot_stats(cents, cont, ells, ells_pp, theory):
if len(cont['tt']) < 3: return
print("Calculating stats...")
st = {}
for spec in ['tt', 'ee', 'te', 'bb', 'pp']:
st[spec] = stats.getStats(cont[spec])
print("Plotting...")
pl = io.Plotter(scaleY='log', scaleX='log')
for spec in ['tt', 'ee', 'bb']:
pl.add(ells, theory[spec] * ells**2., lw=2)
pl.addErr(cents,
st[spec]['mean'] * cents**2.,
yerr=st[spec]['errmean'] * cents**2.,
ls="none",
marker="o")
pl.done(os.environ['WORK'] + "/web/plots/clsauto.png")
pl = io.Plotter(scaleX='log')
for spec in ['te']:
pl.add(ells, theory[spec] * ells**2., lw=2)
pl.addErr(cents,
st[spec]['mean'] * cents**2.,
yerr=st[spec]['errmean'] * cents**2.,
ls="none",
marker="o")
pl.done(os.environ['WORK'] + "/web/plots/clste.png")
pl = io.Plotter(scaleY='log')
for spec in ['pp']:
pl.add(ells_pp, theory[spec], lw=2)
pl.addErr(cents,
st[spec]['mean'],
yerr=st[spec]['errmean'],
ls="none",
marker="o")
pl._ax.set_xlim(2, 3000)
pl.done(os.environ['WORK'] + "/web/plots/clspp.png")
def plot_powers(unlensed_map, lensed_map, modlmap, theory, lbinner_dat,
out_dir):
utt2d = fmaps.get_simple_power_enmap(unlensed_map)
ltt2d = fmaps.get_simple_power_enmap(lensed_map)
iutt2d = theory.uCl("TT", modlmap)
iltt2d = theory.lCl("TT", modlmap)
lb = lbinner_dat
cents, utt = lb.bin(utt2d)
cents, ltt = lb.bin(ltt2d)
cents, iutt = lb.bin(iutt2d)
cents, iltt = lb.bin(iltt2d)
pl = oio.Plotter()
pdiff = (utt - iutt) * 100. / iutt
pl.add(cents, pdiff)
pl.done(out_dir + "uclpdiff.png")
pl = oio.Plotter()
pdiff = (ltt - iltt) * 100. / iltt
pl.add(cents, pdiff)
pl.done(out_dir + "lclpdiff.png")
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)
clbb = theory.lCl('BB',ellrange)
pl.add(ellrange,cltt*ellrange**2.,color="k")
pl.add(ellrange,clee*ellrange**2.,color="k")
pl.add(ellrange,clbb*ellrange**2.,color="k")
pl.add(cents,dtt*cents**2.)
pl.add(cents,dee*cents**2.)
pl.add(cents,dbb*cents**2.)
pl.done(out_dir+"powers_"+suffix+".png")
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")
with io.nostdout():
Fisher, paramList = sfisher.cluster_fisher_from_config(
Config,
expName,
grid,
cal,
fish + fish_suff_pass,
tauOverride=tau,
do_clkk_override=do_clkk_ov)
if fish == "mnu-paper": print(paramList)
margerrs = sfisher.marginalized_errs(Fisher, paramList)
print((margerrs['mnu'] * 1000.))
performance[cal][fish_suff].append(margerrs['mnu'] * 1000.)
#print margerrs['b_wl']*100.
pl = io.Plotter(labelY='$\\sigma(\\Sigma m_{\\nu})$ (meV)', ftsize=18)
for fish_suff, lab in zip(fishall, laball):
pl._ax.bar(y_pos,
performance[cal][fish_suff],
align='center',
alpha=al,
label=lab)
pl._ax.set_xticks(y_pos) #y_pos, objects)
pl._ax.set_xticklabels(objects)
pl._ax.set_ylim(0, 62)
min_mass = 58.
pl._ax.axhline(y=min_mass, ls="-", color="k", alpha=0.3)
pl._ax.axhline(y=old_div(min_mass, 3.), ls="--", color="k")
pl._ax.axhline(y=old_div(min_mass, 5.), ls="-.", color="k")
pl.legendOn(labsize=16)
if rank == 0:
print(
("Rank ", rank, " doing job ", k + 1, " / ", len(my_tasks), "..."))
sim(index, Nsims + index)
sim(2 * Nsims + index, 3 * Nsims + index)
sim(4 * Nsims + index, 5 * Nsims + index)
sim(6 * Nsims + index, 5 * Nsims + index, skip_kappa_verif=True
) # skip kappa verification because kappa is repeated
mpibox.get_stats()
if rank == 0:
plot_list = ["unlensed", "lensed", "dlensed"
] if not (vonly) else ['dlensed']
spec_list = ["TT", "EE", "BB"] if pol else ['TT']
pl = io.Plotter(scaleY='log')
for spec in spec_list:
if not (vonly):
sverif_cmb.plot(spec, plot_list, xlim=[kellmin, kellmax], pl=pl)
sverif_dcmb.plot(spec, plot_list, xlim=[kellmin, kellmax], pl=pl)
pl.done(pout_dir + "cl.png")
if pol:
plot_list = ["unlensed", "lensed", "dlensed"
] if not (vonly) else ['dlensed']
spec_list = ["TE"]
pl = io.Plotter()
for spec in spec_list:
if not (vonly):
sverif_cmb.plot(spec,
plot_list,
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")
def dump(self,save_meanfield,skip_recon):
mlist = ['s','e','r']
def unpack(label,m):
dic = self.mpibox.stats[label+"-"+m]
return dic['mean'],dic['errmean']
ellrange = np.arange(0,self.bin_edges[-1])
cltheory = self.theory.lCl('TT',ellrange)
# CLTT vs input powers
pl = io.Plotter()
pdiff = (self.mpibox.stats["fullsky_ps"]['mean'][:ellrange.size]-cltheory)/cltheory
perr = self.mpibox.stats["fullsky_ps"]['errmean'][:ellrange.size]/cltheory
pl.addErr(ellrange,pdiff,yerr=perr,label="sht fullsky",ls="-",alpha=0.3)
for m in mlist:
modlmap = self.modlmap[m]
cltt = self.binner[m].bin(self.theory.lCl('TT',modlmap))[1]
pcltt,pcltt_err = unpack("cmb",m)
pdiff = (pcltt-cltt)/cltt
perr = pcltt_err/cltt
pl.addErr(self.cents,pdiff,yerr=perr,label=m,ls="-")
pl.hline()
pl.legendOn()
pl._ax.set_ylim(-0.1,0.1)
pl.done(io.dout_dir+"clttdiff.png")
# CLKK vs input powers
pl = io.Plotter()
for m in mlist:
modlmap = self.modlmap[m]
clkk = self.binner[m].bin(self.theory.gCl('kk',modlmap))[1]
pclkk,pclkk_err = unpack("ixi",m)
pdiff = (pclkk-clkk)/clkk
perr = pclkk_err/clkk
pl.addErr(self.cents,pdiff,yerr=perr,label=m,ls="-")
pl.hline()
pl.legendOn()
pl.done(io.dout_dir+"clkkdiff.png")
if skip_recon: return
if save_meanfield:
for m in mlist:
mf = self.mpibox.stacks["meanfield-"+m]
enmap.write_map("meanfield_"+m+".hdf",mf)
# RECONSTRUCTION VS CLKK PLOT
ellrange = np.arange(0,3000)
clkk = self.theory.gCl("kk",ellrange)
cents = self.cents
for m in mlist:
modlmap = self.modlmap[m]
clkk2d = self.theory.gCl('kk',modlmap)
clkk1d = self.binner[m].bin(clkk2d)[1]
nlkk = self.binner[m].bin(self.qest[m].N.Nlkk['TT'])[1]
totkk = self.binner[m].bin(clkk2d+self.qest[m].N.Nlkk['TT'])[1]
pl = io.Plotter(scaleY='log')
pl.add(ellrange,clkk,color="k",lw=2)
pl.add(cents,nlkk,ls="--")
pl.add(cents,totkk,ls="-")
y,err = unpack("rxr",m)
pl.addErr(cents,y,err,ls="none",marker="o")
y,err = unpack("rxr-n0",m)
pl.addErr(cents,y,err,ls="none",marker="o")
y,err = unpack("rxi",m)
pl.addErr(cents,y,err,ls="none",marker="o")
y,err = unpack("ixi",m)
pl.add(cents,y,ls="none",marker="x",color="k")
y,err = unpack("n0",m)
pl.add(cents,y,ls="--")
pl.add(cents,y+clkk1d,ls="-")
pl.legendOn()
pl._ax.set_ylim(1.e-10,1.e-6)
pl.done(io.dout_dir+"clkkrecon_"+m+".png")
pl = io.Plotter()
rxi_e,rxi_err_e = unpack("rxi","e")
for m in ['s','r']:
y,err = unpack("rxi",m)
diff = (y-rxi_e)/rxi_e
diff_err = np.abs(y/rxi_e)*np.sqrt((err/y)**2.+(rxi_err_e/rxi_e)**2.)
pl.addErr(cents,diff,diff_err,ls="--",marker="o",label=m+"-cross")
pl.legendOn()
pl.hline()
pl._ax.set_ylim(-0.1,0.1)
pl.done(io.dout_dir+"clkkdiffrecon_cross.png")
pl = io.Plotter()
rxr_e,rxr_err_e = unpack("rxr-n0","e")
for m in ['s','r']:
y,err = unpack("rxr-n0",m)
diff = (y-rxr_e)/rxr_e
diff_err = np.abs(y/rxr_e)*np.sqrt((err/y)**2.+(rxr_err_e/rxr_e)**2.)
pl.addErr(cents,diff,diff_err,ls="-",marker="o",label=m+"-auto")
pl.legendOn()
pl.hline()
pl._ax.set_ylim(-0.4,0.4)
pl.done(io.dout_dir+"clkkdiffrecon_auto.png")
pl = io.Plotter()
for m in mlist:
modlmap = self.modlmap[m]
clkk2d = self.theory.gCl('kk',modlmap)
clkk1d = self.binner[m].bin(clkk2d)[1]
y,err = unpack("rxi",m)
diff = (y-clkk1d)/clkk1d
diff_err = err/clkk1d
pl.addErr(cents,diff,diff_err,ls="--",marker="o",label=m+"-cross")
pl.legendOn()
pl.hline()
pl._ax.set_ylim(-0.1,0.1)
pl.done(io.dout_dir+"clkkdiffrecon_theory_cross.png")
pl = io.Plotter()
for m in mlist:
modlmap = self.modlmap[m]
clkk2d = self.theory.gCl('kk',modlmap)
clkk1d = self.binner[m].bin(clkk2d)[1]
y,err = unpack("rxr-n0",m)
diff = (y-clkk1d)/clkk1d
diff_err = err/clkk1d
pl.addErr(cents,diff,diff_err,ls="-",marker="o",label=m+"-auto")
pl.legendOn()
pl.hline()
pl._ax.set_ylim(-0.4,0.4)
pl.done(io.dout_dir+"clkkdiffrecon_theory_auto.png")
import os, sys, glob
from orphics.theory.cosmology import Cosmology
import numpy as np
cc = Cosmology(lmax=3000, pickling=True)
ells = np.arange(2, 3000, 1)
clkktheory = cc.theory.gCl("kk", ells)
output_dir = "/gpfs01/astro/workarea/msyriac/data/sigurd_sims/"
clkkn0pers = []
clkkpers = []
sdppers = []
clttpers = []
pl = io.Plotter(scaleY="log")
pl.add(ells, clkktheory, color="k", lw=3)
for k in range(50):
print(k)
try:
exp_name = "south"
cents_pwr, sn0subbed = pickle.load(
open(
output_dir + exp_name + "_clkk_n0subbed_" + str(k).zfill(2) +
".pkl", 'rb'))
cents_pwr, saclkk = pickle.load(
open(
output_dir + exp_name + "_rawclkk_" + str(k).zfill(2) + ".pkl",
'rb'))
theory_file_root = "data/Aug6_highAcc_CDM"
theory = cmb.loadTheorySpectraFromCAMB(theory_file_root,
unlensedEqualsLensed=False,
useTotal=False,
TCMB=2.7255e6,
lpad=9000,
get_dimensionless=False)
ells, tcltt = b(theory.lCl('TT', fineells))
ells, tclee = b(theory.lCl('EE', fineells))
ells, tclte = b(theory.lCl('TE', fineells))
ells, tclbb = b(theory.lCl('BB', fineells))
pl = io.Plotter(scaleY='log')
pl.add(ells, cltt * ells**2.)
pl.add(ells, clee * ells**2.)
pl.add(ells, tcltt * ells**2., color="k")
pl.add(ells, tclee * ells**2., color="k")
pl.add(ells, clbb * ells**2.)
pl.add(ells, tclbb * ells**2., color="k")
pl._ax.set_ylim(1.e-3, 5e5)
pl.done(io.dout_dir + "sigurd_alex_clcomp_.png")
cut_root = "/gpfs01/astro/workarea/msyriac/data/depot/distortions/"
mells, mcltt, _ = np.loadtxt(
cut_root + "distspectrav6unlensed_equator_car_TT_unlensed.txt",
unpack=True)
mells, mclee, _ = np.loadtxt(
cut_root + "distspectrav6unlensed_equator_car_EE_unlensed.txt",
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']))
pl.addErr(cents,rxr_raw['mean'],yerr=rxr_raw['errmean'],ls="none",marker="o",label='Total Autospectrum',alpha=0.5)
io.save_cols(pout_dir+"_plot_reconXrecon_raw.txt",(cents,rxr_raw['mean'],rxr_raw['errmean']))
if not(paper): pl.addErr(cents,rxr['mean'],yerr=rxr['errmean'],ls="none",marker="o",label='rxr sdn0')
# pl.addErr(cents,ixi['mean'],yerr=ixi['errmean'],ls="none",marker="x",color="k",label='Input x Reconstruction')
#pl.add(cents,ixi['mean'],ls="none",marker="x",color="k",label='Input x Input')
if not(paper) and doN1: pl.add(cents+140,unb1d,marker="o",label='Debiased Reconstruction Autospectrum',ls="none")
if not(paper): pl.add(cents,diagraw,ls="--",marker="^",label="diag raw",alpha=0.5)
pl.add(cents,diagn0sub,ls="--",marker="^",label="Variance of Power")
io.save_cols(pout_dir+"_plot_varPower.txt",(cents,diagn0sub))
#pl.add(cents,idiag_est,ls="--",marker="^",label="Variance of Power from Cross")
#pl.add(cents,diagcross,ls="--",marker="^",label="diag cross")
def plot_diff(self,
spec,
keys,
out_dir=None,
scaleY='linear',
scaleX='linear',
xlim=None,
ylim=None,
pl=None,
skip_labels=True,
ratio=True,
save_root=None):
if pl is None: pl = io.Plotter(scaleY=scaleY, scaleX=scaleX)
cmb_specs = ['TT', 'EE', 'BB', 'TE', 'ET', 'EB', 'BE', 'TB', 'BT']
done_spec = []
suffspec = ""
if (spec in cmb_specs) and self.pol:
suffspec = spec
for key in keys:
st = self.mpibox.stats[key + suffspec]
if ("unlensed" in key) or ("delensed" in key):
spec_key = "u" + spec
else:
if (spec in cmb_specs):
spec_key = "l" + spec
else:
spec_key = spec
if spec_key not in done_spec:
done_spec.append(spec_key)
th2d = self.theory.gCl(spec_key, self.modlmap)
if ("unlensed" in key) or ("delensed" in key):
cents, th1d_unlensed = self.lbinner.bin(th2d)
else:
cents, th1d = self.lbinner.bin(th2d)
if ("unlensed" in key) or ("delensed" in key):
th1dnow = th1d_unlensed
else:
th1dnow = th1d
rdiff = (st['mean'] - th1dnow)
rerr = st['errmean']
div = th1dnow if ratio else 1.
pl.addErr(cents,
rdiff / div,
yerr=rerr / div,
marker="x",
ls="none",
label=key)
if save_root is not None:
io.save_cols(save_root + spec + "_" + key + ".txt",
(cents, rdiff / div, rerr / div))
if not (skip_labels): pl.legendOn(labsize=10)
if xlim is not None: pl._ax.set_xlim(xlim[0], xlim[1])
if ylim is not None: pl._ax.set_ylim(ylim[0], ylim[1])
pl.hline()
if pl is None: pl.done(out_dir)
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
cents1d, bin1d_iso = binner1d.binned(fine1d_ells, cl1d * fine1d_ells)
cents1d, bin1d_iso_norm = binner1d.binned(fine1d_ells, fine1d_ells)
bin1d_iso /= bin1d_iso_norm
# the most correctest way to do it if you can work with 2d matrices
cents2d, bin2d = binner2d.bin(cl2d)
assert np.all(np.isclose(cents1d, cents2d))
# the not so great way to do it, especially if your spectrum is very
# red like with TT, or has peaks and troughs like with TT
try:
interped1d = theory.lCl(spec, cents1d)
except:
interped1d = theory.gCl(spec, cents1d)
# a percentage difference function
pdiff = lambda x, y: (x - y) * 100. / y
# define 2d binning as the truth
truth = bin2d
cents = cents2d
pl = io.Plotter(labelX="$\ell$", labelY="% diff")
pl.add(cents, pdiff(bin1d, truth), label="1d mean")
pl.add(cents, pdiff(bin1d_iso, truth), label="1d iso mean")
pl.add(cents, pdiff(interped1d, truth), label="interpolated")
pl.legendOn(loc="upper right")
pl._ax.set_ylim(-5, 30)
pl.done(spec + "_bin.png")
theory = cc.theory
cltt = theory.lCl('TT',ellfine)
cltt2d = theory.lCl('TT',modLMap)
nfunc = cmb.get_noise_func(beamArcmin,noiseMukArcmin,ellmin=ellmin_cmb,ellmax=ellmax_cmb,TCMB=2.7255e6,lknee=lknee,alpha=alpha)
nells = nfunc(ellfine)
n2d = nfunc(modLMap)
n2dp = n2d/pwindow**2.
cents, nclsp = binner.bin(n2dp)
cents, ncls = binner.bin(n2d)
pl = io.Plotter(scaleY='log',scaleX='log')
pl.add(ellfine,cltt*ellfine**2.)
pl.add(ellfine,nells*ellfine**2.,ls="--")
pl.add(cents,nclsp*cents**2.,ls="-.")
pl.legendOn()
pl.done(out_dir+"pcls.png")
pl = io.Plotter(labelY="% diff of $N_{\ell}$ with pixel",labelX="$\ell$")
pl.add(cents,(nclsp-ncls)*100./ncls)
pl.done(out_dir+"pdiff.png")
#meanfield = {}
#meanfieled_pwr = {}
cross = {}
n0 = {}
for region in ['equator', 'south']:
print(region)
save_dir = "/gpfs01/astro/workarea/msyriac/data/depot/distortions/distspectrav4mfsub_" + region + "_"
autokk[region] = np.loadtxt(save_dir + "autokk.txt", unpack=True)
inputkk[region] = np.loadtxt(save_dir + "ikk.txt", unpack=True)
cross[region] = np.loadtxt(save_dir + "rxikk.txt", unpack=True)
n0[region] = np.loadtxt(save_dir + "sdn0.txt", unpack=True)
ells = inputkk["equator"][0]
# First let's look at the difference of the inputs
pl = io.Plotter(labelX="$L$", labelY="$\Delta C_L^{II}/C_L^{II}$")
eq = inputkk["equator"][1]
so = inputkk["south"][1]
pl.add(ells, (so - eq) / eq)
pl.hline()
pl._ax.set_xlim(0, lmax)
pl.done(io.dout_dir + "dist_inpdiff.png")
# Next diff w.r.t input
pl = io.Plotter(labelX="$L$", labelY="$(C_L^{IR}-C_L^{II})/C_L^{II}$")
for ls, region in zip(("-", "--"), ['equator', 'south']):
inp = inputkk[region][1]
crossp = cross[region][1]
pl.add(ells, (crossp - inp) / inp, ls=ls, label=region)
pl.hline()
pl.legendOn()
expList = ['S4-1.0-paper','S4-1.5-paper','S4-2.0-paper','S4-2.5-paper','S4-3.0-paper']
gridName = "grid-default"
# get mass and z grids
ms = listFromConfig(Config,gridName,'mexprange')
mexp_edges = np.arange(ms[0],ms[1]+ms[2],ms[2])
zs = listFromConfig(Config,gridName,'zrange')
z_edges = np.arange(zs[0],zs[1]+zs[2],zs[2])
lkneeList = np.arange(0,6000,500.)
alphaList = [-4.,-4.5,-5.]
pl = io.Plotter(scaleY='log',labelX="$\ell_{\mathrm{knee}}$",labelY="Cluster detections",ftsize=16)
lslist = ["--","-","-."]
collist = ['#1C110A','#E4D6A7','#E9B44C','#9B2915','#50A2A7']
lablist = ['S4 1.0\'','S4 1.5\'','S4 2.0\'','S4 2.5\'','S4 3.0\'']
for expName,col,lab in zip(expList,collist,lablist):
for alpha,ls in zip(alphaList,lslist):
Ns = []
for lknee in lkneeList:
try:
N = sfisher.counts_from_config(Config,bigDataDir,version,expName,gridName,mexp_edges,z_edges,lkneeTOverride = lknee,alphaTOverride=alpha)
print(N)
except:
io.quickPlot2d(np.fft.fftshift(reb2d), out_dir + "reb2d.png")
finells = np.arange(2, kellmax, 1)
clkk1d = theory.gCl('kk', finells)
ntt2d = rtt2d - clkk2d
neb2d = reb2d - clkk2d
cents, rtt1d = lbinner_dat.bin(rtt2d)
cents, reb1d = lbinner_dat.bin(reb2d)
cents, ntt1d = lbinner_dat.bin(ntt2d)
cents, neb1d = lbinner_dat.bin(neb2d)
cents, thntt1d = lbinner_dat.bin(thntt2d)
cents, thneb1d = lbinner_dat.bin(thneb2d)
pl = io.Plotter(scaleX='linear', scaleY='log')
pl.add(finells, clkk1d, color="k")
pl.add(cents,
rtt1d,
ls="none",
marker="o",
alpha=0.1,
label="clkk+ntt",
color="C0")
pl.add(cents,
reb1d,
ls="none",
marker="o",
alpha=0.1,
label="clkk+neb",
np.random.seed(100)
# probability function is assumed to be exponential
x0 = 10. # the knee of the exponential
norm = 6.065 # this norm was explicitly calculated for x0=10 and richness bounds [5,10]
prob = lambda x: np.exp(-x / x0
) / norm # analytical pdf of exponential distribution
cdf = lambda x: np.piecewise(
x, [x <= a, np.logical_and(x > a, x < b), x >= b], [
lambda x: 0., lambda x: x0 *
(np.exp(-a / x0) - np.exp(-x / x0)) / norm, lambda x: 1.
]) # analytic cdf of the same
# check cdf and norm
prange = np.linspace(a, b, 100)
pl = io.Plotter(labelX="richness $x$", labelY="$P(X<x)$")
pl.add(prange, cdf(prange))
pl.done("cdf.png")
print(("Norm: ", np.trapz(prob(prange), prange)))
# sample using the inverse transform sampling method
inv_cdf = lambda y: -x0 * np.log(np.exp(-a / x0) - y * norm / x0
) # analytic inverse of cdf
Nsamples = 8000
samples = [inv_cdf(np.random.random()) for x in range(Nsamples)]
# histogram
nbins = 20
n, bins, patches = plt.hist(samples,
nbins,
facecolor='blue',
io.quickPlot2d(mpibox.stacks['mkappa'],out_dir+"stack.png")
mean = mpibox.stats['prof']['mean']
cov = mpibox.stats['prof']['covmean']
siginv = np.linalg.inv(cov)
chisq = np.dot(np.dot(mean,siginv),mean)
print((np.sqrt(chisq)))
mass_range = np.linspace(1.e14,5.e14,300)
Likes = []
for k,m in enumerate(mass_range):
trial = get_nfw(m)
kellmin = 200
kellmax = 8500
trial = enmap.ndmap(fmaps.filter_map(trial,true2d*0.+1.,modlmap,lowPass=kellmax,highPass=kellmin),wcs)
cents,theory = rbinner.bin(trial)
Likes.append(np.exp(-0.5*stats.fchisq(mean,siginv,theory,amp=1.)))
if k%10==0: print(m)
Likes = np.array(Likes)
Likes /= Likes.sum()
pl = io.Plotter()
pl.add(mass_range,Likes)
pl._ax.axvline(x=true_mass,ls="--")
pl.done(out_dir+"likes.png")
tellmaxX=tellmax,
pellminX=pellmin,
pellmaxX=pellmax)
nlgen.N.getNlkk2d('TT', halo=True)
nlkk0_2d = nlgen.N.Nlkk['TT']
cents, nlkk0 = lbinner_dat.bin(nlkk0_2d)
clkk2d = theory.gCl('kk', modlmap_dat)
cents, nltt = lbinner_dat.bin(nTX)
# lensed cls prediction
dtheory = cmb.get_lensed_cls(theory, ellrange, clkk, lmax)
dlcltt = dtheory.lCl('TT', ellrange)
ducltt = dtheory.uCl('TT', ellrange)
plkk = io.Plotter(scaleY='log')
plkk.add(ellrange, clkk, color="k", lw=3)
plkk.add(cents, nlkk0, ls="--") #,alpha=1/(niter+3.))
pltt = io.Plotter(scaleY='log')
pltt.add(ellrange, ucltt * ellrange**2., ls="--")
pltt.add(ellrange, lcltt * ellrange**2., ls="-")
pltt.add(cents, nltt * cents**2., ls="--", color="k")
#pltt.add(ellrange,dlcltt*ellrange**2.,ls="-.")
# unlensed limit
nlgen = qe.NlGenerator(template, theory, lensedEqualsUnlensed=True)
nlgen.updateNoise(beamX=beam,
noiseTX=noiseT,
noisePX=0.,
tellminX=tellmin,
from orphics.theory.cosmology import Cosmology
import numpy as np
import orphics.tools.io as io
cc = Cosmology(lmax=6000,pickling=True)
ells = np.arange(2,6000,1)
ucltt = cc.theory.uCl('TT',ells)
lcltt = cc.theory.lCl('TT',ells)
pl = io.Plotter(scaleY='log',scaleX='log')
pl.add(ells,ucltt*ells**2.,ls="--")
pl.add(ells,lcltt*ells**2.)
pl.done("cmbdemo.png")
Config.optionxform = str
Config.read(iniFile)
freq_to_use = 150.
cc = Cosmology(lmax=8000, pickling=True)
theory = cc.theory
ells = np.arange(2, 8000, 1)
cltt = theory.lCl('TT', ells)
TCMB = 2.7255e6
out_dir = os.environ['WWW']
pl = io.Plotter(scaleY='log',
labelX="$\ell$",
labelY="$\ell^2 C_{\ell}$",
ftsize=20)
for expName, lab in zip(['S4-1.0-0.4-noatm', 'S4-1.0-0.4'],
['S4 1arc no atm', 'S4 1arc lknee=5500 (in paper)']):
beam = listFromConfig(Config, expName, 'beams')
noise = listFromConfig(Config, expName, 'noises')
freq = listFromConfig(Config, expName, 'freqs')
lkneeT, lkneeP = listFromConfig(Config, expName, 'lknee')
alphaT, alphaP = listFromConfig(Config, expName, 'alpha')
print((expName, beam, noise, lkneeT, lkneeP, alphaT, alphaP))
ind = np.where(np.isclose(freq, freq_to_use))
beamFind = np.array(beam)[ind]
