def test_br_term_mult():
"BR Tools : br_term_mult"
#secular tests
for kk in range(10):
N = 10
H = rand_herm(N, 0.5)
Hf = H.full('f')
t = 1.0
a = rand_herm(N, 0.5)
A = a.full('f')
vec = np.ones(N**2, dtype=complex)
out = np.zeros(N**2, dtype=complex)
use_secular = 1
atol = 1e-12
spec = lambda w: 1.0
H_diag = H.transform(H.eigenstates()[1])
L_diag = liouvillian(H_diag)
R = (bloch_redfield_tensor(
H, [[a, spec]], c_ops=[], use_secular=use_secular)[0] - L_diag)
ans = R.data.dot(vec)
evals = np.zeros(N, dtype=float)
evecs = _test_zheevr(Hf, evals)
_test_br_term_mult(t, A, evecs, evals, vec, out, use_secular, 0.1,
atol)
assert_(np.allclose(ans, out))
#non-secular tests
for kk in range(10):
N = 10
H = rand_herm(N, 0.5)
Hf = H.full('f')
t = 1.0
a = rand_herm(N, 0.5)
A = a.full('f')
vec = np.ones(N**2, dtype=complex)
out = np.zeros(N**2, dtype=complex)
use_secular = 0
atol = 1e-12
spec = lambda w: 1.0
H_diag = H.transform(H.eigenstates()[1])
L_diag = liouvillian(H_diag)
R = (bloch_redfield_tensor(
H, [[a, spec]], c_ops=[], use_secular=use_secular)[0] - L_diag)
ans = R.data.dot(vec)
evals = np.zeros(N, dtype=float)
evecs = _test_zheevr(Hf, evals)
_test_br_term_mult(t, A, evecs, evals, vec, out, use_secular, 0.1,
atol)
assert_(np.allclose(ans, out))
def test_br_zheevr():
"BR Tools : zheevr"
for kk in range(2,100):
H = rand_herm(kk, 1/kk)
H2 =H.full('F')
eigvals = np.zeros(kk,dtype=float)
Z = _test_zheevr(H2, eigvals)
ans_vals, ans_vecs = la.eigh(H.full())
assert_(np.allclose(ans_vals,eigvals))
assert_(np.allclose(Z,ans_vecs))
def test_zheevr():
"""
zheevr: store eigenvalues in the passed array, and return the eigenvectors
of a complex Hermitian matrix.
"""
for dimension in range(2, 100):
H = qutip.rand_herm(dimension, 1/dimension)
our_evals = np.zeros(dimension, dtype=np.float64)
our_evecs = _test_zheevr(H.full('F'), our_evals)
scipy_evals, scipy_evecs = scipy.linalg.eigh(H.full())
assert np.allclose(scipy_evals, our_evals)
assert np.allclose(scipy_evecs, our_evecs)
def test_dense_operator_to_eigbasis(operator):
"BR Tools : dense operator to eigenbasis"
dimension = 10
operator = operator(dimension)
for _ in range(50):
H = qutip.rand_herm(dimension, 0.5)
basis = H.eigenstates()[1]
target = operator.transform(basis).full()
_eigenvalues = np.empty((dimension, ), dtype=np.float64)
basis_zheevr = _test_zheevr(H.full('F'), _eigenvalues)
calculated = _test_dense_to_eigbasis(operator.full('F'), basis_zheevr,
dimension, qutip.settings.atol)
np.testing.assert_allclose(target, calculated, atol=1e-12)
def test_eigvec_to_fockbasis():
"BR Tools : eigvector to fockbasis"
N = 10
for kk in range(50):
H = rand_herm(N,0.5)
h = H.full('F')
R = rand_dm(N,0.5)
r = mat2vec(R.full()).ravel()
eigvals = np.zeros(N,dtype=float)
Z = _test_zheevr(H.full('F'), eigvals)
eig_vec = mat2vec(R.transform(H.eigenstates()[1]).full()).ravel()
out = _test_eigvec_to_fockbasis(eig_vec, Z, N)
assert_(np.allclose(r,out))
def test_eigvec_to_fockbasis():
"BR Tools : eigvector to fockbasis"
dimension = 10
for _ in range(50):
H = qutip.rand_herm(dimension, 0.5)
basis = H.eigenstates()[1]
R = qutip.rand_dm(dimension, 0.5)
target = qutip.mat2vec(R.full()).ravel()
_eigenvalues = np.empty((dimension, ), dtype=np.float64)
evecs_zheevr = _test_zheevr(H.full('F'), _eigenvalues)
flat_eigenvectors = qutip.mat2vec(R.transform(basis).full()).ravel()
calculated = _test_eigvec_to_fockbasis(flat_eigenvectors, evecs_zheevr,
dimension)
np.testing.assert_allclose(target, calculated, atol=1e-12)
def test_cop_super_mult():
"BR Tools : cop_super_mult"
dimension = 10
for _ in range(50):
H = qutip.rand_herm(dimension, 0.5)
basis = H.eigenstates()[1]
a = qutip.destroy(dimension)
L = qutip.liouvillian(None, [a.transform(basis)])
vec = np.ones((dimension * dimension, ), dtype=np.complex128)
target = L.data.dot(vec)
calculated = np.zeros_like(target)
_eigenvalues = np.empty((dimension, ), dtype=np.float64)
_cop_super_mult(a.full('F'), _test_zheevr(H.full('F'), _eigenvalues),
vec, 1, calculated, dimension, qutip.settings.atol)
np.testing.assert_allclose(target, calculated, atol=1e-12)
def test_cop_super_mult():
"BR Tools : cop_super_mult"
N = 10
for kk in range(50):
H = rand_herm(N,0.5)
R = rand_dm(N,0.5)
a = destroy(N)
A = a.transform(H.eigenstates()[1])
vec = np.ones(N**2,dtype=complex)
L = liouvillian(None,[A])
ans = L.data.dot(vec)
eigvals = np.zeros(N,dtype=float)
Z = _test_zheevr(H.full('F'),eigvals)
out = np.zeros_like(vec)
_cop_super_mult(a.full('F'), Z, vec, 1, out, N, qset.atol)
assert_(np.allclose(ans,out))
def test_br_dense_to_eigbasis():
"BR Tools : dense operator to eigenbasis"
N = 10
for kk in range(50):
H = rand_herm(N,0.5)
a = rand_herm(N,0.5)
evals, evecs = H.eigenstates()
A = a.transform(evecs).full()
H2 = H.full('F')
eigvals = np.zeros(N,dtype=float)
Z = _test_zheevr(H2, eigvals)
a2 = a.full('F')
assert_(np.allclose(A,_test_dense_to_eigbasis(a2,Z,N,qset.atol)))
b = destroy(N)
B = b.transform(evecs).full()
b2 = b.full('F')
assert_(np.allclose(B,_test_dense_to_eigbasis(b2,Z,N,qset.atol)))
def test_zheevr(dimension):
"""
zheevr: store eigenvalues in the passed array, and return the eigenvectors
of a complex Hermitian matrix.
"""
H = qutip.rand_herm(dimension, 1 / dimension)
Hf = H.full()
evals = np.zeros(dimension, dtype=np.float64)
# This routine modifies its arguments inplace, so we must make a copy.
evecs = _test_zheevr(Hf.copy(order='F'), evals).T
# Assert linear independence of all the eigenvectors.
assert abs(scipy.linalg.det(evecs)) > 1e-12
for value, vector in zip(evals, evecs):
# Assert the eigenvector satisfies the eigenvalue equation.
unit = vector / scipy.linalg.norm(vector)
test_value = np.conj(unit.T) @ Hf @ unit
assert abs(test_value.imag) < 1e-12
assert abs(test_value - value) < 1e-12
def test_br_term_mult(secular):
"BR Tools : br_term_mult"
dimension = 10
time = 1.0
atol = 1e-12
for _ in range(10):
H = qutip.rand_herm(dimension, 0.5)
basis = H.eigenstates()[1]
L_diagonal = qutip.liouvillian(H.transform(basis))
evals = np.empty((dimension,), dtype=np.float64)
evecs = _test_zheevr(H.full('F'), evals)
operator = qutip.rand_herm(dimension, 0.5)
a_ops = [[operator, lambda w: 1.0]]
vec = np.ones((dimension*dimension,), dtype=np.complex128)
br_tensor, _ = qutip.bloch_redfield_tensor(H, a_ops,
use_secular=secular)
target = (br_tensor - L_diagonal).data.dot(vec)
calculated = np.zeros_like(target)
_test_br_term_mult(time, operator.full('F'), evecs, evals, vec,
calculated, secular, 0.1, atol)
assert np.allclose(target, calculated)
