def test_power_sigma8norm_norms_consistent(tf):
# make a cosmo with A_s
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.045,
h=0.67,
A_s=2e-9,
n_s=0.96,
transfer_function=tf)
sigma8 = ccl.sigma8(cosmo)
# remake same but now give sigma8
cosmo_s8 = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.045,
h=0.67,
sigma8=sigma8,
n_s=0.96,
transfer_function=tf)
# make sure they come out the same-ish
assert np.allclose(ccl.sigma8(cosmo), ccl.sigma8(cosmo_s8))
# and that the power spectra look right
a = 0.8
gfac = (ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_s8, a))**2
pk_rat = (ccl.linear_matter_power(cosmo, 1e-4, a) /
ccl.linear_matter_power(cosmo_s8, 1e-4, a))
assert np.allclose(pk_rat, gfac)
def __init__(self, config):
"""
config - dict
{'dtype': 'galaxy_density',
'seed': None,
'nside': ***,
'fsky': 0.2,
'cosmo': {
'Omega_c': 0.2640,
'Omega_b': 0.0493,
'h': 0.6736,
'n_s': 0.9649,
'sigma8': 0.8111,
'w0': -1,
'wa': 0,
'transfer_function': 'boltzmann_camb',
'baryons_power_spectrum': 'nobaryons'
}
'zbin': 0,
'width': 0.5,
}
"""
self._get_defaults(config)
self.seed = self.config.get('seed', None)
self.fsky = self.config.get('fsky', 0.2)
cosmo = {
# Planck 2018: Table 2 of 1807.06209
# Omega_m: 0.3133
'Omega_c': 0.2640,
'Omega_b': 0.0493,
'h': 0.6736,
'n_s': 0.9649,
'sigma8': 0.8111,
'w0': -1,
'wa': 0,
'transfer_function': 'boltzmann_camb',
'baryons_power_spectrum': 'nobaryons',
}
self.cosmo_pars = self.config.get('cosmo', cosmo)
self.noise_level = self.config.get('noise_level', 0)
self.cosmo = ccl.Cosmology(**self.cosmo_pars)
ccl.sigma8(self.cosmo)
self.dtype = self.config.get('dtype', 'galaxy_density')
self._check_dtype()
self.spin = self._get_spin_from_dtype(self.dtype)
self.nmaps = 1
if self.spin:
self.nmaps = 2
self.custom_auto = self.config.get('custom_auto', False)
self.custom_offset = self.config.get('custom_offset', 0.)
self.signal_map = None
self.cl_coupled = None
self.cls_cov = None
self.nl_coupled = None
self.mask = None
self.dndz = None
self.cl = None
self.dec0 = self.config.get('dec0', 0.)
self.ra0 = self.config.get('ra0', 0.)
self.aposize = self.config.get('aposize', 1.)
def compute_cls(oc,ob,h,s8,ns,w,fname_out=False) :
#Fiducial cosmological parameters
cosmo=ccl.Cosmology(Omega_c=oc,Omega_b=ob,h=h,sigma8=s8,n_s=ns,w0=w,
transfer_function='eisenstein_hu')
print ccl.sigma8(cosmo)
#Tracers
tracers=[]
for i in np.arange(nbins) :
print i
# tracers.append(ccl.ClTracer(cosmo,tracer_type='nc',z=zarr,n=nz_bins[i],bias=bzarr))
tracers.append(ccl.ClTracer(cosmo,tracer_type='wl',z=zarr,n=nz_bins[i]))#,bias=bzarr))
#Power spectra
c_ij=np.zeros([LMAX+1,nbins,nbins])
for i1 in np.arange(nbins) :
for i2 in np.arange(i1,nbins) :
print i1,i2
if xcorr[i1,i2]<-1:#1E-6 :
c_ij[:,i1,i2]=0
else :
c_ij[:,i1,i2]=ccl.angular_cl(cosmo,tracers[i1],tracers[i2],np.arange(LMAX+1))#,l_limber=100)
if i1!=i2 :
c_ij[:,i2,i1]=c_ij[:,i1,i2]
if fname_out!=False :
np.save(fname_out,c_ij)
return c_ij
def test_camb_class_consistent_smoke(kwargs=None, pkerr=1e-3):
kwargs = kwargs or {}
print('kwargs:', kwargs)
c_camb = ccl.Cosmology(Omega_c=0.25,
Omega_b=0.05,
h=0.7,
n_s=0.95,
A_s=2e-9,
transfer_function='boltzmann_camb',
**kwargs)
c_class = ccl.Cosmology(Omega_c=0.25,
Omega_b=0.05,
h=0.7,
n_s=0.95,
A_s=2e-9,
transfer_function='boltzmann_class',
**kwargs)
rel_sigma8 = np.abs(ccl.sigma8(c_camb) / ccl.sigma8(c_class) - 1)
a = 0.845
k = np.logspace(-3, 1, 100)
pk_camb = ccl.linear_matter_power(c_camb, k, a)
pk_class = ccl.linear_matter_power(c_class, k, a)
rel_pk = np.max(np.abs(pk_camb / pk_class - 1))
print('rel err pk:', rel_pk)
print('rel err sigma8:', rel_sigma8)
assert rel_sigma8 < 3e-3
assert rel_pk < pkerr
def plot_model(ax, CBase, C, fmt, name):
zar = np.linspace(0, 2.5, 100)
aar = 1 / (1 + zar)
f = ccl.growth_rate(C, aar)
s8 = ccl.sigma8(C) * ccl.growth_factor(C, aar)
f0 = ccl.growth_rate(CBase, aar)
s80 = ccl.sigma8(CBase) * ccl.growth_factor(CBase, aar)
ax.plot(zar, (f * s8) / (f0 * s80), fmt, label=name)
return interp1d(zar, (s80 * f0))
def test_cosmo_methods():
""" Check that all pyccl functions that take cosmo
as their first argument are methods of the Cosmology object.
"""
from inspect import getmembers, isfunction, signature
from pyccl import background, bcm, boltzmann, \
cls, correlations, covariances, neutrinos, \
pk2d, power, tk3d, tracers, halos, nl_pt
from pyccl.core import CosmologyVanillaLCDM
cosmo = CosmologyVanillaLCDM()
subs = [
background, boltzmann, bcm, cls, correlations, covariances, neutrinos,
pk2d, power, tk3d, tracers, halos, nl_pt
]
funcs = [getmembers(sub, isfunction) for sub in subs]
funcs = [func for sub in funcs for func in sub]
for name, func in funcs:
pars = signature(func).parameters
if list(pars)[0] == "cosmo":
_ = getattr(cosmo, name)
# quantitative
assert ccl.sigma8(cosmo) == cosmo.sigma8()
assert ccl.rho_x(cosmo, 1., "matter", is_comoving=False) == \
cosmo.rho_x(1., "matter", is_comoving=False)
assert ccl.get_camb_pk_lin(cosmo).eval(1., 1., cosmo) == \
cosmo.get_camb_pk_lin().eval(1., 1., cosmo)
prof = ccl.halos.HaloProfilePressureGNFW()
hmd = ccl.halos.MassDef200m()
hmf = ccl.halos.MassFuncTinker08(cosmo)
hbf = ccl.halos.HaloBiasTinker10(cosmo)
hmc = ccl.halos.HMCalculator(cosmo, massfunc=hmf, hbias=hbf, mass_def=hmd)
assert ccl.halos.halomod_power_spectrum(cosmo, hmc, 1., 1., prof) == \
cosmo.halomod_power_spectrum(hmc, 1., 1., prof)
def S8z(mcmc, a, MG=False, size=None):
p = mcmc.getParams()
if size is None:
size = p.A_s.size
S8_ar = np.zeros((size, a.size))
for i in range(size):
cosmo = ccl.Cosmology(h=p.h[i],
Omega_c=p.Omega_c[i],
Omega_b=p.Omega_b[i],
A_s=1e-9 * p.A_s[i],
n_s=p.n_s[i],
w0=-1,
wa=0,
transfer_function='boltzmann_class')
# Compute everything
sigma8 = ccl.sigma8(cosmo)
Dz = ccl.background.growth_factor(cosmo, a)
Om = ccl.background.omega_x(cosmo, 1, 'matter')
if MG:
d1 = p.dpk1[i]
else:
d1 = 0
S8_ar[i] = (1 + d1 * (1 - a)) * Dz * sigma8 * (Om / 0.3)**0.5
return S8_ar
def test_power_mu_sigma_sigma8norm(tf):
cosmo = ccl.Cosmology(
Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96,
transfer_function=tf)
cosmo_musig = ccl.Cosmology(
Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96,
transfer_function=tf, mu_0=0.1, sigma_0=0.2)
# make sure sigma8 is correct
assert np.allclose(ccl.sigma8(cosmo_musig), 0.8)
if tf != 'boltzmann_isitgr':
# make sure P(k) ratio is right
a = 0.8
gfac = (
ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_musig, a))**2
pk_rat = (
ccl.linear_matter_power(cosmo, 1e-4, a) /
ccl.linear_matter_power(cosmo_musig, 1e-4, a))
assert np.allclose(pk_rat, gfac)
with mock.patch.dict(sys.modules, {'isitgr': None}):
with assert_raises(ImportError):
get_isitgr_pk_lin(cosmo)
# Importing ccl without isitgr is fine. No ImportError triggered.
with mock.patch.dict(sys.modules, {'isitgr': None}):
reload(ccl.boltzmann)
def main():
# zmins, zmaxs, fs8s, fs8errs =
fig, ax = plt.subplots(figsize=(10, 3))
tc = thincandy.ThinCandy()
basefs8 = plot_model(ax, tc.CBase, tc.CBase, "k:", "$\Lambda$CDM")
if True:
tc.getModels()
plot_model(ax, tc.CBase, tc.Copen, "r--", "o$\Lambda$CDM")
plot_model(ax, tc.CBase, tc.Cw, "g-.", "wCDM")
plot_model(ax, tc.CBase, tc.Cmnu, "b-", "$\\nu$CDM")
# plot_model(ax,tc.CBase,tc.Cmnuless, 'b:', "massles $\\nu$CDM")
EdSP = tc.CBaseP
EdSP["Omega_c"] = 1 - EdSP["Omega_b"]
EdSP["sigma8"] = ccl.sigma8(tc.CBase)
del EdSP["A_s"]
plot_model(ax, tc.CBase, ccl.Cosmology(**EdSP), "m:", "EdS CDM")
for zmin, zmax, fs8, fs8err in np.loadtxt("data/fs8.txt",
usecols=(1, 2, 3, 4)):
print(zmin, zmax, fs8, fs8err, 0.5 * (zmin + zmax))
zeff = 0.5 * (zmin + zmax)
fs8 /= basefs8(zeff)
fs8err /= basefs8(zeff)
#ax.errorbar(
# zeff, fs8, yerr=fs8err, xerr=(zmax - zmin) / 2, fmt="-", color="k", lw=1
#)
ax.errorbar(zeff, fs8, yerr=fs8err, fmt="o-", color="k", lw=2)
#ax.errorbar(zeff, fs8, yerr=fs8err, fmt="o", color="k", lw=2)
# for zmin,zmax,val,errplus, errmin in np.loadtxt('data/wl.txt',usecols=(1,2,3,4,5)):
# ## value is (Om/0.3)^1/2*sigma8
# baseval = np.sqrt(tc.CBase['Omega_m']/0.3)*ccl.sigma8(tc.CBase)
# print (val,baseval,errplus)
# zeff = np.sqrt((1+zmin)*(1+zmax))-1
# fs8eff = (ccl.growth_rate(tc.CBase,1/(1+zeff))*
# ccl.sigma8(tc.CBase)*ccl.growth_factor(tc.CBase,1/(1+zeff)) )
# fact = fs8eff/baseval
# val*=fact
# errplus*=fact
# errmin*=fact
# ax.errorbar(zeff,val, yerr=([errmin],[errplus]),
# xerr=([zeff-zmin],[zmax-zeff]),fmt='c',lw=1)
# ax.errorbar(zeff,val, yerr=([errmin],[errplus]),fmt='oc',lw=2)
# #ax.add_patch(Rectangle((zmin,val-errmin), zmax-zmin, errmin+errplus,color='blue',alpha=0.5))
ax.set_xlim(0, 2.5)
ax.set_xlabel("$z$", fontsize=14)
ax.set_ylim(0.4, 1.6)
ax.set_ylabel("$f\,\sigma_8 / [f\,\sigma_8]_{\\rmfid}$", fontsize=14)
plt.legend(fontsize=12, ncol=5, frameon=False, loc="upper center")
plt.tight_layout()
plt.savefig("output/thincandy_gr.pdf")
plt.show()
def get_sigma_8(var):
#Get cosmological parameters
var_tot = get_cosmo(var)
#Cosmology
cosmo = ccl.Cosmology(h=var_tot[0],
Omega_c=var_tot[1] / var_tot[0]**2.,
Omega_b=var_tot[2] / var_tot[0]**2.,
A_s=(10.**(-10.)) * np.exp(var_tot[3]),
n_s=var_tot[4])
sigma8 = ccl.sigma8(cosmo)
return sigma8
def compute_cls(oc,ob,h,s8,ns,w,nbins,zarr,nz_bins,lmax,fname_out=False) :
cosmo=ccl.Cosmology(Omega_c=oc,Omega_b=ob,h=h,sigma8=s8,n_s=ns,w0=w)#,transfer_function='eisenstein_hu')
print ccl.sigma8(cosmo)
#Tracers
tracers=[]
for i in np.arange(nbins) :
tracers.append(ccl.ClTracer(cosmo,tracer_type='wl',z=zarr,n=nz_bins[i]))
#Power spectra
c_ij=np.zeros([lmax+1,nbins,nbins])
for i1 in np.arange(nbins) :
print i1
for i2 in np.arange(i1,nbins) :
c_ij[:,i1,i2]=ccl.angular_cl(cosmo,tracers[i1],tracers[i2],np.arange(lmax+1))#,l_limber=100)
if i1!=i2 :
c_ij[:,i2,i1]=c_ij[:,i1,i2]
if fname_out!=False :
np.save(fname_out,c_ij)
return c_ij
def test_camb_class_consistent_smoke(kwargs=None, pkerr=1e-3):
kwargs = kwargs or {}
print('kwargs:', kwargs)
c_camb = ccl.Cosmology(Omega_c=0.25,
Omega_b=0.05,
h=0.7,
n_s=0.95,
A_s=2e-9,
transfer_function='boltzmann_camb',
**kwargs)
c_class = ccl.Cosmology(Omega_c=0.25,
Omega_b=0.05,
h=0.7,
n_s=0.95,
A_s=2e-9,
transfer_function='boltzmann_class',
**kwargs)
with warnings.catch_warnings():
# We do some tests here with massive neutrinos, which currently raises
# a warning.
# XXX: Do you really want to be raising a warning for this?
# This seems spurious to me. (MJ)
warnings.simplefilter("ignore")
rel_sigma8 = np.abs(ccl.sigma8(c_camb) / ccl.sigma8(c_class) - 1)
a = 0.845
k = np.logspace(-3, 1, 100)
pk_camb = ccl.linear_matter_power(c_camb, k, a)
pk_class = ccl.linear_matter_power(c_class, k, a)
rel_pk = np.max(np.abs(pk_camb / pk_class - 1))
print('rel err pk:', rel_pk)
print('rel err sigma8:', rel_sigma8)
assert rel_sigma8 < 3e-3
assert rel_pk < pkerr
def calculate(self, state, want_derived=True, **params_values_dict):
# Get background from upstream
distance = self.provider.get_comoving_radial_distance(self.z_bg)
hubble_z = self.provider.get_Hubble(self.z_bg)
H0 = hubble_z[0]
E_of_z = hubble_z / H0
distance = np.flip(distance)
E_of_z = np.flip(E_of_z)
# Translate into CCL parameters
h = H0 * 0.01
Omega_c = self.provider.get_param('omch2') / h**2
Omega_b = self.provider.get_param('ombh2') / h**2
# Generate cosmology and populate background
a = 1. / (1 + self.z_bg[::-1])
cosmo = ccl.Cosmology(Omega_c=Omega_c,
Omega_b=Omega_b,
h=h,
n_s=self.provider.get_param('ns'),
A_s=self.provider.get_param('As'),
T_CMB=2.7255,
m_nu=self.provider.get_param('mnu'),
transfer_function=self.transfer_function,
matter_power_spectrum=self.matter_pk,
baryons_power_spectrum=self.baryons_pk)
cosmo._set_background_from_arrays(a_array=a,
chi_array=distance,
hoh0_array=E_of_z)
# Populate P(k)
if self.kmax:
for pair in self._var_pairs:
k, z, Pk_lin = self.provider.get_Pk_grid(var_pair=pair,
nonlinear=False)
Pk_lin = np.flip(Pk_lin, axis=0)
a = 1. / (1 + np.flip(z))
cosmo._set_linear_power_from_arrays(a, k, Pk_lin)
if self.external_nonlin_pk:
k, z, Pk_nl = self.provider.get_Pk_grid(var_pair=pair,
nonlinear=True)
Pk_nl = np.flip(Pk_nl, axis=0)
a = 1. / (1 + np.flip(z))
cosmo._set_nonlin_power_from_arrays(a, k, Pk_nl)
state['CCL'] = {'cosmo': cosmo}
# Compute sigma8 (we should actually only do this if required -- TODO)
state['sigma8'] = ccl.sigma8(cosmo)
for req_res, method in self._required_results.items():
state['CCL'][req_res] = method(cosmo)
def check_power(cosmo):
"""
Check that power spectrum and sigma functions can be run.
"""
# Types of scale factor
a = 0.9
a_arr = np.linspace(0.2, 1., 5)
# Types of wavenumber input (scalar, list, array)
k_scl = 1e-1
k_lst = [1e-4, 1e-3, 1e-2, 1e-1, 1e0]
k_arr = np.logspace(-4., 0., 5)
# Types of smoothing scale, R
R_scl = 8.
R_lst = [1., 5., 10., 20., 50., 100.]
R_arr = np.array([1., 5., 10., 20., 50., 100.])
# linear_matter_power
assert_(all_finite(ccl.linear_matter_power(cosmo, k_scl, a)))
assert_(all_finite(ccl.linear_matter_power(cosmo, k_lst, a)))
assert_(all_finite(ccl.linear_matter_power(cosmo, k_arr, a)))
assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_scl, a_arr)
assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_lst, a_arr)
assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_arr, a_arr)
# nonlin_matter_power
assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_scl, a)))
assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_lst, a)))
assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_arr, a)))
assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_scl, a_arr)
assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_lst, a_arr)
assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_arr, a_arr)
# sigmaR
assert_(all_finite(ccl.sigmaR(cosmo, R_scl)))
assert_(all_finite(ccl.sigmaR(cosmo, R_lst)))
assert_(all_finite(ccl.sigmaR(cosmo, R_arr)))
# sigmaV
assert_(all_finite(ccl.sigmaV(cosmo, R_scl)))
assert_(all_finite(ccl.sigmaV(cosmo, R_lst)))
assert_(all_finite(ccl.sigmaV(cosmo, R_arr)))
# sigma8
assert_(all_finite(ccl.sigma8(cosmo)))
def calculate(self, state, want_derived=True, **params_values_dict):
# Generate the CCL cosmology object which can then be used downstream
cosmo = ccl.Cosmology(Omega_c=self.provider.get_param('Omega_c'),
Omega_b=self.provider.get_param('Omega_b'),
h=self.provider.get_param('h'),
n_s=self.provider.get_param('n_s'),
A_s=self.provider.get_param('A_sE9') * 1E-9,
T_CMB=2.7255,
m_nu=self.provider.get_param('m_nu'),
transfer_function=self.transfer_function,
matter_power_spectrum=self.matter_pk,
baryons_power_spectrum=self.baryons_pk)
state['CCL'] = {'cosmo': cosmo}
# Compute sigma8 (we should actually only do this if required -- TODO)
state['sigma8'] = ccl.sigma8(cosmo)
for req_res, method in self._required_results.items():
state['CCL'][req_res] = method(cosmo)
def test_power_mu_sigma_sigma8norm(tf):
cosmo = ccl.Cosmology(
Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96,
transfer_function=tf)
cosmo_musig = ccl.Cosmology(
Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96,
transfer_function=tf, mu_0=0.1, sigma_0=0.2)
# make sure sigma8 is correct
assert np.allclose(ccl.sigma8(cosmo_musig), 0.8)
# make sure P(k) ratio is right
a = 0.8
gfac = (
ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_musig, a))**2
pk_rat = (
ccl.linear_matter_power(cosmo, 1e-4, a) /
ccl.linear_matter_power(cosmo_musig, 1e-4, a))
assert np.allclose(pk_rat, gfac)
import pyccl as ccl
cosmo = ccl.Cosmology(
Omega_c=0.25,
Omega_b=0.05,
h=0.7,
n_s=0.95,
A_s=2.1e-9,
transfer_function="boltzmann_camb",
)
print("sigma8:", ccl.sigma8(cosmo))
assert ccl.sigma8(cosmo) > 0.82 and ccl.sigma8(cosmo) < 0.825
def fs8(self, C):
fs8 = ccl.growth_rate(C, self.aar) * ccl.sigma8(C)
fs80 = ccl.growth_rate(self.CBase, self.aar) * ccl.sigma8(self.CBase)
return fs8 / fs80
def calculate(self, state, want_derived=True, **params_values_dict):
# Get background from upstream
distance = self.provider.get_comoving_radial_distance(self.z_bg)
hubble_z = self.provider.get_Hubble(self.z_bg)
H0 = hubble_z[0]
E_of_z = hubble_z / H0
distance = np.flip(distance)
E_of_z = np.flip(E_of_z)
# Translate into CCL parameters
h = H0 * 0.01
Omega_c = self.provider.get_param('omch2') / h**2
Omega_b = self.provider.get_param('ombh2') / h**2
# Generate cosmology and populate background
a_bg = 1. / (1 + self.z_bg[::-1])
if self.kmax:
pkln = {}
if self.external_nonlin_pk:
pknl = {}
for pair in self._var_pairs:
name = self._translate_camb(pair)
k, z, Pk_lin = self.provider.get_Pk_grid(var_pair=pair,
nonlinear=False)
Pk_lin = np.flip(Pk_lin, axis=0)
a = 1. / (1 + np.flip(z))
pkln[name] = Pk_lin
pkln['a'] = a
pkln['k'] = k
if self.external_nonlin_pk:
k, z, Pk_nl = self.provider.get_Pk_grid(var_pair=pair,
nonlinear=True)
Pk_nl = np.flip(Pk_nl, axis=0)
a = 1. / (1 + np.flip(z))
pknl[name] = Pk_nl
pknl['a'] = a
pknl['k'] = k
cosmo = ccl.CosmologyCalculator(
Omega_c=Omega_c,
Omega_b=Omega_b,
h=h,
n_s=self.provider.get_param('ns'),
A_s=self.provider.get_param('As'),
T_CMB=2.7255,
m_nu=self.provider.get_param('mnu'),
background={
'a': a_bg,
'chi': distance,
'h_over_h0': E_of_z
},
pk_linear=pkln,
pk_nonlin=pknl)
else:
cosmo = ccl.CosmologyCalculator(
Omega_c=Omega_c,
Omega_b=Omega_b,
h=h,
n_s=self.provider.get_param('ns'),
A_s=self.provider.get_param('As'),
T_CMB=2.7255,
m_nu=self.provider.get_param('mnu'),
background={
'a': a_bg,
'chi': distance,
'h_over_h0': E_of_z
})
state['CCL'] = {'cosmo': cosmo}
# Compute sigma8 (we should actually only do this if required -- TODO)
state['sigma8'] = ccl.sigma8(cosmo)
for req_res, method in self._required_results.items():
state['CCL'][req_res] = method(cosmo)
def bgplot(self):
print(ccl.sigma8(self.CBase), self.rd(self.CBase))
print("getting open")
# [(aiso,'isotropic BAO'), (aperp, 'transverse BAO'), (apar,
#'radial BAO'), (sn, 'SN distance '), (fs8, 'fsigma8'),
# (shearshear, 'WL shear auto')]):
self.getModels()
f, axl = plt.subplots(
3,
2,
facecolor="w",
gridspec_kw={
"width_ratios": (3, 1),
"hspace": 0.0,
"wspace": 0.05
},
figsize=(10, 6),
)
print(axl) # [(self.aiso,'BAO $\\bigcirc$'),
for i, ((fun, name), (axl, axr)) in enumerate(
zip(
[
(self.aperp, "BAO $\perp$"),
(self.apar, "BAO $\parallel$"),
(self.sn, "SN"),
],
axl,
)):
for model, label, style in [
(self.CBase, "LCDM", "k:"),
(self.Copen, "OLCDM", "r--"),
(self.Cw, "wCDM", "g-."),
(self.Cmnu, "$\\nu$CDM", "b-"),
]:
vals = fun(model)
axl.plot(self.zar[:self.Nl],
vals[:self.Nl],
style,
label=label)
axr.plot(self.zar[-self.Nr:], vals[-self.Nr:], style)
if "perp" in name:
for zb, iso, isoe, perp, perpe, par, pare in self.baodata:
axr.errorbar(1150, 1, yerr=0.000605211, fmt="ko")
if perp > 0:
norm = ccl.comoving_angular_distance(
self.CBase, 1 / (1 + zb)) / self.rd(self.CBase)
# print (zb,norm,perp,perpe,perp/norm,perpe/norm)
axl.errorbar(zb,
perp / norm,
yerr=perpe / norm,
fmt="ko")
if iso > 0:
print(self.rd(self.CBase))
normperp = ccl.comoving_angular_distance(
self.CBase, 1 / (1 + zb)) / self.rd(self.CBase)
normpar = 299792.45 / (ccl.h_over_h0(
self.CBase, 1 /
(1 + zb)) * self.CBase["H0"] * self.rd(self.CBase))
norm = (zb * normpar)**(1 / 3) * normperp**(2 / 3)
axl.errorbar(zb,
iso / norm,
yerr=isoe / norm,
fmt="ko")
elif "par" in name:
for zb, iso, isoe, perp, perpe, par, pare in self.baodata:
if par > 0:
norm = 299792.45 / (ccl.h_over_h0(
self.CBase, 1 /
(1 + zb)) * self.CBase["H0"] * self.rd(self.CBase))
# print (zb,norm,par,pare,par/norm,pare/norm)
axl.errorbar(zb,
par / norm,
yerr=pare / norm,
fmt="ko")
elif "SN" in name:
axl.errorbar(self.snz, self.snval, yerr=self.snerr, fmt="ko")
if i == 1:
axl.legend(fontsize=12,
ncol=2,
frameon=False,
loc="lower center")
axl.set_ylabel(name, fontsize=14)
axl.spines["right"].set_visible(False)
axr.spines["left"].set_visible(False)
# axl.yaxis.tick_left()
# axl.tick_params(labelright='off')
axl.tick_params(axis="x", direction="inout", length=5)
axr.tick_params(axis="x", direction="inout", length=5)
axl.patch.set_alpha(0.0)
axr.patch.set_alpha(0.0)
axl.set_xlim(0.0, 3.1)
axr.set_xlim(1100, 1200)
axr.set_xticks([1120, 1200])
if i < 2:
axl.set_ylim(0.85, 1.15)
axl.set_yticks([0.90, 1.0, 1.1])
else:
axl.set_ylim(0.8, 1.2)
axl.set_yticks([0.9, 1.0, 1.1])
if i == 0:
axr.set_ylim(0.995, 1.005)
axr.set_yticks([0.997, 1.0, 1.003])
elif i == 1:
axr.set_ylim(0.995, 1.005)
axr.set_yticks([0.997, 1.0, 1.003])
elif i == 2:
axr.set_ylim(0.8, 1.2)
axr.set_yticks([0.9, 1.0, 1.1])
if i < 2:
for l in axl.get_xticklabels():
l.set_visible(False)
for l in axr.get_xticklabels():
l.set_visible(False)
for l in axr.get_yticklabels():
l.set_visible(False)
axr.get_yaxis().tick_right() # set_visible(False)
d = 0.05
kwargs = dict(transform=axl.transAxes, color="k", clip_on=False)
axl.plot((1 - d / 5, 1 + d / 5), (-d, +d), **kwargs)
axl.plot((1 - d / 5, 1 + d / 5), (1 - d, 1 + d), **kwargs)
kwargs = dict(transform=axr.transAxes, color="k", clip_on=False)
axr.plot((-d * 3 / 5, +d * 3 / 5), (-d, +d), **kwargs)
axr.plot((-d * 3 / 5, +d * 3 / 5), (1 - d, 1 + d), **kwargs)
if i == 2:
axl.set_xlabel("$z$", fontsize=14)
# plt.tight_layout()
plt.savefig(f"output/thincandy_bg.pdf")
plt.show()
plt.loglog(k, Pk_nonlin, 'g', linewidth=2, label='Non-linear (halofit)')
plt.loglog(k, Pk_baryon, 'm', linewidth=2, linestyle=':', label='With baryonic correction')
plt.loglog(k, Pk_emu, 'b', linewidth=2, linestyle = '--', label='CosmicEmu')
plt.xlabel('$k, \\frac{1}{\\rm Mpc}$', fontsize=20)
plt.ylabel('$P(k), {\\rm Mpc^3}$', fontsize=20)
plt.xlim(0.001, 50)
plt.ylim(0.01, 10**6)
plt.tick_params(labelsize=13)
plt.legend(loc='lower left')
plt.show()
plt.close()
R = np.linspace(5, 20, 15)
sigmaR = ccl.sigmaR(cosmo, R)
sigma8 = ccl.sigma8(cosmo)
print("sigma8 =", sigma8)
# ###############
# Can also compute C_ell for galaxy counts, galaxy lensing and CMB lensing
# for autocorrelations or any cross-correlation
z_pz = np.linspace(0.3, 3., 3) # Define the edges of the photo-z bins.
# array([0.3 , 1.65, 3. ]) AKA 2 bins
pz = ccl.PhotoZGaussian(sigma_z0=0.05)
def dndz(z,args) :
return z**2*np.exp(-(z/0.5)**1.5)
redshift_dist=ccl.dNdzFunction(dndz)
#Calculate the matter power spectrum
k = np.logspace(-4., 1., 100) #Wavenumber
a = 1. #Scale factor
#Matter power spectrum, lin and nonlin
pk_lin = np.asarray(ccl.linear_matter_power(cosmo, k, a))
pk_nl = np.asarray(ccl.nonlin_matter_power(cosmo, k, a))
plt.plot(k, pk_lin, 'b-')
plt.plot(k, pk_nl, 'r-')
plt.xscale('log')
plt.yscale('log')
plt.savefig('power_spectrum.png', format='png')
#Transforms these to lists
k = k.tolist()
pk_lin = pk_lin.tolist()
pk_nl = pk_nl.tolist()
#Adds a header line
k = ['k'] + k
pk_lin =['pk lin'] + pk_lin
pk_nl = ['pk_nl'] + pk_nl
np.savetxt('power_spec.dat', np.transpose([k, pk_lin, pk_nl]), fmt='%-20s')
#Get the power spectrum normalization, sigma_8
normal = ccl.sigma8(cosmo)
pdb.set_trace()
def test_sigma8_consistent():
assert np.allclose(ccl.sigma8(COSMO), COSMO['sigma8'])
assert np.allclose(ccl.sigmaR(COSMO, 8 / COSMO['h'], 1), COSMO['sigma8'])
