def get_hz_errs(fname):
"""
Load Fisher matrix and invert to get errors on H(z) as a function of z.
"""
root = "output/" + fname
print(root)
# Load cosmo fns.
dat = np.atleast_2d( np.genfromtxt(root+"-cosmofns-zc.dat") ).T
zc, Hc, dAc, Dc, fc = dat
z, H, dA, D, f = np.genfromtxt(root+"-cosmofns-smooth.dat").T
kc = np.genfromtxt(root+"-fisher-kc.dat").T
# Load Fisher matrices as fn. of z
Nbins = zc.size
F_list = [np.genfromtxt(root+"-fisher-full-%d.dat" % i) for i in range(Nbins)]
# EOS FISHER MATRIX
# Actually, (aperp, apar) are (D_A, H)
pnames = rf.load_param_names(root+"-fisher-full-0.dat")
zfns = ['bs8', 'fs8', 'H', 'DA',]
excl = ['Tb', 'n_s', 'sigma8', 'omegak', 'omegaDE', 'w0', 'wa', 'h',
'gamma', 'N_eff', 'pk*', 'f', 'b_HI',
'gamma0', 'gamma1', 'eta0', 'eta1', 'A_xi', 'logkmg',
'sigma8tot', 'sigma_8', 'k*', 'A', 'aperp', 'apar']
F, lbls = rf.combined_fisher_matrix( F_list,
expand=zfns, names=pnames,
exclude=excl )
print(lbls)
cov = np.linalg.inv(F)
errs = np.sqrt(np.diag(cov))
# Identify functions of z
pH = rf.indices_for_param_names(lbls, 'H*')
errH = 1e2 * errs[pH] / Hc
pfs8 = rf.indices_for_param_names(lbls, 'fs8*')
errfs8 = errs[pfs8] / (cosmo['sigma_8'] * fc * Dc)
# Return values
return zc, errH, errfs8
#zfns = ['A', 'b_HI', 'f', 'H', 'DA', 'aperp', 'apar']
zfns = ['bs8', 'fs8', 'H', 'DA',]
excl = ['Tb', 'n_s', 'sigma8', 'omegak', 'omegaDE', 'w0', 'wa', 'h',
'gamma', 'N_eff', 'pk*', 'f', 'b_HI',
'gamma0', 'gamma1', 'eta0', 'eta1', 'A_xi', 'logkmg',
'sigma8tot', 'sigma_8', 'k*', 'A', 'aperp', 'apar']
F, lbls = rf.combined_fisher_matrix( F_list,
expand=zfns, names=pnames,
exclude=excl )
cov = np.linalg.inv(F)
errs = np.sqrt(np.diag(cov))
# Identify functions of z
pfs8 = rf.indices_for_param_names(lbls, 'fs8*')
err = errs[pfs8] / (cosmo['sigma_8']*fc*Dc)
P.plot( zc, err, color=colours[k], label=labels[k], lw=2.2,
marker=marker[k], markersize=ms[k], markeredgecolor=colours[k],
dashes=linestyle[k] )
# Load actual f.sigma_8 data and plot it
dat = np.genfromtxt("fsigma8_data.dat").T
#P.plot(dat[1], dat[3], 'kD')
P.plot(dat[1], dat[3]/dat[2], 'ko', mfc='none', mew=1.8, ms=8.)
P.tick_params(axis='both', which='major', labelsize=18, width=1.5, size=8., pad=10)
P.tick_params(axis='both', which='minor', labelsize=18, width=1.5, size=5.)
# Set axis limits
names=pnames,
exclude=excl)
cov2 = np.linalg.inv(F2)
errs2 = np.sqrt(np.diag(cov2))
for d, l in zip(np.diag(F2), lbls2):
print "%10s %3.1e" % (l, d)
"""
rf.plot_corrmat(F2, lbls2)
P.show()
exit()
"""
# Identify functions of z
#pfs8 = rf.indices_for_param_names(lbls, 'fs8*')
pfs8_2 = rf.indices_for_param_names(lbls2, 'fs8*')
"""
print ""
print "#", names[k]
print "# z, fsigma8, sigma(fsigma8)"
for j in range(zc.size):
print "%4.4f %5.5e %5.5e" % (zc[j], (cosmo['sigma_8']*fc*Dc)[j], errs[pfs8][j])
"""
# FIXME: Disable to get redshift markers
#marker[k] = None
"""
# Plot errors as fn. of redshift (b_1 marginalised)
err = errs[pfs8] / (cosmo['sigma_8']*fc*Dc)
line = P.plot( zc, err, color=colours[k], lw=1.8, ls='dashed',
marker=marker[k], markersize=ms[k], markeredgecolor=colours[k] )
#line[0].set_dashes('dashed')
#zfns = ['A', 'b_HI', 'f', 'DV', 'F']
zfns = ['A', 'bs8', 'fs8', 'DV', 'F']
excl = [
'Tb', 'sigma8', 'n_s', 'omegak', 'omegaDE', 'w0', 'wa', 'h', 'gamma',
'N_eff', 'pk*', 'f', 'b_HI'
] #'fs8', 'bs8']
F, lbls = rf.combined_fisher_matrix(F_list,
expand=zfns,
names=pnames,
exclude=excl)
print lbls
cov = np.linalg.inv(F)
errs = np.sqrt(np.diag(cov))
# Identify functions of z
pDV = rf.indices_for_param_names(lbls, 'DV*')
pFF = rf.indices_for_param_names(lbls, 'F*')
pfs8 = rf.indices_for_param_names(lbls, 'fs8*')
DV = ((1. + zc)**2. * dAc**2. * C * zc / Hc)**(1. / 3.)
Fz = (1. + zc) * dAc * Hc / C
fs8 = cosmo['sigma_8'] * fc * Dc
indexes = [pfs8, pFF]
fn_vals = [fs8, Fz]
# Plot errors as fn. of redshift
for jj in range(len(axes)):
err = errs[indexes[jj]] / fn_vals[jj]
line = axes[jj].plot(zc,
err,
]
#excl = ['A', 'bs8', 'fs8', 'H', 'DA', 'aperp', 'apar', 'Tb', 'N_eff', 'pk*', 'f', 'wa', 'gamma0', 'gamma1', 'eta0', 'eta1', 'A_xi', 'logkmg',]
#zfns = ['w0', ]
# Marginalising over b_1
F, lbls = rf.combined_fisher_matrix(F_list,
expand=zfns,
names=pnames,
exclude=excl)
print lbls
cov = np.linalg.inv(F)
errs = np.sqrt(np.diag(cov))
# Identify functions of z
pDA = rf.indices_for_param_names(lbls, 'DA*')
errDA = 1e3 * errs[pDA] / dAc
# FIXME: Disable to get redshift markers
#marker[k] = None
"""
# Plot errors as fn. of redshift (b_1 marginalised)
err = errs[pfs8] / (cosmo['sigma_8']*fc*Dc)
line = P.plot( zc, err, color=colours[k], lw=1.8, ls='dashed',
marker=marker[k], markersize=ms[k], markeredgecolor=colours[k] )
#line[0].set_dashes('dashed')
"""
# Plot errors as fn. of redshift
if labels[k] is not None:
P.plot(zc,
errDA,
if (Fbs8 < 1e-8) or (Ffs8 < 1e-8):
excl += [pbs8, pfs8]
F, lbls = rf.combined_fisher_matrix([
F,
],
expand=[],
names=lbls,
exclude=excl)
cov = np.linalg.inv(F)
errs = np.sqrt(np.diag(cov))
# Identify scale-dependent functions
for j in range(2):
l = labels[k] if j == 1 else None
try:
pfs8 = rf.indices_for_param_names(lbls, 'k%dfs8*' % j)
pbs8 = rf.indices_for_param_names(lbls, 'k%dbs8*' % j)
# Plot errors as fn. of redshift
err = errs[pfs8] / (cosmo['sigma_8'] * fc * Dc)
if 'Euclid' in labels[k]:
idxs = np.where(np.logical_and(zc >= 1.1, zc <= 1.9))
zc = zc[idxs]
err = err[idxs]
P.plot(zc,
err,
color=colours[j],
lw=lws[j],
alpha=alphas[j],
np.genfromtxt(root + "-fisher-full-%d.dat" % i) for i in range(Nbins)
]
# EOS FISHER MATRIX
pnames = rf.load_param_names(root + "-fisher-full-0.dat")
zfns = ['A', 'bs8', 'fs8', 'DA', 'H', 'aperp', 'apar']
excl = [
'Tb', 'sigma8', 'n_s', 'omegak', 'omegaDE', 'w0', 'wa', 'h', 'gamma',
'N_eff', 'pk*', 'f', 'b_HI'
]
F, lbls = rf.combined_fisher_matrix(F_list,
expand=zfns,
names=pnames,
exclude=excl)
# Get indices of f, b_HI
pf = rf.indices_for_param_names(lbls, 'fs8*')
pb = rf.indices_for_param_names(lbls, 'bs8*')
for jj in pf:
print jj, lbls[jj]
print "-" * 50
print names[k]
print "-" * 50
# Invert matrix
cov_pl = np.linalg.inv(F)
for jj in range(pf.size):
#if jj % 2 == 0: continue
pnames = rf.load_param_names(root + "-fisher-full-0.dat")
zfns = ['A', 'bs8', 'fs8', 'H', 'DA', 'aperp', 'apar']
excl = [
'Tb', 'n_s', 'sigma8', 'omegak', 'omegaDE', 'w0', 'wa', 'h', 'gamma',
'N_eff', 'pk*', 'f', 'b_HI'
]
F, lbls = rf.combined_fisher_matrix(F_list,
expand=zfns,
names=pnames,
exclude=excl)
cov = np.linalg.inv(F)
errs = np.sqrt(np.diag(cov))
# Identify functions of z
# Identify functions of z
pA = rf.indices_for_param_names(lbls, 'A*')
pDA = rf.indices_for_param_names(lbls, 'DA*')
pH = rf.indices_for_param_names(lbls, 'H*')
pf = rf.indices_for_param_names(lbls, 'fs8*')
#pf = rf.indices_for_param_names(lbls, 'f*')
indexes = [pf, pDA, pH]
fn_vals = [cosmo['sigma_8'] * fc * Dc, dAc / 1e3, Hc / 1e2]
# Plot errors as fn. of redshift
for jj in range(len(axes)):
err = errs[indexes[jj]] / fn_vals[jj]
line = axes[jj].plot(zc,
err,
color=colours[k],
lw=1.8,
# Load cosmo fns.
dat = np.atleast_2d(np.genfromtxt(root + "-cosmofns-zc.dat")).T
zc, Hc, dAc, Dc, fc = dat
z, H, dA, D, f = np.genfromtxt(root + "-cosmofns-smooth.dat").T
kc = np.genfromtxt(root + "-fisher-kc.dat").T
# Load Fisher matrices as fn. of z
Nbins = zc.size
F_list = [
np.genfromtxt(root + "-fisher-full-%d.dat" % i) for i in range(Nbins)
]
# EOS FISHER MATRIX
# Actually, (aperp, apar) are (D_A, H)
pnames = rf.load_param_names(root + "-fisher-full-0.dat")
ppk = rf.indices_for_param_names(pnames, 'pk*')
cmap = matplotlib.cm.Blues_r
for j in range(len(F_list))[::-1]:
F = F_list[j]
# Just do the simplest thing for P(k) and get 1/sqrt(F)
cov = np.sqrt(1. / np.diag(F)[ppk])
pk = cosmo['pk_nobao'](kc) * (1. + fbao(kc))
# Replace nan/inf values
cov[np.where(np.isnan(cov))] = 1e10
cov[np.where(np.isinf(cov))] = 1e10
# Line with fading colour
col = cmap(0.8 * j / len(F_list))
excl = ['Tb', 'n_s', 'sigma8', 'omegak', 'omegaDE', 'w0', 'wa', 'h',
'gamma', 'N_eff', 'pk*', 'f', 'b_HI',
'gamma0', 'gamma1', 'eta0', 'eta1', 'A_xi', 'logkmg',
'sigma8tot', 'sigma_8', 'k*']
# Marginalising over b_1
F, lbls = rf.combined_fisher_matrix( F_list,
expand=zfns, names=pnames,
exclude=excl )
print lbls
cov = np.linalg.inv(F)
errs = np.sqrt(np.diag(cov))
# Identify functions of z
#errDA = 1e3 * errs[pDA] / dAc
pH = rf.indices_for_param_names(lbls, 'H*')
errH = 1e2 * errs[pH] / Hc
# Plot errors as fn. of redshift
if labels[k] is not None:
P.plot( zc, errH, color=colours[k], label=labels[k], lw=2.8,
marker=marker[k], markersize=ms[k], markeredgecolor=colours[k] )
else:
P.plot( zc, errH, color=colours[k], label=labels[k], lw=2.8,
marker=marker[k], markersize=ms[k], markeredgecolor=colours[k],
dashes=[4,3] )
P.tick_params(axis='both', which='major', labelsize=20, width=1.5, size=8., pad=10)
P.tick_params(axis='both', which='minor', labelsize=20, width=1.5, size=5.)
# Set axis limits
