def get_bao_rs_dV(zs,params=None,engine='camb',de='ppf'):
#FIXME: camb and class only agree at 3% level!!!
import camb
params = map_params(params,engine=engine)
if engine=='camb':
pars = set_camb_pars(params=params,de=de)
results = camb.get_results(pars)
retval = results.get_BAO(zs,pars)[:,0]
elif engine=='class':
from classy import Class
zs = np.asarray(zs)
cosmo = Class()
params['output'] = ''
cosmo.set(params)
cosmo.compute()
Hzs = np.array([cosmo.Hubble(z) for z in zs])
D_As = np.array([cosmo.angular_distance(z) for z in zs])
D_Vs = ((1+zs)**2 * D_As**2 * zs/Hzs)**(1/3.)
retval = cosmo.rs_drag()/D_Vs
cosmo.struct_cleanup()
cosmo.empty()
return retval
# (but not exactly zero because we neglected radiation)
derived = CDM.get_current_derived_parameters(['Omega0_lambda'])
print derived
print "Omega_Lambda =", derived['Omega0_lambda']
# In[ ]:
#Get background quantities and recover their names:
baLCDM = LCDM.get_background()
baCDM = CDM.get_background()
baCDM.viewkeys()
# In[ ]:
#Get H_0 in order to plot the distances in this unit
fLCDM = LCDM.Hubble(0)
fCDM = CDM.Hubble(0)
# In[ ]:
namelist = ['lum. dist.', 'comov. dist.', 'ang.diam.dist.']
colours = ['b', 'g', 'r']
for name in namelist:
idx = namelist.index(name)
plt.loglog(baLCDM['z'], fLCDM * baLCDM[name], colours[idx] + '-')
plt.legend(namelist, loc='upper left')
for name in namelist:
idx = namelist.index(name)
plt.loglog(baCDM['z'], fCDM * baCDM[name], colours[idx] + '--')
plt.xlim([0.07, 10])
plt.ylim([0.08, 20])
print('rd=', rd)
for j in range(len(chunk)):
z = zs[j]
b1 = b1ar[j]
b2 = b2ar[j]
bG2 = bG2ar[j]
css0 = css0ar[j]
css2 = css2ar[j]
Pshot = Pshotar[j]
bGamma3 = bGamma3ar[j]
b4 = b4ar[j]
fz = cosmo.scale_independent_growth_factor_f(z)
da = cosmo.angular_distance(z)
# print('DA=',da)
hz = cosmo.Hubble(z) / kmsMpc
# print('Hz=',hz)
DV = (z * (1 + z)**2 * da**2 / cosmo.Hubble(z))**(1. / 3.)
# print('DV=',DV)
fs8 = cosmo.scale_independent_growth_factor(
z) * cosmo.scale_independent_growth_factor_f(z) * cosmo.sigma8()
# print('fs8=',fs8)
# print('sigma8=',cosmo.sigma8())
print('rd/DV=', rd / DV)
print('rdH=', rd * cosmo.Hubble(z))
print('rd/DA=', rd / da)
P2noW = np.zeros(k_size)
P0noW = np.zeros(k_size)
for i in range(k_size):
kinloop1 = k[i] * h
from classy import Class
cosmo = Class()
cosmo.set({'N_eff': 3.046, 'output': 'tCl'})
print(cosmo.Hubble(0))
bg_t = background['proper time [Gyr]'][::-1] bg_H = background['H [1/Mpc]'][::-1] bg_D = background['gr.fac. D'][::-1] bg_f = background['gr.fac. f'][::-1] bg_z = background['z'][::-1] bg_a = 1. / (1 + bg_z) bg_rho = background['(.)rho_tot'][::-1] bg_p = background['(.)p_tot'][::-1] #Size of arrays of background quantities nz = 1000 zmax = max(1000, z_f * 1.05, z_i * 1.05) zmin = 0 #Curvature parameter K = -cosmo.Omega0_k() * cosmo.Hubble(0)**2 #Compute conformal derivative of the Hubble rate bg_H_prime = -1.5 * (bg_rho + bg_p) * bg_a + K / bg_a bg_H_dot = bg_H_prime / bg_a bg_Hdot_over_H2 = bg_H_dot / bg_H**2 #Normalize the growth factor # z_norm = z_f # D_norm = cosmo.scale_independent_growth_factor(z_norm) # a_norm = 1./(1+z_norm) # bg_D = bg_D/D_norm #Compute central difference derivative of the logarithmic growth rate bg_df_dlogD = np.gradient(bg_f) / np.gradient(np.log(bg_D))
def calculate_derivative_param(params, param_to_test, param_fiducial,
percentage_difference, param_list, der_param,
write_file, i):
cosmo = Class() # Create an instance of the CLASS wrapper
param = np.zeros((N, 3, len(param_list)))
for j in range(3):
# going over a_c and Om_fld values
# if j==0:
# params['Omega_fld_ac'] = Omega_ac_fid[i]
# if j==1:
# params['Omega_fld_ac'] = Omega_ac_fid[i]+percentage_difference*Omega_ac_fid[i]
# if j==2:
# params['Omega_fld_ac'] = Omega_ac_fid[i]-percentage_difference*Omega_ac_fid[i]
if param_to_test == 'scf_parameters':
if j == 0:
params['scf_parameters'] = '%.5f,0.0' % (param_fiducial)
if j == 1:
params['scf_parameters'] = '%.5f,0.0' % (
param_fiducial + percentage_difference * param_fiducial)
if j == 2:
params['scf_parameters'] = '%.5f,0.0' % (
param_fiducial - percentage_difference * param_fiducial)
else:
if j == 0:
params[param_to_test] = param_fiducial
if j == 1:
params[
param_to_test] = param_fiducial + percentage_difference * param_fiducial
if j == 2:
params[
param_to_test] = param_fiducial - percentage_difference * param_fiducial
# if j==0:
# params['Omega_many_fld'] = Omega0_fld
# if j==1:
# params['Omega_many_fld'] = Omega0_fld+percentage_difference*Omega0_fld
# if j==2:
# params['Omega_many_fld'] = Omega0_fld-percentage_difference*Omega0_fld
print params[param_to_test], param_fiducial
# try to solve with a certain cosmology, no worries if it cannot
# l_theta_s = np.pi/(theta_s)
# print "here:",l_theta_s
# try:
cosmo.set(params) # Set the parameters to the cosmological code
cosmo.compute() # solve physics
cl = cosmo.lensed_cl(2500)
ell = cl['ell'][2:]
tt = cl['tt'][2:]
fTT = interp1d(ell, tt * ell * (ell + 1))
for k in range(len(param_list)):
print 'k', k, len(param_list)
#calculate height peak difference
if (param_list[k] == 'HP'):
# param[i][j][k] = max(tt)-fTT(10)
param[i][j][k] = max(tt * ell * (ell + 1))
elif (param_list[k] == 'rs_rec'):
param[i][j][k] = cosmo.rs_rec()
elif (param_list[k] == 'rd_rec'):
param[i][j][k] = cosmo.rd_rec()
elif (param_list[k] == 'rs_rec_over_rd_rec'):
# print cosmo.rs_rec()/cosmo.rd_rec()
param[i][j][k] = cosmo.rs_rec() / cosmo.rd_rec()
elif (param_list[k] == 'da_rec'):
param[i][j][k] = cosmo.da_rec()
elif (param_list[k] == 'theta_s'):
param[i][j][k] = cosmo.theta_s()
elif (param_list[k] == 'H0'):
param[i][j][k] = cosmo.Hubble(0)
print max(tt * ell * (ell + 1)), cosmo.theta_s(), cosmo.da_rec(
), cosmo.rs_rec(), cosmo.z_rec()
# for l in range(len(tt)):
# # print l, tt[l], max(tt*ell*(ell+1))
# if tt[l]*ell[l]*(ell[l]+1) == max(tt*ell*(ell+1)):
# print "l:", l,max(tt*ell*(ell+1))
# except CosmoComputationError: # this happens when CLASS fails
# print CosmoComputationError
# pass # eh, don't do anything
#calculate derivative
# der_HP[i]= (HP[i][1]-HP[i][2])/(Omega_ac_fid[i]+percentage_difference*Omega_ac_fid[i]-(Omega_ac_fid[i]-percentage_difference*Omega_ac_fid[i]))*Omega_ac_fid[0]/HP[i][0]
cosmo.empty()
cosmo.struct_cleanup()
if write_file == True:
f.write(str(ac_values[i]) + '\t\t')
print "calculating derivative"
for k in range(len(param_list)):
# der_HP[i]= (HP[i][1]-HP[i][2])/(fraction_fiducial+percentage_difference*fraction_fiducial-(fraction_fiducial-percentage_difference*fraction_fiducial))*fraction_fiducial/HP[i][0]
der_param[i][k] = (param[i][1][k] - param[i][2][k]) / (
param_fiducial + percentage_difference * param_fiducial -
(param_fiducial - percentage_difference * param_fiducial)
) * param_fiducial / param[i][0][k]
if write_file == True:
f.write(str(der_param[i][k]) + '\t\t') # info on format
print param_list[k], der_param[i][k]
if write_file == True:
f.write('\n')
return
def constraints(params, zs):
cosmo = Class()
cosmo.set(params)
cosmo.compute()
h = cosmo.Hubble(0) * 299792.458
om0 = cosmo.Omega0_m()
#print(cosmo.pars)
zarr2 = cosmo.get_background().get('z')
hz = cosmo.get_background().get('H [1/Mpc]')
hf = interpolate.InterpolatedUnivariateSpline(zarr2[-1:0:-1], hz[-1:0:-1])
chiz = cosmo.get_background().get('comov. dist.')
chif = interpolate.InterpolatedUnivariateSpline(zarr2[-1:0:-1],
chiz[-1:0:-1])
pkz = np.zeros((nk, nz))
pklz2 = np.zeros((nk, nz))
dprime = np.zeros((nk, 1))
zarr = np.linspace(0, zmax, nz)
karr = np.logspace(-3, np.log10(20), nk)
rcollarr = np.zeros(nz)
kcarr = np.zeros(nz)
delz = 0.01
for i in np.arange(nz):
Dz = (cosmo.scale_independent_growth_factor(zarr[i]) /
cosmo.scale_independent_growth_factor(0))
sigz = lambda x: Dz * cosmo.sigma(x, zarr[i]) - 1.192182033080519
if (sigz(1e-5) > 0) & (sigz(10) < 0):
rcollarr[i] = optimize.brentq(sigz, 1e-5, 10)
else:
rcollarr[i] = 0
for j in np.arange(nk):
pkz[j, i] = cosmo.pk(karr[j], zarr[i])
for i in np.arange(nk):
pklz0 = np.log(cosmo.pk(karr[i], zs - delz) / cosmo.pk(karr[i], 0))
pklz1 = np.log(cosmo.pk(karr[i], zs + delz) / cosmo.pk(karr[i], 0))
pklz2[i] = cosmo.pk(karr[i], 0)
dprime[i] = -hf(zs) * np.sqrt(
cosmo.pk(karr[i], zs) / pklz2[i, 0]) * (pklz1 - pklz0) / 4 / delz
#divided by 2 for step size, another for defining D'
w0 = params.get('w0_fld')
wa = params.get('wa_fld')
mt = 5 * np.log10(cosmo.luminosity_distance(zs))
#mt = 5*np.log10(fanal.dlatz(zs, om0, og0, w0, wa))
Rc = (2 * 4.302e-9 * Mc / h**2 / om0)**(1 / 3)
mask = (0 < rcollarr) & (rcollarr < Rc)
kcarr[mask] = 2 * np.pi / rcollarr[mask]
mask = (rcollarr >= Rc)
kcarr[mask] = 2 * np.pi / Rc
#plt.semilogy(zarr, kcarr)
pksmooth = pdf.pkint(karr, zarr, pkz, kcarr)
par2 = {'w0': w0, 'wa': wa, 'Omega_m': om0}
print(par2)
#kmin = conv.kmin(zs, chif, hf)*(-3./2.*hf(0)**2*om0)
kvar = conv.kvar(zs, pksmooth, chif, hf) * (3. / 2. * hf(0)**2 * om0)**2
#sigln = np.log(1+kvar/np.abs(kmin)**2)
#L = pdf.convpdf(kmin, sigln, sig, mfid-mt)
#sigln = np.sqrt(sig**2+(5/np.log(10))**2*kvar)
#L = pdf.gausspdf(sig, mfid-mt)
#lnL = mt/sig
vvar = np.trapz(pklz2[:, 0] * dprime[:, 0]**2,
karr) / 6 / np.pi**2 * (1 -
(1 + zs) / hf(zs) / chif(zs))**2
#var_tot = norm*kvar+sig**2
lnL = -mt**2 / 2
print('Sigmasq = {}, {}, Likelihood = {}'.format(kvar, vvar, lnL))
cosmo.struct_cleanup()
cosmo.empty()
return [mt, kvar, vvar]
#[mt, var_tot]
class classy(SlikPlugin):
"""
Compute the CMB power spectrum with CLASS.
Based on work by: Brent Follin, Teresa Hamill
"""
#{cosmoslik name : class name}
name_mapping = {
'As': 'A_s',
'lmax': 'l_max_scalars',
'mnu': 'm_ncdm',
'Neff': 'N_ncdm',
'ns': 'n_s',
'nt': 'n_t',
'ombh2': 'omega_b',
'omch2': 'omega_cdm',
'omk': 'Omega_k',
'pivot_scalar': 'k_pivot',
'r': 'r',
'tau': 'tau_reio',
'Tcmb': 'T_cmb',
'Yp': 'YHe',
}
def __init__(self, **defaults):
super().__init__()
from classy import Class
self.model = Class()
self.defaults = defaults
def convert_params(self, **params):
"""
Convert from CosmoSlik params to CLASS
"""
params = {self.name_mapping.get(k, k): v for k, v in params.items()}
if 'theta' in params:
params['100*theta_s'] = 100 * params.pop('theta')
params['lensing'] = 'yes' if params.pop('DoLensing', True) else 'no'
return params
def __call__(self,
As=None,
DoLensing=True,
H0=None,
lmax=None,
mnu=None,
Neff=None,
nrun=None,
ns=None,
ombh2=None,
omch2=None,
omk=None,
output='tCl, lCl, pCl',
pivot_scalar=None,
r=None,
tau=None,
Tcmb=2.7255,
theta=None,
w=None,
Yp=None,
nowarn=False,
**kwargs):
if not nowarn and kwargs:
print('Warning: passing unknown parameters to CLASS: ' +
str(kwargs) + ' (set nowarn=True to turn off this message.)')
params = dict(
self.defaults, **{
k: v
for k, v in arguments(include_kwargs=False,
exclude=["nowarn"]).items()
if v is not None
})
self.model.set(self.convert_params(**params))
self.model.compute()
lmax = params['lmax']
ell = arange(lmax + 1)
if params['DoLensing'] == True:
self.cmb_result = {
x: (self.model.lensed_cl(lmax)[x.lower()]) * Tcmb**2 * 1e12 *
ell * (ell + 1) / 2 / pi
for x in ['TT', 'TE', 'EE', 'BB', 'PP', 'TP']
}
else:
self.cmb_result = {
x: (self.model.raw_cl(lmax)[x.lower()]) * Tcmb**2 * 1e12 *
ell * (ell + 1) / 2 / pi
for x in ['TT']
}
self.model.struct_cleanup()
self.model.empty()
return self.cmb_result
def get_bao_observables(self, z):
return {
'H':
self.model.Hubble(z),
'D_A':
self.model.angular_distance(z),
'c':
1.0,
'r_d':
(self.model.get_current_derived_parameters(['rs_rec']))['rs_rec']
}
