def fun(Ecomplex):
E = Ecomplex[0] + 1j*Ecomplex[1]
q = sqrt(2*(E+V0))
g = sqrt(-2*E)
y = q*spherical_jn(l, q*a, True)*spherical_kn(l,g*a) \
- g*spherical_kn(l, g*a, True)*spherical_jn(l,q*a)
return array([real(y), imag(y)])
def test_spherical_jn_yn_cross_product_2(self):
# http://dlmf.nist.gov/10.50.E3
n = np.array([1, 5, 8])
x = np.array([0.1, 1, 10])
left = spherical_jn(n + 2, x) * spherical_yn(n, x) - spherical_jn(n, x) * spherical_yn(n + 2, x)
right = (2 * n + 3) / x ** 3
assert_allclose(left, right)
def test_spherical_jn_yn_cross_product_1(self):
# https://dlmf.nist.gov/10.50.E3
n = np.array([1, 5, 8])
x = np.array([0.1, 1, 10])
left = (spherical_jn(n + 1, x) * spherical_yn(n, x) -
spherical_jn(n, x) * spherical_yn(n + 1, x))
right = 1/x**2
assert_allclose(left, right)
def test_mie_internal_coeffs():
if os.name == 'nt':
raise SkipTest()
m = 1.5 + 0.1j
x = 50.
n_stop = miescatlib.nstop(x)
al, bl = miescatlib.scatcoeffs(m, x, n_stop)
cl, dl = miescatlib.internal_coeffs(m, x, n_stop)
n = np.arange(n_stop)+1
jlx = spherical_jn(n, x)
jlmx = spherical_jn(n, m*x)
hlx = jlx + 1.j * spherical_yn(n, x)
assert_allclose(cl, (jlx - hlx * bl) / jlmx, rtol = 1e-6, atol = 1e-6)
assert_allclose(dl, (jlx - hlx * al)/ (m * jlmx), rtol = 1e-6, atol = 1e-6)
def spline_int_jlqr(l, qmax, rcut, numq=None, numr=None):
r"""
Compute :math:`j_n(z) = \int_0^{rcut} r^2 j_l(qr) dr`
where :math:`j_l` is the Spherical Bessel function.
Args:
l: Angular momentum
qmax: Max :math:`|q|` in integral in Ang-1
rcut: Sphere radius in Angstrom.
numq: Number of q-points in qmesh.
numr: Number of r-points for integration.
Return:
Spline object.
"""
numq = numq if numq is not None else _DEFAULTS["numq"]
numr = numr if numr is not None else _DEFAULTS["numr"]
rs = np.linspace(0, rcut, num=numr)
r2 = rs ** 2
qmesh = np.linspace(0, qmax, num=numq)
values = []
for q in qmesh:
qrs = q * rs
#qrs = 2 * np.pi * q * rs
ys = spherical_jn(l, qrs) * r2
intg = simps(ys, x=rs)
values.append(intg)
return UnivariateSpline(qmesh, values, s=0)
def test_spherical_jn_inf_complex(self):
# https://dlmf.nist.gov/10.52.E3
n = 7
x = np.array([-inf + 0j, inf + 0j, inf*(1+1j)])
with suppress_warnings() as sup:
sup.filter(RuntimeWarning, "invalid value encountered in multiply")
assert_allclose(spherical_jn(n, x), np.array([0, 0, inf*(1+1j)]))
def test_spherical_jn_exact(self):
# http://dlmf.nist.gov/10.49.E3
# Note: exact expression is numerically stable only for small
# n or z >> n.
x = np.array([0.12, 1.23, 12.34, 123.45, 1234.5])
assert_allclose(spherical_jn(2, x),
(-1/x + 3/x**3)*sin(x) - 3/x**2*cos(x))
def spbessel(n, kr):
"""Spherical Bessel function (first kind) of order n at kr
Parameters
----------
n : array_like
Order
kr: array_like
Argument
Returns
-------
J : complex float
Spherical Bessel
"""
n, kr = scalar_broadcast_match(n, kr)
if _np.any(n < 0) | _np.any(kr < 0) | _np.any(_np.mod(n, 1) != 0):
J = _np.zeros(kr.shape, dtype=_np.complex_)
kr_non_zero = kr != 0
J[kr_non_zero] = _np.lib.scimath.sqrt(_np.pi / 2 / kr[kr_non_zero]) * besselj(n[kr_non_zero] + 0.5,
kr[kr_non_zero])
J[_np.logical_and(kr == 0, n == 0)] = 1
else:
J = scy.spherical_jn(n.astype(_np.int), kr)
return _np.squeeze(J)
def scattering_amplitude_energy(Evec, U, R, theta, lmax=30):
costheta = cos(theta)
P = lpmv(0, arange(lmax), costheta) # Legendre polynomial
f = zeros(len(Evec), dtype=complex)
for ll in range(lmax):
kR = sqrt(2*Evec)*R
qR = sqrt(2*(Evec+U))*R
## Spherical bessels/hankels, and their derivatives
jl = spherical_jn(ll, qR)
jlp = spherical_jn(ll, qR, derivative=True)
hl = spherical_jn(ll, kR) + 1j*spherical_yn(ll, kR)
hlp = spherical_jn(ll, kR, True) + 1j*spherical_yn(ll, kR, True)
delt = 0.5*pi - angle((kR*hlp*jl - qR*hl*jlp)/R)
f += (-0.5j*R/kR) * (exp(2j*delt)-1) * (2*ll+1) * P[ll]
return f
def scattering_amplitude_theta(E, U, R, thetavec, lmax=30):
lvec = arange(lmax)
P = zeros((len(lvec), len(thetavec))) # Legendre polynomials
for jj in range(len(lvec)):
P[jj,:] = lpmv(0, lvec[jj], cos(thetavec))
kR = sqrt(2*E)*R
qR = sqrt(2*(E+U))*R
## Spherical bessels/hankels, and their derivatives
jl = spherical_jn(lvec, qR)
jlp = spherical_jn(lvec, qR, derivative=True)
hl = spherical_jn(lvec, kR) + 1j*spherical_yn(lvec, kR)
hlp = spherical_jn(lvec, kR, True) + 1j*spherical_yn(lvec, kR, True)
## Phase shifts for each l component
delt = 0.5*pi - angle((kR*hlp*jl - qR*hl*jlp)/R)
coef = (exp(2j*delt)-1) * (2*lvec+1)
return (-0.5j*R/kR) * dot(coef, P)
def spherical_hn2(n, z):
r"""Spherical Hankel function of 2nd kind.
Defined as http://dlmf.nist.gov/10.47.E6,
.. math::
\hankel{2}{n}{z} = \sqrt{\frac{\pi}{2z}}
\Hankel{2}{n + \frac{1}{2}}{z},
where :math:`\Hankel{2}{n}{\cdot}` is the Hankel function of the
second kind and n-th order, and :math:`z` its complex argument.
Parameters
----------
n : array_like
Order of the spherical Hankel function (n >= 0).
z : array_like
Argument of the spherical Hankel function.
"""
return spherical_jn(n, z) - 1j * spherical_yn(n, z)
def test_sph_jn(self):
s1 = np.empty((2, 3))
x = 0.2
s1[0][0] = spherical_jn(0, x)
s1[0][1] = spherical_jn(1, x)
s1[0][2] = spherical_jn(2, x)
s1[1][0] = spherical_jn(0, x, derivative=True)
s1[1][1] = spherical_jn(1, x, derivative=True)
s1[1][2] = spherical_jn(2, x, derivative=True)
s10 = -s1[0][1]
s11 = s1[0][0] - 2.0 / 0.2 * s1[0][1]
s12 = s1[0][1] - 3.0 / 0.2 * s1[0][2]
assert_array_almost_equal(
s1[0], [0.99334665397530607731, 0.066400380670322230863, 0.0026590560795273856680], 12
)
assert_array_almost_equal(s1[1], [s10, s11, s12], 12)
def jn_zeros(n, k, method="sympy", dps=15):
"""
Zeros of the spherical Bessel function of the first kind.
This returns an array of zeros of jn up to the k-th zero.
* method = "sympy": uses :func:`mpmath.besseljzero`
* method = "scipy": uses the
`SciPy's sph_jn <http://docs.scipy.org/doc/scipy/reference/generated/scipy.special.jn_zeros.html>`_
and
`newton <http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.newton.html>`_
to find all
roots, which is faster than computing the zeros using a general
numerical solver, but it requires SciPy and only works with low
precision floating point numbers. [The function used with
method="sympy" is a recent addition to mpmath, before that a general
solver was used.]
Examples
========
>>> from sympy import jn_zeros
>>> jn_zeros(2, 4, dps=5)
[5.7635, 9.095, 12.323, 15.515]
See Also
========
jn, yn, besselj, besselk, bessely
"""
from math import pi
if method == "sympy":
from mpmath import besseljzero
from mpmath.libmp.libmpf import dps_to_prec
from sympy import Expr
prec = dps_to_prec(dps)
return [Expr._from_mpmath(besseljzero(S(n + 0.5)._to_mpmath(prec),
int(l)), prec)
for l in range(1, k + 1)]
elif method == "scipy":
from scipy.optimize import newton
try:
from scipy.special import spherical_jn
f = lambda x: spherical_jn(n, x)
except ImportError:
from scipy.special import sph_jn
f = lambda x: sph_jn(n, x)[0][-1]
else:
raise NotImplementedError("Unknown method.")
def solver(f, x):
if method == "scipy":
root = newton(f, x)
else:
raise NotImplementedError("Unknown method.")
return root
# we need to approximate the position of the first root:
root = n + pi
# determine the first root exactly:
root = solver(f, root)
roots = [root]
for i in range(k - 1):
# estimate the position of the next root using the last root + pi:
root = solver(f, root + pi)
roots.append(root)
return roots
def f(self, n, z):
return spherical_jn(n, z)
def test_spherical_jn_recurrence_complex(self):
# https://dlmf.nist.gov/10.51.E1
n = np.array([1, 2, 3, 7, 12])
x = 1.1 + 1.5j
assert_allclose(spherical_jn(n - 1, x) + spherical_jn(n + 1, x),
(2*n + 1)/x*spherical_jn(n, x))
def test_spherical_jn_inf_real(self):
# http://dlmf.nist.gov/10.52.E3
n = 6
x = np.array([-inf, inf])
assert_allclose(spherical_jn(n, x), np.array([0, 0]))
def f(x):
return spherical_jn(n, x)
def test_spherical_jn_large_arg_2(self):
# https://github.com/scipy/scipy/issues/1641
# Reference value computed using mpmath, via
# besselj(n + mpf(1)/2, z)*sqrt(pi/(2*z))
assert_allclose(spherical_jn(2, 10000), 3.0590002633029811e-05)
def xi(n, z):
# Riccati-Bessel function of third kind
return z * (spherical_jn(n, z) + 1j * spherical_yn(n, z))
def spherical_jn_(n, x):
return spherical_jn(n.astype('l'), x)
def Jn(r, n):
"""
numerical spherical bessel functions of order n
"""
return sp.spherical_jn(n, r)
def sphj(n, z):
return spherical_jn(range(n), z)
def jprimel(kchi, l):
return spherical_jn(n=l, z=kchi, derivative=True)
def fluid_sphere(f, Radius, Range, Rho_w, Rho_b, Theta, c_w, c_b):
#compute wavelength and wave number in the external fluid
K_ext = k(c_w, f) # wave number
#compute wavenumber inside the scattering body
K_int = k(c_b, f)
#set convergence parameters
ConvLim = 1e-10
MaxCount = 200
#wavenumbers
kr = K_ext * Range #wavenumber at range
ka = K_ext * Radius #wvenumber radius
kdasha = K_int * Radius #wavenumber radius inside
#density and soundspeed contrasts
g = Rho_b / Rho_w #density contrast
h = c_b / c_w #sound velocity contrast
rho_c = Rho_w * c_w
#check for convergence and set starting parameters
Done = False
Count = 0
m = 0
while Done == False:
# build vector of theta angles and ranges inside/outside of sphere
#Theta = np.arange(0.0,np.pi,np.pi/180)
CosTheta = np.cos(Theta)
#Ext_Range = np.arange(1.5 * Radius, Radius, -0.5 * Radius / 20)
#Int_Range = np.arange(Radius,0,-Radius/40)
###compute spherical bessel fucntions with ka, k'a, kr, k'r
###use functions from scipy.special
#Bessel functions first degree
Jm_kr = ss.spherical_jn(m, kr)
Jm_ka = ss.spherical_jn(m, ka)
Jm_kdasha = ss.spherical_jn(m, kdasha)
#bessel functions second degree
Nm_Kr = ss.spherical_yn(m, kr)
Nm_Ka = ss.spherical_yn(m, ka)
#First degree derivate bessel functions
Alpham_kdasha = (2 * m + 1) * ss.spherical_jn(
m, kdasha, derivative=True)
Alpham_ka = (2 * m + 1) * ss.spherical_jn(m, ka, derivative=True)
Alpham_kr = (2 * m + 1) * ss.spherical_jn(m, kr, derivative=True)
#Second degree derivate bessel functions
Betam_ka = (2 * m + 1) * ss.spherical_yn(m, ka, derivative=True)
Betam_kr = (2 * m + 1) * ss.spherical_yn(m, kr, derivative=True)
# Compute Legendre Polynom, dependent on Theta
Pm = legendreP(m, CosTheta)
# Calculate Cm for the current m value - independant of theta
Cm = (( Alpham_kdasha / Alpham_ka) * (Nm_Ka / Jm_kdasha) - \
(Betam_ka / Alpham_ka) * g * h) / ((Alpham_kdasha / Alpham_ka) * \
(Jm_ka / Jm_kdasha) - g * h)
# Use Cm coefficient to calculate Am explcitely and then Bm from this
Am = -((-1j)**m) * (2 * m + 1) / (1 + 1j * Cm)
# Now use Cm to calculate current 'm' value scattered pressure contribution
ThisPs = -(((-1j)**m) * (2 * m + 1) / (1 + 1j * Cm)) * Pm * \
(Jm_kr + 1j * Nm_Kr)
ThisPi = ((-1j)**m) * (2 * m + 1) * Pm * Jm_kr
ThisTS = ((-1)**m) * (2 * m + 1) / (1 + 1j * Cm)
# exterior domain particle velocity
ThisVel = (-1j / rho_c) * (Am / (2 * m + 1)) * Pm * (Alpham_kr +\
1j * Betam_kr)
ThisVel_Inc = (-1j / rho_c) * ((-1j)**m) * Pm * Alpham_kr
if m == 0:
Ps = ThisPs
Pi = ThisPi
TS = ThisTS
Vel = ThisVel
Vel_Inc = ThisVel_Inc
else:
Ps = Ps + ThisPs
Pi = Pi + ThisPi
TS = TS + ThisTS
Vel = Vel + ThisVel
Vel_Inc = Vel_Inc + ThisVel_Inc
m += 1
Count += 1
if max(abs(ThisPs)) < ConvLim and m > 10:
Done = True
elif Count > MaxCount:
Done = True
print('Convergence failure in FluidSphereScat')
IsBad = np.isnan(Ps)
Ps[IsBad] = 0
#Calculate final TS after summation is complete
TS = (2 / ka)**2 * abs(TS)**2 * (np.pi * Radius * Radius)
TS = 10 * np.log10(TS / (4 * np.pi))
#print('Backscatter TS of the sphere is %.2f dB re 1m^2'%TS)
return (TS)
# func_k[i] = int_0*int_0*p_nl[i]/(k_nl[i]*k_nl[i])
# k_min = np.log(k_nl.min())
# k_max = np.log(k_nl.max())
# term = integrate.quad(interp1d, k_min, k_max,args=(k_nl,func_k), epsrel = 1e-6)[0]
# units = l*(l+1)*1e-12*term*omega_m*omega_m/(9.*np.pi*np.pi*chi_Rmax*chi_Rmax)
# print(l,units)
# C_l[l-1] = units
C_l1 = np.zeros(2601) #eq 25 in the paper
func_k1 = np.zeros(nklin_cmb)
for l in range(0, 2601):
print(l)
for i, kloop in enumerate(klin_cmb):
func_k1[i] = kloop*kloop*special.spherical_jn(l,kloop*chi_Rmax)*P_0[i]*\
(special.spherical_jn(l,kloop*chi_Rmax)*l - special.spherical_jn(l+1,kloop*chi_Rmax)*kloop*chi_Rmax)\
/(8.*np.pi*np.pi*np.pi)
# func_k1[i] = p_nl_R[i]*kloop*kloop*special.spherical_jn(l,kloop*chi_Rmax)*\
# (special.spherical_jn(l,kloop*chi_Rmax)*l - special.spherical_jn(l+1,kloop*chi_Rmax)*kloop*chi_Rmax)\
# /(np.power(2.*np.pi,3.))
k_min = np.log(klin_cmb.min())
k_max = np.log(klin_cmb.max())
term = integrate.quad(interp1d,
k_min,
k_max,
args=(klin_cmb, func_k1),
epsrel=1e-6)[0]
C_l1[l] = term
print(chi_Rmax)
def hankel(n,z,derivative=False):
return special.spherical_jn(n,z,derivative) + 1j*special.spherical_yn(n,z,derivative)
def riccati_1_single(n, x):
"""Riccati_1, but only a single n value"""
jn = special.spherical_jn(n, x)
jnp = special.spherical_jn(n, x, derivative=True)
return np.array([x * jn, jn + x * jnp])
#!/usr/bin/env python3
#
# Plots the power spectra and Fourier-space biases for the HI.
#
import numpy as np
import os, sys
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, HuberRegressor
from scipy.optimize import minimize
from scipy.interpolate import InterpolatedUnivariateSpline as ius
from scipy.integrate import simps
from scipy.special import spherical_jn
j0 = lambda x: spherical_jn(0, x)
#
sys.path.append('../')
from uvbg import mfpathz
from matplotlib import rc, rcParams, font_manager
rcParams['font.family'] = 'serif'
fsize = 12
fontmanage = font_manager.FontProperties(family='serif',
style='normal',
size=fsize,
weight='normal',
stretch='normal')
font = {
'family': fontmanage.get_family()[0],
def spherical_hn1(n, z):
return sp.spherical_jn(
n, z, derivative=False) + 1j * sp.spherical_yn(n, z, derivative=False)
def test_spherical_jn_at_zero(self):
# http://dlmf.nist.gov/10.52.E1
# But note that n = 0 is a special case: j0 = sin(x)/x -> 1
n = np.array([0, 1, 2, 5, 10, 100])
x = 0
assert_allclose(spherical_jn(n, x), np.array([1, 0, 0, 0, 0, 0]))
def f(self, n, z):
return spherical_jn(n, z)
def test_spherical_jn_large_arg_1(self):
# https://github.com/scipy/scipy/issues/2165
# Reference value computed using mpmath, via
# besselj(n + mpf(1)/2, z)*sqrt(pi/(2*z))
assert_allclose(spherical_jn(2, 3350.507), -0.00029846226538040747)
def test_spherical_jn_d_zero(self):
n = np.array([1, 2, 3, 7, 15])
assert_allclose(spherical_jn(n, 0, derivative=True), np.zeros(5))
def test_spherical_jn_inf_complex(self):
# http://dlmf.nist.gov/10.52.E3
n = 7
x = np.array([-inf + 0j, inf + 0j, inf * (1 + 1j)])
assert_allclose(spherical_jn(n, x), np.array([0, 0, inf * (1 + 1j)]))
def test_spherical_jn_inf_complex(self):
# http://dlmf.nist.gov/10.52.E3
n = 7
x = np.array([-inf + 0j, inf + 0j, inf * (1 + 1j)])
assert_allclose(spherical_jn(n, x), np.array([0, 0, inf * (1 + 1j)]))
def test_spherical_jn_d_zero(self):
n = np.array([1, 2, 3, 7, 15])
assert_allclose(spherical_jn(n, 0, derivative=True), np.zeros(5))
def test_spherical_jn_large_arg_2(self):
# https://github.com/scipy/scipy/issues/1641
# Reference value computed using mpmath, via
# besselj(n + mpf(1)/2, z)*sqrt(pi/(2*z))
assert_allclose(spherical_jn(2, 10000), 3.0590002633029811e-05)
def df(self, n, z):
return spherical_jn(n, z, derivative=True)
def spherical_jn_(n, x):
return spherical_jn(n.astype('l'), x)
def _create_parameters(package):
# Start by copying everything in the package
parameters = {**package}
# Set up the random seed
if parameters['seed'] is None:
parameters['seed'] = random.randrange(2**32 - 1)
np.random.seed(parameters['seed'])
#########################
# Background quantities #
#########################
phi0 = parameters['phi0']
phi0dot = parameters['phi0dot']
infmodel = parameters['infmodel']
rho = compute_rho(phi0, phi0dot, infmodel)
# Estimate Hubble
H0 = compute_hubble(rho, 0)
# Construct Rmax and kappa
parameters['Rmax'] = Rmax = parameters['Rmaxfactor'] / H0
parameters['kappa'] = kappa = parameters['kappafactor'] * H0
####################
# Wavenumber grids #
####################
k_max_factor = parameters['k_max_factor']
num_k_modes = int(np.ceil(Rmax * kappa * k_max_factor / np.pi))
if not parameters['hartree'] or num_k_modes < 2:
num_k_modes = 2
parameters['num_k_modes'] = num_k_modes
k_grids = get_jn_roots(1, num_k_modes)
# Iterate through all wavenumbers, dividing by Rmax
# to turn the roots into wavenumbers
for ell in range(2):
k_grids[ell] /= Rmax
parameters['k_grids'] = k_grids
# Make a tuple storing the number of wavenumbers for each ell
parameters['total_wavenumbers'] = total_wavenumbers = 2 * num_k_modes - 1
# Construct wavenumbers squared
k2_grids = [grid * grid for grid in k_grids]
# Construct a list of all wavenumbers in order, and their squares
all_wavenumbers = np.concatenate(k_grids)
all_wavenumbers2 = all_wavenumbers**2
# Compute Gaussian suppression for wavenumbers
factor = 2 * kappa**2
gaussian_profile = [
np.exp(-k_grids[0]**2 / factor),
np.exp(-k_grids[1]**2 / factor)
]
# Compute the normalizations associated with each wavenumber
normalizations = [None for ell in range(2)]
factor = np.sqrt(2) / Rmax**1.5
for ell in range(2):
normalizations[ell] = factor / np.abs(
spherical_jn(ell + 1, k_grids[ell] * Rmax))
parameters['normalizations'] = normalizations
# Compute 1 / |j_{ell + 1}(k R)|^2, which we'll need for gradient Hartree corrections
denom_fac = [None for ell in range(2)]
for ell in range(2):
denom_fac[ell] = 1 / np.abs(spherical_jn(ell + 1,
k_grids[ell] * Rmax))**2
###############################
# Construct mode coefficients #
###############################
poscoeffs = [None, [None] * 3]
velcoeffs = [None, [None] * 3]
if parameters['perturbBD']:
# perturb away from Bunch-Davies initial conditions slightly
# create range for draws of parameters to initialized modes
delta_min, delta_max = parameters['perturbranges']['delta']
gamma_min, gamma_max = parameters['perturbranges']['gamma']
# random coefficients for l = 0 modes
delta0 = np.random.uniform(delta_min, delta_max, len(k_grids[0]))
if parameters['perturblogarithmic']:
gamma0 = np.exp(
np.random.uniform(np.log(gamma_min), np.log(gamma_max),
len(k_grids[0])))
else:
gamma0 = np.random.uniform(gamma_min, gamma_max, len(k_grids[0]))
alpha0 = 1 / gamma0
# attach coefficients
poscoeffs[0] = alpha0 / np.sqrt(2 * k_grids[0])
velcoeffs[0] = np.sqrt(k_grids[0] / 2) * (-1j * gamma0 + delta0 -
(H0 * alpha0 / k_grids[0]))
if parameters['l1modeson']:
for i in range(3):
# random coefficients for l = 1 modes
delta1 = np.random.uniform(delta_min, delta_max,
len(k_grids[1]))
if parameters['perturblogarithmic']:
gamma1 = np.exp(
np.random.uniform(np.log(gamma_min), np.log(gamma_max),
len(k_grids[1])))
else:
gamma1 = np.random.uniform(gamma_min, gamma_max,
len(k_grids[1]))
alpha1 = 1 / gamma1
poscoeffs[1][i] = alpha1 / np.sqrt(2 * k_grids[1])
velcoeffs[1][i] = np.sqrt(
k_grids[1] / 2) * (-1j * gamma1 + delta1 -
(H0 * alpha1 / k_grids[1]))
else:
for i in range(3):
poscoeffs[1][i] = np.zeros_like(k_grids[1])
velcoeffs[1][i] = np.zeros_like(k_grids[1])
else:
# run standard Bunch-Davies initial conditions
poscoeffs[0] = 1 / np.sqrt(2 * k_grids[0])
velcoeffs[0] = np.sqrt(k_grids[0] / 2) * (-1j - H0 / k_grids[0])
if parameters['l1modeson']:
for i in range(3):
poscoeffs[1][i] = 1 / np.sqrt(2 * k_grids[1])
velcoeffs[1][i] = np.sqrt(
k_grids[1] / 2) * (-1j - H0 / k_grids[1])
else:
for i in range(3):
poscoeffs[1][i] = np.zeros_like(k_grids[1])
velcoeffs[1][i] = np.zeros_like(k_grids[1])
###########################
# Construct EOMParameters #
###########################
parameters['eomparams'] = EOMParameters(
Rmax, kappa, num_k_modes, parameters['total_wavenumbers'],
parameters['hartree'], infmodel, k_grids, k2_grids, all_wavenumbers,
all_wavenumbers2, denom_fac, gaussian_profile, poscoeffs, velcoeffs)
################################
# Construct Initial Conditions #
################################
# The starting value of the scale factor
a = 1
# phi0 and phi0dot have been obtained already
# Initialize the fields phi_{nlm}
phiA = np.ones(total_wavenumbers)
phidotA = np.zeros(total_wavenumbers)
phiB = np.zeros(total_wavenumbers)
phidotB = np.ones(total_wavenumbers)
# Compute the Hartree corrections
if parameters['hartree']:
phi2pt, phi2ptdt, phi2ptgrad = compute_hartree(phiA, phidotA, phiB,
phidotB,
parameters['eomparams'])
deltarho2 = compute_deltarho2(a, phi0, phi2pt, phi2ptdt, phi2ptgrad,
infmodel)
else:
phi2pt, phi2ptdt, phi2ptgrad = (0, 0, 0)
deltarho2 = 0
# Compute adot from Hubble
adot = compute_hubble(rho, deltarho2) * a
# Compute Hdot
Hdot = compute_hubbledot(a, phi0dot, phi2ptdt, phi2ptgrad)
# Make sure that we don't have a denominator blowup in computing the initial psi values
carefulfactor = 10 # The maximum dimensionless boost that a psi mode can get from the denominator
badk2 = Hdot + 2 / 3 * phi2ptgrad
if parameters['rescale']:
if badk2 < 0 and np.any(
np.abs(all_wavenumbers**2 + badk2) < H0**2 / carefulfactor):
# We have a mode that is getting an artificial boost
# Report an issue so we can try again
raise BadK()
# Now compute the initial values for the psi fields
psiA, psiB = compute_initial_psi(a, adot, phi0, phi0dot, phiA, phidotA,
phiB, phidotB, phi2pt, phi2ptdt,
phi2ptgrad, parameters['eomparams'])
# Pack all the initial data together
parameters['initial_data'] = pack(a, phi0, phi0dot, phiA, phidotA, psiA,
phiB, phidotB, psiB)
# Return everything
return parameters
def j1d(z): return spherical_jn(1, z, derivative=True) except ImportError:
def scatteringcoefficients(mhu, mhu_p, lamda, lamda_p, rho, rho_p, Flag):
rho_ratio = rho_p / rho
R_0 = 200e-6
Nf = 1000
f = np.linspace(1.0e5, 3.0e6, Nf)
#c_L_i = m.sqrt((lamda + 2*mhu)/rho)
#c_T_i = m.sqrt(mhu/rho)
T1 = np.zeros((2, Nf), dtype=complex)
T2 = np.zeros((4, Nf), dtype=complex)
KKTi = np.zeros((1, Nf), dtype=complex)
KKLi = np.zeros((1, Nf), dtype=complex)
resonance = np.zeros((1, Nf), dtype=complex)
for iterator in range(0, Nf):
omega = 2 * m.pi * f[iterator]
lame1 = 3.6e9 + 0.1e9 * (
(omega * 5000e-9)**2 -
1j * omega * 5000e-9) / (1 + (omega * 5000e-9)**2) + 0.3e9 * (
(omega * 500e-9)**2 -
1j * omega * 500e-9) / (1 + (omega * 500e-9)**2) + 0.25e9 * (
(omega * 50e-9)**2 -
1j * omega * 50e-9) / (1 + (omega * 50e-9)**2) + 0.3e9 * (
(omega * 8e-9)**2 -
1j * omega * 8e-9) / (1 + (omega * 8e-9)**2)
lame2 = 1.05e9 + 0.2e9 * (
(omega * 5000e-9)**2 -
1j * omega * 5000e-9) / (1 + (omega * 5000e-9)**2) + 0.15e9 * (
(omega * 500e-9)**2 -
1j * omega * 500e-9) / (1 + (omega * 500e-9)**2) - 0.1e9 * (
(omega * 14e-9)**2 -
1j * omega * 14e-9) / (1 + (omega * 14e-9)**2) + 0.15e9 * (
(omega * 50e-9)**2 -
1j * omega * 50e-9) / (1 + (omega * 50e-9)**2)
lamda = lame1
mhu = lame2
c_L_i = cm.sqrt((lame1 + 2 * lame2) / rho)
c_T_i = cm.sqrt(lame2 / rho)
alphaL_f = 0.1 + 0.25 / 2000000 * f[iterator]
alphaS_f = 0.05 + 0.1 / 2000000 * f[iterator]
k_L_i = omega / c_L_i + 1j * alphaL_f
k_T_i = omega / c_T_i + 1j * alphaS_f
K_L = k_L_i * R_0
K_T = k_T_i * R_0
k_L_p = omega * m.sqrt(rho_p / (lamda_p + 2 * mhu_p))
k_T_p = omega * m.sqrt(rho_p / mhu_p)
K_L_p = k_L_p * R_0
K_T_p = k_T_p * R_0
KKTi[:, iterator] = K_T
KKLi[:, iterator] = K_L
if Flag == "T":
n = 1
hnL_n = spherical_hn1(n, K_L)
hnT_n = spherical_hn1(n, K_T)
hnL_1n = spherical_hn1(n + 1, K_L)
hnT_1n = spherical_hn1(n + 1, K_T)
jnL_n = sp.spherical_jn(n, K_L)
jnT_n = sp.spherical_jn(n, K_T)
jnL_np = sp.spherical_jn(n, K_L_p)
jnT_np = sp.spherical_jn(n, K_T_p)
jnL_1n = sp.spherical_jn(n + 1, K_L)
jnT_1n = sp.spherical_jn(n + 1, K_T)
jnL_1np = sp.spherical_jn(n + 1, K_L_p)
jnT_1np = sp.spherical_jn(n + 1, K_T_p)
U_L_p = n * jnL_np - K_L_p * jnL_1np
U_T_p = n * (n + 1) * jnT_np
U_L = n * hnL_n - K_L * hnL_1n
U_T = n * (n + 1) * hnT_n
U_I = n * (n + 1) * jnT_n
V_L_p = jnL_np
V_T_p = (1 + n) * jnT_np - K_T * jnT_1np
V_L = hnL_n
V_T = (1 + n) * hnT_n - K_T * hnT_1n
V_I = (1 + n) * jnT_n - K_T * jnT_1n
W_S = 1j * (K_T * hnT_n)
W_S_p = 1j * (K_T_p * jnT_np)
W_I = 1j * (K_T * jnT_n)
SS_L_p = (2 * n * (n - 1) * mhu_p - (lamda_p + 2 * mhu_p) *
K_L_p**2) * jnL_np + 4 * mhu_p * K_L_p * jnL_1np
SS_T_p = 2 * n * (n + 1) * mhu_p * (
(n - 1) * jnT_np - K_T_p * jnT_1np)
SS_L = (
2 * n * (n - 1) * mhu -
(lamda + 2 * mhu) * K_L**2) * hnL_n + 4 * mhu * K_L * hnL_1n
SS_T = 2 * n * (n + 1) * mhu * ((n - 1) * hnT_n - K_T * hnT_1n)
SS_I = 2 * n * (n + 1) * mhu * ((n - 1) * jnT_n - K_T * jnT_1n)
Tau_L_p = 2 * mhu_p * ((n - 1) * jnL_np - K_L_p * jnL_1np)
Tau_L = 2 * mhu * ((n - 1) * hnL_n - K_L * hnL_1n)
Tau_T_p = mhu_p * (
(2 * n**2 - 2 - K_T_p**2) * jnT_np + 2 * K_T_p * jnT_1np)
Tau_T = mhu * ((2 * n**2 - 2 - K_T**2) * hnT_n + 2 * K_T * hnT_1n)
Tau_I = mhu * ((2 * n**2 - 2 - K_T**2) * jnT_n + 2 * K_T * jnT_1n)
Sig_S_p = 1j * mhu_p * K_T_p * ((n - 1) * jnT_np - K_T_p * jnT_1np)
Sig_S = 1j * mhu * K_T * ((n - 1) * hnT_n - K_T * hnT_1n)
Sig_I = 1j * mhu * K_T * ((n - 1) * jnT_n - K_T * jnT_1n)
#Build system of equations
Designmatrix_LHS = np.array([[U_L, U_T, -U_L_p, -U_T_p],
[V_L, V_T, -V_L_p, -V_T_p],
[SS_L, SS_T, -SS_L_p, -SS_T_p],
[Tau_L, Tau_T, -Tau_L_p, -Tau_T_p]])
Designmatrix_RHS = np.array([U_I, V_I, SS_I, Tau_I])
t1 = np.linalg.solve(Designmatrix_LHS, -Designmatrix_RHS)
T2[:, iterator] = t1
Designmatrix2_LHS = np.array([[W_S, -W_S_p], [Sig_S, -Sig_S_p]])
Designmatrix2_RHS = np.array([W_I, Sig_I])
t2 = np.linalg.solve(Designmatrix2_LHS, -Designmatrix2_RHS)
T1[:, iterator] = t2
if Flag == "L":
f_res = (3 * c_T_i * m.sqrt(8 * rho_ratio)) / (4 * m.pi * R_0 *
(2 * rho_ratio + 1))
omega_res = 2 * m.pi * f_res
K_L_i_res = R_0 * omega_res / c_L_i
#K_T_i_res = R_0*omega_res/c_T_i
resonance[:, iterator] = K_L_i_res
for n in range(0, 2):
hnL_n = spherical_hn1(n, K_L)
hnT_n = spherical_hn1(n, K_T)
hnL_1n = spherical_hn1((n + 1), K_L)
hnT_1n = spherical_hn1((n + 1), K_T)
jnL_n = sp.spherical_jn(n, K_L)
jnT_n = sp.spherical_jn(n, K_T)
jnL_np = sp.spherical_jn(n, K_L_p)
jnT_np = sp.spherical_jn(n, K_T_p)
jnL_1n = sp.spherical_jn((n + 1), K_L)
jnT_1n = sp.spherical_jn((n + 1), K_T)
jnL_1np = sp.spherical_jn((n + 1), K_L_p)
jnT_1np = sp.spherical_jn((n + 1), K_T_p)
U_L_p = n * jnL_np - K_L_p * jnL_1np
U_T_p = n * (n + 1) * jnT_np
U_L = n * hnL_n - K_L * hnL_1n
U_T = n * (n + 1) * hnT_n
U_I = n * jnL_n - K_L * jnL_1n
V_L_p = jnL_np
V_T_p = (1 + n) * jnT_np - K_T * jnT_1np
V_L = hnL_n
V_T = (1 + n) * hnT_n - K_T * hnT_1n
V_I = jnL_n
SS_L_p = (2 * n * (n - 1) * mhu_p - (lamda_p + 2 * mhu_p) *
K_L_p**2) * jnL_np + 4 * mhu_p * K_L_p * jnL_1np
SS_T_p = 2 * n * (n + 1) * mhu_p * (
(n - 1) * jnT_np - K_T_p * jnT_1np)
SS_L = (2 * n * (n - 1) * mhu - (lamda + 2 * mhu) *
K_L**2) * hnL_n + 4 * mhu * K_L * hnL_1n
SS_T = 2 * n * (n + 1) * mhu * ((n - 1) * hnT_n - K_T * hnT_1n)
SS_I = (2 * n * (n - 1) * mhu - (lamda + 2 * mhu) *
K_L**2) * jnL_n + 4 * mhu * K_L * jnL_1n
Tau_L_p = 2 * mhu_p * ((n - 1) * jnL_np - K_L_p * jnL_1np)
Tau_L = 2 * mhu * ((n - 1) * hnL_n - K_L * hnL_1n)
Tau_T_p = mhu_p * (
(2 * n**2 - 2 - K_T_p**2) * jnT_np + 2 * K_T_p * jnT_1np)
Tau_T = mhu * (
(2 * n**2 - 2 - K_T**2) * hnT_n + 2 * K_T * hnT_1n)
Tau_I = 2 * mhu * ((n - 1) * jnL_n - K_L * jnL_1n)
if n == 0:
LHS = np.array([[U_L, -U_L_p], [SS_L, -SS_L_p]])
RHS = np.array([U_I, SS_I])
a0 = np.linalg.solve(LHS, -RHS)
T1[:, iterator] = a0
elif n == 1:
LHS1 = np.array([[U_L, U_T, -U_L_p, -U_T_p],
[V_L, V_T, -V_L_p, -V_T_p],
[SS_L, SS_T, -SS_L_p, -SS_T_p],
[Tau_L, Tau_T, -Tau_L_p, -Tau_T_p]])
RHS1 = np.array([U_I, V_I, SS_I, Tau_I])
a1 = np.linalg.solve(LHS1, -RHS1)
T2[:, iterator] = a1
if Flag == "T":
coefficients = np.vstack((KKTi[0, :], T1[0, :], T2[0, :], T2[1, :]))
print(
"Transverse incident wave, scatteringcoefficients are ordered as [K_T , T1_SS , T1_TL , T1_TT] in np.array"
)
if Flag == "L":
coefficients = np.vstack(
(KKLi[0, :], T1[0, :], T2[0, :], T2[1, :], resonance[0, :]))
print(
"Longitudinal incident wave, scatteringcoefficients are ordered as [K_L , T0_LL , T1_LL , T1_LT, K_Lires] in np.array"
)
return coefficients
def riccati_jn(n, x, derivative=False):
if derivative == True:
return spherical_jn(
n, x, derivative=False) + x * spherical_jn(n, x, derivative=True)
else:
return x * spherical_jn(n, x, derivative=False)
def df(self, n, z):
return spherical_jn(n, z, derivative=True)
def ricc1_psi(x):
return (x * sp.spherical_jn(1, x, 0))
def test_spherical_jn_recurrence_real(self):
# http://dlmf.nist.gov/10.51.E1
n = np.array([1, 2, 3, 7, 12])
x = 0.12
assert_allclose(spherical_jn(n - 1, x) + spherical_jn(n + 1, x), (2 * n + 1) / x * spherical_jn(n, x))
def ricc1_psi_ch(x):
return (sp.spherical_jn(1, x, 0) + x * sp.spherical_jn(1, x, 1))
def test_spherical_jn_inf_real(self):
# http://dlmf.nist.gov/10.52.E3
n = 6
x = np.array([-inf, inf])
assert_allclose(spherical_jn(n, x), np.array([0, 0]))
def ricc1_xi(x):
return (x * (sp.spherical_jn(1, x, 0) + 1j * sp.spherical_yn(1, x, 0)))
def test_spherical_jn_large_arg_1(self):
# https://github.com/scipy/scipy/issues/2165
# Reference value computed using mpmath, via
# besselj(n + mpf(1)/2, z)*sqrt(pi/(2*z))
assert_allclose(spherical_jn(2, 3350.507), -0.00029846226538040747)
def ricc1_xi_ch(x):
return ((sp.spherical_jn(1, x, 0) + 1j * sp.spherical_yn(1, x, 0)) + x *
(sp.spherical_jn(1, x, 1) + 1j * sp.spherical_yn(1, x, 1)))
def test_spherical_jn_at_zero(self):
# http://dlmf.nist.gov/10.52.E1
# But note that n = 0 is a special case: j0 = sin(x)/x -> 1
n = np.array([0, 1, 2, 5, 10, 100])
x = 0
assert_allclose(spherical_jn(n, x), np.array([1, 0, 0, 0, 0, 0]))
def jn_zeros(n, k, method="sympy", dps=15):
"""
Zeros of the spherical Bessel function of the first kind.
This returns an array of zeros of jn up to the k-th zero.
* method = "sympy": uses :func:`mpmath.besseljzero`
* method = "scipy": uses the
`SciPy's sph_jn <http://docs.scipy.org/doc/scipy/reference/generated/scipy.special.jn_zeros.html>`_
and
`newton <http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.newton.html>`_
to find all
roots, which is faster than computing the zeros using a general
numerical solver, but it requires SciPy and only works with low
precision floating point numbers. [The function used with
method="sympy" is a recent addition to mpmath, before that a general
solver was used.]
Examples
========
>>> from sympy import jn_zeros
>>> jn_zeros(2, 4, dps=5)
[5.7635, 9.095, 12.323, 15.515]
See Also
========
jn, yn, besselj, besselk, bessely
"""
from math import pi
if method == "sympy":
from mpmath import besseljzero
from mpmath.libmp.libmpf import dps_to_prec
from sympy import Expr
prec = dps_to_prec(dps)
return [
Expr._from_mpmath(besseljzero(S(n + 0.5)._to_mpmath(prec), int(l)),
prec) for l in range(1, k + 1)
]
elif method == "scipy":
from scipy.optimize import newton
try:
from scipy.special import spherical_jn
f = lambda x: spherical_jn(n, x)
except ImportError:
from scipy.special import sph_jn
f = lambda x: sph_jn(n, x)[0][-1]
else:
raise NotImplementedError("Unknown method.")
def solver(f, x):
if method == "scipy":
root = newton(f, x)
else:
raise NotImplementedError("Unknown method.")
return root
# we need to approximate the position of the first root:
root = n + pi
# determine the first root exactly:
root = solver(f, root)
roots = [root]
for i in range(k - 1):
# estimate the position of the next root using the last root + pi:
root = solver(f, root + pi)
roots.append(root)
return roots
def j1(z): return spherical_jn(1, z)
def j1d(z): return spherical_jn(1, z, derivative=True)
def psi(n, z):
# Riccati-Bessel function of first kind
return z * spherical_jn(n, z)
def psiDz(n, z):
# Derivative of Riccati-Bessel function of first kind
return spherical_jn(n, z) + z * spherical_jn(n, z, 1)
c_L_p = m.sqrt((lamda_p + 2 * mhu_p) / rho_p)
c_T_p = m.sqrt(mhu_p / rho_p)
k_L_p = omega * m.sqrt(rho_p / (lamda_p + 2 * mhu_p))
k_T_p = omega * m.sqrt(rho_p / mhu_p)
K_L_p = k_L_p * R_0
K_T_p = k_T_p * R_0
#Loop over two values of n
for n in range(1, 2):
hnL_n = spherical_hn1(n, K_L)
hnT_n = spherical_hn1(n, K_T)
hnL_1n = spherical_hn1(n + 1, K_L)
hnT_1n = spherical_hn1(n + 1, K_T)
jnL_n = sp.spherical_jn(n, K_L)
jnT_n = sp.spherical_jn(n, K_T)
jnL_np = sp.spherical_jn(n, K_L_p)
jnT_np = sp.spherical_jn(n, K_T_p)
jnL_1n = sp.spherical_jn(n + 1, K_L)
jnT_1n = sp.spherical_jn(n + 1, K_T)
jnL_1np = sp.spherical_jn(n + 1, K_L_p)
jnT_1np = sp.spherical_jn(n + 1, K_T_p)
U_L_p = n * jnL_np - K_L_p * jnL_1np
U_T_p = n * (n + 1) * jnT_np
U_L = n * hnL_n - K_L * hnL_1n
U_T = n * (n + 1) * hnT_n
U_I = n * (n + 1) * jnT_n
