/[escript]/trunk/escript/test/python/test_linearPDEs.py
ViewVC logotype

Contents of /trunk/escript/test/python/test_linearPDEs.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2995 - (show annotations)
Tue Mar 23 06:14:26 2010 UTC (9 years, 1 month ago) by artak
File MIME type: text/x-python
File size: 182366 byte(s)
AMG levels maximum set 5
1
2 ########################################################
3 #
4 # Copyright (c) 2003-2010 by University of Queensland
5 # Earth Systems Science Computational Center (ESSCC)
6 # http://www.uq.edu.au/esscc
7 #
8 # Primary Business: Queensland, Australia
9 # Licensed under the Open Software License version 3.0
10 # http://www.opensource.org/licenses/osl-3.0.php
11 #
12 ########################################################
13
14 __copyright__="""Copyright (c) 2003-2010 by University of Queensland
15 Earth Systems Science Computational Center (ESSCC)
16 http://www.uq.edu.au/esscc
17 Primary Business: Queensland, Australia"""
18 __license__="""Licensed under the Open Software License version 3.0
19 http://www.opensource.org/licenses/osl-3.0.php"""
20 __url__="https://launchpad.net/escript-finley"
21
22 """
23 Test suite for linearPDEs class
24
25 The tests must be linked with a Domain class object in the setUp method:
26
27 from esys.finley import Rectangle
28 class Test_LinearPDEOnFinley(Test_LinearPDE):
29 def setUp(self):
30 self.domain = Rectangle(10,10,2)
31 def tearDown(self):
32 del self.domain
33 suite = unittest.TestSuite()
34 suite.addTest(unittest.makeSuite(Test_LinearPDEOnFinley))
35 unittest.TextTestRunner(verbosity=2).run(suite)
36
37 :var __author__: name of author
38 :var __copyright__: copyrights
39 :var __license__: licence agreement
40 :var __url__: url entry point on documentation
41 :var __version__: version
42 :var __date__: date of the version
43 """
44
45 __author__="Lutz Gross, l.gross@uq.edu.au"
46
47 from esys.escript.util import Lsup,kronecker,interpolate,whereZero, outer, swap_axes
48 from esys.escript import Function,FunctionOnBoundary,FunctionOnContactZero,Solution,ReducedSolution,Vector,ContinuousFunction,Scalar, ReducedFunction,ReducedFunctionOnBoundary,ReducedFunctionOnContactZero,Data, Tensor4, Tensor
49 from esys.escript.linearPDEs import LinearPDE,IllegalCoefficientValue,Poisson, IllegalCoefficientFunctionSpace, TransportPDE, IllegalCoefficient, Helmholtz, LameEquation, SolverOptions
50 import numpy
51 import unittest
52
53 class Test_linearPDEs(unittest.TestCase):
54 TOL=1.e-6
55 SOLVER_TOL=1.e-10
56 DEBUG=False
57 VERBOSE=False
58 def check(self,arg,ref_arg,tol=None):
59 """
60 checks if arg and ref_arg are nearly identical using the `Lsup`
61 """
62 if tol==None: tol=self.TOL
63 return Lsup(arg-ref_arg)<=tol*Lsup(ref_arg)
64
65 class Test_LameEquation(Test_linearPDEs):
66
67 def test_config(self):
68 mypde=LameEquation(self.domain,debug=self.DEBUG)
69 d=self.domain.getDim()
70 self.failUnlessEqual((mypde.getNumEquations(), mypde.getNumSolutions(), mypde.getSolverOptions().isSymmetric()),(d,d,True),"set up incorrect")
71
72 def test_setCoefficient_q(self):
73 mypde=LameEquation(self.domain,debug=self.DEBUG)
74 x=self.domain.getX()
75 mypde.setValue(q=x)
76
77 q_ref=interpolate(x,Solution(self.domain))
78 self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
79 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
80 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
81 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
82 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
83 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
84 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
85 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
86 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
87 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
88 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
89 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
90 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
91 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
92 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
93 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
94 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
95 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
96 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
97 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
98 self.failUnless(self.check(mypde.getCoefficient("q"),q_ref),"q is not empty")
99 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
100
101 def test_setCoefficient_r(self):
102 mypde=LameEquation(self.domain,debug=self.DEBUG)
103 x=self.domain.getX()
104 mypde.setValue(r=x)
105
106 r_ref=interpolate(x,Solution(self.domain))
107 self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
108 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
109 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
110 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
111 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
112 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
113 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
114 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
115 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
116 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
117 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
118 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
119 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
120 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
121 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
122 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
123 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
124 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
125 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
126 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
127 self.failUnless(self.check(mypde.getCoefficient("r"),r_ref),"r is nor x")
128 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
129
130
131 def test_setCoefficient_F(self):
132 mypde=LameEquation(self.domain,debug=self.DEBUG)
133 x=self.domain.getX()
134 mypde.setValue(F=x)
135
136 Y_ref=interpolate(x,Function(self.domain))
137 self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
138 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
139 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
140 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
141 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
142 self.failUnless(self.check(mypde.getCoefficient("Y"),Y_ref),"Y is not x")
143 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
144 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
145 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
146 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
147 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
148 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
149 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
150 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
151 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
152 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
153 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
154 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
155 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
156 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
157 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
158 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
159
160 def test_setCoefficient_f(self):
161 mypde=LameEquation(self.domain,debug=self.DEBUG)
162 x=self.domain.getX()
163 mypde.setValue(f=x)
164
165 y_ref=interpolate(x,FunctionOnBoundary(self.domain))
166 self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
167 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
168 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
169 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
170 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
171 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
172 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
173 self.failUnless(self.check(mypde.getCoefficient("y"),y_ref),"d is not x[0]")
174 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
175 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
176 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
177 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
178 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
179 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
180 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
181 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"X_reduced is not empty")
182 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
183 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
184 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
185 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
186 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
187 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
188
189 def test_setCoefficient_sigma(self):
190 mypde=LameEquation(self.domain,debug=self.DEBUG)
191 x=self.domain.getX()
192 mypde.setValue(sigma=outer(x,x))
193
194 X_ref=interpolate(outer(x,x),Function(self.domain))
195 self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
196 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
197 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
198 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
199 self.failUnless(self.check(mypde.getCoefficient("X"),X_ref),"X is not x X x")
200 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
201 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
202 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
203 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
204 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
205 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
206 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
207 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
208 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
209 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
210 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"X_reduced is not empty")
211 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
212 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
213 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
214 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
215 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
216 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
217
218 def test_setCoefficient_lambda(self):
219 mypde=LameEquation(self.domain,debug=self.DEBUG)
220 x=self.domain.getX()
221 mypde.setValue(lame_lambda=x[0])
222
223
224 k3=kronecker(Function(self.domain))
225 k3Xk3=outer(k3,k3)
226 A_ref=x[0]*k3Xk3
227
228 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
229 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
230 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
231 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
232 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
233 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
234 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
235 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
236 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
237 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
238 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
239 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
240 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
241 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
242 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
243 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
244 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
245 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
246 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
247 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
248 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
249 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
250
251 def test_setCoefficient_mu(self):
252 mypde=LameEquation(self.domain,debug=self.DEBUG)
253 x=self.domain.getX()
254 mypde.setValue(lame_mu=x[0])
255
256
257 k3=kronecker(Function(self.domain))
258 k3Xk3=outer(k3,k3)
259 A_ref=x[0]*(swap_axes(k3Xk3,0,3)+swap_axes(k3Xk3,1,3))
260
261 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
262 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
263 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
264 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
265 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
266 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
267 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
268 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
269 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
270 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
271 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
272 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
273 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
274 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
275 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
276 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
277 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
278 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
279 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
280 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
281 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
282 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
283
284 def test_setCoefficient_lambdamu(self):
285 mypde=LameEquation(self.domain,debug=self.DEBUG)
286 x=self.domain.getX()
287 mypde.setValue(lame_lambda=x[0], lame_mu=x[1])
288
289 k3=kronecker(Function(self.domain))
290 k3Xk3=outer(k3,k3)
291 A_ref=x[0]*k3Xk3+x[1]*(swap_axes(k3Xk3,0,3)+swap_axes(k3Xk3,1,3))
292
293 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
294 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
295 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
296 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
297 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
298 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
299 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
300 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
301 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
302 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
303 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
304 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
305 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
306 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
307 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
308 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
309 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
310 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
311 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
312 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
313 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
314 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
315
316 def test_solve(self):
317 d=self.domain.getDim()
318 mypde=LameEquation(self.domain)
319 cf=ContinuousFunction(self.domain)
320 x=cf.getX()
321 u_ex=x
322 msk=Vector(0.,cf)
323 for i in range(d): msk[i]=whereZero(x[i])
324 mypde.setValue(q=msk,r=u_ex,lame_mu=3,lame_lambda=50,f=(2*3+50*d)*FunctionOnBoundary(self.domain).getNormal())
325
326 u=mypde.getSolution()
327 self.failUnless(self.check(u,u_ex,10*self.TOL),"incorrect solution")
328
329 class Test_Helmholtz(Test_linearPDEs):
330
331 def test_config(self):
332 mypde=Helmholtz(self.domain,debug=self.DEBUG)
333 self.failUnlessEqual((mypde.getNumEquations(), mypde.getNumSolutions(), mypde.getSolverOptions().isSymmetric()),(1,1,True),"set up incorrect")
334 def test_setCoefficient_q(self):
335 mypde=Helmholtz(self.domain,debug=self.DEBUG)
336 x=self.domain.getX()
337 mypde.setValue(q=whereZero(x[0]))
338
339 q_ref=interpolate(whereZero(x[0]),Solution(self.domain))
340 A_ref=kronecker(self.domain)
341
342 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
343 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
344 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
345 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
346 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
347 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
348 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
349 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
350 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
351 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
352 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
353 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
354 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
355 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
356 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
357 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
358 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
359 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
360 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
361 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
362 self.failUnless(self.check(mypde.getCoefficient("q"),q_ref),"q is not empty")
363 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
364
365 def test_setCoefficient_r(self):
366 mypde=Helmholtz(self.domain,debug=self.DEBUG)
367 x=self.domain.getX()
368 mypde.setValue(r=x[0])
369
370 r_ref=interpolate(x[0],Solution(self.domain))
371 A_ref=kronecker(self.domain)
372 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
373 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
374 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
375 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
376 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
377 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
378 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
379 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
380 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
381 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
382 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
383 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
384 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
385 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
386 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
387 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
388 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
389 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
390 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
391 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
392 self.failUnless(self.check(mypde.getCoefficient("r"),r_ref),"r is nor x[0]")
393 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
394
395
396 def test_setCoefficient_f(self):
397 mypde=Helmholtz(self.domain,debug=self.DEBUG)
398 x=self.domain.getX()
399 mypde.setValue(f=x[0])
400
401 Y_ref=interpolate(x[0],Function(self.domain))
402 A_ref=kronecker(self.domain)
403 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
404 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
405 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
406 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
407 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
408 self.failUnless(self.check(mypde.getCoefficient("Y"),Y_ref),"Y is not x[0]")
409 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
410 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
411 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
412 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
413 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
414 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
415 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
416 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
417 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
418 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
419 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
420 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
421 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
422 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
423 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
424 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
425
426 def test_setCoefficient_alpha(self):
427 mypde=Helmholtz(self.domain,debug=self.DEBUG)
428 x=self.domain.getX()
429 mypde.setValue(alpha=x[0])
430
431 d_ref=interpolate(x[0],FunctionOnBoundary(self.domain))
432 A_ref=kronecker(self.domain)
433 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
434 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
435 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
436 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
437 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
438 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
439 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
440 self.failUnless(self.check(mypde.getCoefficient("d"),d_ref),"d is not x[0]")
441 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
442 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
443 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
444 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
445 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
446 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
447 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
448 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"X_reduced is not empty")
449 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
450 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
451 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
452 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
453 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
454 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
455
456 def test_setCoefficient_g(self):
457 mypde=Helmholtz(self.domain,debug=self.DEBUG)
458 x=self.domain.getX()
459 mypde.setValue(g=x[0])
460
461 y_ref=interpolate(x[0],FunctionOnBoundary(self.domain))
462 A_ref=kronecker(self.domain)
463 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
464 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
465 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
466 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
467 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
468 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
469 self.failUnless(self.check(mypde.getCoefficient("y"),y_ref),"y is not x[0]")
470 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
471 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
472 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
473 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
474 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
475 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
476 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
477 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
478 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
479 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
480 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
481 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
482 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
483 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
484 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
485
486 def test_setCoefficient_omega(self):
487 mypde=Helmholtz(self.domain,debug=self.DEBUG)
488 x=self.domain.getX()
489 mypde.setValue(omega=x[0])
490
491 D_ref=interpolate(x[0],Function(self.domain))
492 A_ref=kronecker(self.domain)
493 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
494 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
495 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
496 self.failUnless(self.check(mypde.getCoefficient("D"),D_ref),"D is not x[0]")
497 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
498 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
499 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
500 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
501 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
502 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
503 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
504 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
505 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
506 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
507 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
508 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
509 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
510 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
511 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
512 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
513 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
514 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
515
516 def test_solve(self):
517 d=self.domain.getDim()
518 cf=ContinuousFunction(self.domain)
519 u_ex=Scalar(1.,cf)
520 mypde=Helmholtz(self.domain)
521 mypde.setValue(f=3,omega=3,alpha=2,g=2)
522 u=mypde.getSolution()
523 self.failUnless(self.check(u,u_ex,10*self.TOL),"incorrect solution")
524
525 class Test_Poisson(Test_linearPDEs):
526
527 def test_config(self):
528 mypde=Poisson(self.domain,debug=self.DEBUG)
529 self.failUnlessEqual((mypde.getNumEquations(), mypde.getNumSolutions(), mypde.getSolverOptions().isSymmetric()),(1,1,True),"set up incorrect")
530 def test_setCoefficient_q(self):
531 mypde=Poisson(self.domain,debug=self.DEBUG)
532 x=self.domain.getX()
533 q_ref=interpolate(whereZero(x[0]),Solution(self.domain))
534 A_ref=kronecker(self.domain)
535 mypde.setValue(q=whereZero(x[0]))
536 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
537 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
538 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
539 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
540 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
541 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
542 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
543 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
544 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
545 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
546 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
547 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
548 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
549 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
550 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
551 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
552 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
553 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
554 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
555 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
556 self.failUnless(self.check(mypde.getCoefficient("q"),q_ref),"q is not empty")
557 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
558 def test_setCoefficient_f(self):
559 mypde=Poisson(self.domain,debug=self.DEBUG)
560 x=self.domain.getX()
561 Y_ref=interpolate(x[0],Function(self.domain))
562 A_ref=kronecker(self.domain)
563 mypde.setValue(f=x[0])
564 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
565 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
566 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
567 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
568 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
569 self.failUnless(self.check(mypde.getCoefficient("Y"),Y_ref),"Y is not x[0]")
570 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
571 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
572 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
573 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
574 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
575 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
576 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
577 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
578 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
579 self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
580 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
581 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
582 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
583 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
584 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
585 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
586 def test_setCoefficient_f_reduced(self):
587 mypde=Poisson(self.domain,debug=self.DEBUG)
588 x=self.domain.getX()
589 Y_ref=interpolate(x[0],ReducedFunction(self.domain))
590 A_ref=kronecker(self.domain)
591 mypde.setValue(f_reduced=x[0])
592 self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
593 self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
594 self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
595 self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
596 self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
597 self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
598 self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
599 self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
600 self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
601 self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
602 self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
603 self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
604 self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
605 self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
606 self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
607 self.failUnless(self.check(mypde.getCoefficient("Y_reduced"),Y_ref),"Y_reduced is not x[0]")
608 self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
609 self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
610 self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
611 self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
612 self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
613 self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
614 def test_solve(self):
615 d=self.domain.getDim()
616 cf=ContinuousFunction(self.domain)
617 x=cf.getX()
618 #construct exact solution:
619 u_ex=Scalar(1.,cf)
620 for i in range(d):
621 u_ex*=x[i]*(2.-x[i])
622 #construct mask:
623 msk=Scalar(0.,cf)
624 for i in range(d):
625 msk+=whereZero(x[i])
626 #construct right hand side
627 f=Scalar(0,cf)
628 for i in range(d):
629 f_p=Scalar(1,cf)
630 for j in range(d):
631 if i==j:
632 f_p*=2.
633 else:
634 f_p*=x[j]*(2-x[j])
635 f+=f_p
636 mypde=Poisson(self.domain)
637 mypde.setValue(f=f,q=msk)
638 u=mypde.getSolution()
639 self.failUnless(self.check(u,u_ex,10*self.TOL),"incorrect solution")
640
641 class Test_LinearPDE_noLumping(Test_linearPDEs):
642 N=4
643 def test_SolverOptions(self):
644 so=SolverOptions()
645
646 self.failUnless(so.getSmoother() == 28, "initial Smoother is wrong.")
647 self.failUnlessRaises(ValueError,so.setSmoother,-1)
648 so.setSmoother(so.GAUSS_SEIDEL)
649 self.failUnless(so.getSmoother() == 28, "Gauss-Seidel smoother is not set.")
650 so.setSmoother(so.JACOBI)
651 self.failUnless(so.getSmoother() == 10, "Jacobi smoother is not set.")
652
653 self.failUnless(so.getLevelMax() == 5, "initial LevelMax is wrong.")
654 self.failUnlessRaises(ValueError,so.setLevelMax,-1)
655 so.setLevelMax(20)
656 self.failUnless(so.getLevelMax() == 20, "LevelMax is wrong.")
657
658 self.failUnless(so.getCoarseningThreshold() == 0.25, "initial CoarseningThreshold is wrong.")
659 self.failUnlessRaises(ValueError,so.setCoarseningThreshold,-1)
660 so.setCoarseningThreshold(0.1)
661 self.failUnless(so.getCoarseningThreshold() == 0.1, "CoarseningThreshold is wrong.")
662
663 self.failUnless(so.getMinCoarseMatrixSize() == 500, "initial Minimum Coarse Matrix Size is wrong.")
664 self.failUnlessRaises(ValueError,so.setMinCoarseMatrixSize,-1)
665 so.setMinCoarseMatrixSize(1000)
666 self.failUnless(so.getMinCoarseMatrixSize() == 1000, "Minimum Coarse Matrix Size is wrong.")
667
668 self.failUnless(so.getNumSweeps() == 2, "initial Sweeps is wrong.")
669 self.failUnlessRaises(ValueError,so.setNumSweeps,-1)
670 so.setNumSweeps(3)
671 self.failUnless(so.getNumSweeps() == 3, "Sweeps is wrong.")
672
673 self.failUnless(so.getNumPreSweeps() == 2, "initial PreSweeps is wrong.")
674 self.failUnlessRaises(ValueError,so.setNumPreSweeps,-1)
675 so.setNumPreSweeps(4)
676 self.failUnless(so.getNumPreSweeps() == 4, "PreSweeps is wrong.")
677
678 self.failUnless(so.getNumPostSweeps() == 2, "initial PreSweeps is wrong.")
679 self.failUnlessRaises(ValueError,so.setNumPostSweeps,-1)
680 so.setNumPostSweeps(5)
681 self.failUnless(so.getNumPostSweeps() == 5, "PreSweeps is wrong.")
682
683 self.failUnless(so.getTolerance() == 1.e-8, "initial Tolerance is wrong.")
684 self.failUnlessRaises(ValueError,so.setTolerance,-1)
685 so.setTolerance(0.2)
686 self.failUnless(so.getTolerance() == 0.2, "Tolerance is wrong.")
687
688 self.failUnless(so.getAbsoluteTolerance() == 0., "initial AbsoluteTolerance is wrong.")
689 self.failUnlessRaises(ValueError,so.setAbsoluteTolerance,-1)
690 so.setAbsoluteTolerance(0.3)
691 self.failUnless(so.getAbsoluteTolerance() == 0.3, "AbsoluteTolerance is wrong.")
692
693 self.failUnless(so.getInnerTolerance() == 0.9, "initial InnerTolerance is wrong.")
694 self.failUnlessRaises(ValueError,so.setInnerTolerance,-1)
695 so.setInnerTolerance(0.4)
696 self.failUnless(so.getInnerTolerance() == 0.4, "InnerTolerance is wrong.")
697
698 self.failUnless(so.getDropTolerance() == 0.01, "initial DropTolerance is wrong.")
699 self.failUnlessRaises(ValueError,so.setDropTolerance,-1)
700 so.setDropTolerance(0.5)
701 self.failUnless(so.getDropTolerance() == 0.5, "DropDropTolerance is wrong.")
702
703 self.failUnless(so.getDropStorage() == 2., "initial DropStorage is wrong.")
704 self.failUnlessRaises(ValueError,so.setDropStorage,-1)
705 so.setDropStorage(10)
706 self.failUnless(so.getDropStorage() == 10, "DropStorage is wrong.")
707
708 self.failUnless(so.getRelaxationFactor() == 0.3, "initial RelaxationFactor is wrong.")
709 self.failUnlessRaises(ValueError,so.setRelaxationFactor,-1)
710 so.setRelaxationFactor(0.1)
711 self.failUnless(so.getRelaxationFactor() == 0.1, "Relaxation is wrong.")
712
713
714 self.failUnless(so.getIterMax() == 100000, "initial IterMax is wrong.")
715 self.failUnlessRaises(ValueError,so.setIterMax,0)
716 so.setIterMax(11)
717 self.failUnless(so.getIterMax() == 11, "IterMax is wrong.")
718
719 self.failUnless(so.getInnerIterMax() == 10, "initial InnerIterMax is wrong.")
720 self.failUnlessRaises(ValueError,so.setInnerIterMax,0)
721 so.setInnerIterMax(12)
722 self.failUnless(so.getInnerIterMax() == 12, "InnerIterMax is wrong.")
723
724 self.failUnless(so.getTruncation() == 20, "initial Truncation is wrong.")
725 self.failUnlessRaises(ValueError,so.setTruncation,0)
726 so.setTruncation(13)
727 self.failUnless(so.getTruncation() == 13, "Truncation is wrong.")
728
729 self.failUnless(so.getRestart() == None, "initial Truncation is wrong.")
730 self.failUnlessRaises(ValueError,so.setTruncation,0)
731 so.setRestart(14)
732 self.failUnless(so.getRestart() == 14, "Truncation is wrong.")
733 so.setRestart(None)
734 self.failUnless(so.getRestart() == None, "Truncation is wrong.")
735
736 self.failUnless(not so.isVerbose(), "initial verbosity flag is wrong.")
737 so.setVerbosityOn()
738 self.failUnless(so.isVerbose(), "verbosity (1) flag is wrong.")
739 so.setVerbosityOff()
740 self.failUnless(not so.isVerbose(), "verbosity (2) flag is wrong.")
741 so.setVerbosity(verbose=True)
742 self.failUnless(so.isVerbose(), "verbosity (3) flag is wrong.")
743 so.setVerbosity(verbose=False)
744 self.failUnless(not so.isVerbose(), "verbosity (4) flag is wrong.")
745
746 self.failUnless(not so.isSymmetric(), "initial symmetry flag is wrong.")
747 so.setSymmetryOn()
748 self.failUnless(so.isSymmetric(), "symmetry (1) flag is wrong.")
749 so.setSymmetryOff()
750 self.failUnless(not so.isSymmetric(), "symmetry (2) flag is wrong.")
751 so.setSymmetry(flag=True)
752 self.failUnless(so.isSymmetric(), "symmetry (3) flag is wrong.")
753 so.setSymmetry(flag=False)
754 self.failUnless(not so.isSymmetric(), "symmetry (4) flag is wrong.")
755
756 self.failUnless(so.adaptInnerTolerance(), "initial InnerToleranceAdaption flag is wrong.")
757 so.setInnerToleranceAdaptionOn()
758 self.failUnless(so.adaptInnerTolerance(), "InnerToleranceAdaption (1) flag is wrong.")
759 so.setInnerToleranceAdaptionOff()
760 self.failUnless(not so.adaptInnerTolerance(), "InnerToleranceAdaption (2) flag is wrong.")
761 so.setInnerToleranceAdaption(adapt=True)
762 self.failUnless(so.adaptInnerTolerance(), "InnerToleranceAdaption (3) flag is wrong.")
763 so.setInnerToleranceAdaption(adapt=False)
764 self.failUnless(not so.adaptInnerTolerance(), "InnerToleranceAdaption (4) flag is wrong.")
765
766 self.failUnless(not so.acceptConvergenceFailure(), "initial acceptConvergenceFailure flag is wrong.")
767 so.setAcceptanceConvergenceFailureOn()
768 self.failUnless(so.acceptConvergenceFailure(), "acceptConvergenceFailure (1) flag is wrong.")
769 so.setAcceptanceConvergenceFailureOff()
770 self.failUnless(not so.acceptConvergenceFailure(), "acceptConvergenceFailure (2) flag is wrong.")
771 so.setAcceptanceConvergenceFailure(accept=True)
772 self.failUnless(so.acceptConvergenceFailure(), "acceptConvergenceFailure (3) flag is wrong.")
773 so.setAcceptanceConvergenceFailure(accept=False)
774 self.failUnless(not so.acceptConvergenceFailure(), "acceptConvergenceFailure (4) flag is wrong.")
775
776 self.failUnless(so.getReordering() == 30, "initial Reordering is wrong.")
777 self.failUnlessRaises(ValueError,so.setReordering,-1)
778 so.setReordering(so.NO_REORDERING)
779 self.failUnless(so.getReordering() == 17, "NO_REORDERING is not set.")
780 so.setReordering(so.MINIMUM_FILL_IN)
781 self.failUnless(so.getReordering() == 18, "MINIMUM_FILL_IN is not set.")
782 so.setReordering(so.NESTED_DISSECTION)
783 self.failUnless(so.getReordering() == 19, "NESTED_DISSECTION is not set.")
784 so.setReordering(so.DEFAULT_REORDERING)
785 self.failUnless(so.getReordering() == 30, "DEFAULT_REORDERING is not set.")
786
787 self.failUnless(so.getPackage() == 0, "initial solver package is wrong.")
788 self.failUnlessRaises(ValueError,so.setPackage,-1)
789 so.setPackage(so.PASO)
790 self.failUnless(so.getPackage() == 21, "PASO is not set.")
791 so.setPackage(so.SUPER_LU)
792 self.failUnless(so.getPackage() == 31, "SUPER_LU is not set.")
793 so.setPackage(so.PASTIX)
794 self.failUnless(so.getPackage() == 32, "PASTIX is not set.")
795 so.setPackage(so.MKL)
796 self.failUnless(so.getPackage() == 15, "MKL is not set.")
797 so.setPackage(so.UMFPACK)
798 self.failUnless(so.getPackage() == 16, "UMFPACK is not set.")
799 so.setPackage(so.TRILINOS)
800 self.failUnless(so.getPackage() == 24, "TRILINOS is not set.")
801
802 self.failUnless(so.getSolverMethod() == 0, "initial SolverMethod is wrong.")
803 self.failUnlessRaises(ValueError,so.setSolverMethod,-1)
804 so.setSolverMethod(so.DIRECT)
805 self.failUnless(so.getSolverMethod() == 1, "DIRECT is not set.")
806 so.setSolverMethod(so.CHOLEVSKY)
807 self.failUnless(so.getSolverMethod() == 2, "CHOLEVSKY is not set.")
808 so.setSolverMethod(so.PCG)
809 self.failUnless(so.getSolverMethod() == 3, "PCG is not set.")
810 so.setSolverMethod(so.CR)
811 self.failUnless(so.getSolverMethod() == 4, "CR is not set.")
812 so.setSolverMethod(so.CGS)
813 self.failUnless(so.getSolverMethod() == 5, "CGS is not set.")
814 so.setSolverMethod(so.BICGSTAB)
815 self.failUnless(so.getSolverMethod() == 6, "BICGSTAB is not set.")
816 so.setSolverMethod(so.SSOR)
817 self.failUnless(so.getSolverMethod() == 7, "SSOR is not set.")
818 so.setSolverMethod(so.GMRES)
819 self.failUnless(so.getSolverMethod() == 11, "GMRES is not set.")
820 so.setSolverMethod(so.PRES20)
821 self.failUnless(so.getSolverMethod() == 12, "PRES20 is not set.")
822 so.setSolverMethod(so.LUMPING)
823 self.failUnless(so.getSolverMethod() == 13, "LUMPING is not set.")
824 so.setSolverMethod(so.ITERATIVE)
825 self.failUnless(so.getSolverMethod() == 20, "ITERATIVE is not set.")
826 so.setSolverMethod(so.AMG)
827 self.failUnless(so.getSolverMethod() == 22, "AMG is not set.")
828 so.setSolverMethod(so.NONLINEAR_GMRES)
829 self.failUnless(so.getSolverMethod() == 25, "NONLINEAR_GMRES is not set.")
830 so.setSolverMethod(so.TFQMR)
831 self.failUnless(so.getSolverMethod() == 26, "TFQMR is not set.")
832 so.setSolverMethod(so.MINRES)
833 self.failUnless(so.getSolverMethod() == 27, "MINRES is not set.")
834 so.setSolverMethod(so.DEFAULT)
835 self.failUnless(so.getSolverMethod() == 0, "DEFAULT is not set.")
836
837 self.failUnless(so.getPreconditioner() == 10, "initial Preconditioner is wrong.")
838 self.failUnlessRaises(ValueError,so.setPreconditioner,-1)
839 so.setPreconditioner(so.ILU0)
840 self.failUnless(so.getPreconditioner() == 8, "ILU0 is not set.")
841 so.setPreconditioner(so.SSOR)
842 self.failUnless(so.getPreconditioner() == 7, "SSOR is not set.")
843 so.setPreconditioner(so.ILUT)
844 self.failUnless(so.getPreconditioner() == 9, "ILUT is not set.")
845 so.setPreconditioner(so.JACOBI)
846 self.failUnless(so.getPreconditioner() == 10, "JACOBI is not set.")
847 so.setPreconditioner(so.AMG)
848 self.failUnless(so.getPreconditioner() == 22, "AMG is not set.")
849 so.setPreconditioner(so.REC_ILU)
850 self.failUnless(so.getPreconditioner() == 23, "REC_ILU is not set.")
851 so.setPreconditioner(so.GAUSS_SEIDEL)
852 self.failUnless(so.getPreconditioner() == 28, "GAUSS_SEIDEL is not set.")
853 so.setPreconditioner(so.RILU)
854 self.failUnless(so.getPreconditioner() == 29, "RILU is not set.")
855 so.setPreconditioner(so.NO_PRECONDITIONER)
856 self.failUnless(so.getPreconditioner() == 36, "NO_PRECONDITIONER is not set.")
857
858 self.failUnless(so.getCoarsening() == 0, "initial Coarseningr is wrong.")
859 self.failUnlessRaises(ValueError,so.setCoarsening,-1)
860 so.setCoarsening(so.YAIR_SHAPIRA_COARSENING)
861 self.failUnless(so.getCoarsening() == 33, "YAIR_SHAPIRA_COARSENING is not set.")
862 so.setCoarsening(so.RUGE_STUEBEN_COARSENING)
863 self.failUnless(so.getCoarsening() == 34, "RUGE_STUEBEN_COARSENING is not set.")
864 so.setCoarsening(so.AGGREGATION_COARSENING)
865 self.failUnless(so.getCoarsening() == 35, "AGREGATION_COARSENING is not set.")
866 so.setCoarsening(so.STANDARD_COARSENING)
867 self.failUnless(so.getCoarsening() == 39, "STANDARD_COARSENING is not set.")
868 so.setCoarsening(so.DEFAULT)
869 self.failUnless(so.getCoarsening() == 0, "DEFAULT is not set.")
870
871 self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
872 self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
873 self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
874 self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
875 self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
876 self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
877 self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong.")
878 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 0, "initial cum_num_inner_iter is wrong.")
879 self.failUnless(so.getDiagnostics("cum_num_iter") == 0, "initial cum_num_iter is wrong.")
880 self.failUnless(so.getDiagnostics("cum_time") ==0, "initial cum_time is wrong.")
881 self.failUnless(so.getDiagnostics("cum_set_up_time") == 0, "initial cum_set_up_time is wrong.")
882
883 so._updateDiagnostics("num_iter",1)
884 so._updateDiagnostics("num_inner_iter",2)
885 so._updateDiagnostics("time",3)
886 so._updateDiagnostics("set_up_time",4)
887 so._updateDiagnostics("residual_norm",5)
888 so._updateDiagnostics("converged",True)
889
890 self.failUnless(so.getDiagnostics("num_iter") == 1, "num_iter is wrong.")
891 self.failUnless(so.getDiagnostics("num_inner_iter") == 2, "num_inner_iter is wrong.")
892 self.failUnless(so.getDiagnostics("time") == 3, "time is wrong.")
893 self.failUnless(so.getDiagnostics("set_up_time") == 4, "set_up_time is wrong.")
894 self.failUnless(so.getDiagnostics("residual_norm") == 5, "residual_norm is wrong.")
895 self.failUnless(so.getDiagnostics("converged"), "converged is wrong.")
896 self.failUnless(so.hasConverged(), "convergence flag is wrong.")
897 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 2, "cum_num_inner_iter is wrong.")
898 self.failUnless(so.getDiagnostics("cum_num_iter") == 1, "cum_num_iter is wrong.")
899 self.failUnless(so.getDiagnostics("cum_time") ==3, "cum_time is wrong.")
900 self.failUnless(so.getDiagnostics("cum_set_up_time") == 4, "cum_set_up_time is wrong.")
901
902 so.resetDiagnostics()
903 self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
904 self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
905 self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
906 self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
907 self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
908 self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
909 self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong")
910 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 2, "cum_num_inner_iter is wrong.")
911 self.failUnless(so.getDiagnostics("cum_num_iter") == 1, "cum_num_iter is wrong.")
912 self.failUnless(so.getDiagnostics("cum_time") ==3, "cum_time is wrong.")
913 self.failUnless(so.getDiagnostics("cum_set_up_time") == 4, "cum_set_up_time is wrong.")
914
915 so._updateDiagnostics("num_iter",10)
916 so._updateDiagnostics("num_inner_iter",20)
917 so._updateDiagnostics("time",30)
918 so._updateDiagnostics("set_up_time",40)
919 so._updateDiagnostics("residual_norm",50)
920 so._updateDiagnostics("converged",False)
921
922 self.failUnless(so.getDiagnostics("num_iter") == 10, "num_iter is wrong.")
923 self.failUnless(so.getDiagnostics("num_inner_iter") == 20, "num_inner_iter is wrong.")
924 self.failUnless(so.getDiagnostics("time") == 30, "time is wrong.")
925 self.failUnless(so.getDiagnostics("set_up_time") == 40, "set_up_time is wrong.")
926 self.failUnless(so.getDiagnostics("residual_norm") == 50, "residual_norm is wrong.")
927 self.failUnless(not so.getDiagnostics("converged"), "converged is wrong.")
928 self.failUnless(not so.hasConverged(), "convergence flag is wrong.")
929 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 22, "cum_num_inner_iter is wrong.")
930 self.failUnless(so.getDiagnostics("cum_num_iter") == 11, "cum_num_iter is wrong.")
931 self.failUnless(so.getDiagnostics("cum_time") ==33, "cum_time is wrong.")
932 self.failUnless(so.getDiagnostics("cum_set_up_time") == 44, "cum_set_up_time is wrong.")
933
934 so.resetDiagnostics(all=True)
935 self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
936 self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
937 self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
938 self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
939 self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
940 self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
941 self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong.")
942 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 0, "initial cum_num_inner_iter is wrong.")
943 self.failUnless(so.getDiagnostics("cum_num_iter") == 0, "initial cum_num_iter is wrong.")
944 self.failUnless(so.getDiagnostics("cum_time") ==0, "initial cum_time is wrong.")
945 self.failUnless(so.getDiagnostics("cum_set_up_time") == 0, "initial cum_set_up_time is wrong.")
946
947 def test_setCoefficient_WithIllegalFunctionSpace(self):
948 mypde=LinearPDE(self.domain,debug=self.DEBUG)
949 self.failUnlessRaises(IllegalCoefficientFunctionSpace, mypde.setValue, C=Vector(0.,FunctionOnBoundary(self.domain)))
950
951 def test_setCoefficient_WithWrongName(self):
952 mypde=LinearPDE(self.domain,debug=self.DEBUG)
953 self.failUnlessRaises(IllegalCoefficient, mypde.setValue, ROMA=0.)
954
955 def test_resetCoefficient_WithWrongShape(self):
956 mypde=LinearPDE(self.domain,numEquations=2,debug=self.DEBUG)
957 self.failUnlessRaises(IllegalCoefficientValue, mypde.setValue, C=0.)
958
959 def test_reducedOn(self):
960 mypde=LinearPDE(self.domain,debug=self.DEBUG)
961 x=self.domain.getX()
962 mypde.setReducedOrderOn()
963 mypde.setValue(A=kronecker(self.domain),D=x[0],Y=x[0])
964 u=mypde.getSolution()
965 self.failUnless(self.check(u,1.),'solution is wrong.')
966
967 def test_attemptToChangeOrderAfterDefinedCoefficient(self):
968 mypde=LinearPDE(self.domain,debug=self.DEBUG)
969 mypde.setValue(D=1.)
970 self.failUnlessRaises(RuntimeError, mypde.setReducedOrderOn)
971
972 def test_reducedOnConfig(self):
973 mypde=LinearPDE(self.domain,debug=self.DEBUG)
974 mypde.setReducedOrderOn()
975 self.failUnlessEqual((mypde.getFunctionSpaceForSolution(), mypde.getFunctionSpaceForEquation()),(ReducedSolution(self.domain),ReducedSolution(self.domain)),"reduced function spaces expected.")
976 #
977 # set coefficients for scalars:
978 #
979 def test_setCoefficient_A_Scalar(self):
980 d=self.domain.getDim()
981 mypde=LinearPDE(self.domain,debug=self.DEBUG)
982 mypde.setValue(A=numpy.ones((d,d)))
983 coeff=mypde.getCoefficient("A")
984 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),Function(self.domain),1,1))
985 def test_setCoefficient_B_Scalar(self):
986 d=self.domain.getDim()
987 mypde=LinearPDE(self.domain,debug=self.DEBUG)
988 mypde.setValue(B=numpy.ones((d,)))
989 coeff=mypde.getCoefficient("B")
990 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
991 def test_setCoefficient_C_Scalar(self):
992 d=self.domain.getDim()
993 mypde=LinearPDE(self.domain,debug=self.DEBUG)
994 mypde.setValue(C=numpy.ones((d,)))
995 coeff=mypde.getCoefficient("C")
996 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
997 def test_setCoefficient_D_Scalar(self):
998 d=self.domain.getDim()
999 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1000 mypde.setValue(D=1.)
1001 coeff=mypde.getCoefficient("D")
1002 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),Function(self.domain),1,1))
1003 def test_setCoefficient_X_Scalar(self):
1004 d=self.domain.getDim()
1005 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1006 mypde.setValue(X=numpy.ones((d,)))
1007 coeff=mypde.getCoefficient("X")
1008 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),Function(self.domain),1))
1009 def test_setCoefficient_Y_Scalar(self):
1010 d=self.domain.getDim()
1011 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1012 mypde.setValue(Y=1.)
1013 coeff=mypde.getCoefficient("Y")
1014 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),Function(self.domain),1))
1015 def test_setCoefficient_y_Scalar(self):
1016 d=self.domain.getDim()
1017 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1018 mypde.setValue(y=1.)
1019 coeff=mypde.getCoefficient("y")
1020 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1))
1021 def test_setCoefficient_d_Scalar(self):
1022 d=self.domain.getDim()
1023 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1024 mypde.setValue(d=1.)
1025 coeff=mypde.getCoefficient("d")
1026 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1,1))
1027 def test_setCoefficient_d_contact_Scalar(self):
1028 d=self.domain.getDim()
1029 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1030 mypde.setValue(d_contact=1.)
1031 coeff=mypde.getCoefficient("d_contact")
1032 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1,1))
1033 def test_setCoefficient_y_contact_Scalar(self):
1034 d=self.domain.getDim()
1035 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1036 mypde.setValue(y_contact=1.)
1037 coeff=mypde.getCoefficient("y_contact")
1038 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1))
1039 def test_setCoefficient_A_reduced_Scalar(self):
1040 d=self.domain.getDim()
1041 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1042 mypde.setValue(A_reduced=numpy.ones((d,d)))
1043 coeff=mypde.getCoefficient("A_reduced")
1044 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
1045 def test_setCoefficient_B_reduced_Scalar(self):
1046 d=self.domain.getDim()
1047 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1048 mypde.setValue(B_reduced=numpy.ones((d,)))
1049 coeff=mypde.getCoefficient("B_reduced")
1050 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1051 def test_setCoefficient_C_reduced_Scalar(self):
1052 d=self.domain.getDim()
1053 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1054 mypde.setValue(C_reduced=numpy.ones((d,)))
1055 coeff=mypde.getCoefficient("C_reduced")
1056 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1057 def test_setCoefficient_D_reduced_Scalar(self):
1058 d=self.domain.getDim()
1059 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1060 mypde.setValue(D_reduced=1.)
1061 coeff=mypde.getCoefficient("D_reduced")
1062 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
1063 def test_setCoefficient_X_reduced_Scalar(self):
1064 d=self.domain.getDim()
1065 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1066 mypde.setValue(X_reduced=numpy.ones((d,)))
1067 coeff=mypde.getCoefficient("X_reduced")
1068 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
1069 def test_setCoefficient_Y_reduced_Scalar(self):
1070 d=self.domain.getDim()
1071 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1072 mypde.setValue(Y_reduced=1.)
1073 coeff=mypde.getCoefficient("Y_reduced")
1074 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
1075 def test_setCoefficient_y_reduced_Scalar(self):
1076 d=self.domain.getDim()
1077 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1078 mypde.setValue(y_reduced=1.)
1079 coeff=mypde.getCoefficient("y_reduced")
1080 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
1081 def test_setCoefficient_d_reduced_Scalar(self):
1082 d=self.domain.getDim()
1083 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1084 mypde.setValue(d_reduced=1.)
1085 coeff=mypde.getCoefficient("d_reduced")
1086 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
1087 def test_setCoefficient_d_contact_reduced_Scalar(self):
1088 d=self.domain.getDim()
1089 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1090 mypde.setValue(d_contact_reduced=1.)
1091 coeff=mypde.getCoefficient("d_contact_reduced")
1092 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
1093 def test_setCoefficient_y_contact_reduced_Scalar(self):
1094 d=self.domain.getDim()
1095 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1096 mypde.setValue(y_contact_reduced=1.)
1097 coeff=mypde.getCoefficient("y_contact_reduced")
1098 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
1099 def test_setCoefficient_r_Scalar(self):
1100 d=self.domain.getDim()
1101 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1102 mypde.setValue(r=1.)
1103 coeff=mypde.getCoefficient("r")
1104 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
1105 def test_setCoefficient_q_Scalar(self):
1106 d=self.domain.getDim()
1107 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1108 mypde.setValue(q=1.)
1109 coeff=mypde.getCoefficient("q")
1110 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
1111 def test_setCoefficient_r_Scalar_reducedOn(self):
1112 d=self.domain.getDim()
1113 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1114 mypde.setReducedOrderOn()
1115 mypde.setValue(r=1.)
1116 coeff=mypde.getCoefficient("r")
1117 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
1118 def test_setCoefficient_q_Scalar_reducedOn(self):
1119 d=self.domain.getDim()
1120 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1121 mypde.setReducedOrderOn()
1122 mypde.setValue(q=1.)
1123 coeff=mypde.getCoefficient("q")
1124 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
1125
1126 def test_setCoefficient_A_reduced_Scalar_usingA(self):
1127 d=self.domain.getDim()
1128 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1129 mypde.setValue(A=Data(numpy.ones((d,d)),ReducedFunction(self.domain)))
1130 coeff=mypde.getCoefficient("A_reduced")
1131 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
1132 def test_setCoefficient_B_reduced_Scalar_usingB(self):
1133 d=self.domain.getDim()
1134 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1135 mypde.setValue(B=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1136 coeff=mypde.getCoefficient("B_reduced")
1137 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1138 def test_setCoefficient_C_reduced_Scalar_usingC(self):
1139 d=self.domain.getDim()
1140 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1141 mypde.setValue(C=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1142 coeff=mypde.getCoefficient("C_reduced")
1143 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1144 def test_setCoefficient_D_reduced_Scalar_usingD(self):
1145 d=self.domain.getDim()
1146 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1147 mypde.setValue(D=Scalar(1.,ReducedFunction(self.domain)))
1148 coeff=mypde.getCoefficient("D_reduced")
1149 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
1150 def test_setCoefficient_X_reduced_Scalar_usingX(self):
1151 d=self.domain.getDim()
1152 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1153 mypde.setValue(X_reduced=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1154 coeff=mypde.getCoefficient("X_reduced")
1155 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
1156 def test_setCoefficient_Y_reduced_Scalar_usingY(self):
1157 d=self.domain.getDim()
1158 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1159 mypde.setValue(Y=Scalar(1.,ReducedFunction(self.domain)))
1160 coeff=mypde.getCoefficient("Y_reduced")
1161 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
1162 def test_setCoefficient_y_reduced_Scalar_using_y(self):
1163 d=self.domain.getDim()
1164 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1165 mypde.setValue(y=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
1166 coeff=mypde.getCoefficient("y_reduced")
1167 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
1168 def test_setCoefficient_d_reduced_Scalar_using_d(self):
1169 d=self.domain.getDim()
1170 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1171 mypde.setValue(d=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
1172 coeff=mypde.getCoefficient("d_reduced")
1173 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
1174 def test_setCoefficient_d_contact_reduced_Scalar_using_d_contact(self):
1175 d=self.domain.getDim()
1176 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1177 mypde.setValue(d_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
1178 coeff=mypde.getCoefficient("d_contact_reduced")
1179 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
1180 def test_setCoefficient_y_contact_reduced_Scalar_using_y_contact(self):
1181 d=self.domain.getDim()
1182 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1183 mypde.setValue(y_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
1184 coeff=mypde.getCoefficient("y_contact_reduced")
1185 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
1186 #
1187 # set coefficients for systems:
1188 #
1189 def test_setCoefficient_A_System(self):
1190 d=self.domain.getDim()
1191 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1192 mypde.setValue(A=numpy.ones((self.N,d,self.N,d)))
1193 coeff=mypde.getCoefficient("A")
1194 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),Function(self.domain),self.N,self.N))
1195 def test_setCoefficient_B_System(self):
1196 d=self.domain.getDim()
1197 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1198 mypde.setValue(B=numpy.ones((self.N,d,self.N)))
1199 coeff=mypde.getCoefficient("B")
1200 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),Function(self.domain),self.N,self.N))
1201 def test_setCoefficient_C_System(self):
1202 d=self.domain.getDim()
1203 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1204 mypde.setValue(C=numpy.ones((self.N,self.N,d)))
1205 coeff=mypde.getCoefficient("C")
1206 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),Function(self.domain),self.N,self.N))
1207 def test_setCoefficient_D_System(self):
1208 d=self.domain.getDim()
1209 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1210 mypde.setValue(D=numpy.ones((self.N,self.N)))
1211 coeff=mypde.getCoefficient("D")
1212 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),Function(self.domain),self.N,self.N))
1213 def test_setCoefficient_X_System(self):
1214 d=self.domain.getDim()
1215 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1216 mypde.setValue(X=numpy.ones((self.N,d)))
1217 coeff=mypde.getCoefficient("X")
1218 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),Function(self.domain),self.N))
1219 def test_setCoefficient_Y_System(self):
1220 d=self.domain.getDim()
1221 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1222 mypde.setValue(Y=numpy.ones((self.N,)))
1223 coeff=mypde.getCoefficient("Y")
1224 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),Function(self.domain),self.N))
1225 def test_setCoefficient_y_System(self):
1226 d=self.domain.getDim()
1227 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1228 mypde.setValue(y=numpy.ones((self.N,)))
1229 coeff=mypde.getCoefficient("y")
1230 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnBoundary(self.domain),self.N))
1231 def test_setCoefficient_d_System(self):
1232 d=self.domain.getDim()
1233 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1234 mypde.setValue(d=numpy.ones((self.N,self.N)))
1235 coeff=mypde.getCoefficient("d")
1236 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnBoundary(self.domain),self.N,self.N))
1237 def test_setCoefficient_d_contact_System(self):
1238 d=self.domain.getDim()
1239 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1240 mypde.setValue(d_contact=numpy.ones((self.N,self.N)))
1241 coeff=mypde.getCoefficient("d_contact")
1242 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnContactZero(self.domain),self.N,self.N))
1243 def test_setCoefficient_y_contact_System(self):
1244 d=self.domain.getDim()
1245 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1246 mypde.setValue(y_contact=numpy.ones((self.N,)))
1247 coeff=mypde.getCoefficient("y_contact")
1248 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnContactZero(self.domain),self.N))
1249 def test_setCoefficient_A_reduced_System(self):
1250 d=self.domain.getDim()
1251 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1252 mypde.setValue(A_reduced=numpy.ones((self.N,d,self.N,d)))
1253 coeff=mypde.getCoefficient("A_reduced")
1254 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1255 def test_setCoefficient_B_reduced_System(self):
1256 d=self.domain.getDim()
1257 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1258 mypde.setValue(B_reduced=numpy.ones((self.N,d,self.N)))
1259 coeff=mypde.getCoefficient("B_reduced")
1260 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
1261 def test_setCoefficient_C_reduced_System(self):
1262 d=self.domain.getDim()
1263 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1264 mypde.setValue(C_reduced=numpy.ones((self.N,self.N,d)))
1265 coeff=mypde.getCoefficient("C_reduced")
1266 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1267 def test_setCoefficient_D_System_reduced(self):
1268 d=self.domain.getDim()
1269 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1270 mypde.setValue(D_reduced=numpy.ones((self.N,self.N)))
1271 coeff=mypde.getCoefficient("D_reduced")
1272 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
1273 def test_setCoefficient_X_System_reduced(self):
1274 d=self.domain.getDim()
1275 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1276 mypde.setValue(X_reduced=numpy.ones((self.N,d)))
1277 coeff=mypde.getCoefficient("X_reduced")
1278 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
1279 def test_setCoefficient_Y_System_reduced(self):
1280 d=self.domain.getDim()
1281 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1282 mypde.setValue(Y_reduced=numpy.ones((self.N,)))
1283 coeff=mypde.getCoefficient("Y_reduced")
1284 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
1285 def test_setCoefficient_y_System_reduced(self):
1286 d=self.domain.getDim()
1287 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1288 mypde.setValue(y_reduced=numpy.ones((self.N,)))
1289 coeff=mypde.getCoefficient("y_reduced")
1290 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
1291 def test_setCoefficient_d_reduced_System(self):
1292 d=self.domain.getDim()
1293 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1294 mypde.setValue(d_reduced=numpy.ones((self.N,self.N)))
1295 coeff=mypde.getCoefficient("d_reduced")
1296 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
1297 def test_setCoefficient_d_contact_reduced_System(self):
1298 d=self.domain.getDim()
1299 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1300 mypde.setValue(d_contact_reduced=numpy.ones((self.N,self.N)))
1301 coeff=mypde.getCoefficient("d_contact_reduced")
1302 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
1303 def test_setCoefficient_y_contact_reduced_System(self):
1304 d=self.domain.getDim()
1305 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1306 mypde.setValue(y_contact_reduced=numpy.ones((self.N,)))
1307 coeff=mypde.getCoefficient("y_contact_reduced")
1308 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
1309 def test_setCoefficient_r_System(self):
1310 d=self.domain.getDim()
1311 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1312 mypde.setValue(r=numpy.ones((self.N,)))
1313 coeff=mypde.getCoefficient("r")
1314 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
1315 def test_setCoefficient_q_System(self):
1316 d=self.domain.getDim()
1317 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1318 mypde.setValue(q=numpy.ones((self.N,)))
1319 coeff=mypde.getCoefficient("q")
1320 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
1321 def test_setCoefficient_r_System_reducedOn(self):
1322 d=self.domain.getDim()
1323 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1324 mypde.setReducedOrderOn()
1325 mypde.setValue(r=numpy.ones((self.N,)))
1326 coeff=mypde.getCoefficient("r")
1327 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
1328 def test_setCoefficient_q_System_reducedOn(self):
1329 d=self.domain.getDim()
1330 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1331 mypde.setReducedOrderOn()
1332 mypde.setValue(q=numpy.ones((self.N,)))
1333 coeff=mypde.getCoefficient("q")
1334 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
1335
1336 def test_setCoefficient_A_reduced_System_using_A(self):
1337 d=self.domain.getDim()
1338 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1339 mypde.setValue(A=Data(numpy.ones((self.N,d,self.N,d)),ReducedFunction(self.domain)))
1340 coeff=mypde.getCoefficient("A_reduced")
1341 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1342 def test_setCoefficient_B_reduced_System_using_B(self):
1343 d=self.domain.getDim()
1344 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1345 mypde.setValue(B=Data(numpy.ones((self.N,d,self.N)),ReducedFunction(self.domain)))
1346 coeff=mypde.getCoefficient("B_reduced")
1347 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
1348 def test_setCoefficient_C_reduced_System_using_C(self):
1349 d=self.domain.getDim()
1350 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1351 mypde.setValue(C=Data(numpy.ones((self.N,self.N,d)),ReducedFunction(self.domain)))
1352 coeff=mypde.getCoefficient("C_reduced")
1353 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1354 def test_setCoefficient_D_System_reduced_using_D(self):
1355 d=self.domain.getDim()
1356 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1357 mypde.setValue(D=Data(numpy.ones((self.N,self.N)),ReducedFunction(self.domain)))
1358 coeff=mypde.getCoefficient("D_reduced")
1359 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
1360 def test_setCoefficient_X_System_reduced_using_X(self):
1361 d=self.domain.getDim()
1362 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1363 mypde.setValue(X=Data(numpy.ones((self.N,d)),ReducedFunction(self.domain)))
1364 coeff=mypde.getCoefficient("X_reduced")
1365 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
1366 def test_setCoefficient_Y_System_reduced_using_Y(self):
1367 d=self.domain.getDim()
1368 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1369 mypde.setValue(Y=Data(numpy.ones((self.N,)),ReducedFunction(self.domain)))
1370 coeff=mypde.getCoefficient("Y_reduced")
1371 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
1372 def test_setCoefficient_y_reduced_System_using_y(self):
1373 d=self.domain.getDim()
1374 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1375 mypde.setValue(y=Data(numpy.ones((self.N,)),ReducedFunctionOnBoundary(self.domain)))
1376 coeff=mypde.getCoefficient("y_reduced")
1377 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
1378 def test_setCoefficient_d_reduced_System_using_d(self):
1379 d=self.domain.getDim()
1380 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1381 mypde.setValue(d=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnBoundary(self.domain)))
1382 coeff=mypde.getCoefficient("d_reduced")
1383 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
1384 def test_setCoefficient_d_contact_reduced_System_using_d_contact(self):
1385 d=self.domain.getDim()
1386 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1387 mypde.setValue(d_contact=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnContactZero(self.domain)))
1388 coeff=mypde.getCoefficient("d_contact_reduced")
1389 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
1390 def test_setCoefficient_y_contact_reduced_System_using_y_contact(self):
1391 d=self.domain.getDim()
1392 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1393 mypde.setValue(y_contact=Data(numpy.ones((self.N,)),ReducedFunctionOnContactZero(self.domain)))
1394 coeff=mypde.getCoefficient("y_contact_reduced")
1395 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
1396 def test_resetCoefficient_HomogeneousConstraint(self):
1397 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1398 x=self.domain.getX()
1399 mypde.setValue(A=kronecker(self.domain),Y=1.,q=whereZero(x[0]))
1400 u1=mypde.getSolution()
1401 mypde.setValue(Y=2.)
1402 u2=mypde.getSolution()
1403 self.failUnless(self.check(u2,2*u1),'solution is wrong.')
1404
1405 def test_resetCoefficient_InHomogeneousConstraint(self):
1406 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1407 mypde.setSymmetryOn()
1408 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1409 x=self.domain.getX()
1410 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.,r=1,q=whereZero(x[0]))
1411 u1=mypde.getSolution()
1412 mypde.setValue(Y=2.,D=2)
1413 u2=mypde.getSolution()
1414 self.failUnless(self.check(u2,u1),'first solution is wrong.')
1415 u2=mypde.getSolution()
1416 self.failUnless(self.check(u2,u1),'first solution is wrong.')
1417 mypde.setValue(r=2,Y=4.)
1418 u2=mypde.getSolution()
1419 self.failUnless(self.check(u2,2*u1),'second solution is wrong.')
1420
1421 def test_Status(self):
1422 DIM=self.domain.getDim()
1423 x=self.domain.getX()
1424 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1425 mypde.getSolverOptions().setSymmetryOn()
1426 mypde.getSolverOptions().setTolerance(self.RES_TOL)
1427 mypde.setValue(A=kronecker(self.domain), q=whereZero(x[0])+whereZero(x[0]-1.), Y=2.)
1428 x1=self.domain.getX()
1429 u1_ref=x1[0]*(1.-x1[0])
1430 u1=mypde.getSolution()
1431 error1=Lsup(u1-u1_ref)/Lsup(u1_ref)
1432 self.failUnless(mypde.getDomainStatus() == mypde.getSystemStatus(), "status of first pde does not match domain status.")
1433
1434 self.domain.setX(x*5)
1435
1436 self.failUnless(mypde.getDomainStatus() != mypde.getSystemStatus(), "status of first pde matches updated domain status.")
1437 x2=self.domain.getX()
1438 u2_ref=x2[0]*(5.-x2[0])
1439 u2=mypde.getSolution()
1440 error2=Lsup(u2-u2_ref)/Lsup(u2_ref)
1441 self.failUnless(error2 <= max(error1,self.RES_TOL)*10., "solution of second PDE wrong.")
1442 self.failUnless(mypde.getDomainStatus() == mypde.getSystemStatus(), "status of second pde does not match domain status.")
1443
1444 def test_symmetryCheckTrue_System(self):
1445 d=self.domain.getDim()
1446 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1447 A=numpy.ones((self.N,d,self.N,d))
1448 C=2*numpy.ones((self.N,self.N,d))
1449 B=2*numpy.ones((self.N,d,self.N))
1450 D=3*numpy.ones((self.N,self.N))
1451 d=4*numpy.ones((self.N,self.N))
1452 d_contact=5*numpy.ones((self.N,self.N))
1453 mypde.setValue(A=A,B=B,C=C,D=D,d=d,d_contact=d_contact,A_reduced=-A,B_reduced=-B,C_reduced=-C,D_reduced=-D,d_reduced=-d,d_contact_reduced=-d_contact)
1454 self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
1455
1456 def test_symmetryCheckFalse_A_System(self):
1457 d=self.domain.getDim()
1458 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1459 A=numpy.ones((self.N,d,self.N,d))
1460 A[1,1,1,0]=0.
1461 mypde.setValue(A=A)
1462 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1463 def test_symmetryCheckFalse_BC_System(self):
1464 d=self.domain.getDim()
1465 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1466 C=2*numpy.ones((self.N,self.N,d))
1467 B=2*numpy.ones((self.N,d,self.N))
1468 B[0,0,1]=1.
1469 mypde.setValue(B=B,C=C)
1470 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1471
1472 def test_symmetryCheckFalse_D_System(self):
1473 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1474 D=3*numpy.ones((self.N,self.N))
1475 D[0,1]=0.
1476 mypde.setValue(D=D)
1477 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1478
1479 def test_symmetryCheckFalse_d_System(self):
1480 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1481 d=4*numpy.ones((self.N,self.N))
1482 d[0,1]=0.
1483 mypde.setValue(d=d)
1484 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1485
1486 def test_symmetryCheckFalse_d_contact_System(self):
1487 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1488 d_contact=5*numpy.ones((self.N,self.N))
1489 d_contact[0,1]=0.
1490 mypde.setValue(d_contact=d_contact)
1491 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1492
1493 def test_symmetryCheckFalse_A_reduced_System(self):
1494 d=self.domain.getDim()
1495 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1496 A=numpy.ones((self.N,d,self.N,d))
1497 A[1,1,1,0]=0.
1498 mypde.setValue(A_reduced=A)
1499 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1500 def test_symmetryCheckFalse_BC_reduced_System(self):
1501 d=self.domain.getDim()
1502 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1503 C=2*numpy.ones((self.N,self.N,d))
1504 B=2*numpy.ones((self.N,d,self.N))
1505 B[0,0,1]=1.
1506 mypde.setValue(B_reduced=B,C_reduced=C)
1507 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1508
1509 def test_symmetryCheckFalse_D_reduced_System(self):
1510 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1511 D=3*numpy.ones((self.N,self.N))
1512 D[0,1]=0.
1513 mypde.setValue(D_reduced=D)
1514 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1515
1516 def test_symmetryCheckFalse_d_reduced_System(self):
1517 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1518 d=4*numpy.ones((self.N,self.N))
1519 d[0,1]=0.
1520 mypde.setValue(d_reduced=d)
1521 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1522
1523 def test_symmetryCheckFalse_d_contact_reduced_System(self):
1524 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1525 d_contact=5*numpy.ones((self.N,self.N))
1526 d_contact[0,1]=0.
1527 mypde.setValue(d_contact_reduced=d_contact)
1528 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1529
1530 def test_symmetryCheckTrue_Scalar(self):
1531 d=self.domain.getDim()
1532 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1533 A=numpy.ones((d,d))
1534 C=2*numpy.ones((d,))
1535 B=2*numpy.ones((d,))
1536 D=3
1537 d=4
1538 d_contact=5
1539 mypde.setValue(A=A,B=B,C=C,D=D,d=d,d_contact=d_contact,A_reduced=-A,B_reduced=-B,C_reduced=-C,D_reduced=-D,d_reduced=-d,d_contact_reduced=-d_contact)
1540 self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
1541
1542 def test_symmetryCheckFalse_A_Scalar(self):
1543 d=self.domain.getDim()
1544 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1545 A=numpy.ones((d,d))
1546 A[1,0]=0.
1547 mypde.setValue(A=A)
1548 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1549 def test_symmetryCheckFalse_BC_Scalar(self):
1550 d=self.domain.getDim()
1551 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1552 C=2*numpy.ones((d,))
1553 B=2*numpy.ones((d,))
1554 B[0]=1.
1555 mypde.setValue(B=B,C=C)
1556 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1557 def test_symmetryCheckFalse_A_reduced_Scalar(self):
1558 d=self.domain.getDim()
1559 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1560 A=numpy.ones((d,d))
1561 A[1,0]=0.
1562 mypde.setValue(A_reduced=A)
1563 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1564 def test_symmetryCheckFalse_BC_reduced_Scalar(self):
1565 d=self.domain.getDim()
1566 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1567 C=2*numpy.ones((d,))
1568 B=2*numpy.ones((d,))
1569 B[0]=1.
1570 mypde.setValue(B_reduced=B,C_reduced=C)
1571 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1572 #
1573 # solver checks (single PDE)
1574 #
1575 def test_symmetryOnIterative(self):
1576 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1577 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1578 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1579 u=mypde.getSolution()
1580 self.failUnless(self.check(u,1.),'solution is wrong.')
1581 def test_symmetryOnDirect(self):
1582 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1583 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1584 mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1585 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1586 u=mypde.getSolution()
1587 self.failUnless(self.check(u,1.),'solution is wrong.')
1588 def test_PCG_JACOBI(self):
1589 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1590 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1591 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1592 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1593 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1594 u=mypde.getSolution()
1595 self.failUnless(self.check(u,1.),'solution is wrong.')
1596 def test_PCG_AMG(self):
1597 if self.order!=2:
1598 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1599 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1600 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1601 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1602 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1603 u=mypde.getSolution()
1604 self.failUnless(self.check(u,1.),'solution is wrong.')
1605 def test_PCG_ILU0(self):
1606 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1607 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1608 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1609 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1610 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1611 u=mypde.getSolution()
1612 self.failUnless(self.check(u,1.),'solution is wrong.')
1613 def test_PCG_RILU(self):
1614 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1615 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1616 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1617 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1618 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1619 u=mypde.getSolution()
1620 self.failUnless(self.check(u,1.),'solution is wrong.')
1621 def test_PCG_REC_ILU(self):
1622 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1623 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1624 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1625 mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1626 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1627 u=mypde.getSolution()
1628 self.failUnless(self.check(u,1.),'solution is wrong.')
1629 def test_DIRECT(self):
1630 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1631 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1632 mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1633 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1634 u=mypde.getSolution()
1635 self.failUnless(self.check(u,1.),'solution is wrong.')
1636 def test_BICGSTAB_JACOBI(self):
1637 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1638 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1639 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1640 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1641 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1642 u=mypde.getSolution()
1643 self.failUnless(self.check(u,1.),'solution is wrong.')
1644 def test_BICGSTAB_AMG(self):
1645 if self.order!=2:
1646 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1647 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1648 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1649 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1650 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1651 u=mypde.getSolution()
1652 self.failUnless(self.check(u,1.),'solution is wrong.')
1653 def test_BICGSTAB_ILU0(self):
1654 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1655 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1656 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1657 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1658 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1659 u=mypde.getSolution()
1660 self.failUnless(self.check(u,1.),'solution is wrong.')
1661 def test_BICGSTAB_RILU(self):
1662 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1663 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1664 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1665 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1666 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1667 u=mypde.getSolution()
1668 self.failUnless(self.check(u,1.),'solution is wrong.')
1669 def test_BICGSTAB_REC_ILU(self):
1670 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1671 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1672 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1673 mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1674 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1675 u=mypde.getSolution()
1676 self.failUnless(self.check(u,1.),'solution is wrong.')
1677 def test_MINRES_JACOBI(self):
1678 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1679 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1680 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1681 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1682 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1683 u=mypde.getSolution()
1684 self.failUnless(self.check(u,1.),'solution is wrong.')
1685 def test_MINRES_AMG(self):
1686 if self.order!=2:
1687 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1688 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1689 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1690 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1691 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1692 u=mypde.getSolution()
1693 self.failUnless(self.check(u,1.),'solution is wrong.')
1694 def test_MINRES_ILU0(self):
1695 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1696 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1697 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1698 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1699 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1700 u=mypde.getSolution()
1701 self.failUnless(self.check(u,1.),'solution is wrong.')
1702 def test_MINRES_RILU(self):
1703 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1704 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1705 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1706 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1707 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1708 u=mypde.getSolution()
1709 self.failUnless(self.check(u,1.),'solution is wrong.')
1710 def test_MINRES_REC_ILU(self):
1711 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1712 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1713 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1714 mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1715 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1716 u=mypde.getSolution()
1717 self.failUnless(self.check(u,1.),'solution is wrong.')
1718 def test_TFQMR_JACOBI(self):
1719 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1720 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1721 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1722 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1723 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1724 u=mypde.getSolution()
1725 self.failUnless(self.check(u,1.),'solution is wrong.')
1726 def test_TFQMR_AMG(self):
1727 if self.order!=2:
1728 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1729 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1730 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1731 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1732 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1733 u=mypde.getSolution()
1734 self.failUnless(self.check(u,1.),'solution is wrong.')
1735 def test_TFQMR_ILU0(self):
1736 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1737 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1738 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1739 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1740 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1741 u=mypde.getSolution()
1742 self.failUnless(self.check(u,1.),'solution is wrong.')
1743 def test_TFQMR_RILU(self):
1744 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1745 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1746 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1747 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1748 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1749 u=mypde.getSolution()
1750 self.failUnless(self.check(u,1.),'solution is wrong.')
1751 def test_TFQMR_REC_ILU(self):
1752 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1753 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1754 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1755 mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1756 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1757 u=mypde.getSolution()
1758 self.failUnless(self.check(u,1.),'solution is wrong.')
1759 def test_PRES20_JACOBI(self):
1760 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1761 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1762 mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1763 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1764 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1765 u=mypde.getSolution()
1766 self.failUnless(self.check(u,1.),'solution is wrong.')
1767 def test_PRES20_AMG(self):
1768 if self.order!=2:
1769 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1770 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1771 mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1772 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1773 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1774 u=mypde.getSolution()
1775 self.failUnless(self.check(u,1.),'solution is wrong.')
1776 def test_PRES20_ILU0(self):
1777 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1778 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1779 mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1780 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1781 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1782 u=mypde.getSolution()
1783 self.failUnless(self.check(u,1.),'solution is wrong.')
1784 def test_PRES20_RILU(self):
1785 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1786 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1787 mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1788