def dosph(self, n, x, f, tilt=1.5, extrap=True, q1=1e-3, q2=5e2):
f = f * self.renorm
if not self.extrapker:
return sph(x, nu=n, q=tilt)(f, extrap=extrap)
else:
q, p = sph(x, nu=n, q=tilt)(f, extrap=extrap)
q1, q2 = numpy.where(q > q1)[0][0], numpy.where(q > q2)[0][0]
qv = numpy.logspace(-6, 7, 1e4)
ip = self.loginterp(q[q1:q2], p[q1:q2])
return (qv, ip(qv))
def template(self,
k,
l,
func,
expon,
suppress,
power=1,
za=False,
expon_za=1.,
tilt=None,
species='mm'):
'''
Generic template that is followed by mu integrals
j0 is different since its exponent has sigma subtracted that is
later used to suppress integral
'''
Fq = np.zeros_like(self.qv)
if za == True and l == 0:
Fq = expon_za * func * (self.yq)**l
else:
Fq = expon * func * (self.yq)**l
if tilt is not None:
q = max(0, tilt - l)
else:
q = max(0, 1.5 - l)
# note that the angular integral for even powers of mu gives J_(l+1)
ktemp, ftemp = sph(self.qv, nu=l + (power % 2), q=q)(Fq * self.renorm,
extrap=False)
ftemp *= suppress
return 1 * k**l * np.interp(k, ktemp, ftemp)
def template_MII(self,
k,
l,
func,
expon,
suppress,
power=1,
za=False,
expon_za=1.,
tilt=None):
''' Generic template that is followed by mu integrals using method MII.
j0 is different since its exponent has sigma subtracted that is
later used to suppress integral
'''
Fq = np.zeros_like(self.qv)
if za == True and l == 0:
#Fq = expon_za * func * (-2./k/self.qv)**l
Fq = expon * func * (-2. / k / self.qv)**l - 1
else:
Fq = expon * func * (-2. / k / self.qv)**l
if tilt is not None:
q = tilt
else:
q = 1.5 - l
# note that the angular integral for even powers of mu gives J_(l+1)
ktemp, ftemp = sph(self.qv, nu=l + (power % 2), q=q)(Fq * self.renorm,
extrap=False)
ftemp *= suppress
return np.interp(k, ktemp, ftemp)
def dosph(n, x, f, a, tilt=1.5):
# Function to calculate spherical Bessel integrals returns q values and integral values
# Parameters: n = order of Bessel, x = variable of the function, f = function integrating over, a = power law
func = renorm * np.power(x, a) * f(x)
return sph(x, nu=n, q=tilt, lowring=True)(func, extrap=True)
def template(k, func, extrap=False):
'''Template for higher bessel integrals
'''
expon = numpy.exp(-0.5 * k**2 * (XYlin))
Fq = 0
toret = 0
for l in range(1, jn):
Fq = expon * func(k=k, l=l) * yq**l
ktemp, ftemp = \
sph(qv, nu= l, q=max(0, 1.5 - l))(Fq*renorm, extrap = extrap)
toret += 1 * k**l * numpy.interp(k, ktemp, ftemp)
return toret * 4 * np.pi
def template(self,
k,
l,
func,
expon,
suppress,
power=1,
za=False,
expon_za=1.,
tilt=None):
''' Simplified vs the original code. Beta.
Generic template that is followed by mu integrals
j0 is different since its exponent has sigma subtracted that is
later used to suppress integral
'''
Fq = np.zeros_like(self.qv)
if za == True and l == 0:
Fq = expon_za * func * self.yq**l
else:
Fq = expon * func * self.yq**l
if tilt is not None:
q = max(0, tilt - l)
else:
q = max(0, 1.5 - l)
# note that the angular integral for even powers of mu gives J_(l+1)
ktemp, ftemp = sph(self.qv, nu=l + (power % 2), q=q)(Fq * self.renorm,
extrap=False)
# if l or ( power%2 == 1 ): # note that the angular integral for even powers of mu gives J_(l+1)
# Fq = expon*func*self.yq**l
#elif j0:
# Fq = expon0*func
#
#if power == 1:
# ktemp, ftemp = \
# sph(self.qv, nu= l+1, q=max(0, 1.5 - l))(Fq*self.renorm,\
# extrap = False)
# #else:
# #ktemp, ftemp = \
# sph(self.qv, nu= l, q=max(0, 1.5 - l))(Fq*self.renorm,\
# extrap = False)
ftemp *= suppress
return 1 * k**l * np.interp(k, ktemp, ftemp)
def template0(k, func, extrap=False):
'''Template for j0 integral
'''
expon0 = numpy.exp(-0.5 * k**2 * (XYlin - sigma))
suppress = numpy.exp(-0.5 * k**2 * sigma)
Fq = expon0 * func(k=k, l=0)
if abs(func(k=k, l=0)[-1]) > 1e-7:
#print("Subtracting large scale constant = ", func(0)[-1], k)
sigma2 = func(k=k, l=0)[-1]
#print(sigma2)
Fq -= sigma2
ktemp, ftemp = \
sph(qv, nu= 0, q=1.5)(Fq*renorm,extrap = extrap)
ftemp *= suppress
return 1 * numpy.interp(k, ktemp, ftemp) * 4 * np.pi
def template(self, k, l, func, expon, expon0, suppress, j0=True):
'''Generic template that is followed by mu integrals
j0 is different since its exponent has sigma subtracted that is
later used to suppress integral
'''
Fq = numpy.zeros_like(self.qv)
if l:
Fq = expon * func * self.yq**l
elif j0:
Fq = expon0 * func
ktemp, ftemp = \
sph(self.qv, nu= l, q=max(0, 1.5 - l))(Fq*self.renorm,\
extrap = False)
if l == 0 and j0:
ftemp *= suppress
return 1 * k**l * numpy.interp(k, ktemp, ftemp)
def template_MI(self,
k,
l,
func,
expon,
suppress,
power=0,
za=False,
expon_za=1.,
tilt=None,
pair='mm'):
''' Generic template that is followed by mu integrals using method MI.
j0 is different since its exponent has sigma subtracted that is
later used to suppress integral
'''
D2 = self.D**2
Fq = np.zeros_like(self.qv)
if za == True and l == 0:
#Fq = expon_za * func * (-2./k/self.qv)**l
Fq = expon * func - 1
else:
Fq = expon * func * (D2 * self.yqs[pair])**l
if tilt is not None:
q = tilt
else:
q = max(0, 1.5 - l)
# note that the angular integral for even powers of mu gives J_(l+1)
ktemp, ftemp = sph(self.qv, nu=l + power, q=q)(Fq * self.renorm,
extrap=False)
ftemp *= suppress
return 1 * k**l * np.interp(k, ktemp, ftemp)
def dosph(self, n, x, f, tilt=1.5, extrap=True):
#Function to do bessel integral using FFTLog for kernels
f = f * self.renorm
return sph(x, nu=n, q=tilt)(f, extrap=extrap)
def dosph(n, x, f, a, tilt=1.5):
func = renorm * np.power(x, a) * f(x)
return sph(x, nu=n, q=tilt, lowring=True)(func, extrap=True)
def get_Pktharray(output_nl_grid,
klin,
knl,
Pkzlin,
Pnl_kz,
usePNL_for_Pk=True,
pt_type=None,
Pk_terms_names=None,
z_array=None,
output_xi=False,
use_fftlog=False):
klinlog = np.log(klin)
Pk0lin = Pkzlin[0, :]
ind = np.where(klin > 0.03)[0][0]
Growth = np.sqrt(Pkzlin[:, ind] / Pkzlin[0, ind])
nk = 4 * len(
klin
) # higher res increases runtime, decreases potential ringing at low-k
# eps = 1e-6
# eps = 0.
# kmin = np.log10((1. + eps) * klin[0])
# kmax = np.log10((1. - eps) * klin[-1])
kmin = -6.0
kmax = 3.0
klin_fpt = np.logspace(kmin, kmax, nk)
k1log = np.log(klin_fpt)
# pinterp=interp1d(klinlog,np.log(Pk0lin),bounds_error=False, fill_value="extrapolate")
plininterp = interp1d(klinlog,
np.log(Pk0lin),
fill_value='extrapolate',
bounds_error=False)
## This interpolation should be at the input bounds. Extrapolate used to avoid failure due to numerical noise. No actual extrapolation is done. We could handle this using a margin or something else
Plin_klin_fpt = np.exp(plininterp(k1log))
if (knl[0] < klin_fpt[0]) or (knl[-1] > klin_fpt[-1]):
EK1 = k_extend(klin_fpt, np.log10(knl[0]), np.log10(knl[-1]))
klin_fpt = EK1.extrap_k()
Plin_klin_fpt = EK1.extrap_P_low(Plin_klin_fpt)
Plin_klin_fpt = EK1.extrap_P_high(Plin_klin_fpt)
klin_fpt_log = np.log(klin_fpt)
knl_log = np.log(knl)
# print output_nl_grid
if output_nl_grid:
temp = intspline(klin_fpt_log, np.log(Plin_klin_fpt))
Plin = np.exp(temp(knl_log))
Pnl1 = Pnl_kz
if usePNL_for_Pk:
knl2mat = np.tile(knl**2, (Pnl_kz.shape[0], 1))
k2Pnl1 = np.multiply(knl2mat, Pnl_kz)
else:
k2Pnl1 = np.outer(Growth**2, (knl**2) * Plin)
if output_xi:
renorm = np.sqrt(np.pi / 2.)
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * Plin,
nu=1.5,
c_window_width=0.2)
r_lin, xi_lin_z0 = myfftlog.fftlog(0)
else:
r_lin, xitemp = sph(knl, nu=0, q=1.5)(Plin * renorm,
extrap=True)
xi_lin_z0 = (1 / (2 * np.pi**2)) * xitemp
xi_lin = np.outer(Growth**2, xi_lin_z0)
xi_nl = np.zeros(xi_lin.shape)
xi_k2Pk = np.zeros(xi_lin.shape)
for j in range(len(z_array)):
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * Pnl_kz[j, :],
nu=1.5,
c_window_width=0.2)
_, xi_basis = myfftlog.fftlog(0)
else:
_, xitemp = sph(knl, nu=0, q=1.5)(Pnl_kz[j, :] * renorm,
extrap=True)
xi_basis = (1 / (2 * np.pi**2)) * xitemp
xi_nl[j, :] = xi_basis
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * k2Pnl1[j, :],
nu=1.5,
c_window_width=0.2)
_, xi_basis = myfftlog.fftlog(0)
else:
_, xitemp = sph(knl, nu=0, q=1.5)(k2Pnl1[j, :] * renorm,
extrap=True)
xi_basis = (1 / (2 * np.pi**2)) * xitemp
xi_k2Pk[j, :] = xi_basis
else:
Plin = Plin_klin_fpt
Pnl1 = Pnl_kz
if usePNL_for_Pk:
k2Pnl1 = np.outer(Growth**2, (klin_fpt**2) * Pnl1[0, :])
else:
k2Pnl1 = np.outer(Growth**2, (klin_fpt**2) * Plin)
Plin_kz = np.outer(Growth**2, Plin)
n_pad = len(klin_fpt)
if pt_type in ['oneloop_eul_bk']:
fastpt = FASTPT.FASTPT(klin_fpt,
to_do=['one_loop_dd'],
low_extrap=-5,
high_extrap=3,
n_pad=n_pad)
PXXNL_b1b2bsb3nl = fastpt.one_loop_dd_bias_b3nl(Plin_klin_fpt,
C_window=.75)
if output_nl_grid:
temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[2]))
Pd1d2 = np.outer(Growth**4, (temp(knl_log)))
if output_xi:
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * temp(knl_log),
nu=1.5,
c_window_width=0.2)
_, xi_d1d2_z0 = myfftlog.fftlog(0)
else:
_, xitemp = sph(knl, nu=0, q=1.5)(temp(knl_log) * renorm,
extrap=True)
xi_d1d2_z0 = (1 / (2 * np.pi**2)) * xitemp
xi_d1d2 = np.outer(Growth**4, xi_d1d2_z0)
temp = intspline(klin_fpt_log, np.log(PXXNL_b1b2bsb3nl[3]))
Pd2d2 = np.outer(Growth**4, np.exp(temp(knl_log)))
if output_xi:
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * np.exp(temp(knl_log)),
nu=1.5,
c_window_width=0.2)
_, xi_d2d2_z0 = myfftlog.fftlog(0)
else:
_, xitemp = sph(knl, nu=0,
q=1.5)(np.exp(temp(knl_log)) * renorm,
extrap=True)
xi_d2d2_z0 = (1 / (2 * np.pi**2)) * xitemp
xi_d2d2 = np.outer(Growth**4, xi_d2d2_z0)
temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[4]))
Pd1s2 = np.outer(Growth**4, (temp(knl_log)))
if output_xi:
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * temp(knl_log),
nu=1.5,
c_window_width=0.2)
_, xi_d1s2_z0 = myfftlog.fftlog(0)
else:
_, xitemp = sph(knl, nu=0, q=1.5)(temp(knl_log) * renorm,
extrap=True)
xi_d1s2_z0 = (1 / (2 * np.pi**2)) * xitemp
xi_d1s2 = np.outer(Growth**4, xi_d1s2_z0)
temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[5]))
Pd2s2 = np.outer(Growth**4, (temp(knl_log)))
if output_xi:
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * temp(knl_log),
nu=1.5,
c_window_width=0.2)
_, xi_d2s2_z0 = myfftlog.fftlog(0)
else:
rval, xitemp = sph(knl, nu=0,
q=1.5)(temp(knl_log) * renorm,
extrap=False)
xi_d2s2_z0 = (1 / (2 * np.pi**2)) * xitemp
# pdb.set_trace()
xi_d2s2 = np.outer(Growth**4, xi_d2s2_z0)
temp = intspline(klin_fpt_log, np.log(PXXNL_b1b2bsb3nl[6]))
Ps2s2 = np.outer(Growth**4, np.exp(temp(knl_log)))
if output_xi:
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * np.exp(temp(knl_log)),
nu=1.5,
c_window_width=0.2)
_, xi_s2s2_z0 = myfftlog.fftlog(0)
else:
_, xitemp = sph(knl, nu=0,
q=1.5)(np.exp(temp(knl_log)) * renorm,
extrap=True)
xi_s2s2_z0 = (1 / (2 * np.pi**2)) * xitemp
xi_s2s2 = np.outer(Growth**4, xi_s2s2_z0)
temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[7]))
sig3nl = np.outer(Growth**4, (temp(knl_log)))
if output_xi:
if use_fftlog:
myfftlog = fftlog(knl, (knl**3) * temp(knl_log),
nu=1.5,
c_window_width=0.2)
_, xi_sig3nl_z0 = myfftlog.fftlog(0)
else:
_, xitemp = sph(knl, nu=0, q=1.5)(temp(knl_log) * renorm,
extrap=True)
xi_sig3nl_z0 = (1 / (2 * np.pi**2)) * xitemp
xi_sig3nl = np.outer(Growth**4, xi_sig3nl_z0)
sig4 = np.outer(Growth**4, PXXNL_b1b2bsb3nl[8] * np.ones_like(knl))
else:
[Pd1d2, Pd2d2, Pd1s2, Pd2s2, Ps2s2, sig3nl, sig4] = [
np.outer(Growth**4, PXXNL_b1b2bsb3nl[2]),
np.outer(Growth**4, PXXNL_b1b2bsb3nl[3]),
np.outer(Growth**4, PXXNL_b1b2bsb3nl[4]),
np.outer(Growth**4, PXXNL_b1b2bsb3nl[5]),
np.outer(Growth**4, PXXNL_b1b2bsb3nl[6]),
np.outer(Growth**4, PXXNL_b1b2bsb3nl[7]),
np.outer(
Growth**4,
PXXNL_b1b2bsb3nl[8] * np.ones_like(PXXNL_b1b2bsb3nl[0]))
]
pdb.set_trace()
Pk_th_array = [
Plin_kz, Pnl1, Pd1d2, Pd2d2, Pd1s2, Pd2s2, Ps2s2, sig3nl, k2Pnl1,
sig4
]
if output_xi:
xi_th_array = [
xi_lin, xi_nl, xi_d1d2, xi_d2d2, xi_d1s2, xi_d2s2, xi_s2s2,
xi_sig3nl, xi_k2Pk
]
elif pt_type in ['oneloop_cleft_bk']:
cl = cpool.CLEFT(k=klin_fpt, p=Plin_klin_fpt)
Pk_th_array = np.zeros((len(Pk_terms_names), len(Growth), len(knl)))
kinput_ind = np.where((knl < 4.) & (knl > 1e-3))[0]
kinput = knl[kinput_ind]
# pdb.set_trace()
pk_table_f = cpool.get_nonlinear_kernels_wgroth(cl,
kinput,
koutput=knl,
Growth=Growth,
do_analysis=False,
Pnl_toplot=Pnl1,
z_array=z_array)
Pk_th_array[1:-1, :, :] = pk_table_f
Pk_th_array[0, :, :] = Plin_kz
Pk_th_array[1, :, :] = Pnl1
Pk_th_array[-1, :, :] = k2Pnl1
else:
Pk_th_array = None
print('give correct pt_type')
if output_nl_grid:
kout = knl
else:
kout = klin_fpt
if output_xi:
return Pk_th_array, kout, xi_th_array, r_lin
else:
return Pk_th_array, kout
