def pk2corrfunc(k, pk, r, h=0.001):
# compute correlation function for a given matter power spectrum
#r = np.arange(rmin,rmax,dr)
# power spectrum
pkfunc = spline(k, k**0.5 / (2**1.5 * np.pi**1.5) * pk)
# setup hankel transform
ht = hankel.HankelTransform(nu=0.5, h=h)
# compute correlation function
XI = ht.transform(pkfunc, r, False, inverse=True) / np.sqrt(r)
return spline(r, XI)
def IntegPJ0(k, pk0, h=.001, verbose=False):
# construct a function: F(r) = int[kP(k)*J_0(kr)/2pi]
r = basic.cosmofuncs.dist_comoving(np.linspace(1e-4, 5., 2000)) * .05
if verbose: print('compute using r between', min(r), max(r), r[1] - r[0])
# setup hankel transform
ht = hankel.HankelTransform(nu=0., h=h)
# not use Hankel transform for r = 0 due to numerical accuracy
PJ0 = integrate.quad(spline(k, k * pk0), 1e-4, 4.)[0] / (2 * np.pi)
# for r /= 0
PJR = ht.transform(spline(k, pk0), r, False, inverse=True) / (2 * np.pi)
# replace r=0 with the exact result
PJR[0] = PJ0
return spline(r, PJR)
def IntegPJ(k, zs, pk, h=.001):
# construct a function: F(r) = int[kP(k)*J_0(kr)/2pi]
r = basic.cosmofuncs.dist_comoving(np.linspace(1e-4, 5., 2000)) * .05
# setup hankel transform
ht = hankel.HankelTransform(nu=0., h=h)
PJR = np.zeros((len(zs), len(r)))
for zi, z in enumerate(zs):
# for r /= 0
PJR[zi, :] = ht.transform(spline(k, pk[zi]), r, False,
inverse=True) / (2 * np.pi)
# replace r=0 with the exact result
PJR[zi, 0] = integrate.quad(spline(k, k * pk[zi]), 1e-4,
4.)[0] / (2 * np.pi)
return interp2d(r, zs, PJR, kind='cubic')
def initialize_postload(self):
self.covmat = self.fullcov[np.ix_(self.used_indices,
self.used_indices)]
self.covinv = np.linalg.inv(self.covmat)
self.data_vector = self.make_vector(self.data_arrays)
self.errors = copy.deepcopy(self.data_arrays)
cov_ix = 0
for i, (type_ix, f1, f2, ix) in enumerate(self.indices):
self.errors[type_ix][f1, f2][ix] = np.sqrt(self.fullcov[cov_ix,
cov_ix])
cov_ix += 1
self.theta_bins_radians = self.theta_bins / 60 * np.pi / 180
# Note hankel assumes integral starts at ell=0
# (though could change spline to zero at zero).
# At percent level it matters what is assumed
if self.use_hankel: # pragma: no cover
# noinspection PyUnresolvedReferences
import hankel
maxx = self.theta_bins_radians[-1] * self.l_max
h = 3.2 * np.pi / maxx
N = int(3.2 / h)
self.hankel0 = hankel.HankelTransform(nu=0, N=N, h=h)
self.hankel2 = hankel.HankelTransform(nu=2, N=N, h=h)
self.hankel4 = hankel.HankelTransform(nu=4, N=N, h=h)
elif self.binned_bessels:
# Approximate bessel integral as binned smooth C_L against integrals of
# bessel in each bin. Here we crudely precompute an approximation to the
# bessel integral by brute force
dls = np.diff(
np.unique((np.exp(
np.linspace(np.log(1.), np.log(self.l_max),
int(500 * self.acc)))).astype(int)))
groups = []
ell = 2 # ell_min
self.ls_bessel = np.zeros(dls.size)
for i, dlx in enumerate(dls):
self.ls_bessel[i] = (2 * ell + dlx - 1) / 2.
groups.append(np.arange(ell, ell + dlx))
ell += dlx
js = np.empty(
(3, self.ls_bessel.size, len(self.theta_bins_radians)))
bigell = np.arange(0, self.l_max + 1, dtype=np.float64)
for i, theta in enumerate(self.theta_bins_radians):
bigx = bigell * theta
for ix, nu in enumerate([0, 2, 4]):
bigj = special.jn(nu, bigx) * bigell / (2 * np.pi)
for j, g in enumerate(groups):
js[ix, j, i] = np.sum(bigj[g])
self.bessel_cache = js[0, :, :], js[1, :, :], js[2, :, :]
else: # pragma: no cover
# get ell for bessel transform in dense array,
# and precompute bessel function matrices
# Much slower than binned_bessels as many more sampling points
dl = 4
self.ls_bessel = np.arange(2 + dl / 2,
self.l_max + 1,
dl,
dtype=np.float64)
j0s = np.empty((len(self.ls_bessel), len(self.theta_bins_radians)))
j2s = np.empty((len(self.ls_bessel), len(self.theta_bins_radians)))
j4s = np.empty((len(self.ls_bessel), len(self.theta_bins_radians)))
for i, theta in enumerate(self.theta_bins_radians):
x = self.ls_bessel * theta
j0s[:, i] = self.ls_bessel * special.jn(0, x)
j2s[:, i] = self.ls_bessel * special.jn(2, x)
j4s[:, i] = self.ls_bessel * special.jn(4, x)
j0s *= dl / (2 * np.pi)
j2s *= dl / (2 * np.pi)
j4s *= dl / (2 * np.pi)
self.bessel_cache = j0s, j2s, j4s
# Fine z sampling
if self.acc > 1:
self.zs = np.linspace(0.005, self.zmax, int(350 * self.acc))
else:
self.zs = self.zmid[self.zmid <= self.zmax]
# Interpolator z sampling
assert self.zmax <= 5, "z max too large!"
self.zs_interp = np.linspace(0, self.zmax, 100)
import matplotlib.pyplot as plt
import numpy as np
import hankel
# We need the spline interpolation to obtain a smooth function that can be transformed back to the original function
from scipy.interpolate import InterpolatedUnivariateSpline as spline
realspace = np.linspace(0, 100, 300)[1:] # Realspace domain
hankelspace = np.logspace(-5, 15, 300) # Hankel space domain
ht = hankel.HankelTransform(nu=1, N=500, h=0.0005)
gupFilter = np.genfromtxt('gup1997J147pt.csv', float, delimiter=',').flatten()
print(f"n={len(gupFilter)} Filter loaded")
print(gupFilter)
def abscissaeJ1(r):
# Returns the lambdas used in the method of Guptasarma and Singh 1997
# function f(lambda) is evaluated at these lambdas
# 47 point filter parameters:
a = -3.05078187595e0
s = 1.10599010095e-1
# 140 point filter parameters
# a = -7.91001919000e0
# s = 8.79671439570e-2
rangefunc = np.arange(0, len(gupFilter))
eval_points = (1 / r[:, np.newaxis]) * np.power(10, a + (rangefunc * s))
return eval_points
def wint(self, rr, nn=100, hh=0.03):
"""Hankel integrator"""
fpow = self.fmaker(rr)
h = hankel.HankelTransform(nu=2, N=nn, h=hh)
val = np.array(h.transform(fpow)) / rr / (2. * np.pi)
return val