def test_mkl_spsolve7():
"""
MKL spsolve : Solution shape same as input RHS vec
"""
row = np.array([0,0,1,2,2,2])
col = np.array([0,2,2,0,1,2])
data = np.array([1,2,3,-4,5,6], dtype=complex)
A = sp.csr_matrix((data,(row,col)), shape=(3,3), dtype=complex)
b = np.array([0,2,0],dtype=complex)
out = mkl_spsolve(A,b)
assert_(b.shape==out.shape)
b = np.array([0,2,0],dtype=complex).reshape((3,1))
out = mkl_spsolve(A,b)
assert_(b.shape==out.shape)
def test_mklspsolve2():
"""
MKL spsolve : Single RHS vector (Complex)
"""
A = rand_herm(10)
x = rand_ket(10).full()
b = A * x
y = mkl_spsolve(A.data,b)
assert_array_almost_equal(x, y)
def test_mkl_spsolve9():
"""
MKL spsolve : Hermitian (complex) solver
"""
A = rand_herm(np.arange(1,11)).data
x = np.ones(10,dtype=complex)
b = A.dot(x)
y = mkl_spsolve(A, b, hermitian=1)
assert_array_almost_equal(x, y)
def test_mkl_spsolve10():
"""
MKL spsolve : Hermitian (real) solver
"""
A = rand_herm(np.arange(1,11)).data
A = sp.csr_matrix((np.real(A.data), A.indices, A.indptr), dtype=float)
x = np.ones(10, dtype=float)
b = A.dot(x)
y = mkl_spsolve(A, b, hermitian=1)
assert_array_almost_equal(x, y)
def test_mkl_spsolve1():
"""
MKL spsolve : Single RHS vector (Real)
"""
Adense = np.array([[0., 1., 1.],
[1., 0., 1.],
[0., 0., 1.]])
As = sp.csr_matrix(Adense)
np.random.seed(1234)
x = np.random.randn(3)
b = As * x
x2 = mkl_spsolve(As, b)
assert_array_almost_equal(x, x2)
def _pseudo_inverse_sparse(L, rhoss, method='splu', **pseudo_args):
"""
Internal function for computing the pseudo inverse of an Liouvillian using
sparse matrix methods. See pseudo_inverse for details.
"""
N = np.prod(L.dims[0][0])
rhoss_vec = operator_to_vector(rhoss)
tr_op = tensor([identity(n) for n in L.dims[0][0]])
tr_op_vec = operator_to_vector(tr_op)
P = sp.kron(rhoss_vec.data, tr_op_vec.data.T, format='csr')
I = sp.eye(N*N, N*N, format='csr')
Q = I - P
if pseudo_args['use_rcm']:
perm = reverse_cuthill_mckee(L.data)
A = sp_permute(L.data, perm, perm, 'csr')
Q = sp_permute(Q, perm, perm, 'csr')
else:
if not settings.has_mkl:
A = L.data.tocsc()
A.sort_indices()
if method == 'splu':
if settings.has_mkl:
LIQ = mkl_spsolve(A,Q.toarray())
else:
lu = sp.linalg.splu(A, permc_spec=pseudo_args['permc_spec'],
diag_pivot_thresh=pseudo_args['diag_pivot_thresh'],
options=dict(ILU_MILU=pseudo_args['ILU_MILU']))
LIQ = lu.solve(Q.toarray())
elif method == 'spilu':
lu = sp.linalg.spilu(A, permc_spec=pseudo_args['permc_spec'],
fill_factor=pseudo_args['fill_factor'],
drop_tol=pseudo_args['drop_tol'])
LIQ = lu.solve(Q.toarray())
else:
raise ValueError("unsupported method '%s'" % method)
R = sp.csr_matrix(Q * LIQ)
if pseudo_args['use_rcm']:
rev_perm = np.argsort(perm)
R = sp_permute(R, rev_perm, rev_perm, 'csr')
return Qobj(R, dims=L.dims)
def test_mkl_spsolve4():
"""
MKL spsolve : Multi RHS vector (Complex)
"""
row = np.array([0,0,1,2,2,2])
col = np.array([0,2,2,0,1,2])
data = np.array([1,2,3,-4,5,6],dtype=complex)
sM = sp.csr_matrix((data,(row,col)), shape=(3,3), dtype=complex)
M = sM.toarray()
row = np.array([0,0,1,1,0,0])
col = np.array([0,2,1,1,0,0])
data = np.array([1,1,1,1,1,1],dtype=complex)
sN = sp.csr_matrix((data, (row,col)), shape=(3,3), dtype=complex)
N = sN.toarray()
sX = mkl_spsolve(sM, N)
X = la.solve(M, N)
assert_array_almost_equal(X, sX)
def test_mkl_spsolve8():
"""
MKL spsolve : Sparse RHS matrix
"""
A = sp.csr_matrix([
[1, 2, 0],
[0, 3, 0],
[0, 0, 5]])
b = sp.csr_matrix([
[0, 1],
[1, 0],
[0, 0]])
x = mkl_spsolve(A, b)
ans = np.array([[-0.66666667, 1],
[0.33333333, 0],
[0, 0]])
assert_array_almost_equal(x.toarray(), ans)
def _steadystate_direct_sparse(L, ss_args):
"""
Direct solver that uses scipy sparse matrices
"""
if settings.debug:
logger.debug('Starting direct LU solver.')
dims = L.dims[0]
n = int(np.sqrt(L.shape[0]))
b = np.zeros(n ** 2, dtype=complex)
b[0] = ss_args['weight']
if settings.has_mkl:
has_mkl = 1
else:
has_mkl = 0
L, perm, perm2, rev_perm, ss_args = _steadystate_LU_liouvillian(L, ss_args, has_mkl)
if np.any(perm):
b = b[np.ix_(perm,)]
if np.any(perm2):
b = b[np.ix_(perm2,)]
ss_args['info']['permc_spec'] = ss_args['permc_spec']
ss_args['info']['drop_tol'] = ss_args['drop_tol']
ss_args['info']['diag_pivot_thresh'] = ss_args['diag_pivot_thresh']
ss_args['info']['fill_factor'] = ss_args['fill_factor']
ss_args['info']['ILU_MILU'] = ss_args['ILU_MILU']
if not has_mkl:
# Use superLU solver
orig_nnz = L.nnz
_direct_start = time.time()
lu = splu(L, permc_spec=ss_args['permc_spec'],
diag_pivot_thresh=ss_args['diag_pivot_thresh'],
options=dict(ILU_MILU=ss_args['ILU_MILU']))
v = lu.solve(b)
_direct_end = time.time()
ss_args['info']['solution_time'] = _direct_end - _direct_start
if (settings.debug or ss_args['return_info']) and _scipy_check:
L_nnz = lu.L.nnz
U_nnz = lu.U.nnz
ss_args['info']['l_nnz'] = L_nnz
ss_args['info']['u_nnz'] = U_nnz
ss_args['info']['lu_fill_factor'] = (L_nnz + U_nnz)/L.nnz
if settings.debug:
logger.debug('L NNZ: %i ; U NNZ: %i' % (L_nnz, U_nnz))
logger.debug('Fill factor: %f' % ((L_nnz + U_nnz)/orig_nnz))
else: # Use MKL solver
if len(ss_args['info']['perm']) !=0:
in_perm = np.arange(n**2, dtype=np.int32)
else:
in_perm = None
_direct_start = time.time()
v = mkl_spsolve(L, b, perm = in_perm, verbose = ss_args['verbose'])
_direct_end = time.time()
ss_args['info']['solution_time'] = _direct_end-_direct_start
if ss_args['return_info']:
ss_args['info']['residual_norm'] = la.norm(b - L*v)
if (not ss_args['use_umfpack']) and ss_args['use_rcm']:
v = v[np.ix_(rev_perm,)]
data = vec2mat(v)
data = 0.5 * (data + data.conj().T)
if ss_args['return_info']:
return Qobj(data, dims=dims, isherm=True), ss_args['info']
else:
return Qobj(data, dims=dims, isherm=True)
