def test_tracer_nz_support():
z_max = 1.0
a = np.linspace(1 / (1 + z_max), 1.0, 100)
background_def = {
"a": a,
"chi": ccl.comoving_radial_distance(COSMO, a),
"h_over_h0": ccl.h_over_h0(COSMO, a)
}
calculator_cosmo = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.045,
h=0.67,
sigma8=0.8,
n_s=0.96,
background=background_def)
z = np.linspace(0., 2., 2000)
n = dndz(z)
with pytest.raises(ValueError):
_ = ccl.WeakLensingTracer(calculator_cosmo, (z, n))
with pytest.raises(ValueError):
_ = ccl.NumberCountsTracer(calculator_cosmo,
has_rsd=False,
dndz=(z, n),
bias=(z, np.ones_like(z)))
with pytest.raises(ValueError):
_ = ccl.CMBLensingTracer(calculator_cosmo, z_source=2.0)
def setup(self):
# Initialize cosmology
par = self.get_cosmological_parameters()
dpk = self.get_pk()
a = 1./(1+dpk['z'][::-1])
self.cosmo = ccl.CosmologyCalculator(Omega_c=par['Omega_m']-par['Omega_b'],
Omega_b=par['Omega_b'],
h=par['h'], n_s=par['n_s'],
A_s=par['A_s'], w0=par['w0'],
pk_linear={'a': a,
'k': dpk['k'],
'delta_matter:delta_matter': dpk['pk_lin'][::-1][:]},
pk_nonlin={'a': a,
'k': dpk['k'],
'delta_matter:delta_matter': dpk['pk_nl'][::-1][:]})
# Initialize tracers
if self.config.get('tracers_from_kernels', False):
tpar = self.get_tracer_parameters()
ker = self.get_tracer_kernels()
a_g = 1./(1+ker['z_cl'][::-1])
self.t_g = []
for k in ker['kernels_cl']:
t = ccl.Tracer()
barr = np.ones_like(a_g)
t.add_tracer(self.cosmo,
(ker['chi_cl'], k),
transfer_a=(a_g, barr))
self.t_g.append(t)
self.t_s = []
for k in ker['kernels_sh']:
t = ccl.Tracer()
t.add_tracer(self.cosmo,
kernel=(ker['chi_sh'], k),
der_bessel=-1, der_angles=2)
self.t_s.append(t)
else:
nzs = self.get_tracer_dndzs()
tpar = self.get_tracer_parameters()
z_g = nzs['z_cl']
z_s = nzs['z_sh']
self.t_g = [ccl.NumberCountsTracer(self.cosmo, True,
(z_g, nzs['dNdz_cl'][:, ni]),
bias=(z_g,
np.full(len(z_g), b)))
for ni, b in zip(range(0, 10),
tpar['b_g'])]
self.t_s = [ccl.WeakLensingTracer(self.cosmo,
(z_s, nzs['dNdz_sh'][:, ni]),
True)
for ni in range(0, 5)]
def test_input_arrays():
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9)
# Where the input quantities are calculated.
a_arr = np.linspace(0.1, 1, 100)
chi_from_ccl = ccl.background.comoving_radial_distance(cosmo, a_arr)
hoh0_from_ccl = ccl.background.h_over_h0(cosmo, a_arr)
growthu_from_ccl = ccl.background.growth_factor_unnorm(cosmo, a_arr)
fgrowth_from_ccl = ccl.background.growth_rate(cosmo, a_arr)
background = {'a': a_arr, 'chi': chi_from_ccl, 'h_over_h0': hoh0_from_ccl}
growth = {
'a': a_arr,
'growth_factor': growthu_from_ccl,
'growth_rate': fgrowth_from_ccl
}
cosmo_input = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
background=background,
growth=growth)
# Where to compare chi(a) from CCL and from CCL with input quantities.
a_arr = np.linspace(0.102, 0.987, 158)
chi_ccl_input = ccl.background.comoving_radial_distance(cosmo_input, a_arr)
chi_from_ccl = ccl.background.comoving_radial_distance(cosmo, a_arr)
# Relative difference (a-b)/b < 1e-5 = 0.001 %
assert np.allclose(chi_ccl_input, chi_from_ccl, atol=0., rtol=1e-5)
growth_ccl_input = ccl.background.growth_factor(cosmo_input, a_arr)
growth_from_ccl = ccl.background.growth_factor(cosmo, a_arr)
assert np.allclose(growth_ccl_input, growth_from_ccl, atol=0., rtol=1e-5)
growthu_ccl_input = ccl.background.growth_factor_unnorm(cosmo_input, a_arr)
growthu_from_ccl = ccl.background.growth_factor_unnorm(cosmo, a_arr)
assert np.allclose(growthu_ccl_input, growthu_from_ccl, atol=0., rtol=1e-5)
fgrowth_ccl_input = ccl.background.growth_rate(cosmo_input, a_arr)
fgrowth_from_ccl = ccl.background.growth_rate(cosmo, a_arr)
assert np.allclose(fgrowth_ccl_input, fgrowth_from_ccl, atol=0., rtol=1e-5)
# Test that the distance/growth flags have been set
assert cosmo_input.has_distances
assert cosmo_input.has_growth
def test_pk2d_parsing():
a_arr = np.linspace(0.1, 1, 100)
k_arr = np.geomspace(1E-4, 1E3, 1000)
pk_arr = a_arr[:, None] * ((k_arr / 0.01) / (1 +
(k_arr / 0.01)**3))[None, :]
psp = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_arr))
cosmo = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.045,
h=0.67,
sigma8=0.8,
n_s=0.96,
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter': pk_arr,
'a:b': pk_arr
})
z = np.linspace(0., 1., 200)
n = np.exp(-((z - 0.5) / 0.1)**2)
lens1 = ccl.WeakLensingTracer(cosmo, (z, n))
ells = np.linspace(2, 100, 10)
cls1 = ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a=None)
cls2 = ccl.angular_cl(cosmo,
lens1,
lens1,
ells,
p_of_k_a='delta_matter:delta_matter')
cls3 = ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a='a:b')
cls4 = ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a=psp)
assert all_finite(cls1)
assert all_finite(cls2)
assert all_finite(cls3)
assert all_finite(cls4)
assert np.all(np.fabs(cls2 / cls1 - 1) < 1E-10)
assert np.all(np.fabs(cls3 / cls1 - 1) < 1E-10)
assert np.all(np.fabs(cls4 / cls1 - 1) < 1E-10)
# Wrong name
with pytest.raises(KeyError):
ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a='a:c')
# Wrong type
with pytest.raises(ValueError):
ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a=3)
def start_ccl(self):
try:
self.pk
except:
print('Calculating CAMB power spectrum (with default values)')
self.get_camb_pk()
try:
self.chi, self.hubble
except:
print('Calculating CAMB background')
self.get_camb_background()
# CCL uses an array of a, not z, so need to flip everything
aarr = 1. / (1. + self.z)
aarr = np.sort(aarr)
pk = np.flip(self.pk, axis=0)
chi = np.flip(self.chi)
h = self.hubble/self.hubble[0]
h = np.flip(h)
self.cosmo_ccl = ccl.CosmologyCalculator(
Omega_b=self.pars['omegab'],
Omega_c=self.pars['omegac'],
h=self.pars['h'],
n_s=self.pars['ns'],
A_s=self.pars['As'],
m_nu=self.pars['mnu'],
background={'a': aarr,
'chi': chi,
'h_over_h0': h},
pk_nonlin={'a': aarr,
'k': self.k,
'delta_matter:delta_matter': pk}
)
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 calculate(self, state, want_derived=True, **params_values_dict):
# calculate the general CCL cosmo object which likelihoods can then use to get
# what they need (likelihoods should cache results appropriately)
# get our requirements from self.provider
distance = self.provider.get_comoving_radial_distance(self.z)
hubble_z = self.provider.get_Hubble(self.z)
H0 = hubble_z[0]
h = H0 / 100
E_of_z = hubble_z / H0
Omega_c = self.provider.get_param('omch2') / h**2
Omega_b = self.provider.get_param('ombh2') / h**2
# Array z is sorted in ascending order. CCL requires an ascending scale factor
# as input
# Flip the arrays to make them a function of the increasing scale factor.
# If redshift sampling is changed, check that it is monotonically increasing
distance = np.flip(distance)
E_of_z = np.flip(E_of_z)
# Array z is sorted in ascending order. CCL requires an ascending scale
# factor as input
a = 1. / (1 + self.z[::-1])
#growth = ccl.background.growth_factor(cosmo, a)
#fgrowth = ccl.background.growth_rate(cosmo, a)
if self.kmax:
for pair in self._var_pairs:
# Get the matter power spectrum:
k, z, Pk_lin = self.provider.get_Pk_grid(var_pair=pair,
nonlinear=False)
Pk_lin = np.flip(Pk_lin, axis=0)
if self.nonlinear:
_, z, Pk_nonlin = self.provider.get_Pk_grid(var_pair=pair,
nonlinear=True)
Pk_nonlin = np.flip(Pk_nonlin, axis=0)
# Create a CCL cosmology object. Because we are giving it background
# quantities, it should not depend on the cosmology parameters given
cosmo = ccl.CosmologyCalculator(
Omega_c=Omega_c,
Omega_b=Omega_b,
h=h,
sigma8=0.8,
n_s=0.96,
background={
'a': a,
'chi': distance,
'h_over_h0': E_of_z
},
pk_linear={
'a': a,
'k': k,
'delta_matter:delta_matter': Pk_lin
},
pk_nonlin={
'a': a,
'k': k,
'delta_matter:delta_matter': Pk_nonlin
})
else:
cosmo = ccl.CosmologyCalculator(
Omega_c=Omega_c,
Omega_b=Omega_b,
h=h,
sigma8=0.8,
n_s=0.96,
background={
'a': a,
'chi': distance,
'h_over_h0': E_of_z
},
pk_linear={
'a': a,
'k': k,
'delta_matter:delta_matter': Pk_lin
})
state['CCL'] = {'cosmo': cosmo}
for required_result, method in self._required_results.items():
state['CCL'][required_result] = method(cosmo)
def test_input_nonlin_raises():
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
transfer_function='bbks')
a_arr = np.linspace(0.1, 1.0, 50)
k_arr = np.logspace(np.log10(2e-4), np.log10(1), 1000)
pkl_arr = np.array(
[ccl.power.linear_matter_power(cosmo, k_arr, a) for a in a_arr])
pk_arr = np.array(
[ccl.power.nonlin_matter_power(cosmo, k_arr, a) for a in a_arr])
# Not a dictionary
with pytest.raises(TypeError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_nonlin=np.pi)
# k not present
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_nonlin={
'a': a_arr,
'kk': k_arr,
'delta_matter;delta_matter': pk_arr
})
# a not increasing
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_nonlin={
'a': a_arr[::-1],
'k': k_arr,
'delta_matter:delta_matter': pk_arr
})
# delta_matter:delta_matter not present
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter;delta_matter': pk_arr
})
# Non-parsable power spectrum
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter': pk_arr,
'a;b': pk_arr
})
# Wrong shape
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter': pk_arr,
'a:b': pk_arr[0]
})
# Linear Pk not set for halofit
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
nonlinear_model='halofit')
# Check new power spectrum is stored
cosmo_input = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_linear={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter':
pkl_arr,
'a:b': pkl_arr
},
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter':
pk_arr
},
nonlinear_model='halofit')
assert 'a:b' in cosmo_input._pk_nl
assert cosmo_input.has_nonlin_power
def test_input_nonlinear_model_raises():
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
transfer_function='bbks')
a_arr = np.linspace(0.1, 1.0, 50)
k_arr = np.logspace(np.log10(2e-4), np.log10(1), 1000)
pkl_arr = np.array(
[ccl.power.linear_matter_power(cosmo, k_arr, a) for a in a_arr])
# If no non-linear model provided, delta_matter:delta_matter
# should be there.
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_nonlin={
'a': a_arr,
'k': k_arr,
'a:b': pkl_arr
})
with pytest.raises(TypeError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_linear={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter': pkl_arr
},
nonlinear_model=np.pi)
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
nonlinear_model='halofit')
with pytest.raises(KeyError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_linear={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter': pkl_arr
},
nonlinear_model={'y:z': 'halofit'})
with pytest.raises(ValueError):
ccl.CosmologyCalculator(
Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_linear={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter': pkl_arr
},
nonlinear_model={'delta_matter:delta_matter': None})
with pytest.raises(KeyError):
ccl.CosmologyCalculator(
Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
sigma8=0.8,
pk_linear={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter': pkl_arr
},
nonlinear_model={'delta_matter:delta_matter': 'hmcode'})
def test_input_nonlin_power_spectrum():
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
transfer_function='boltzmann_class')
a_arr = np.linspace(0.1, 1.0, 50)
chi_from_ccl = ccl.background.comoving_radial_distance(cosmo, a_arr)
hoh0_from_ccl = ccl.background.h_over_h0(cosmo, a_arr)
growth_from_ccl = ccl.background.growth_factor_unnorm(cosmo, a_arr)
fgrowth_from_ccl = ccl.background.growth_rate(cosmo, a_arr)
k_arr = np.logspace(np.log10(2e-4), np.log10(1), 1000)
pk_arr = np.empty(shape=(len(a_arr), len(k_arr)))
for i, a in enumerate(a_arr):
pk_arr[i] = ccl.power.nonlin_matter_power(cosmo, k_arr, a)
cosmo_input = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
background={
'a': a_arr,
'chi': chi_from_ccl,
'h_over_h0': hoh0_from_ccl
},
growth={
'a': a_arr,
'growth_factor': growth_from_ccl,
'growth_rate': fgrowth_from_ccl
},
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter':
pk_arr
})
pk_CCL_input = ccl.power.nonlin_matter_power(cosmo_input, k_arr, 0.5)
pk_CCL = ccl.power.nonlin_matter_power(cosmo, k_arr, 0.5)
assert np.allclose(pk_CCL_input, pk_CCL, atol=0., rtol=1e-5)
# Test again with negative power spectrum (so it's not logscaled)
cosmo_input = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
background={
'a': a_arr,
'chi': chi_from_ccl,
'h_over_h0': hoh0_from_ccl
},
growth={
'a': a_arr,
'growth_factor': growth_from_ccl,
'growth_rate': fgrowth_from_ccl
},
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter':
-pk_arr
})
pk_CCL_input = -ccl.power.nonlin_matter_power(cosmo_input, k_arr, 0.5)
assert np.allclose(pk_CCL_input, pk_CCL, atol=0., rtol=1e-5)
def test_input_nonlinear_model():
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
transfer_function='boltzmann_class')
a_arr = np.linspace(0.1, 1.0, 50)
k_arr = np.logspace(np.log10(2e-4), np.log10(1), 1000)
pk_arr = np.empty(shape=(len(a_arr), len(k_arr)))
for i, a in enumerate(a_arr):
pk_arr[i] = ccl.power.nonlin_matter_power(cosmo, k_arr, a)
pk_CCL = ccl.power.nonlin_matter_power(cosmo, k_arr, 0.5)
# Test again passing only linear Pk, but letting HALOFIT do its thing
kl_arr = np.logspace(-4, 1, 1000)
pkl_arr = np.array(
[ccl.power.linear_matter_power(cosmo, kl_arr, a) for a in a_arr])
cosmo_input = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
pk_linear={
'a': a_arr,
'k': kl_arr,
'delta_matter:delta_matter':
pkl_arr
},
nonlinear_model='halofit')
pk_CCL_input = ccl.power.nonlin_matter_power(cosmo_input, k_arr, 0.5)
assert np.allclose(pk_CCL_input, pk_CCL, atol=0., rtol=1e-5)
# Test extra power spectrum
kl_arr = np.logspace(-4, 1, 1000)
pkl_arr = np.array(
[ccl.power.linear_matter_power(cosmo, kl_arr, a) for a in a_arr])
cosmo_input = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
pk_linear={
'a': a_arr,
'k': kl_arr,
'delta_matter:delta_matter':
pkl_arr,
'a:b': pkl_arr
},
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter':
-pk_arr
},
nonlinear_model='halofit')
pk_CCL_input = cosmo_input.get_nonlin_power('a:b').eval(
k_arr, 0.5, cosmo_input)
assert np.allclose(pk_CCL_input, pk_CCL, atol=0., rtol=1e-5)
# Via `nonlin_power`
pk_CCL_input = ccl.power.nonlin_power(cosmo_input,
k_arr,
0.5,
p_of_k_a='a:b')
assert np.allclose(pk_CCL_input, pk_CCL, atol=0., rtol=1e-5)
# Use dictionary
cosmo_input = ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
pk_linear={
'a': a_arr,
'k': kl_arr,
'delta_matter:delta_matter':
pkl_arr,
'a:b': pkl_arr,
'c:d': pkl_arr
},
pk_nonlin={
'a': a_arr,
'k': k_arr,
'delta_matter:delta_matter':
-pk_arr
},
nonlinear_model={
'a:b': 'halofit',
'c:d': None
})
pk_CCL_input = ccl.power.nonlin_power(cosmo_input,
k_arr,
0.5,
p_of_k_a='a:b')
assert np.allclose(pk_CCL_input, pk_CCL, atol=0., rtol=1e-5)
assert 'c:d' not in cosmo_input._pk_nl
def test_hodcl():
# With many thanks to Ryu Makiya, Eiichiro Komatsu
# and Shin'ichiro Ando for providing this benchmark.
# HOD params
lMcut = 11.8
lM1 = 11.73
sigma_Ncen = 0.15
alp_Nsat = 0.77
rmax = 4.39
rgs = 1.17
# Input power spectrum
ks = np.loadtxt("benchmarks/data/k_hod.txt")
zs = np.loadtxt("benchmarks/data/z_hod.txt")
pks = np.loadtxt("benchmarks/data/pk_hod.txt")
l_bm, cl_bm = np.loadtxt("benchmarks/data/cl_hod.txt",
unpack=True)
# Set N(z)
def _nz_2mrs(z):
# From 1706.05422
m = 1.31
beta = 1.64
x = z / 0.0266
return x**m * np.exp(-x**beta)
z1 = 1e-5
z2 = 0.1
z_arr = np.linspace(z1, z2, 1024)
dndz = _nz_2mrs(z_arr)
# CCL prediction
# Make sure we use the same P(k)
cosmo = ccl.CosmologyCalculator(
Omega_b=0.05,
Omega_c=0.25,
h=0.67,
n_s=0.9645,
A_s=2.0E-9,
m_nu=0.00001,
m_nu_type='equal',
pk_linear={'a': 1./(1.+zs[::-1]),
'k': ks,
'delta_matter:delta_matter': pks[::-1, :]})
cosmo.compute_growth()
# Halo model setup
mass_def = ccl.halos.MassDef(200, 'critical')
cm = ccl.halos.ConcentrationDuffy08(mass_def)
hmf = ccl.halos.MassFuncTinker08(cosmo, mass_def=mass_def)
hbf = ccl.halos.HaloBiasTinker10(cosmo, mass_def=mass_def)
hmc = ccl.halos.HMCalculator(cosmo, hmf, hbf, mass_def)
prf = ccl.halos.HaloProfileHOD(cm,
lMmin_0=np.log10(10.**lMcut/cosmo['h']),
siglM_0=sigma_Ncen,
lM0_0=np.log10(10.**lMcut/cosmo['h']),
lM1_0=np.log10(10.**lM1/cosmo['h']),
alpha_0=alp_Nsat,
bg_0=rgs,
bmax_0=rmax)
prf2pt = ccl.halos.Profile2ptHOD()
# P(k)
k_arr = np.geomspace(1E-4, 1E2, 512)
a_arr = np.linspace(0.8, 1, 32)
pk_hod = ccl.halos.halomod_Pk2D(cosmo, hmc, prf, prof_2pt=prf2pt,
normprof1=True, lk_arr=np.log(k_arr),
a_arr=a_arr)
# C_ell
tr = ccl.NumberCountsTracer(cosmo, False, (z_arr, dndz),
(z_arr, np.ones(len(dndz))))
cl_hod = ccl.angular_cl(cosmo, tr, tr, l_bm, p_of_k_a=pk_hod)
assert np.all(np.fabs(cl_hod/cl_bm-1) < 0.005)
def test_input_arrays_raises():
"""
Test for input scale factor array being descending,
not ending in 1.0, being different size, as well as
for no input arrays.
"""
for input_a in [
input_a_array_descending, input_a_array_not1, input_a_array[:-2]
]:
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
growth={
'a': input_a,
'growth_factor': input_growth,
'growth_rate': input_fgrowth
})
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
background={
'a': input_a,
'chi': input_chi,
'h_over_h0': input_hoh0
})
# Not a dictionary
with pytest.raises(TypeError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
growth=3)
with pytest.raises(TypeError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
background=3)
# Incomplete dictionary
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
background={
'a': input_a_array,
'h_over_h0': input_hoh0
})
with pytest.raises(ValueError):
ccl.CosmologyCalculator(Omega_c=0.27,
Omega_b=0.05,
h=0.7,
n_s=0.965,
A_s=2e-9,
growth={
'a': input_a_array,
'growth_rate': input_fgrowth
})
