wassname/simpeg
1
0
Fork 0
mirror of https://github.com/wassname/simpeg.git synced 2026-08-14 12:50:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

#69 Removed most solvers, replaced by wrappers.

Browse Source
This commit is contained in:
rowanc1
2014-05-16 18:33:57 -07:00
parent 1f0e37d773
commit f3170a8a7f
11 changed files with 92 additions and 670 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SimPEG/Tests/test_Solver.py
+31 -126
View File
@@ -1,5 +1,5 @@
import unittest
from SimPEG import Solver
from SimPEG import *
from SimPEG.Mesh import TensorMesh
from SimPEG.Utils import sdiag
import numpy as np
@@ -8,136 +8,41 @@ import scipy.sparse as sparse
TOL = 1e-10
numRHS = 5
def dotest(solver, multi=False, **solverOpts):
h1 = np.ones(10)*100.
h2 = np.ones(10)*100.
h3 = np.ones(10)*100.
h = [h1,h2,h3]
M = TensorMesh(h)
D = M.faceDiv
G = -M.faceDiv.T
Msig = M.getFaceInnerProduct()
A = D*Msig*G
A[0,0] *= 10 # remove the constant null space from the matrix
Ainv = Solver(A, **solverOpts)
if multi:
e = np.ones(M.nC)
else:
e = np.ones((M.nC, numRHS))
rhs = A * e
x = Ainv * rhs
return np.linalg.norm(e-x,np.inf) < TOL
class TestSolver(unittest.TestCase):
def setUp(self):
h1 = np.ones(10)*100.
h2 = np.ones(10)*100.
h3 = np.ones(10)*100.
def test_direct_spsolve_1(self): self.assertTrue(dotest(Solver, False))
def test_direct_spsolve_M(self): self.assertTrue(dotest(Solver, True))
h = [h1,h2,h3]
def test_direct_splu_1(self): self.assertTrue(dotest(SolverLU, False))
def test_direct_splu_M(self): self.assertTrue(dotest(SolverLU, True))
M = TensorMesh(h)
D = M.faceDiv
G = M.cellGrad
Msig = M.getFaceInnerProduct()
A = D*Msig*G
A[0,0] *= 10 # remove the constant null space from the matrix
self.A = A
self.M = M
def test_directFactored_1(self):
solve = Solver(self.A, doDirect=True, flag=None, options={'factorize':True,'backend':'scipy'})
e = np.ones(self.M.nC)
rhs = self.A.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directFactored_M(self):
solve = Solver(self.A, doDirect=True, flag=None, options={'factorize':True,'backend':'scipy'})
e = np.ones((self.M.nC,numRHS))
rhs = self.A.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directSpsolve_1(self):
solve = Solver(self.A, doDirect=True, flag=None, options={'factorize':False,'backend':'scipy'})
e = np.ones(self.M.nC)
rhs = self.A.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directSpsolve_M(self):
solve = Solver(self.A, doDirect=True, flag=None, options={'factorize':False,'backend':'scipy'})
e = np.ones((self.M.nC, numRHS))
rhs = self.A.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directLower_1_python(self):
AL = sparse.tril(self.A)
solve = Solver(AL, doDirect=True, flag='L', options={'backend':'python'})
e = np.ones(self.M.nC)
rhs = AL.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directLower_M_python(self):
AL = sparse.tril(self.A)
solve = Solver(AL, doDirect=True, flag='L', options={'backend':'python'})
e = np.ones((self.M.nC,numRHS))
rhs = AL.dot(e)
x = solve.solve(rhs)
def test_directLower_1_fortran(self):
AL = sparse.tril(self.A)
solve = Solver(AL, doDirect=True, flag='L', options={'backend':'fortran'})
e = np.ones(self.M.nC)
rhs = AL.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directLower_M_fortran(self):
AL = sparse.tril(self.A)
solve = Solver(AL, doDirect=True, flag='L', options={'backend':'fortran'})
e = np.ones((self.M.nC,numRHS))
rhs = AL.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directUpper_1_python(self):
AU = sparse.triu(self.A)
solve = Solver(AU, doDirect=True, flag='U', options={})
e = np.ones(self.M.nC)
rhs = AU.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directUpper_M_python(self):
AU = sparse.triu(self.A)
solve = Solver(AU, doDirect=True, flag='U', options={})
e = np.ones((self.M.nC,numRHS))
rhs = AU.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directUpper_1_fortran(self):
AU = sparse.triu(self.A)
solve = Solver(AU, doDirect=True, flag='U', options={'backend':'fortran'})
e = np.ones(self.M.nC)
rhs = AU.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directUpper_M_fortran(self):
AU = sparse.triu(self.A)
solve = Solver(AU, doDirect=True, flag='U', options={'backend':'fortran'})
e = np.ones((self.M.nC,numRHS))
rhs = AU.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directDiagonal_1(self):
AD = sdiag(self.A.diagonal())
solve = Solver(AD, doDirect=True, flag='D', options={})
e = np.ones(self.M.nC)
rhs = AD.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_directDiagonal_M(self):
AD = sdiag(self.A.diagonal())
solve = Solver(AD, doDirect=True, flag='D', options={})
e = np.ones((self.M.nC,numRHS))
rhs = AD.dot(e)
x = solve.solve(rhs)
self.assertTrue(np.linalg.norm(e-x,np.inf) < TOL, True)
def test_iterative_cg_1(self): self.assertTrue(dotest(SolverLU, False))
def test_iterative_cg_M(self): self.assertTrue(dotest(SolverLU, True))
if __name__ == '__main__':
SimPEG/Tests/test_boundaryPoisson.py
+14 -14
View File
@@ -3,7 +3,7 @@ import scipy.sparse as sp
import unittest
from TestUtils import OrderTest
import matplotlib.pyplot as plt
from SimPEG import Utils, Solver
from SimPEG import *
MESHTYPES = ['uniformTensorMesh']
@@ -54,7 +54,7 @@ class Test1D_InhomogeneousDirichlet(OrderTest):
err = np.linalg.norm((q-V*q_anal), np.inf)
elif self.myTest == 'xc':
#TODO: fix the null space
solver = Solver(A, doDirect=False, options={'M':'J','iterSolver':'CG','backend':'scipy','maxIter':1000})
solver = SolverCG(A, maxiter=1000)
xc = solver.solve(rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
err = np.linalg.norm((xc-xc_anal), np.inf)
@@ -220,7 +220,7 @@ class Test1D_InhomogeneousNeumann(OrderTest):
err = np.linalg.norm((xc-xc_anal), np.inf)
if info > 0:
print 'Solve does not work well'
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
elif self.myTest == 'xcJ':
#TODO: fix the null space
xc, info = sp.linalg.minres(A, rhs, tol = 1e-6)
@@ -228,7 +228,7 @@ class Test1D_InhomogeneousNeumann(OrderTest):
err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf)
if info > 0:
print 'Solve does not work well'
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
return err
def test_orderJ(self):
@@ -268,12 +268,12 @@ class Test2D_InhomogeneousNeumann(OrderTest):
j_anal = np.r_[jX_anal,jY_anal]
#TODO: Check where our boundary conditions are CCx or Nx
cxm,cxp,cym,cyp = self.M.cellBoundaryInd
fxm,fxp,fym,fyp = self.M.faceBoundaryInd
gBFx = self.M.gridFx[(fxm|fxp),:]
gBFy = self.M.gridFy[(fym|fyp),:]
gBFy = self.M.gridFy[(fym|fyp),:]
gBCx = self.M.gridCC[(cxm|cxp),:]
gBCy = self.M.gridCC[(cym|cyp),:]
@@ -307,7 +307,7 @@ class Test2D_InhomogeneousNeumann(OrderTest):
err = np.linalg.norm((xc-xc_anal), np.inf)
if info > 0:
print 'Solve does not work well'
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
elif self.myTest == 'xcJ':
#TODO: fix the null space
xc, info = sp.linalg.minres(A, rhs, tol = 1e-6)
@@ -315,7 +315,7 @@ class Test2D_InhomogeneousNeumann(OrderTest):
err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf)
if info > 0:
print 'Solve does not work well'
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
return err
def test_orderJ(self):
@@ -384,7 +384,7 @@ class Test1D_InhomogeneousMixed(OrderTest):
err = np.linalg.norm((xc-xc_anal), np.inf)
if info > 0:
print 'Solve does not work well'
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
elif self.myTest == 'xcJ':
#TODO: fix the null space
xc, info = sp.linalg.minres(A, rhs, tol = 1e-6)
@@ -392,7 +392,7 @@ class Test1D_InhomogeneousMixed(OrderTest):
err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf)
if info > 0:
print 'Solve does not work well'
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
return err
def test_orderJ(self):
@@ -432,12 +432,12 @@ class Test2D_InhomogeneousMixed(OrderTest):
j_anal = np.r_[jX_anal,jY_anal]
#TODO: Check where our boundary conditions are CCx or Nx
cxm,cxp,cym,cyp = self.M.cellBoundaryInd
fxm,fxp,fym,fyp = self.M.faceBoundaryInd
gBFx = self.M.gridFx[(fxm|fxp),:]
gBFy = self.M.gridFy[(fym|fyp),:]
gBFy = self.M.gridFy[(fym|fyp),:]
gBCx = self.M.gridCC[(cxm|cxp),:]
gBCy = self.M.gridCC[(cym|cyp),:]
@@ -471,7 +471,7 @@ class Test2D_InhomogeneousMixed(OrderTest):
err = np.linalg.norm((xc-xc_anal), np.inf)
if info > 0:
print 'Solve does not work well'
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
elif self.myTest == 'xcJ':
#TODO: fix the null space
xc, info = sp.linalg.minres(A, rhs, tol = 1e-6)
@@ -479,7 +479,7 @@ class Test2D_InhomogeneousMixed(OrderTest):
err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf)
if info > 0:
print 'Solve does not work well'
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs)
return err
def test_orderJ(self):
SimPEG/Tests/test_example_linear.py
+1 -1
View File
@@ -6,7 +6,7 @@ import numpy as np
class TestLinear(unittest.TestCase):
def test_running(self):
Linear.run(100)
Linear.run(100, plotIt=False)
self.assertTrue(True)
if __name__ == '__main__':