def _test_real(self):
zeta_p = self.zeta_p
z = 1.0
k = 1.0
ene = 0.5 * k * k
zeta_b = 1.1
print ""
for L in [1, 2, 3]:
for M in [-1, 0, 1]:
g_psi0 = (SymGTOs.create().sym(C1()).sub(
sub_solid_sh(L, M, zeta_p, 0)).setup())
g_a = (SymGTOs.create().sym(C1()).sub(
sub_solid_sh(L, M, [1.0], 0)).setup())
g_b = (SymGTOs.create().sym(C1()).sub(
sub_solid_sh(L, M, [zeta_b], 0)).setup())
c_npsi0 = calc_coulomb_cck(g_psi0, g_a, 0, z, ene)
s_psi0_b = calc_mat(g_psi0, g_b, False)["s"][0, 0].col(0)
calc_ip = np.dot(c_npsi0, s_psi0_b).imag
rs = np.linspace(0, 10, num=100)
ref_ip = calc_ip_numint(
lambda r: coulombf(L, -z / k, r * k),
lambda r: r**(L + 1) * np.exp(-zeta_b * r * r), rs)
msg = """
(L, M) = ({0}, {1})
calc = {2}
ref = {3}
err = {4}
""".format(L, M, calc_ip, ref_ip, abs(calc_ip - ref_ip))
print L, M, calc_ip, ref_ip, abs(calc_ip - ref_ip)
self.assertAlmostEqual(calc_ip, ref_ip, places=3, msg=msg)
def _test_complex_v(self):
zeta_p = self.zeta_p
z = 1.0
k = 1.0
ene = 0.5 * k * k
zeta1 = 0.6-0.3j; c1 = 0.4
zeta2 = 1.2-0.2j; c2 = 0.6
# how to calculate
# general case:
# <Im y | s> = <(y - y*)/2i | s> = <y-y* | s> / (-2i)
# s is real function:
# = (<y*|s> - <y|s> )/2i = Im[<y*|s>]
for L in [5]:
for M in [-1, 0, +1]:
g_psi0 = (SymGTOs.create()
.sym(C1())
.sub(sub_solid_sh(L, M, zeta_p, 0))
.atom((0,0,0), 1)
.setup())
g_a = (SymGTOs.create()
.sym(C1())
.sub(sub_solid_sh(L, M, [1.0], 0))
.atom((0,0,0), 1)
.setup())
g_b = (SymGTOs.create()
.sym(C1())
.sub(sub_solid_sh(L, M, [zeta1, zeta2], 0))
.atom((0,0,0), z)
.setup())
c_npsi0 = calc_coulomb_cck(g_psi0, g_a, 0, z, ene)
v_psi0_b_C = calc_mat(g_psi0, g_b, True)["v"][0, 0]
v_psi0_b_H = calc_mat(g_psi0.conj(), g_b, True)["v"][0, 0]
c_b = np.array([c1, c2])
calc_ip = (+np.dot(c_npsi0.conj(), v_psi0_b_H * c_b)
-np.dot(c_npsi0, v_psi0_b_C * c_b)) / (-2.0j)
rs = np.linspace(0, 10, num=100)
eps = 0.000000001
ref_ip = calc_ip_numint_2(lambda r: -z/(r+eps) * coulombf(L, -z/k, r*k),
lambda r: r**(L+1) * np.exp(-zeta1 * r * r),
lambda r: r**(L+1) * np.exp(-zeta2 * r * r),
c1, c2, rs)
print L, M, calc_ip, ref_ip
self.assertAlmostEqual(calc_ip, ref_ip, places=4)
def _test_complex_v(self):
zeta_p = self.zeta_p
z = 1.0
k = 1.0
ene = 0.5 * k * k
zeta1 = 0.6 - 0.3j
c1 = 0.4
zeta2 = 1.2 - 0.2j
c2 = 0.6
# how to calculate
# general case:
# <Im y | s> = <(y - y*)/2i | s> = <y-y* | s> / (-2i)
# s is real function:
# = (<y*|s> - <y|s> )/2i = Im[<y*|s>]
for L in [5]:
for M in [-1, 0, +1]:
g_psi0 = (SymGTOs.create().sym(C1()).sub(
sub_solid_sh(L, M, zeta_p, 0)).atom((0, 0, 0), 1).setup())
g_a = (SymGTOs.create().sym(C1()).sub(
sub_solid_sh(L, M, [1.0], 0)).atom((0, 0, 0), 1).setup())
g_b = (SymGTOs.create().sym(C1()).sub(
sub_solid_sh(L, M, [zeta1, zeta2], 0)).atom((0, 0, 0),
z).setup())
c_npsi0 = calc_coulomb_cck(g_psi0, g_a, 0, z, ene)
v_psi0_b_C = calc_mat(g_psi0, g_b, True)["v"][0, 0]
v_psi0_b_H = calc_mat(g_psi0.conj(), g_b, True)["v"][0, 0]
c_b = np.array([c1, c2])
calc_ip = (+np.dot(c_npsi0.conj(), v_psi0_b_H * c_b) -
np.dot(c_npsi0, v_psi0_b_C * c_b)) / (-2.0j)
rs = np.linspace(0, 10, num=100)
eps = 0.000000001
ref_ip = calc_ip_numint_2(
lambda r: -z / (r + eps) * coulombf(L, -z / k, r * k),
lambda r: r**(L + 1) * np.exp(-zeta1 * r * r),
lambda r: r**(L + 1) * np.exp(-zeta2 * r * r), c1, c2, rs)
print L, M, calc_ip, ref_ip
self.assertAlmostEqual(calc_ip, ref_ip, places=4)
def _test_real(self):
zeta_p = self.zeta_p
z = 1.0
k = 1.0
ene = 0.5 * k * k
zeta_b = 1.1
print ""
for L in [1, 2, 3]:
for M in [-1,0,1]:
g_psi0 = (SymGTOs.create()
.sym(C1())
.sub(sub_solid_sh(L, M, zeta_p, 0))
.setup())
g_a = (SymGTOs.create()
.sym(C1())
.sub(sub_solid_sh(L, M, [1.0], 0))
.setup())
g_b = (SymGTOs.create()
.sym(C1())
.sub(sub_solid_sh(L, M, [zeta_b], 0))
.setup())
c_npsi0 = calc_coulomb_cck(g_psi0, g_a, 0, z, ene)
s_psi0_b = calc_mat(g_psi0, g_b, False)["s"][0, 0].col(0)
calc_ip = np.dot(c_npsi0, s_psi0_b).imag
rs = np.linspace(0, 10, num=100)
ref_ip = calc_ip_numint(lambda r: coulombf(L, -z/k, r*k),
lambda r: r**(L+1) * np.exp(-zeta_b * r * r),
rs)
msg = """
(L, M) = ({0}, {1})
calc = {2}
ref = {3}
err = {4}
""".format(L, M, calc_ip, ref_ip, abs(calc_ip-ref_ip))
print L, M, calc_ip, ref_ip, abs(calc_ip-ref_ip)
self.assertAlmostEqual(calc_ip, ref_ip, places=3, msg=msg)
