def itam(self):
''' the main algorithm '''
target_s = self.pk
if self.flag_lin == True:
s_g_iterate = self.pk_l
else:
s_g_iterate = self.pk
eps0 = 1.
eps1 = 1.
ii = 0
Deps = 1.
while Deps > self.Deps and eps1 > self.eps:
ii += 1
print('iteration =', ii)
eps0 = eps1
r_g_iterate = hank.pk_to_xi(s_g_iterate, self.r, self.k, self.nmax,
self.stepsize)
if N.any(N.isnan(r_g_iterate)):
raise ValueError("r_g_iterate contains NaN")
sigma2 = r_g_iterate[0]
r_ng_iterate = N.asarray([
self.solve_integral(r_g / sigma2, sigma2)
for r_g in r_g_iterate
])
if N.any(N.isnan(r_ng_iterate)):
raise ValueError("r_ng_iterate contains NaN")
s_ng_iterate = hank.xi_to_pk(r_ng_iterate, self.r, self.k,
self.nmax, self.stepsize * 10)
eps1 = N.sqrt(
N.sum((target_s - s_ng_iterate)**2.) / N.sum(target_s**2))
Deps = abs(eps1 - eps0)
Deps /= eps1
print('eps = %.5f' % eps1, 'Deps =%.5f' % Deps)
if Deps > self.Deps and eps1 > self.eps:
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=RuntimeWarning)
s_g_iterate = N.power(target_s / s_ng_iterate,
self.beta) * s_g_iterate
s_g_iterate[N.isnan(s_g_iterate)] = 0.
if N.any(N.isnan(s_g_iterate)):
raise ValueError("s_g_iterate contains NaN")
else:
print('converged at', ii, 'iteration')
return s_g_iterate, s_ng_iterate
def test_itam_lognormal(nmax=10000,
stepsize=1e-04,
boxsize=256.,
ng=256,
Rth=2.):
'''
Check ITAM gives the exact result in the lognormal case
'''
lmin = boxsize / float(ng) / 10.
lmax = boxsize
kmin = 2. * N.pi / lmax
kmax = 2. * N.pi / lmin
k = N.logspace(N.log10(kmin), N.log10(kmax), 200) # spectral grid
rr = N.logspace(N.log10(lmin), N.log10(lmax), 200) # physical grid
kny = 2.0 * N.pi / boxsize * ng / 2.0
# linear
kbins, pk = N.loadtxt('data_itam/planck_pk.txt')
pk = 10.**N.interp(N.log10(k),
N.log10(kbins),
N.log10(pk),
left=0.,
right=0.)
Wk2 = N.exp(-k * k * Rth * Rth)
pk *= Wk2
xi = hankel3d.pk_to_xi(pk, rr, k, nmax, stepsize)
print('solving integral')
sigma2_l = xi[0]
xi_ng = N.asarray(
[solve_integral_lognormal(rrho, sigma2_l) for rrho in xi / xi[0]])
pkfromxi = hankel3d.xi_to_pk(xi_ng, rr, k, nmax, stepsize * 10)
pkfromxi_th = hankel3d.xi_to_pk(N.exp(xi) - 1., rr, k, nmax, stepsize * 10)
plt.clf()
plt.subplot(211)
plt.xlim([-2., 150.])
plt.plot(rr, rr**2 * (N.exp(xi) - 1.), label='theoretical')
plt.plot(rr, rr**2 * xi_ng, 'r--', label='numerical')
plt.title('correlation')
plt.legend()
plt.subplot(212)
plt.semilogx(k, (pkfromxi - pkfromxi_th) / pkfromxi_th, lw=2.)
plt.xlabel(r'$k [h/{\rm Mpc}]$')
plt.ylabel(r'$\Delta P(k)/P(k)$')
plt.legend()
plt.xlim([kmin, kmax / 2.])
plt.ylim([-0.01, 0.01])
plt.show()
return 0
def test_hankel(boxsize=256., ng=256, Rth=2., nmax=10000, stepsize=1e-04):
'''
test the hankel transformation applied to the Nbody realization
'''
lmin = boxsize / float(ng) / 10.
lmax = boxsize
kmin = 2. * N.pi / lmax
kmax = 2. * N.pi / lmin
print('kny=', N.pi / boxsize * ng)
k = N.logspace(N.log10(kmin), N.log10(kmax), 400) # spectral grid
r = N.logspace(N.log10(lmin), N.log10(lmax), 400) # physical grid
kny = 2.0 * N.pi / boxsize * ng / 2.0
kbins, pk = N.loadtxt('data_itam/planck_pk.txt')
pk = 10.**N.interp(N.log10(k),
N.log10(kbins),
N.log10(pk),
left=0.,
right=0.)
Wk2 = N.exp(-k * k * Rth * Rth)
pk *= Wk2
xi = hankel3d.pk_to_xi(pk, r, k, nmax, stepsize)
plt.clf()
plt.subplot(211)
plt.plot(r, r**2 * xi)
plt.xlim([-2., 50.])
#plt.ylim([-5.,15.])
plt.xlabel(r'$r\ [Mpc/{\rm h}]$')
plt.ylabel(r'$r^2 \xi(r)$')
pkfromxi = hankel3d.xi_to_pk(xi, r, k, nmax, stepsize * 10)
pk[k >= kny] = 0.0
plt.subplot(212)
plt.semilogx(k, pkfromxi / pk - 1., label='smoothed')
plt.legend()
plt.xlabel(r'$k [h/{\rm Mpc}]$')
plt.ylabel(r'$R(k)-1$')
plt.ylim([-0.03, 0.03])
plt.show()
return 0
def __init__(self,
boxsize=256.,
ng=256,
Rth=2.,
nmax=10000,
stepsize=1e-04,
beta=1.0,
eps=0.001,
Deps=0.001,
plotty=0,
pathto_linpk=None,
pathto_pk=None):
self.nmax = nmax # for hankel transform
self.stepsize = stepsize # for hankel transform
self.beta = beta # update pk
self.eps = eps
self.Deps = Deps
self.boxsize = boxsize
self.ng = ng
self.Rth = Rth
self.plotty = plotty
try:
kbins, pk = N.loadtxt(pathto_pk)
except:
raise ValueError(
"Select correctly the path to lookup table of target power spectrum"
)
if not pathto_linpk == None:
self.flag_lin = True
print(
'you specified the linear power spectrum for the initilization'
)
if not os.path.exists(pathto_linpk):
raise ValueError(
"The path to the linear power spectrum does not exist")
else:
kbins, pk_l = N.loadtxt(pathto_pk)
else:
self.flag_lin = False
pass
cellsize = boxsize / float(ng)
lmin = boxsize / float(ng) / 10.
lmax = boxsize
self.kmin = 2. * N.pi / lmax
self.kmax = 2. * N.pi / lmin
self.k = N.logspace(N.log10(self.kmin), N.log10(self.kmax), 200)
self.r = N.logspace(N.log10(lmin), N.log10(lmax), 200)
self.pk = 10.**N.interp(N.log10(self.k),
N.log10(kbins),
N.log10(pk),
left=0.,
right=0.)
Wk2 = N.exp(-self.k * self.k * Rth * Rth)
self.pk *= Wk2
if self.flag_lin == True:
pk_l *= correction
self.pk_l = 10.**N.interp(N.log10(self.k),
N.log10(kbins),
N.log10(pk_l),
left=0.,
right=0.)
Wk2 = N.exp(-self.k * self.k * Rth * Rth)
self.pk_l *= Wk2
self.pk_g, self.pk_ng = self.itam()
# Coles and Jones case
xi_ng = hank.pk_to_xi(self.pk, self.r, self.k, self.nmax,
self.stepsize)
xi_g = N.log1p(xi_ng)
self.pk_g_CJ = hank.xi_to_pk(xi_g, self.r, self.k, self.nmax,
self.stepsize * 10)
#self.test_realization(seed=31415)
if plotty == 1:
plt.figure(figsize=(1.62 * 5.5, 5.5))
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=RuntimeWarning)
plt.semilogx(self.k, (self.pk_g_CJ - self.pk_g) / self.pk_g_CJ,
'-',
lw=2.,
label='pre-translation')
plt.semilogx(self.k, (self.pk - self.pk_ng_exact) / self.pk,
'--',
lw=2.,
label='itam')
plt.grid()
plt.legend
plt.ylim([-0.05, 0.05])
plt.xlim([0.02, 1.5])
plt.xlabel('$k \ [h/Mpc]$', fontsize='xx-large')
plt.ylabel('$\Delta P(k) \ [Mpc/h]^3$', fontsize='xx-large')
plt.show()
def test_itam(nmax=10000,
stepsize=1e-04,
boxsize=256.,
ng=256,
target=None,
Rth=2.):
''' check the identity case '''
try:
kbins, pk = N.loadtxt(target)
except:
ValueError(
"Select correctly the path to lookup table of target power spectrum"
)
lmin = boxsize / float(ng) / 10.
lmax = boxsize
kmin = 2. * N.pi / lmax
kmax = 2. * N.pi / lmin
k = N.logspace(N.log10(kmin), N.log10(kmax), 200) # spectral grid
rr = N.logspace(N.log10(lmin), N.log10(lmax), 200) # physical grid
kny = 2.0 * N.pi / boxsize * ng / 2.0
kbins, pk = N.loadtxt('data_itam/planck_pk.txt')
pk = 10.**N.interp(N.log10(k),
N.log10(kbins),
N.log10(pk),
left=0.,
right=0.)
Wk2 = N.exp(-k * k * Rth * Rth)
pk *= Wk2
xi = hankel3d.pk_to_xi(pk, rr, k, nmax, stepsize)
print('solving integral')
cdf, ppf = N.loadtxt('data_itam/_ppf.txt')
xi_ng = N.asarray(
[solve_integral(rrho, cdf, ppf, xi[0]) for rrho in xi / xi[0]])
pkfromxi = hankel3d.xi_to_pk(xi_ng, rr, k, nmax, stepsize * 10)
# correlation function
plt.clf()
plt.subplot(211)
plt.xlim([-2., 150.])
plt.plot(rr, rr**2 * xi, label='before transform')
plt.plot(rr, rr**2 * xi_ng, 'r--', label='after transform')
plt.title('correlation')
plt.legend()
plt.subplot(212)
plt.loglog(k, pkfromxi, lw=2, label='after translation')
plt.loglog(k, pk, 'r--', lw=2, label='initial')
plt.xlabel(r'$k [h/{\rm Mpc}]$')
plt.ylabel(r'$P(k)$')
plt.legend()
plt.xlim([kmin, kmax])
plt.ylim([1., 1e+06])
plt.show()
def integrand(kk):
ppk = N.interp(kk, k, pkfromxi, left=0., right=0.)
ppk *= kk * kk
return ppk
k_min = 2.0 * N.pi / boxsize
k_max = 2.0 * N.pi / boxsize * ng / 2.
sigma2, _ = quad(integrand,
k_min,
k_max,
epsabs=0.0,
epsrel=1e-03,
limit=100)
sigma2 /= 2.0 * N.pi**2.
print('sigma^2=', sigma2, 'whereas is expected=', xi_ng[0])
return 0