def solve(A, B, n_eigs=4, verbose=False): """ Solves the generalized eigenvalue problem. A, B ... scipy matrices returns (lmbd, Q), where lmbd are the eigenvalues and Q is a numpy array of solutions """ if verbose: print "converting to pysparse" n = A.shape[0] A = convert_mat(A) B = convert_mat(B) if verbose: print "solving (%d x %d)" % (n, n) Atau = A.copy() tau = -1 Atau.shift(-tau, B) K = precon.jacobi(Atau) A = A.to_sss() B = B.to_sss() kconv, lmbd, Q, it, it_in = jdsym.jdsym(A, B, K, n_eigs, tau, 1e-6, 150, itsolvers.qmrs) if verbose: print "number of converged eigenvalues:", kconv return lmbd, Q
def __call__(self, mtx_a, mtx_b=None, n_eigs=None, eigenvectors=None, status=None, conf=None): from pysparse import jdsym, itsolvers, precon output("loading...") A = self._convert_mat(mtx_a) output("...done") if mtx_b is not None: M = self._convert_mat(mtx_b) output("solving...") Atau=A.copy() Atau.shift(-conf.tau,M) K=precon.jacobi(Atau) A=A.to_sss(); if mtx_b is not None: M=M.to_sss(); method = getattr(itsolvers, conf.method) kconv, lmbd, Q, it, it_in = jdsym.jdsym(A, M, K, n_eigs, conf.tau, conf.eps_a, conf.i_max, method, clvl=conf.verbosity, strategy=conf.strategy) output("number of converged eigenvalues:", kconv) output("...done") if status is not None: status['q'] = Q status['it'] = it status['it_in'] = it_in return lmbd, Q
def modalSolver(self, nev = 3, ncv = -1, tol = -1, mxiter = -1): if SOLVER == 'default': if ncv < 0: ncv = 4*nev ncv = ncv + nev if tol < 0.: tol = 1e-2 if mxiter < 0: mxiter = 1000. return solver.arpack(self.GK, self.GM, nev, ncv, tol, mxiter) elif SOLVER == 'pysparse': # copy matrixes GK = self.GK A = spmatrix.ll_mat_sym(self.dofcount, len(GK)) # TODO change to scipy for row, col in GK: A[row,col] = GK[row,col] GM = self.GM M = spmatrix.ll_mat_sym(self.dofcount, len(GM)) # TODO change to scipy for row, col in GM: M[row,col] = GM[row,col] # Atau = A + tau*M tau = -1.0 Atau = A.copy() Atau.shift(tau, M) K = precon.jacobi(Atau) # convert to skyline A = A.to_sss() M = M.to_sss() # solve k_conv, lmbd, Q, it, it_innser = \ jdsym.jdsym(A, M, K, nev, tau, 1e-6, 1000, itsolvers.qmrs, jmin=5, jmax=10, clvl=0, strategy=1) # eigen values return lmbd else: raise FEError('unknown solver')
def modalSolver(self, nev=3, ncv=-1, tol=-1, mxiter=-1): if SOLVER == 'default': if ncv < 0: ncv = 4 * nev ncv = ncv + nev if tol < 0.: tol = 1e-2 if mxiter < 0: mxiter = 1000. return solver.arpack(self.GK, self.GM, nev, ncv, tol, mxiter) elif SOLVER == 'pysparse': # copy matrixes GK = self.GK A = spmatrix.ll_mat_sym(self.dofcount, len(GK)) for row, col in GK: A[row, col] = GK[row, col] GM = self.GM M = spmatrix.ll_mat_sym(self.dofcount, len(GM)) for row, col in GM: M[row, col] = GM[row, col] # Atau = A + tau*M tau = -1.0 Atau = A.copy() Atau.shift(tau, M) K = precon.jacobi(Atau) # convert to skyline A = A.to_sss() M = M.to_sss() # solve k_conv, lmbd, Q, it, it_innser = \ jdsym.jdsym(A, M, K, nev, tau, 1e-6, 1000, itsolvers.qmrs, jmin=5, jmax=10, clvl=0, strategy=1) # eigen values return lmbd else: raise FEError('unknown solver')
def __call__( self, mtx_a, mtx_b = None, n_eigs = None, eigenvectors = None, status = None, conf = None ): from pysparse import jdsym, itsolvers, precon conf = get_default( conf, self.conf ) mtx_a = get_default( mtx_a, self.mtx_a ) mtx_b = get_default( mtx_b, self.mtx_b ) n_eigs = get_default( n_eigs, self.n_eigs ) eigenvectors = get_default( eigenvectors, self.eigenvectors ) status = get_default( status, self.status ) output( "loading..." ) A = self._convert_mat( mtx_a ) output( "...done" ) if mtx_b is not None: M = self._convert_mat( mtx_b ) output( "solving..." ) tt = time.clock() Atau=A.copy() Atau.shift(-conf.tau,M) K=precon.jacobi(Atau) A=A.to_sss(); if mtx_b is not None: M=M.to_sss(); method = getattr( itsolvers, conf.method ) kconv, lmbd, Q, it, it_in = jdsym.jdsym( A, M, K, n_eigs, conf.tau, conf.eps_a, conf.i_max, method, clvl = conf.verbosity, strategy = conf.strategy ) output( "number of converged eigenvalues:", kconv ) ttt = time.clock() - tt output( '...done in %.2f s' % ttt ) if status is not None: status['time'] = ttt status['q'] = Q status['it'] = it status['it_in'] = it_in return lmbd, Q
def solve_eig_pysparse(A, B, n_eigs=4, verbose=False): """ Solves the generalized eigenvalue problem. A, B ..... scipy matrices n_eigs ... number of eigenvalues to solve for returns a list of (lmbd, vec), where lmbd is the eigenvalue and vec is the eigenvector """ from pysparse import jdsym, precon, itsolvers if verbose: print "converting to pysparse" n = A.shape[0] A = convert_mat(A) B = convert_mat(B) if verbose: print "solving (%d x %d)" % (n, n) Atau = A.copy() tau = -1 Atau.shift(-tau, B) K = precon.jacobi(Atau) A = A.to_sss() B = B.to_sss() kconv, lmbd, Q, it, it_in = jdsym.jdsym(A, B, K, n_eigs, tau, 1e-6, 150, itsolvers.qmrs) if verbose: print "number of converged eigenvalues:", kconv r = [] for i in range(len(lmbd)): vec = Q[:, i] r.append((lmbd[i], vec)) r.sort(key=lambda x: x[0]) print "eigenvalues:" eigs = [] for w, vec in r: if w > 0: break print w eigs.append(vec) return r
M = spmatrix.ll_mat_from_mtx(os.path.join(path, 'edge6x3x5_B.mtx')) sigma = 25.0 Asigma = A.copy() Asigma.shift(-sigma, M) K = precon.jacobi(Asigma.to_sss()) del Asigma ##n = A.shape[0] ##I = spmatrix.ll_mat(n, n) ##for i in xrange(n): ## I[i,i] = 1.0 ##K = precon.jacobi(I) k_conv, lmbd, Q, it, it_inner = \ jdsym.jdsym(A.to_sss(), M.to_sss(), K, 5, sigma, 1e-10, 150, itsolvers.qmrs, jmin=5, jmax=10, eps_tr=1e-4, toldecay=2.0, linitmax=200, clvl=1, strategy=1) print k_conv, lmbd, it, it_inner ##path = '/homes/geus/jdbsym/test/' ##A = spmatrix.ll_mat_from_mtx(path + 'sameh_10000.mtx').to_sss() ##K = precon.ssor(A) ##k_conv, lmbd, Q, it, it_inner = jdsym.jdsym(A, None, K, 4, 0.0, 1e-10, 50, itsolvers.qmrs, ## jmax=20, eps_tr=1e-4, toldecay=2.0, linitmax=60, clvl=1) ##path = '../spmatrix/' ##A_ll = spmatrix.ll_mat_from_mtx(path + 'cop18_el5_A.mtx') ##M_ll = spmatrix.ll_mat_from_mtx(path + 'cop18_el5_M.mtx')
import sys from pysparse import jdsym, spmatrix, itsolvers, precon matfiles = sys.argv[1:5] target_value = eval(sys.argv[3]) eigenval_num = eval(sys.argv[4]) jdtol = eval(sys.argv[5]) max_iter = eval(sys.argv[6]) mat_left = spmatrix.ll_mat_from_mtx(matfiles[0]) mat_right = spmatrix.ll_mat_from_mtx(matfiles[1]) shape = mat_left.shape T = mat_left.copy() T.shift(-target_value, mat_right) K = precon.ssor(T.to_sss(), 1.0, 1) # K is preconditioner. A = mat_left.to_sss() M = mat_right.to_sss() k_conv, lmbd, Q, it, itall = jdsym.jdsym(A, M, K, eigenval_num, target_value, jdtol, max_iter, itsolvers.minres) NEIG = len(lmbd) #for lam in lmbd: # print "value:", lam eivecfile = open("eivecs.dat", "w") N = len(Q[:,0]) print >> eivecfile, N print >> eivecfile, NEIG for ieig in range(len(lmbd)): eivec = Q[:,ieig] print >> eivecfile, lmbd[ieig] # printing eigenvalue for val in eivec: # printing eigenvector print >> eivecfile, val eivecfile.close()
# Test: compare K=eye with K=None # # results are not the same, ritz-value in 2nd iterations differ path = '/local/home/geus/matrices' A = spmatrix.ll_mat_from_mtx(path + 'edge6x3x5_A.mtx') M = spmatrix.ll_mat_from_mtx(path + 'edge6x3x5_B.mtx') n = A.shape[0] sigma = 25.0 I = spmatrix.ll_mat(n, n) for i in xrange(n): I[i,i] = 1.0 Keye = precon.jacobi(I) k_conv, lmbd, Q, it, it_inner = jdsym.jdsym(A.to_sss(), M.to_sss(), None, 5, sigma, 1e-10, 15, itsolvers.qmrs, jmin=5, jmax=10, eps_tr=1e-4, toldecay=2.0, linitmax=200, clvl=1, strategy=1) k_conv, lmbd, Q, it, it_inner = jdsym.jdsym(A.to_sss(), M.to_sss(), Keye, 5, sigma, 1e-10, 15, itsolvers.qmrs, jmin=5, jmax=10, eps_tr=1e-4, toldecay=2.0, linitmax=200, clvl=1, strategy=1) elif test == 2: # Test 2: K = diag(A - sigma*M), test diagonal prec using Matlab Asigma = A.copy() Asigma.shift(-sigma, M) K = precon.jacobi(Asigma.to_sss()) b = Numeric.ones(n, 'd') x = Numeric.zeros(n, 'd') K.precon(b, x)
import sys from pysparse import jdsym, spmatrix, itsolvers, precon matfiles = sys.argv[1:5] target_value = eval(sys.argv[3]) eigenval_num = eval(sys.argv[4]) jdtol = eval(sys.argv[5]) max_iter = eval(sys.argv[6]) mat_left = spmatrix.ll_mat_from_mtx(matfiles[0]) mat_right = spmatrix.ll_mat_from_mtx(matfiles[1]) shape = mat_left.shape T = mat_left.copy() T.shift(-target_value, mat_right) K = precon.ssor(T.to_sss(), 1.0, 1) # K is preconditioner. A = mat_left.to_sss() M = mat_right.to_sss() k_conv, lmbd, Q, it, itall = jdsym.jdsym(A, M, K, eigenval_num, target_value, jdtol, max_iter, itsolvers.minres) NEIG = len(lmbd) #for lam in lmbd: # print "value:", lam eivecfile = open("eivecs.dat", "w") N = len(Q[:, 0]) print >> eivecfile, N print >> eivecfile, NEIG for ieig in range(len(lmbd)): eivec = Q[:, ieig] print >> eivecfile, lmbd[ieig] # printing eigenvalue for val in eivec: # printing eigenvector print >> eivecfile, val eivecfile.close()
print 'norm(x) = %g' % math.sqrt(numpy.dot(x, x)) r = numpy.zeros(n*n, 'd') A.matvec(x, r) r = b - r print 'norm(b - A*x) = %g' % math.sqrt(numpy.dot(r, r)) # --------------------------------------------------------------------------------------- K_ssor = precon.ssor(S, 1.9) t1 = time.clock() x = numpy.zeros(n*n, 'd') info, iter, relres = itsolvers.pcg(S, b, x, tol, 2000, K_ssor) print 'info=%d, iter=%d, relres=%e' % (info, iter, relres) print 'Time for solving the system using SSS matrix and SSOR preconditioner: %8.2f sec' % (time.clock() - t1, ) print 'norm(x) = %g' % math.sqrt(numpy.dot(x, x)) r = numpy.zeros(n*n, 'd') S.matvec(x, r) r = b - r print 'norm(b - A*x) = %g' % math.sqrt(numpy.dot(r, r)) # --------------------------------------------------------------------------------------- from pysparse import jdsym jdsym.jdsym(S, None, None, 5, 0.0, 1e-8, 100, itsolvers.qmrs, clvl=1)
from pysparse import precon from pysparse import jdsym import time def poisson2d_sym_blk(n): L = spmatrix.ll_mat_sym(n*n) I = spmatrix.ll_mat_sym(n) P = spmatrix.ll_mat_sym(n) for i in range(n): I[i,i] = -1 for i in range(n): P[i,i] = 4 if i > 0: P[i,i-1] = -1 for i in range(0, n*n, n): L[i:i+n,i:i+n] = P if i > 0: L[i:i+n,i-n:i] = I return L n = 200 t1 = time.clock() L = poisson2d_sym_blk(n) print 'Time for constructing the matrix: %8.2f sec' % (time.clock() - t1, ) print L.nnz # --------------------------------------------------------------------------------------- t1 = time.clock() jdsym.jdsym(L.to_sss(), None, None, 5, 0.0, 1e-8, 100, itsolvers.qmrs, clvl=1) print 'Time spend in jdsym: %8.2f sec' % (time.clock() - t1, )
M[i,i] = float(n/2) + i Ms = M.to_sss() normM = M[n-1,n-1] K = diagPrecShifted(A, M, 0.006) #------------------------------------------------------------------------------- # Test 1: M = K = None print 'Test 1' lmbd_exact = zeros(ncv, 'd') for k in xrange(ncv): lmbd_exact[k] = A[k,k] kconv, lmbd, Q, it, it_inner = jdsym.jdsym(As, None, None, ncv, 0.0, tol, 150, itsolvers.qmrs, jmin=5, jmax=10, eps_tr=1e-4, clvl=1) assert ncv == kconv assert allclose(computeResiduals(As, None, lmbd, Q), zeros(kconv), 0.0, tol) assert allclose(lmbd, lmbd_exact, tol*tol, 0.0) print 'OK' #------------------------------------------------------------------------------- # Test 2: K = None print 'Test 2', lmbd_exact = zeros(ncv, 'd') for k in xrange(ncv): lmbd_exact[k] = A[k,k]/M[k,k]