def get_CCL_beta(M, z):
a = 1. / (1 + z)
d = 1.0001
import pyccl as ccl
params = ccl.Parameters(Omega_c=cos['om'] - cos['ob'],
Omega_b=cos['ob'],
h=cos['h'],
sigma8=cos['s8'],
n_s=cos['ns'])
cosmo = ccl.Cosmology(params)
dndM1 = ccl.massfunc(cosmo, M, a) / M
dndM2 = ccl.massfunc(cosmo, M * d, a) / (M * d)
return np.log(dndM2 / dndM1) / np.log(d)
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 test_mass_function():
df = pd.read_csv(os.path.join(os.path.dirname(__file__),
'data/model1_hmf.txt'),
sep=' ',
names=['logmass', 'sigma', 'invsigma', 'logmf'],
skiprows=1)
ccl.physical_constants.T_CMB = 2.7
with ccl.Cosmology(Omega_c=0.25,
Omega_b=0.05,
Omega_g=0,
Omega_k=0,
h=0.7,
sigma8=0.8,
n_s=0.96,
Neff=0,
m_nu=0.0,
w0=-1,
wa=0,
transfer_function='bbks',
mass_function='tinker') as c:
rho_m = ccl.physical_constants.RHO_CRITICAL * c['Omega_m'] * c['h']**2
for i, logmass in enumerate(df['logmass']):
mass = 10**logmass
sigma = ccl.sigmaM(c, mass, 1.0)
loginvsigma = np.log10(1.0 / sigma)
logmf = np.log10(
ccl.massfunc(c, mass, 1, 200) * mass / rho_m / np.log(10))
assert np.allclose(sigma, df['sigma'].values[i], rtol=3e-5)
assert np.allclose(loginvsigma,
df['invsigma'].values[i],
rtol=1e-3)
assert np.allclose(logmf, df['logmf'].values[i], rtol=5e-5)
def check_massfunc(cosmo):
"""
Check that mass function and supporting functions can be run.
"""
z = 0.
z_arr = np.linspace(0., 2., 10)
a = 1.
a_arr = 1. / (1. + z_arr)
mhalo_scl = 1e13
mhalo_lst = [1e11, 1e12, 1e13, 1e14, 1e15, 1e16]
mhalo_arr = np.array([1e11, 1e12, 1e13, 1e14, 1e15, 1e16])
odelta = 200.
# massfunc
assert_(all_finite(ccl.massfunc(cosmo, mhalo_scl, a, odelta)))
assert_(all_finite(ccl.massfunc(cosmo, mhalo_lst, a, odelta)))
assert_(all_finite(ccl.massfunc(cosmo, mhalo_arr, a, odelta)))
assert_raises(TypeError, ccl.massfunc, cosmo, mhalo_scl, a_arr, odelta)
assert_raises(TypeError, ccl.massfunc, cosmo, mhalo_lst, a_arr, odelta)
assert_raises(TypeError, ccl.massfunc, cosmo, mhalo_arr, a_arr, odelta)
# Check whether odelta out of bounds
assert_raises(CCLError, ccl.massfunc, cosmo, mhalo_scl, a, 199.)
assert_raises(CCLError, ccl.massfunc, cosmo, mhalo_scl, a, 5000.)
# massfunc_m2r
assert_(all_finite(ccl.massfunc_m2r(cosmo, mhalo_scl)))
assert_(all_finite(ccl.massfunc_m2r(cosmo, mhalo_lst)))
assert_(all_finite(ccl.massfunc_m2r(cosmo, mhalo_arr)))
# sigmaM
assert_(all_finite(ccl.sigmaM(cosmo, mhalo_scl, a)))
assert_(all_finite(ccl.sigmaM(cosmo, mhalo_lst, a)))
assert_(all_finite(ccl.sigmaM(cosmo, mhalo_arr, a)))
assert_raises(TypeError, ccl.sigmaM, cosmo, mhalo_scl, a_arr)
assert_raises(TypeError, ccl.sigmaM, cosmo, mhalo_lst, a_arr)
assert_raises(TypeError, ccl.sigmaM, cosmo, mhalo_arr, a_arr)
# halo_bias
assert_(all_finite(ccl.halo_bias(cosmo, mhalo_scl, a)))
assert_(all_finite(ccl.halo_bias(cosmo, mhalo_lst, a)))
assert_(all_finite(ccl.halo_bias(cosmo, mhalo_arr, a)))
def nm_integ(z):
"""
Integral to get n(>M_min).
"""
Mh = Mh_range(z, **args)
dndlog10m = ccl.massfunc(cosmo, Mh, 1. / (1. + z))
# Integrate over mass range
return integrate.simps(dndlog10m, np.log10(Mh))
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 pk(self, k, a, lmmin=6., lmmax=17., nlm=256, return_decomposed=False):
"""
Returns power spectrum at redshift `z` sampled at all values of k in `k`.
k : array of wavenumbers in CCL units
a : scale factor
lmmin, lmmax, nlm : mass edges and sampling rate for mass integral.
return_decomposed : if True, returns 1-halo, 2-halo, bias, shot noise and total (see below for order).
"""
z = 1. / a - 1.
marr = np.logspace(lmmin, lmmax, nlm)
dlm = np.log10(marr[1] / marr[0])
u_s = self.u_sat(z, marr, k)
hmf = ccl.massfunc(self.cosmo, marr, a)
hbf = ccl.halo_bias(self.cosmo, marr, a)
rhoM = ccl.rho_x(self.cosmo, a, "matter", is_comoving=True)
n0_1h = (rhoM - np.sum(hmf * marr) * dlm) / marr[0]
n0_2h = (rhoM - np.sum(hmf * hbf * marr) * dlm) / marr[0]
#Number of galaxies
fc = self.fc_f(z)
ngm = self.n_tot(z, marr)
ncm = self.n_cent(z, marr)
nsm = self.n_sat(z, marr)
#Number density
ng = np.sum(hmf * ngm) * dlm + n0_1h * ngm[0]
if ng <= 1E-16: #Make sure we won't divide by 0
return None
#Bias
b_hod = np.sum(
(hmf * hbf * ncm)[None, :] * (fc + nsm[None, :] * u_s[:, :]),
axis=1) * dlm + n0_2h * ncm[0] * (fc + nsm[0] * u_s[:, 0])
b_hod /= ng
#1-halo
#p1h=np.sum((hmf*ncm**2)[None,:]*(fc+nsm[None,:]*u_s[:,:])**2,axis=1)*dlm+n0_1h*(ncm[0]*(fc+nsm[0]*u_s[:,0]))**2
p1h = np.sum(
(hmf * ncm)[None, :] * (2 * fc * nsm[None, :] * u_s[:, :] +
(nsm[None, :] * u_s[:, :])**2),
axis=1) * dlm + n0_1h * ncm[0] * (2 * fc * nsm[0] * u_s[:, 0] +
(nsm[0] * u_s[:, 0])**2)
p1h /= ng**2
#2-halo
p2h = b_hod**2 * ccl.linear_matter_power(self.cosmo, k, a)
if return_decomposed:
return p1h + p2h, p1h, p2h, np.ones_like(k) / ng, b_hod
else:
return p1h + p2h
def test_massfunc_models_smoke(mf_type):
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.045,
h=0.67,
sigma8=0.8,
n_s=0.96,
transfer_function='bbks',
matter_power_spectrum='linear',
mass_function=mf_type)
hmf_cls = ccl.halos.mass_function_from_name(MF_EQUIV[mf_type])
hmf = hmf_cls(cosmo)
for m in MS:
nm_old = ccl.massfunc(cosmo, m, 1.)
nm_new = hmf.get_mass_function(cosmo, m, 1.)
assert np.all(np.isfinite(nm_old))
assert np.shape(nm_old) == np.shape(m)
assert np.all(np.array(nm_old) == np.array(nm_new))
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 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
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$"))
def x(self):
pass
# Specify cosmology
cosmo = ccl.Cosmology(h=0.67,
Omega_c=0.25,
Omega_b=0.045,
n_s=0.965,
sigma8=0.834)
z = 0.
# Halo mass function
Mh = np.logspace(np.log10(MH_MIN), np.log10(MH_MAX), MH_BINS)
dndlog10m = ccl.massfunc(cosmo, Mh, 1. / (1. + z))
bh = ccl.halo_bias(cosmo, Mh, a)
# Cumulative integral of halo mass function
nm = integrate.cumtrapz(dndlog10m[::-1], -np.log10(Mh)[::-1], initial=0.)[::-1]
# Rescale nm to get cdf
cdf = nm / np.max(nm)
# Build interpolator
Mh_interp = interpolate.interp1d(cdf, np.log10(Mh), kind='linear')
np.random.seed(10)
u = np.random.uniform(size=int(1e6))
# Realise halo mass distribution
def test_massfunc_smoke(m):
a = 0.8
mf = ccl.massfunc(COSMO, m, a)
assert np.all(np.isfinite(mf))
assert np.shape(mf) == np.shape(m)
def pk_gm(self,
k,
a,
lmmin=6.,
lmmax=17.,
nlm=256,
return_decomposed=False):
"""
Returns galaxy-matter power spectrum at a single scale-factor a for array of wave vectors k.
:param k: wave vector array
:param a: single scale factor value
:param lmmin: Mmin for HOD integrals
:param lmmax: Mmax for HOD integrals
:param nlm: sampling rate for mass integral
:param return_decomposed: boolean tag, if True return 1h, 2h power spectrum separately
:return:
"""
z = 1. / a - 1.
marr = np.logspace(lmmin, lmmax, nlm)
dlm = np.log10(marr[1] / marr[0])
u_nfw = self.u_sat(z, marr, k)
hmf = ccl.massfunc(self.cosmo, marr, a)
hbf = ccl.halo_bias(self.cosmo, marr, a)
rhoM = ccl.rho_x(self.cosmo, a, "matter", is_comoving=True)
n0_1h = (rhoM - np.sum(hmf * marr) * dlm) / marr[0]
n0_2h = (rhoM - np.sum(hmf * hbf * marr) * dlm) / marr[0]
# n0_2h = (rhoM - np.sum(hmf*hbf*marr)*dlm)
#Number of galaxies
fc = self.fc_f(z)
ngm = self.n_tot(z, marr)
ncm = self.n_cent(z, marr)
nsm = self.n_sat(z, marr)
#Number density
ng = np.sum(hmf * ngm) * dlm + n0_1h * ngm[0]
if ng <= 1E-16: #Make sure we won't divide by 0
return None
#Bias
b_hod=np.sum((hmf*hbf*ncm)[None,:]*(fc+nsm[None,:]*u_nfw[:,:]),axis=1)*dlm \
+ n0_2h*ncm[0]*(fc+nsm[0]*u_nfw[:,0])
b_m = np.sum((hmf * hbf)[None, :] * marr[None, :] * u_nfw[:, :],
axis=1) * dlm + n0_2h * u_nfw[:, 0]
b_hod /= ng
b_m /= rhoM
#1-halo
#p1h=np.sum((hmf*ncm**2)[None,:]*(fc+nsm[None,:]*u_s[:,:])**2,axis=1)*dlm+n0_1h*(ncm[0]*(fc+nsm[0]*u_s[:,0]))**2
p1h=np.sum((hmf*ncm)[None,:]*(fc+nsm[None,:]*u_nfw[:,:])*marr*u_nfw[:,:],axis=1)*dlm \
+ n0_1h*ncm[0]*(fc + nsm[0]*u_nfw[:,0])*u_nfw[:,0]
p1h /= ng * rhoM
#2-halo
p2h = b_hod * b_m * ccl.linear_matter_power(self.cosmo, k, a)
if return_decomposed:
return p1h + p2h, p1h, p2h, np.ones_like(k) / ng, b_hod
else:
return p1h + p2h
def __init__(self):
"""
Initialise.
"""
Mh = Mh_range(z, **args)
dndlog10m = ccl.massfunc(cosmo, Mh, 1. / (1. + z))
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
r500 = rDelta(data['MSZ'] * HH * 1E14, data['REDSHIFT'], 500)
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
