Nmodes2D = Pk.Nmodes2D
# 1D Pk
k1D = Pk.k1D
Pk1D = Pk.Pk1D
Nmodes1D = Pk.Nmodes1D
#~ ####################################################################
#~ #### Addition for matter
#~ ####################################################################
d = np.loadtxt('/home/david/codes/class/output/test_pk.dat', skiprows = 4)
e = np.loadtxt('/home/david/codes/class/output/test_pk_nl.dat', skiprows = 4)
kclass = d[:,0]
kpk = d[:,1]
kpk_nl = e[:,1]
f = Class.scale_independent_growth_factor_f(self,z=2.)
f = 0.45
mono = (1 + 2/3.*(f) + 1/5.*(f)**2)
quadru = (4/3.*(f) + 4/7.*(f)**2)
def jen(pk,var1, var2):
if var1 == 'delta' and var2 == 'theta':
alpha0 = -12288.7
alpha1 = 1.43
alpha2 = 1367.7
alpha3 = 1.54
elif var1 == 'theta' and var2 == 'theta':
alpha0 = -12462.1
alpha1 = 0.839
'thetai_scf': 2.78,
'attractor_ic_scf': 'no',
'scf_parameters': '1, 1, 1, 1, 1, 0.0',
'n_scf': 3,
'CC_scf': 1,
'scf_tuning_index': 3,
'Omfid': 0.31,
'SigmaFOG': 0.
})
t1 = time()
cosmo.compute()
h = cosmo.h()
Da = cosmo.angular_distance(z)
print("Da=", Da)
fz = cosmo.scale_independent_growth_factor_f(z)
print("fz=", fz)
# omb = cosmo.omega_b()
# Omm = cosmo.Omega_m()
# # omm = cosmo.Omega_m()
# # rat = omb/omm
# # print("rat",rat)
# print("omega_b =",omb)
# print("Omega_m =",Omm)
#omcdm = Omm * h**2. - omb
# omcdm = cosmo.omegach2()
# print("omega_cdm =",omcdm)
#k1 = 0.7*1.028185622909e-5
kmsMpc = 3.33564095198145e-6
rd = cosmo.rs_drag()
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)
class ModelPk(object):
""" """
logger = logging.getLogger(__name__)
def __init__(self, **param_dict):
""" """
self.params = params.copy()
self.class_params = class_params.copy()
self.set(**param_dict) #other params for CLASS
self._cosmo = None
self._redshift_func = None
self._logpk_func = None
if self.params['mpk'] is not None:
self.load_pk_from_file(self.params['mpk'])
def load_pk_from_file(self, path):
""" """
self.logger.info(f"Loading matter power spectrum from file {path}")
k, pk = np.loadtxt(path, unpack=True)
self.logger.info(f"min k: {k.min()}, max k: {k.max()}, steps {len(k)}")
pk *= self.params['bias']**2
lk = np.log(k)
lpk = np.log(pk)
self._logpk_func = interpolate.interp1d(lk,
lpk,
bounds_error=False,
fill_value=(0, 0))
def set(self, **param_dict):
""" """
for key, value in param_dict.items():
if key == 'non_linear':
key = 'non linear'
self.logger.debug("Set %s=%s", key, value)
found = False
if key in self.class_params:
self.class_params[key] = value
found = True
if key in self.params:
self.params[key] = value
found = True
if not found:
continue
@property
def cosmo(self):
""" """
if not self._cosmo:
self._cosmo = Class()
self._cosmo.set(self.class_params)
self.logger.info("Initializing Class")
self._cosmo.compute()
if self.params['fix_sigma8']:
sig8 = self._cosmo.sigma8()
A_s = self._cosmo.pars['A_s']
self._cosmo.struct_cleanup()
# renormalize to fix sig8
self.A_s = A_s * (self.params['sigma8'] * 1. / sig8)**2
self._cosmo.set(A_s=self.A_s)
self._cosmo.compute()
sig8 = self._cosmo.sigma8()
self.params['sigma8'] = sig8
self.params['A_s'] = self._cosmo.pars['A_s']
self.params[
'sigma8z'] = sig8 * self._cosmo.scale_independent_growth_factor(
self.class_params['z_pk'])
self.params['f'] = self._cosmo.scale_independent_growth_factor_f(
self.class_params['z_pk'])
self.logger.info(f" z: {self.class_params['z_pk']}")
self.logger.info(f" sigma_8: {self.params['sigma8']}")
self.logger.info(f" sigma_8(z): {self.params['sigma8z']}")
self.logger.info(f" f(z): {self.params['f']}")
self.logger.info(
f"f sigma8(z): {self.params['f']*self.params['sigma8z']}")
return self._cosmo
def class_pk(self, k):
""" """
self.logger.info("Computing power spectrum with Class")
z = np.array([self.class_params['z_pk']]).astype('d')
shape = k.shape
k = k.flatten()
nk = len(k)
k = np.reshape(k, (nk, 1, 1))
pk = self.cosmo.get_pk(k * self.class_params['h'], z, nk, 1,
1).reshape((nk, ))
k = k.reshape((nk, ))
# set h units
pk *= self.class_params['h']**3
pk *= self.params['bias']**2
pk = pk.reshape(shape)
return pk
def get_pk(self, k):
ii = k > 0
out = np.zeros(k.shape, dtype='d')
out[ii] = np.exp(self.logpk_func(np.log(k[ii])))
return out
@property
def logpk_func(self):
if self._logpk_func is None:
k = np.logspace(self.params['log_kmin'], self.params['log_kmax'],
self.params['log_ksteps'])
pk = self.class_pk(k)
lk = np.log(k)
lpk = np.log(pk)
print("logk min", lk.min())
self._logpk_func = interpolate.interp1d(lk,
lpk,
bounds_error=False,
fill_value=(0, 0))
return self._logpk_func
def comoving_distance(self, z):
""" """
return (1 +
z) * self.cosmo.angular_distance(z) * self.class_params['h']
def redshift_at_comoving_distance(self, r):
""" """
try:
z = 10**self.redshift_func(r) - 1
except ValueError:
self.logger.error(f"r min {r.min()} max {r.max()}",
file=sys.stderr)
raise
return z
@property
def redshift_func(self):
""" """
if self._redshift_func is None:
zz = np.logspace(self.params['logzmin'], self.params['logzmax'],
self.params['logzsteps']) - 1
r = np.zeros(len(zz))
for i, z in enumerate(zz):
r[i] = self.comoving_distance(z)
self._redshift_func = interpolate.interp1d(r, np.log10(1 + zz))
return self._redshift_func
