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_kn_recurrence_complex(self):
# http://dlmf.nist.gov/10.51.E4
n = np.array([1, 2, 3, 7, 12])
x = 1.1 + 1.5j
assert_allclose(
(-1) ** (n - 1) * spherical_kn(n - 1, x) - (-1) ** (n + 1) * spherical_kn(n + 1, x),
(-1) ** n * (2 * n + 1) / x * spherical_kn(n, x),
)
def test_sph_in_kn_order0(self):
x = 1.0
sph_i0 = np.empty((2,))
sph_i0[0] = spherical_in(0, x)
sph_i0[1] = spherical_in(0, x, derivative=True)
sph_i0_expected = np.array([np.sinh(x) / x, np.cosh(x) / x - np.sinh(x) / x ** 2])
assert_array_almost_equal(r_[sph_i0], sph_i0_expected)
sph_k0 = np.empty((2,))
sph_k0[0] = spherical_kn(0, x)
sph_k0[1] = spherical_kn(0, x, derivative=True)
sph_k0_expected = np.array([0.5 * pi * exp(-x) / x, -0.5 * pi * exp(-x) * (1 / x + 1 / x ** 2)])
assert_array_almost_equal(r_[sph_k0], sph_k0_expected)
def test_sph_in_kn_order0(self):
x = 1.
sph_i0 = np.empty((2, ))
sph_i0[0] = spherical_in(0, x)
sph_i0[1] = spherical_in(0, x, derivative=True)
sph_i0_expected = np.array(
[np.sinh(x) / x,
np.cosh(x) / x - np.sinh(x) / x**2])
assert_array_almost_equal(r_[sph_i0], sph_i0_expected)
sph_k0 = np.empty((2, ))
sph_k0[0] = spherical_kn(0, x)
sph_k0[1] = spherical_kn(0, x, derivative=True)
sph_k0_expected = np.array(
[0.5 * pi * exp(-x) / x, -0.5 * pi * exp(-x) * (1 / x + 1 / x**2)])
assert_array_almost_equal(r_[sph_k0], sph_k0_expected)
def test_spherical_kn_inf_complex(self):
# https://dlmf.nist.gov/10.52.E6
# The behavior at complex infinity depends on the sign of the real
# part: if Re(z) >= 0, then the limit is 0; if Re(z) < 0, then it's
# z*inf. This distinction cannot be captured, so we return nan.
n = 7
x = np.array([-inf + 0j, inf + 0j, inf * (1 + 1j)])
assert_allclose(spherical_kn(n, x), np.array([-inf, 0, nan]))
def test_spherical_kn_inf_complex(self):
# http://dlmf.nist.gov/10.52.E6
# The behavior at complex infinity depends on the sign of the real
# part: if Re(z) >= 0, then the limit is 0; if Re(z) < 0, then it's
# z*inf. This distinction cannot be captured, so we return nan.
n = 7
x = np.array([-inf + 0j, inf + 0j, inf * (1 + 1j)])
assert_allclose(spherical_kn(n, x), np.array([-inf, 0, nan]))
def asym_WF_b(self, r, E):
"""
The asymptotic wave function and its derivative (d/drho!)
for both neutral and charged particle bound states.
"""
gammaB=np.sqrt(-2*self.mu*E)/self.hbar # binding momentum
rho=gammaB *r
eta=self.eta_func(gammaB) # corresponding to binding momentum gammaB
if np.sum(np.shape(rho))==0 :
if np.absolute(rho)<1.e-16: rho=1.e-16
else:
rho[np.isclose(rho,0, atol=1.e-16)]=1.e-16
if self.test_not_coulomb:
f=ss.spherical_kn(self.angL, rho)*2./np.pi*rho # note 2/pi factor and the rho factor
df=f/rho+ss.spherical_kn(self.angL, rho, derivative=True)*2./np.pi*rho
else:
hvalue=None
dirvalue=None
f=np.array(coulombw_ufunc(self.angL, -eta, rho)).astype(float)
df=np.array(drho_coulombw_ufunc(self.angL, -eta, rho, hvalue, dirvalue)).astype(float)
return f, df
def test_sph_kn(self):
kn = np.empty((2, 3))
x = 0.2
kn[0][0] = spherical_kn(0, x)
kn[0][1] = spherical_kn(1, x)
kn[0][2] = spherical_kn(2, x)
kn[1][0] = spherical_kn(0, x, derivative=True)
kn[1][1] = spherical_kn(1, x, derivative=True)
kn[1][2] = spherical_kn(2, x, derivative=True)
kn0 = -kn[0][1]
kn1 = -kn[0][0] - 2.0 / 0.2 * kn[0][1]
kn2 = -kn[0][1] - 3.0 / 0.2 * kn[0][2]
assert_array_almost_equal(kn[0], [6.4302962978445670140, 38.581777787067402086, 585.15696310385559829], 12)
assert_array_almost_equal(kn[1], [kn0, kn1, kn2], 9)
def test_sph_kn(self):
kn = np.empty((2, 3))
x = 0.2
kn[0][0] = spherical_kn(0, x)
kn[0][1] = spherical_kn(1, x)
kn[0][2] = spherical_kn(2, x)
kn[1][0] = spherical_kn(0, x, derivative=True)
kn[1][1] = spherical_kn(1, x, derivative=True)
kn[1][2] = spherical_kn(2, x, derivative=True)
kn0 = -kn[0][1]
kn1 = -kn[0][0] - 2.0 / 0.2 * kn[0][1]
kn2 = -kn[0][1] - 3.0 / 0.2 * kn[0][2]
assert_array_almost_equal(kn[0], [
6.4302962978445670140, 38.581777787067402086, 585.15696310385559829
], 12)
assert_array_almost_equal(kn[1], [kn0, kn1, kn2], 9)
def df(self, n, z):
return spherical_kn(n, z, derivative=True)
def f(self, n, z):
return spherical_kn(n, z)
def test_spherical_kn_at_zero_complex(self):
# http://dlmf.nist.gov/10.52.E2
n = np.array([0, 1, 2, 5, 10, 100])
x = 0 + 0j
assert_allclose(spherical_kn(n, x), nan * np.ones(shape=n.shape))
def test_spherical_kn_at_zero(self):
# https://dlmf.nist.gov/10.52.E2
n = np.array([0, 1, 2, 5, 10, 100])
x = 0
assert_allclose(spherical_kn(n, x), inf*np.ones(shape=n.shape))
def test_spherical_kn_inf_real(self):
# http://dlmf.nist.gov/10.52.E6
n = 5
x = np.array([-inf, inf])
assert_allclose(spherical_kn(n, x), np.array([-inf, 0]))
def test_spherical_kn_at_zero(self):
# http://dlmf.nist.gov/10.52.E2
n = np.array([0, 1, 2, 5, 10, 100])
x = 0
assert_allclose(spherical_kn(n, x), inf * np.ones(shape=n.shape))
def test_spherical_kn_exact(self):
# https://dlmf.nist.gov/10.49.E13
x = np.array([0.12, 1.23, 12.34, 123.45])
assert_allclose(spherical_kn(2, x),
pi / 2 * exp(-x) * (1 / x + 3 / x * x + 3 / x * x * x))
def f(self, n, z):
return spherical_kn(n, z)
def df(self, n, z):
return spherical_kn(n, z, derivative=True)
def test_spherical_kn_recurrence_real(self):
# https://dlmf.nist.gov/10.51.E4
n = np.array([1, 2, 3, 7, 12])
x = 0.12
assert_allclose((-1)**(n - 1)*spherical_kn(n - 1, x) - (-1)**(n + 1)*spherical_kn(n + 1,x),
(-1)**n*(2*n + 1)/x*spherical_kn(n, x))
def transl_yuk_z_SR_recurs(LMax, dr, k):
"""
Translate coaxially from regular to singular, Gumerov and Duraiswami.
Inputs
------
l : int
Order of multipole expansion to output rotation matrix coefficient H
Reference
---------
"Recursions for the computation of multipole translation and rotation
coefficients for the 3-d helmholtz equation."
https://arxiv.org/pdf/1403.7698v1.pdf
"""
# Create (E|F)_{l,m}^{m}
eflm = np.zeros([2 * LMax + 1, LMax + 1])
# Start (E|F)_{l, 0}^{0}
ls = np.arange(2 * LMax + 1)
eflm[:, 0] = (-1)**ls * np.sqrt(2 * ls + 1) * sp.spherical_kn(ls, k * dr)
# now recursion 4.86 for (E|F)_{l, m}^{m}
for m in range(LMax):
for l in range(2 * LMax - m):
# (n=m)
blmm = get_bnm(l, -m - 1)
blmp = get_bnm(l + 1, m)
bmm = get_bnm(m + 1, -m - 1)
eflm[l,
m + 1] = (eflm[l - 1, m] * blmm - eflm[l + 1, m] * blmp) / bmm
efms = []
# Now create (E|F)^m matrices (p-|m|)x(p-|m|)
# Start with (2*p-|m|)x(p-|m|) and truncate
for m in range(LMax + 1):
efm = np.zeros([2 * LMax + 1 - 2 * m, LMax - m + 1])
efm[:, 0] = eflm[m:2 * LMax + 1 - m, m]
for n in range(LMax - m):
for l in range(n + 1, 2 * (LMax - m) - n):
anm = get_anm(n + m, m)
alm = get_anm(l + m, m)
almm = get_anm(l - 1 + m, m)
anmm = get_anm(n - 1 + m, m)
print(l, n + 1, l + m, anm, anmm, alm, almm)
if anmm != 0:
print(l, n, m)
efm[l,
n + 1] = (almm * efm[l - 1, n] - alm * efm[l + 1, n] +
anmm * efm[l, n - 1]) / anm
else:
efm[l, n +
1] = (alm * efm[l + 1, n] - almm * efm[l - 1, n]) / anm
efms.append(efm)
for m in range(LMax + 1):
efms[m] = efms[m][:LMax - m + 1, :LMax - m + 1]
lm = len(efms[m])
# Start from m since (E|F)^m matrix starts at (m,m) corner
nls = (np.arange(m, m + lm))
enl = np.transpose(efms[m]) * np.outer((-1)**(nls), (-1)**(nls))
efms[m] += enl
efms[m] -= np.diag(np.diag(enl))
return eflm, efms
def test_spherical_kn_inf_real(self):
# https://dlmf.nist.gov/10.52.E6
n = 5
x = np.array([-inf, inf])
assert_allclose(spherical_kn(n, x), np.array([-inf, 0]))
def test_spherical_kn_recurrence_complex(self):
# https://dlmf.nist.gov/10.51.E4
n = np.array([1, 2, 3, 7, 12])
x = 1.1 + 1.5j
assert_allclose((-1)**(n - 1)*spherical_kn(n - 1, x) - (-1)**(n + 1)*spherical_kn(n + 1,x),
(-1)**n*(2*n + 1)/x*spherical_kn(n, x))
def test_spherical_kn_exact(self):
# http://dlmf.nist.gov/10.49.E13
x = np.array([0.12, 1.23, 12.34, 123.45])
assert_allclose(spherical_kn(2, x), pi / 2 * exp(-x) * (1 / x + 3 / x ** 2 + 3 / x ** 3))
def test_spherical_kn_at_zero_complex(self):
# https://dlmf.nist.gov/10.52.E2
n = np.array([0, 1, 2, 5, 10, 100])
x = 0 + 0j
assert_allclose(spherical_kn(n, x), nan * np.ones(shape=n.shape))
def test_spherical_kn_at_zero(self):
# https://dlmf.nist.gov/10.52.E2
n = np.array([0, 1, 2, 5, 10, 100])
x = 0
assert_allclose(spherical_kn(n, x), np.full(n.shape, inf))