def test_nM_tinker_crit(mf):
a = 0.5
om = ccl.omega_x(COSMO, a, 'matter')
oc = ccl.omega_x(COSMO, a, 'critical')
delta_c = 500.
delta_m = delta_c * oc / om
mdef_c = ccl.halos.MassDef(delta_c, 'critical')
mdef_m = ccl.halos.MassDef(delta_m, 'matter')
nM_c = mf(COSMO, mdef_c)
nM_m = mf(COSMO, mdef_m)
assert np.allclose(nM_c.get_mass_function(COSMO, 1E13, a),
nM_m.get_mass_function(COSMO, 1E13, a))
def check_background_nu(cosmo):
"""
Check that background functions can be run and that the growth functions
exit gracefully in functions with massive neutrinos (not implemented yet).
"""
# Types of scale factor input (scalar, list, array)
a_scl = 0.5
a_lst = [0.2, 0.4, 0.6, 0.8, 1.]
a_arr = np.linspace(0.2, 1., 5)
# growth_factor
assert_raises(CCLError, ccl.growth_factor, cosmo, a_scl)
assert_raises(CCLError, ccl.growth_factor, cosmo, a_lst)
assert_raises(CCLError, ccl.growth_factor, cosmo, a_arr)
# growth_factor_unnorm
assert_raises(CCLError, ccl.growth_factor_unnorm, cosmo, a_scl)
assert_raises(CCLError, ccl.growth_factor_unnorm, cosmo, a_lst)
assert_raises(CCLError, ccl.growth_factor_unnorm, cosmo, a_arr)
# growth_rate
assert_raises(CCLError, ccl.growth_rate, cosmo, a_scl)
assert_raises(CCLError, ccl.growth_rate, cosmo, a_lst)
assert_raises(CCLError, ccl.growth_rate, cosmo, a_arr)
# comoving_radial_distance
assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_scl)))
assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_lst)))
assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_arr)))
# h_over_h0
assert_(all_finite(ccl.h_over_h0(cosmo, a_scl)))
assert_(all_finite(ccl.h_over_h0(cosmo, a_lst)))
assert_(all_finite(ccl.h_over_h0(cosmo, a_arr)))
# luminosity_distance
assert_(all_finite(ccl.luminosity_distance(cosmo, a_scl)))
assert_(all_finite(ccl.luminosity_distance(cosmo, a_lst)))
assert_(all_finite(ccl.luminosity_distance(cosmo, a_arr)))
# scale_factor_of_chi
assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_scl)))
assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_lst)))
assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_arr)))
# omega_m_a
assert_(all_finite(ccl.omega_x(cosmo, a_scl, 'matter')))
assert_(all_finite(ccl.omega_x(cosmo, a_lst, 'matter')))
assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'matter')))
def check_background(cosmo):
"""
Check that background and growth functions can be run.
"""
# Types of scale factor input (scalar, list, array)
a_scl = 0.5
a_lst = [0.2, 0.4, 0.6, 0.8, 1.]
a_arr = np.linspace(0.2, 1., 5)
# growth_factor
assert_( all_finite(ccl.growth_factor(cosmo, a_scl)) )
assert_( all_finite(ccl.growth_factor(cosmo, a_lst)) )
assert_( all_finite(ccl.growth_factor(cosmo, a_arr)) )
# growth_factor_unnorm
assert_( all_finite(ccl.growth_factor_unnorm(cosmo, a_scl)) )
assert_( all_finite(ccl.growth_factor_unnorm(cosmo, a_lst)) )
assert_( all_finite(ccl.growth_factor_unnorm(cosmo, a_arr)) )
# growth_rate
assert_( all_finite(ccl.growth_rate(cosmo, a_scl)) )
assert_( all_finite(ccl.growth_rate(cosmo, a_lst)) )
assert_( all_finite(ccl.growth_rate(cosmo, a_arr)) )
# comoving_radial_distance
assert_( all_finite(ccl.comoving_radial_distance(cosmo, a_scl)) )
assert_( all_finite(ccl.comoving_radial_distance(cosmo, a_lst)) )
assert_( all_finite(ccl.comoving_radial_distance(cosmo, a_arr)) )
# h_over_h0
assert_( all_finite(ccl.h_over_h0(cosmo, a_scl)) )
assert_( all_finite(ccl.h_over_h0(cosmo, a_lst)) )
assert_( all_finite(ccl.h_over_h0(cosmo, a_arr)) )
# luminosity_distance
assert_( all_finite(ccl.luminosity_distance(cosmo, a_scl)) )
assert_( all_finite(ccl.luminosity_distance(cosmo, a_lst)) )
assert_( all_finite(ccl.luminosity_distance(cosmo, a_arr)) )
# scale_factor_of_chi
assert_( all_finite(ccl.scale_factor_of_chi(cosmo, a_scl)) )
assert_( all_finite(ccl.scale_factor_of_chi(cosmo, a_lst)) )
assert_( all_finite(ccl.scale_factor_of_chi(cosmo, a_arr)) )
# omega_m_a
assert_( all_finite(ccl.omega_x(cosmo, a_scl, 'matter')) )
assert_( all_finite(ccl.omega_x(cosmo, a_lst, 'matter')) )
assert_( all_finite(ccl.omega_x(cosmo, a_arr, 'matter')) )
def r_Delta(cosmo, halo_mass, a, Delta=200, is_matter=False):
"""
Calculate the reference radius of a halo.
.. note:: this is R=(3M/(4*pi*rho_c(a)*Delta))^(1/3), where rho_c is the critical
matter density
Arguments
---------
cosmo : ``pyccl.Cosmology`` object
Cosmological parameters.
halo_mass : float or array_like
Halo mass [Msun].
a : float
Scale factor
Delta : float
Overdensity parameter.
Returns
-------
float or array_like : The halo reference radius in `Mpc`.
"""
omega_factor = 1.
if is_matter:
omega_factor = ccl.omega_x(cosmo, a, 'matter')
prefac = Delta * omega_factor * 1.16217766E12 * (
cosmo['h'] * ccl.h_over_h0(cosmo, a))**2
return (halo_mass / prefac)**(1. / 3.)
def profnorm(self, cosmo, a, squeeze=True, **kwargs):
"""Computes the overall profile normalisation for the angular cross-
correlation calculation."""
# Input handling
a = np.atleast_1d(a)
# extract parameters
fc = kwargs["fc"]
logMmin, logMmax = (6, 17) # log of min and max halo mass [Msun]
mpoints = int(64) # number of integration points
M = np.logspace(logMmin, logMmax, mpoints) # masses sampled
# CCL uses delta_matter
Dm = self.Delta / ccl.omega_x(cosmo, a, "matter")
mfunc = [ccl.massfunc(cosmo, M, A1, A2) for A1, A2 in zip(a, Dm)]
Nc = self.n_cent(M, **kwargs) # centrals
Ns = self.n_sat(M, **kwargs) # satellites
if self.ns_independent:
dng = mfunc * (Nc * fc + Ns) # integrand
else:
dng = mfunc * Nc * (fc + Ns) # integrand
ng = simps(dng, x=np.log10(M))
return ng.squeeze() if squeeze else ng
def get_bpe(z, n_r, delta, nmass=256):
a = 1./(1+z)
lmarr = np.linspace(8.,16.,nmass)
marr = 10.**lmarr
Dm = delta/ccl.omega_x(cosmo, a, "matter") # CCL uses Delta_m
mfunc = ccl.massfunc(cosmo, marr, a, Dm)
bh = ccl.halo_bias(cosmo, marr, a, Dm)
et = np.array([integrated_profile(get_battaglia(m,z,delta),n_r) for m in marr])
return itg.simps(et*bh*mfunc,x=lmarr)
def _get_param(self, key):
if key == "Omega_m0":
return ccl.omega_x(self.be_cosmo, 1.0, "matter")
elif key == "Omega_b0":
return self.be_cosmo['Omega_b']
elif key == "Omega_dm0":
return self.be_cosmo['Omega_c']
elif key == "Omega_k0":
return self.be_cosmo['Omega_k']
elif key == 'h':
return self.be_cosmo['h']
elif key == 'H0':
return self.be_cosmo['h']*100.0
else:
raise ValueError(f"Unsupported parameter {key}")
def R_Delta(cosmo, M, a, Delta=500, is_matter=False, squeeze=True, **kwargs):
"""
Calculate the reference radius of a halo.
.. note:: This is ``R = (3M/(4*pi*rho_c(a)*Delta))^(1/3)``, where rho_c is
the critical matter density at scale factor ``a``.
Arguments
---------
cosmo: ~pyccl.core.Cosmology
Cosmology object.
M : float or array_like
Halo mass [Msun].
a : float or array_like
Scale factor
Delta : float
Overdensity parameter.
is_matter : bool
True when R_Delta is calculated using the average matter density.
False when R_Delta is calculated using the critical density.
squeeze : bool
Whether to squeeze extra dimensions.
**kwargs : dict
Parametrisation of the profiles and cosmology.
Returns
-------
float or array_like : The halo reference radius in `Mpc`.
"""
# Input handling
M, a = np.atleast_1d(M, a)
if is_matter:
omega_factor = ccl.omega_x(cosmo, a, "matter")
else:
omega_factor = 1
c1 = (cosmo["h"] * ccl.h_over_h0(cosmo, a))**2
prefac = 1.16217766e12 * Delta * omega_factor * c1
R = (M[..., None] / prefac)**(1 / 3)
return R.squeeze() if squeeze else R
def test_background_omega_x(a, kind):
val = ccl.omega_x(COSMO_NU, a, kind)
assert np.all(np.isfinite(val))
assert np.shape(val) == np.shape(a)
if np.all(a == 1):
if kind == 'matter':
val_z0 = (COSMO_NU['Omega_b'] + COSMO_NU['Omega_c'] +
COSMO_NU['Omega_nu_mass'])
elif kind == 'dark_energy':
val_z0 = COSMO_NU['Omega_l']
elif kind == 'radiation':
val_z0 = COSMO_NU['Omega_g']
elif kind == 'curvature':
val_z0 = COSMO_NU['Omega_k']
elif kind == 'neutrinos_rel':
val_z0 = COSMO_NU['Omega_nu_rel']
elif kind == 'neutrinos_massive':
val_z0 = COSMO_NU['Omega_nu_mass']
assert np.allclose(val, val_z0)
def check_background(cosmo):
"""
Check that background and growth functions can be run.
"""
# Types of scale factor input (scalar, list, array)
a_scl = 0.5
is_comoving = 0
a_lst = [0.2, 0.4, 0.6, 0.8, 1.]
a_arr = np.linspace(0.2, 1., 5)
# growth_factor
assert_(all_finite(ccl.growth_factor(cosmo, a_scl)))
assert_(all_finite(ccl.growth_factor(cosmo, a_lst)))
assert_(all_finite(ccl.growth_factor(cosmo, a_arr)))
# growth_factor_unnorm
assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_scl)))
assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_lst)))
assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_arr)))
# growth_rate
assert_(all_finite(ccl.growth_rate(cosmo, a_scl)))
assert_(all_finite(ccl.growth_rate(cosmo, a_lst)))
assert_(all_finite(ccl.growth_rate(cosmo, a_arr)))
# comoving_radial_distance
assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_scl)))
assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_lst)))
assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_arr)))
# comoving_angular_distance
assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_scl)))
assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_lst)))
assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_arr)))
# h_over_h0
assert_(all_finite(ccl.h_over_h0(cosmo, a_scl)))
assert_(all_finite(ccl.h_over_h0(cosmo, a_lst)))
assert_(all_finite(ccl.h_over_h0(cosmo, a_arr)))
# luminosity_distance
assert_(all_finite(ccl.luminosity_distance(cosmo, a_scl)))
assert_(all_finite(ccl.luminosity_distance(cosmo, a_lst)))
assert_(all_finite(ccl.luminosity_distance(cosmo, a_arr)))
# scale_factor_of_chi
assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_scl)))
assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_lst)))
assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_arr)))
# omega_m_a
assert_(all_finite(ccl.omega_x(cosmo, a_scl, 'matter')))
assert_(all_finite(ccl.omega_x(cosmo, a_lst, 'matter')))
assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'matter')))
# Fractional density of different types of fluid
assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'dark_energy')))
assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'radiation')))
assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'curvature')))
assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'neutrinos_rel')))
assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'neutrinos_massive')))
# Check that omega_x fails if invalid component type is passed
assert_raises(ValueError, ccl.omega_x, cosmo, a_scl, 'xyz')
# rho_crit_a
assert_(all_finite(ccl.rho_x(cosmo, a_scl, 'critical', is_comoving)))
assert_(all_finite(ccl.rho_x(cosmo, a_lst, 'critical', is_comoving)))
assert_(all_finite(ccl.rho_x(cosmo, a_arr, 'critical', is_comoving)))
# rho_m_a
assert_(all_finite(ccl.rho_x(cosmo, a_scl, 'matter', is_comoving)))
assert_(all_finite(ccl.rho_x(cosmo, a_lst, 'matter', is_comoving)))
assert_(all_finite(ccl.rho_x(cosmo, a_arr, 'matter', is_comoving)))
def test_background_omega_x_raises():
with pytest.raises(ValueError):
ccl.omega_x(COSMO, 1, 'blah')
def get_Omega_m(self, z):
return ccl.omega_x(self.be_cosmo, 1.0/(1.0+z), "matter")
# plt.show()
plt.close()
# The ratio of the Hubble parameter at scale factor a to H0:
H_over_H0 = ccl.h_over_h0(cosmo, a)
plt.figure()
plt.plot(z, H_over_H0, 'k', linewidth=2)
plt.xlabel('$z$', fontsize=20)
plt.ylabel('$H / H_0$', fontsize=15)
plt.tick_params(labelsize=13)
# plt.show()
plt.close()
# For each component of the matter / energy budget,
# we can get $\Omega_{\rm x}(z)$, the fractional energy density at $z \ne 0$.
OmM_z = ccl.omega_x(cosmo, a, 'matter')
OmL_z = ccl.omega_x(cosmo, a, 'dark_energy')
OmR_z = ccl.omega_x(cosmo, a, 'radiation')
OmK_z = ccl.omega_x(cosmo, a, 'curvature')
OmNuRel_z = ccl.omega_x(cosmo, a, 'neutrinos_rel')
OmNuMass_z = ccl.omega_x(cosmo, a, 'neutrinos_massive')
plt.figure()
plt.plot(z, OmM_z, 'k', linewidth=2, label='$\Omega_{\\rm M}(z)$')
plt.plot(z, OmL_z, 'g', linewidth=2, label='$\Omega_{\Lambda}(z)$')
plt.plot(z, OmR_z, 'b', linewidth=2, label='$\Omega_{\\rm R}(z)$')
plt.plot(z, OmNuRel_z, 'm', linewidth=2, label='$\Omega_{\\nu}^{\\rm rel}(z)$')
plt.xlabel('$z$',fontsize=20)
plt.ylabel('$\Omega_{\\rm x}(z)$', fontsize= 20)
plt.tick_params(labelsize=13)
plt.legend(loc='upper right')
a = 1 / (1 + z)
cosmo = [
ccl.Cosmology(Omega_c=0.26066676,
Omega_b=0.048974682,
h=0.6766,
sigma8=0.8102,
n_s=0.9665,
mass_function=mf) for mf in ["tinker", "tinker10"]
]
M = np.logspace(10, 15, 100)
mfr = [[]] * len(a)
for i, sf in enumerate(a):
rho = [500 / ccl.omega_x(c, sf, "matter") for c in cosmo]
mf = [ccl.massfunc(c, M, sf, overdensity=r) for c, r in zip(cosmo, rho)]
mfr[i] = mf[0] / mf[1]
mfr = np.array(mfr)
cmap = truncate_colormap(cm.Reds, 0.2, 1.0)
col = [cmap(i) for i in np.linspace(0, 1, len(a))]
fig, ax = plt.subplots()
ax.set_xlim(M.min(), M.max())
ax.axhline(y=1, ls="--", color="k")
[ax.loglog(M, R, c=c, label="%s" % red) for R, c, red in zip(mfr, col, z)]
ax.yaxis.set_major_formatter(FormatStrFormatter("$%.1f$"))
ax.yaxis.set_minor_formatter(FormatStrFormatter("$%.1f$"))
origin='lower',
aspect='auto',
extent=[0, 1, 13.5, 15.5])
plt.scatter(data['REDSHIFT'], np.log10(data['MSZ'] * 1E14), c='r', s=1)
plt.plot(zs, np.log10(selection_planck_mthr(zs)), 'k-', lw=2)
plt.xlim([0, 0.6])
plt.ylim([13.7, 15.2])
plt.xlabel('$z$', fontsize=16)
plt.ylabel('$\\log_{10}(M/M_\\odot)$', fontsize=16)
zranges = [[0, 0.07], [0.07, 0.17], [0.17, 0.3], [0.3, 0.5], [0.5, 1.]]
for z0, zf in zranges:
mask = (data['REDSHIFT'] < zf) & (data['REDSHIFT'] >= z0)
zmean = np.mean(data['REDSHIFT'][mask])
ms = 10.**np.linspace(13.7, 15.5, 20)
Delta = 500. / ccl.omega_x(cosmo, 1. / (1 + zmean), "matter")
hmf = ccl.massfunc(cosmo, ms, 1. / (1 + zmean), Delta)
pd = np.histogram(np.log10(data['MSZ'][mask] * 1E14),
range=[13.7, 15.5],
bins=20)[0] + 0.
pd /= np.sum(pd)
pt = selection_planck_erf(ms, zmean, complementary=False)
pt = pt * hmf / np.sum(pt * hmf)
plt.figure()
plt.plot(ms, pt, 'k-')
plt.plot(ms, pd, 'r-')
plt.xscale('log')
plt.show()
#Compute their angular extent
def hm_power_spectrum(cosmo,
k,
a,
profiles,
logMrange=(6, 17),
mpoints=128,
include_1h=True,
include_2h=True,
squeeze=True,
hm_correction=None,
selection=None,
**kwargs):
"""Computes the halo model prediction for the 3D cross-power
spectrum of two quantities.
Args:
cosmo (:obj:`ccl.Cosmology`): cosmology.
k (array): array of wavenumbers in units of Mpc^-1
a (array): array of scale factor values
profiles (tuple): tuple of two profile objects (currently
only Arnaud and HOD are implemented) corresponding to
the two quantities being correlated.
logMrange (tuple): limits of integration in log10(M/Msun)
mpoints (int): number of mass samples
include_1h (bool): whether to include the 1-halo term.
include_2h (bool): whether to include the 2-halo term.
hm_correction (:obj:`HalomodCorrection` or None):
Correction to the halo model in the transition regime.
If `None`, no correction is applied.
selection (function): selection function in (M,z) to include
in the calculation. Pass None if you don't want to select
a subset of the M-z plane.
**kwargs: parameter used internally by the profiles.
"""
# Input handling
a, k = np.atleast_1d(a), np.atleast_2d(k)
# Profile normalisations
p1, p2 = profiles
Unorm = p1.profnorm(cosmo, a, squeeze=False, **kwargs)
if p1.name == p2.name:
Vnorm = Unorm
else:
Vnorm = p2.profnorm(cosmo, a, squeeze=False, **kwargs)
if (Vnorm < 1e-16).any() or (Unorm < 1e-16).any():
return None # zero division
Unorm, Vnorm = Unorm[..., None], Vnorm[..., None] # transform axes
# Set up integration boundaries
logMmin, logMmax = logMrange # log of min and max halo mass [Msun]
mpoints = int(mpoints) # number of integration points
M = np.logspace(logMmin, logMmax, mpoints) # masses sampled
# Out-of-loop optimisations
Pl = np.array(
[ccl.linear_matter_power(cosmo, k[i], a) for i, a in enumerate(a)])
Dm = p1.Delta / ccl.omega_x(cosmo, a, "matter") # CCL uses Delta_m
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mfunc = np.array(
[ccl.massfunc(cosmo, M, A1, A2) for A1, A2 in zip(a, Dm)])
if selection is not None:
select = np.array([selection(M, 1. / aa - 1) for aa in a])
mfunc *= select
# tinker10 halo bias
csm = ccl.Cosmology(Omega_c=cosmo["Omega_c"],
Omega_b=cosmo["Omega_b"],
h=cosmo["h"],
sigma8=cosmo["sigma8"],
n_s=cosmo["n_s"],
mass_function="tinker10")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
bh = np.array([ccl.halo_bias(csm, M, A1, A2) for A1, A2 in zip(a, Dm)])
# shape transformations
mfunc, bh = mfunc.T[..., None], bh.T[..., None]
if selection is not None:
select = np.array([selection(M, 1. / aa - 1) for aa in a])
select = select.T[..., None]
else:
select = 1
U, UU = p1.fourier_profiles(cosmo, k, M, a, squeeze=False, **kwargs)
# optimise for autocorrelation (no need to recompute)
if p1.name == p2.name:
V = U
UV = UU
else:
V, VV = p2.fourier_profiles(cosmo, k, M, a, squeeze=False, **kwargs)
r = kwargs["r_corr"] if "r_corr" in kwargs else 0
UV = U * V * (1 + r)
# Tinker mass function is given in dn/dlog10M, so integrate over d(log10M)
P1h = simps(mfunc * select * UV, x=np.log10(M), axis=0)
b2h_1 = simps(bh * mfunc * select * U, x=np.log10(M), axis=0)
b2h_2 = simps(bh * mfunc * select * V, x=np.log10(M), axis=0)
# Contribution from small masses (added in the beginning)
rhoM = ccl.rho_x(cosmo, a, "matter", is_comoving=True)
dlM = (logMmax - logMmin) / (mpoints - 1)
mfunc, bh = mfunc.squeeze(), bh.squeeze() # squeeze extra dimensions
n0_1h = np.array((rhoM - np.dot(M, mfunc) * dlM) / M[0])[None, ..., None]
n0_2h = np.array((rhoM - np.dot(M, mfunc * bh) * dlM) / M[0])[None, ...,
None]
P1h += (n0_1h * U[0] * V[0]).squeeze()
b2h_1 += (n0_2h * U[0]).squeeze()
b2h_2 += (n0_2h * V[0]).squeeze()
F = (include_1h * P1h + include_2h *
(Pl * b2h_1 * b2h_2)) / (Unorm * Vnorm)
if hm_correction is not None:
for ia, (aa, kk) in enumerate(zip(a, k)):
R = hm_correction.rk_interp(kk, aa)
F[ia, :] *= R
return F.squeeze() if squeeze else F
def hm_bias(cosmo,
a,
profile,
logMrange=(6, 17),
mpoints=128,
selection=None,
**kwargs):
"""Computes the halo model prediction for the bias of a given
tracer.
Args:
cosmo (:obj:`ccl.Cosmology`): cosmology.
a (array): array of scale factor values
profile (`Profile`): a profile. Only Arnaud and HOD are
implemented.
logMrange (tuple): limits of integration in log10(M/Msun)
mpoints (int): number of mass samples
selection (function): selection function in (M,z) to include
in the calculation. Pass None if you don't want to select
a subset of the M-z plane.
**kwargs: parameter used internally by the profiles.
"""
# Input handling
a = np.atleast_1d(a)
# Profile normalisations
Unorm = profile.profnorm(cosmo, a, squeeze=False, **kwargs)
Unorm = Unorm[..., None]
# Set up integration boundaries
logMmin, logMmax = logMrange # log of min and max halo mass [Msun]
mpoints = int(mpoints) # number of integration points
M = np.logspace(logMmin, logMmax, mpoints) # masses sampled
# Out-of-loop optimisations
Dm = profile.Delta / ccl.omega_x(cosmo, a, "matter") # CCL uses Delta_m
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mfunc = np.array(
[ccl.massfunc(cosmo, M, A1, A2) for A1, A2 in zip(a, Dm)])
bh = np.array(
[ccl.halo_bias(cosmo, M, A1, A2) for A1, A2 in zip(a, Dm)])
# shape transformations
mfunc, bh = mfunc.T[..., None], bh.T[..., None]
if selection is not None:
select = np.array([selection(M, 1. / aa - 1) for aa in a])
select = select.T[..., None]
else:
select = 1
U, _ = profile.fourier_profiles(cosmo,
np.array([0.001]),
M,
a,
squeeze=False,
**kwargs)
# Tinker mass function is given in dn/dlog10M, so integrate over d(log10M)
b2h = simps(bh * mfunc * select * U, x=np.log10(M), axis=0).squeeze()
# Contribution from small masses (added in the beginning)
rhoM = ccl.rho_x(cosmo, a, "matter", is_comoving=True)
dlM = (logMmax - logMmin) / (mpoints - 1)
mfunc, bh = mfunc.squeeze(), bh.squeeze() # squeeze extra dimensions
n0_2h = np.array((rhoM - np.dot(M, mfunc * bh) * dlM) / M[0])[None, ...,
None]
b2h += (n0_2h * U[0]).squeeze()
b2h /= Unorm.squeeze()
return b2h.squeeze()
def get_E2Omega_m(self, z):
a = 1.0/(1.0+z)
return ccl.omega_x(self.be_cosmo, a, "matter")*(ccl.h_over_h0(self.be_cosmo, a))**2
def hm_1h_trispectrum(cosmo,
k,
a,
profiles,
logMrange=(8, 16),
mpoints=128,
selection=None,
**kwargs):
"""Computes the halo model prediction for the 1-halo 3D
trispectrum of four quantities.
Args:
cosmo (:obj:`ccl.Cosmology`): cosmology.
k (array): array of wavenumbers in units of Mpc^-1
a (array): array of scale factor values
profiles (tuple): tuple of four profile objects (currently
only Arnaud and HOD are implemented) corresponding to
the four quantities being correlated.
logMrange (tuple): limits of integration in log10(M/Msun)
mpoints (int): number of mass samples
selection (function): selection function in (M,z) to include
in the calculation. Pass None if you don't want to select
a subset of the M-z plane.
**kwargs: parameter used internally by the profiles.
"""
k = np.atleast_1d(k)
a = np.atleast_1d(a)
pau, pav, pbu, pbv = profiles
aUnorm = pau.profnorm(cosmo, a, squeeze=False, **kwargs)
aVnorm = pav.profnorm(cosmo, a, squeeze=False, **kwargs)
bUnorm = pbu.profnorm(cosmo, a, squeeze=False, **kwargs)
bVnorm = pbv.profnorm(cosmo, a, squeeze=False, **kwargs)
logMmin, logMmax = logMrange
mpoints = int(mpoints)
M = np.logspace(logMmin, logMmax, mpoints)
Dm = pau.Delta / ccl.omega_x(cosmo, a, 'matter')
mfunc = np.array(
[ccl.massfunc(cosmo, M, aa, Dmm) for aa, Dmm in zip(a, Dm)]).T
if selection is not None:
select = np.array([selection(M, 1. / aa - 1) for aa in a]).T
else:
select = 1
aU, aUU = pau.fourier_profiles(cosmo, k, M, a, squeeze=False, **kwargs)
if pau.name == pav.name:
aUV = aUU
else:
aV, aVV = pav.fourier_profiles(cosmo, k, M, a, squeeze=False, **kwargs)
if 'r_corr' in kwargs:
r = kwargs['r_corr']
else:
r = 0
# aUV = np.sqrt(aUU*aVV)*(1+r)
aUV = aU * aV * (1 + r)
bU, bUU = pbu.fourier_profiles(cosmo, k, M, a, squeeze=False, **kwargs)
if pbu.name == pbv.name:
bUV = bUU
else:
bV, bVV = pbv.fourier_profiles(cosmo, k, M, a, squeeze=False, **kwargs)
if 'r_corr' in kwargs:
r = kwargs['r_corr']
else:
r = 0
# bUV = np.sqrt(bUU*bVV)*(1+r)
bUV = bU * bV * (1 + r)
t1h = simps((select * mfunc)[:, :, None, None] * aUV[:, :, :, None] *
bUV[:, :, None, :],
x=np.log10(M),
axis=0)
rhoM = ccl.rho_x(cosmo, a, "matter", is_comoving=True)
dlM = (logMmax - logMmin) / (mpoints - 1)
n0_1h = (rhoM - np.dot(M, mfunc) * dlM) / M[0]
t1h += (n0_1h[:, None, None] * aUV[0, :, :, None] * bUV[0, :, None, :])
t1h /= (aUnorm * aVnorm * bUnorm * bVnorm)[:, None, None]
return t1h
