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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2817 - (show annotations)
Thu Dec 10 02:12:33 2009 UTC (9 years, 9 months ago) by artak
Original Path: trunk/escript/test/python/test_linearPDEs.py
File MIME type: text/x-python
File size: 182561 byte(s)
test is added for selecting standard coarsening.
1
2 ########################################################
3 #
4 # Copyright (c) 2003-2009 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-2009 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.getLevelMax() == 3, "initial LevelMax is wrong.")
647 self.failUnlessRaises(ValueError,so.setLevelMax,-1)
648 so.setLevelMax(20)
649 self.failUnless(so.getLevelMax() == 20, "LevelMax is wrong.")
650
651 self.failUnless(so.getCoarseningThreshold() == 0.25, "initial CoarseningThreshold is wrong.")
652 self.failUnlessRaises(ValueError,so.setCoarseningThreshold,-1)
653 so.setCoarseningThreshold(0.1)
654 self.failUnless(so.getCoarseningThreshold() == 0.1, "CoarseningThreshold is wrong.")
655
656 self.failUnless(so.getMinCoarseMatrixSize() == 500, "initial Minimum Coarse Matrix Size is wrong.")
657 self.failUnlessRaises(ValueError,so.setMinCoarseMatrixSize,-1)
658 so.setMinCoarseMatrixSize(1000)
659 self.failUnless(so.getMinCoarseMatrixSize() == 1000, "Minimum Coarse Matrix Size is wrong.")
660
661 self.failUnless(so.getNumSweeps() == 2, "initial Sweeps is wrong.")
662 self.failUnlessRaises(ValueError,so.setNumSweeps,-1)
663 so.setNumSweeps(3)
664 self.failUnless(so.getNumSweeps() == 3, "Sweeps is wrong.")
665
666 self.failUnless(so.getNumPreSweeps() == 2, "initial PreSweeps is wrong.")
667 self.failUnlessRaises(ValueError,so.setNumPreSweeps,-1)
668 so.setNumPreSweeps(4)
669 self.failUnless(so.getNumPreSweeps() == 4, "PreSweeps is wrong.")
670
671 self.failUnless(so.getNumPostSweeps() == 2, "initial PreSweeps is wrong.")
672 self.failUnlessRaises(ValueError,so.setNumPostSweeps,-1)
673 so.setNumPostSweeps(5)
674 self.failUnless(so.getNumPostSweeps() == 5, "PreSweeps is wrong.")
675
676 self.failUnless(so.getTolerance() == 1.e-8, "initial Tolerance is wrong.")
677 self.failUnlessRaises(ValueError,so.setTolerance,-1)
678 so.setTolerance(0.2)
679 self.failUnless(so.getTolerance() == 0.2, "Tolerance is wrong.")
680
681 self.failUnless(so.getAbsoluteTolerance() == 0., "initial AbsoluteTolerance is wrong.")
682 self.failUnlessRaises(ValueError,so.setAbsoluteTolerance,-1)
683 so.setAbsoluteTolerance(0.3)
684 self.failUnless(so.getAbsoluteTolerance() == 0.3, "AbsoluteTolerance is wrong.")
685
686 self.failUnless(so.getInnerTolerance() == 0.9, "initial InnerTolerance is wrong.")
687 self.failUnlessRaises(ValueError,so.setInnerTolerance,-1)
688 so.setInnerTolerance(0.4)
689 self.failUnless(so.getInnerTolerance() == 0.4, "InnerTolerance is wrong.")
690
691 self.failUnless(so.getDropTolerance() == 0.01, "initial DropTolerance is wrong.")
692 self.failUnlessRaises(ValueError,so.setDropTolerance,-1)
693 so.setDropTolerance(0.5)
694 self.failUnless(so.getDropTolerance() == 0.5, "DropDropTolerance is wrong.")
695
696 self.failUnless(so.getDropStorage() == 2., "initial DropStorage is wrong.")
697 self.failUnlessRaises(ValueError,so.setDropStorage,-1)
698 so.setDropStorage(10)
699 self.failUnless(so.getDropStorage() == 10, "DropStorage is wrong.")
700
701 self.failUnless(so.getRelaxationFactor() == 0.3, "initial RelaxationFactor is wrong.")
702 self.failUnlessRaises(ValueError,so.setRelaxationFactor,-1)
703 so.setRelaxationFactor(0.1)
704 self.failUnless(so.getRelaxationFactor() == 0.1, "Relaxation is wrong.")
705
706
707 self.failUnless(so.getIterMax() == 100000, "initial IterMax is wrong.")
708 self.failUnlessRaises(ValueError,so.setIterMax,0)
709 so.setIterMax(11)
710 self.failUnless(so.getIterMax() == 11, "IterMax is wrong.")
711
712 self.failUnless(so.getInnerIterMax() == 10, "initial InnerIterMax is wrong.")
713 self.failUnlessRaises(ValueError,so.setInnerIterMax,0)
714 so.setInnerIterMax(12)
715 self.failUnless(so.getInnerIterMax() == 12, "InnerIterMax is wrong.")
716
717 self.failUnless(so.getTruncation() == 20, "initial Truncation is wrong.")
718 self.failUnlessRaises(ValueError,so.setTruncation,0)
719 so.setTruncation(13)
720 self.failUnless(so.getTruncation() == 13, "Truncation is wrong.")
721
722 self.failUnless(so.getRestart() == None, "initial Truncation is wrong.")
723 self.failUnlessRaises(ValueError,so.setTruncation,0)
724 so.setRestart(14)
725 self.failUnless(so.getRestart() == 14, "Truncation is wrong.")
726 so.setRestart(None)
727 self.failUnless(so.getRestart() == None, "Truncation is wrong.")
728
729 self.failUnless(not so.isVerbose(), "initial verbosity flag is wrong.")
730 so.setVerbosityOn()
731 self.failUnless(so.isVerbose(), "verbosity (1) flag is wrong.")
732 so.setVerbosityOff()
733 self.failUnless(not so.isVerbose(), "verbosity (2) flag is wrong.")
734 so.setVerbosity(verbose=True)
735 self.failUnless(so.isVerbose(), "verbosity (3) flag is wrong.")
736 so.setVerbosity(verbose=False)
737 self.failUnless(not so.isVerbose(), "verbosity (4) flag is wrong.")
738
739 self.failUnless(not so.isSymmetric(), "initial symmetry flag is wrong.")
740 so.setSymmetryOn()
741 self.failUnless(so.isSymmetric(), "symmetry (1) flag is wrong.")
742 so.setSymmetryOff()
743 self.failUnless(not so.isSymmetric(), "symmetry (2) flag is wrong.")
744 so.setSymmetry(flag=True)
745 self.failUnless(so.isSymmetric(), "symmetry (3) flag is wrong.")
746 so.setSymmetry(flag=False)
747 self.failUnless(not so.isSymmetric(), "symmetry (4) flag is wrong.")
748
749 self.failUnless(so.adaptInnerTolerance(), "initial InnerToleranceAdaption flag is wrong.")
750 so.setInnerToleranceAdaptionOn()
751 self.failUnless(so.adaptInnerTolerance(), "InnerToleranceAdaption (1) flag is wrong.")
752 so.setInnerToleranceAdaptionOff()
753 self.failUnless(not so.adaptInnerTolerance(), "InnerToleranceAdaption (2) flag is wrong.")
754 so.setInnerToleranceAdaption(adapt=True)
755 self.failUnless(so.adaptInnerTolerance(), "InnerToleranceAdaption (3) flag is wrong.")
756 so.setInnerToleranceAdaption(adapt=False)
757 self.failUnless(not so.adaptInnerTolerance(), "InnerToleranceAdaption (4) flag is wrong.")
758
759 self.failUnless(not so.acceptConvergenceFailure(), "initial acceptConvergenceFailure flag is wrong.")
760 so.setAcceptanceConvergenceFailureOn()
761 self.failUnless(so.acceptConvergenceFailure(), "acceptConvergenceFailure (1) flag is wrong.")
762 so.setAcceptanceConvergenceFailureOff()
763 self.failUnless(not so.acceptConvergenceFailure(), "acceptConvergenceFailure (2) flag is wrong.")
764 so.setAcceptanceConvergenceFailure(accept=True)
765 self.failUnless(so.acceptConvergenceFailure(), "acceptConvergenceFailure (3) flag is wrong.")
766 so.setAcceptanceConvergenceFailure(accept=False)
767 self.failUnless(not so.acceptConvergenceFailure(), "acceptConvergenceFailure (4) flag is wrong.")
768
769 self.failUnless(so.getReordering() == 30, "initial Reordering is wrong.")
770 self.failUnlessRaises(ValueError,so.setReordering,-1)
771 so.setReordering(so.NO_REORDERING)
772 self.failUnless(so.getReordering() == 17, "NO_REORDERING is not set.")
773 so.setReordering(so.MINIMUM_FILL_IN)
774 self.failUnless(so.getReordering() == 18, "MINIMUM_FILL_IN is not set.")
775 so.setReordering(so.NESTED_DISSECTION)
776 self.failUnless(so.getReordering() == 19, "NESTED_DISSECTION is not set.")
777 so.setReordering(so.DEFAULT_REORDERING)
778 self.failUnless(so.getReordering() == 30, "DEFAULT_REORDERING is not set.")
779
780 self.failUnless(so.getPackage() == 0, "initial solver package is wrong.")
781 self.failUnlessRaises(ValueError,so.setPackage,-1)
782 so.setPackage(so.PASO)
783 self.failUnless(so.getPackage() == 21, "PASO is not set.")
784 so.setPackage(so.SUPER_LU)
785 self.failUnless(so.getPackage() == 31, "SUPER_LU is not set.")
786 so.setPackage(so.PASTIX)
787 self.failUnless(so.getPackage() == 32, "PASTIX is not set.")
788 so.setPackage(so.MKL)
789 self.failUnless(so.getPackage() == 15, "MKL is not set.")
790 so.setPackage(so.UMFPACK)
791 self.failUnless(so.getPackage() == 16, "UMFPACK is not set.")
792 so.setPackage(so.TRILINOS)
793 self.failUnless(so.getPackage() == 24, "TRILINOS is not set.")
794
795 self.failUnless(so.getSolverMethod() == 0, "initial SolverMethod is wrong.")
796 self.failUnlessRaises(ValueError,so.setSolverMethod,-1)
797 so.setSolverMethod(so.DIRECT)
798 self.failUnless(so.getSolverMethod() == 1, "DIRECT is not set.")
799 so.setSolverMethod(so.CHOLEVSKY)
800 self.failUnless(so.getSolverMethod() == 2, "CHOLEVSKY is not set.")
801 so.setSolverMethod(so.PCG)
802 self.failUnless(so.getSolverMethod() == 3, "PCG is not set.")
803 so.setSolverMethod(so.CR)
804 self.failUnless(so.getSolverMethod() == 4, "CR is not set.")
805 so.setSolverMethod(so.CGS)
806 self.failUnless(so.getSolverMethod() == 5, "CGS is not set.")
807 so.setSolverMethod(so.BICGSTAB)
808 self.failUnless(so.getSolverMethod() == 6, "BICGSTAB is not set.")
809 so.setSolverMethod(so.SSOR)
810 self.failUnless(so.getSolverMethod() == 7, "SSOR is not set.")
811 so.setSolverMethod(so.GMRES)
812 self.failUnless(so.getSolverMethod() == 11, "GMRES is not set.")
813 so.setSolverMethod(so.PRES20)
814 self.failUnless(so.getSolverMethod() == 12, "PRES20 is not set.")
815 so.setSolverMethod(so.LUMPING)
816 self.failUnless(so.getSolverMethod() == 13, "LUMPING is not set.")
817 so.setSolverMethod(so.ITERATIVE)
818 self.failUnless(so.getSolverMethod() == 20, "ITERATIVE is not set.")
819 so.setSolverMethod(so.AMG)
820 self.failUnless(so.getSolverMethod() == 22, "AMG is not set.")
821 so.setSolverMethod(so.NONLINEAR_GMRES)
822 self.failUnless(so.getSolverMethod() == 25, "NONLINEAR_GMRES is not set.")
823 so.setSolverMethod(so.TFQMR)
824 self.failUnless(so.getSolverMethod() == 26, "TFQMR is not set.")
825 so.setSolverMethod(so.MINRES)
826 self.failUnless(so.getSolverMethod() == 27, "MINRES is not set.")
827 so.setSolverMethod(so.GAUSS_SEIDEL)
828 self.failUnless(so.getSolverMethod() == 28, "GAUSS_SEIDEL is not set.")
829 so.setSolverMethod(so.DEFAULT)
830 self.failUnless(so.getSolverMethod() == 0, "DEFAULT is not set.")
831
832 self.failUnless(so.getPreconditioner() == 10, "initial Preconditioner is wrong.")
833 self.failUnlessRaises(ValueError,so.setPreconditioner,-1)
834 so.setPreconditioner(so.ILU0)
835 self.failUnless(so.getPreconditioner() == 8, "ILU0 is not set.")
836 so.setPreconditioner(so.SSOR)
837 self.failUnless(so.getPreconditioner() == 7, "SSOR is not set.")
838 so.setPreconditioner(so.ILUT)
839 self.failUnless(so.getPreconditioner() == 9, "ILUT is not set.")
840 so.setPreconditioner(so.JACOBI)
841 self.failUnless(so.getPreconditioner() == 10, "JACOBI is not set.")
842 so.setPreconditioner(so.AMG)
843 self.failUnless(so.getPreconditioner() == 22, "AMG is not set.")
844 so.setPreconditioner(so.REC_ILU)
845 self.failUnless(so.getPreconditioner() == 23, "REC_ILU is not set.")
846 so.setPreconditioner(so.GAUSS_SEIDEL)
847 self.failUnless(so.getPreconditioner() == 28, "GAUSS_SEIDEL is not set.")
848 so.setPreconditioner(so.RILU)
849 self.failUnless(so.getPreconditioner() == 29, "RILU is not set.")
850 so.setPreconditioner(so.NO_PRECONDITIONER)
851 self.failUnless(so.getPreconditioner() == 36, "NO_PRECONDITIONER is not set.")
852
853 self.failUnless(so.getCoarsening() == 0, "initial Coarseningr is wrong.")
854 self.failUnlessRaises(ValueError,so.setCoarsening,-1)
855 so.setCoarsening(so.YAIR_SHAPIRA_COARSENING)
856 self.failUnless(so.getCoarsening() == 33, "YAIR_SHAPIRA_COARSENING is not set.")
857 so.setCoarsening(so.RUGE_STUEBEN_COARSENING)
858 self.failUnless(so.getCoarsening() == 34, "RUGE_STUEBEN_COARSENING is not set.")
859 so.setCoarsening(so.AGGREGATION_COARSENING)
860 self.failUnless(so.getCoarsening() == 35, "AGREGATION_COARSENING is not set.")
861 so.setCoarsening(so.STANDARD_COARSENING)
862 self.failUnless(so.getCoarsening() == 39, "STANDARD_COARSENING is not set.")
863 so.setCoarsening(so.DEFAULT)
864 self.failUnless(so.getCoarsening() == 0, "DEFAULT is not set.")
865
866 self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
867 self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
868 self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
869 self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
870 self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
871 self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
872 self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong.")
873 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 0, "initial cum_num_inner_iter is wrong.")
874 self.failUnless(so.getDiagnostics("cum_num_iter") == 0, "initial cum_num_iter is wrong.")
875 self.failUnless(so.getDiagnostics("cum_time") ==0, "initial cum_time is wrong.")
876 self.failUnless(so.getDiagnostics("cum_set_up_time") == 0, "initial cum_set_up_time is wrong.")
877
878 so._updateDiagnostics("num_iter",1)
879 so._updateDiagnostics("num_inner_iter",2)
880 so._updateDiagnostics("time",3)
881 so._updateDiagnostics("set_up_time",4)
882 so._updateDiagnostics("residual_norm",5)
883 so._updateDiagnostics("converged",True)
884
885 self.failUnless(so.getDiagnostics("num_iter") == 1, "num_iter is wrong.")
886 self.failUnless(so.getDiagnostics("num_inner_iter") == 2, "num_inner_iter is wrong.")
887 self.failUnless(so.getDiagnostics("time") == 3, "time is wrong.")
888 self.failUnless(so.getDiagnostics("set_up_time") == 4, "set_up_time is wrong.")
889 self.failUnless(so.getDiagnostics("residual_norm") == 5, "residual_norm is wrong.")
890 self.failUnless(so.getDiagnostics("converged"), "converged is wrong.")
891 self.failUnless(so.hasConverged(), "convergence flag is wrong.")
892 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 2, "cum_num_inner_iter is wrong.")
893 self.failUnless(so.getDiagnostics("cum_num_iter") == 1, "cum_num_iter is wrong.")
894 self.failUnless(so.getDiagnostics("cum_time") ==3, "cum_time is wrong.")
895 self.failUnless(so.getDiagnostics("cum_set_up_time") == 4, "cum_set_up_time is wrong.")
896
897 so.resetDiagnostics()
898 self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
899 self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
900 self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
901 self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
902 self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
903 self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
904 self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong")
905 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 2, "cum_num_inner_iter is wrong.")
906 self.failUnless(so.getDiagnostics("cum_num_iter") == 1, "cum_num_iter is wrong.")
907 self.failUnless(so.getDiagnostics("cum_time") ==3, "cum_time is wrong.")
908 self.failUnless(so.getDiagnostics("cum_set_up_time") == 4, "cum_set_up_time is wrong.")
909
910 so._updateDiagnostics("num_iter",10)
911 so._updateDiagnostics("num_inner_iter",20)
912 so._updateDiagnostics("time",30)
913 so._updateDiagnostics("set_up_time",40)
914 so._updateDiagnostics("residual_norm",50)
915 so._updateDiagnostics("converged",False)
916
917 self.failUnless(so.getDiagnostics("num_iter") == 10, "num_iter is wrong.")
918 self.failUnless(so.getDiagnostics("num_inner_iter") == 20, "num_inner_iter is wrong.")
919 self.failUnless(so.getDiagnostics("time") == 30, "time is wrong.")
920 self.failUnless(so.getDiagnostics("set_up_time") == 40, "set_up_time is wrong.")
921 self.failUnless(so.getDiagnostics("residual_norm") == 50, "residual_norm is wrong.")
922 self.failUnless(not so.getDiagnostics("converged"), "converged is wrong.")
923 self.failUnless(not so.hasConverged(), "convergence flag is wrong.")
924 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 22, "cum_num_inner_iter is wrong.")
925 self.failUnless(so.getDiagnostics("cum_num_iter") == 11, "cum_num_iter is wrong.")
926 self.failUnless(so.getDiagnostics("cum_time") ==33, "cum_time is wrong.")
927 self.failUnless(so.getDiagnostics("cum_set_up_time") == 44, "cum_set_up_time is wrong.")
928
929 so.resetDiagnostics(all=True)
930 self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
931 self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
932 self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
933 self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
934 self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
935 self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
936 self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong.")
937 self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 0, "initial cum_num_inner_iter is wrong.")
938 self.failUnless(so.getDiagnostics("cum_num_iter") == 0, "initial cum_num_iter is wrong.")
939 self.failUnless(so.getDiagnostics("cum_time") ==0, "initial cum_time is wrong.")
940 self.failUnless(so.getDiagnostics("cum_set_up_time") == 0, "initial cum_set_up_time is wrong.")
941
942 def test_setCoefficient_WithIllegalFunctionSpace(self):
943 mypde=LinearPDE(self.domain,debug=self.DEBUG)
944 self.failUnlessRaises(IllegalCoefficientFunctionSpace, mypde.setValue, C=Vector(0.,FunctionOnBoundary(self.domain)))
945
946 def test_setCoefficient_WithWrongName(self):
947 mypde=LinearPDE(self.domain,debug=self.DEBUG)
948 self.failUnlessRaises(IllegalCoefficient, mypde.setValue, ROMA=0.)
949
950 def test_resetCoefficient_WithWrongShape(self):
951 mypde=LinearPDE(self.domain,numEquations=2,debug=self.DEBUG)
952 self.failUnlessRaises(IllegalCoefficientValue, mypde.setValue, C=0.)
953
954 def test_reducedOn(self):
955 mypde=LinearPDE(self.domain,debug=self.DEBUG)
956 x=self.domain.getX()
957 mypde.setReducedOrderOn()
958 mypde.setValue(A=kronecker(self.domain),D=x[0],Y=x[0])
959 u=mypde.getSolution()
960 self.failUnless(self.check(u,1.),'solution is wrong.')
961
962 def test_attemptToChangeOrderAfterDefinedCoefficient(self):
963 mypde=LinearPDE(self.domain,debug=self.DEBUG)
964 mypde.setValue(D=1.)
965 self.failUnlessRaises(RuntimeError, mypde.setReducedOrderOn)
966
967 def test_reducedOnConfig(self):
968 mypde=LinearPDE(self.domain,debug=self.DEBUG)
969 mypde.setReducedOrderOn()
970 self.failUnlessEqual((mypde.getFunctionSpaceForSolution(), mypde.getFunctionSpaceForEquation()),(ReducedSolution(self.domain),ReducedSolution(self.domain)),"reduced function spaces expected.")
971 #
972 # set coefficients for scalars:
973 #
974 def test_setCoefficient_A_Scalar(self):
975 d=self.domain.getDim()
976 mypde=LinearPDE(self.domain,debug=self.DEBUG)
977 mypde.setValue(A=numpy.ones((d,d)))
978 coeff=mypde.getCoefficient("A")
979 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),Function(self.domain),1,1))
980 def test_setCoefficient_B_Scalar(self):
981 d=self.domain.getDim()
982 mypde=LinearPDE(self.domain,debug=self.DEBUG)
983 mypde.setValue(B=numpy.ones((d,)))
984 coeff=mypde.getCoefficient("B")
985 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
986 def test_setCoefficient_C_Scalar(self):
987 d=self.domain.getDim()
988 mypde=LinearPDE(self.domain,debug=self.DEBUG)
989 mypde.setValue(C=numpy.ones((d,)))
990 coeff=mypde.getCoefficient("C")
991 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
992 def test_setCoefficient_D_Scalar(self):
993 d=self.domain.getDim()
994 mypde=LinearPDE(self.domain,debug=self.DEBUG)
995 mypde.setValue(D=1.)
996 coeff=mypde.getCoefficient("D")
997 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),Function(self.domain),1,1))
998 def test_setCoefficient_X_Scalar(self):
999 d=self.domain.getDim()
1000 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1001 mypde.setValue(X=numpy.ones((d,)))
1002 coeff=mypde.getCoefficient("X")
1003 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),Function(self.domain),1))
1004 def test_setCoefficient_Y_Scalar(self):
1005 d=self.domain.getDim()
1006 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1007 mypde.setValue(Y=1.)
1008 coeff=mypde.getCoefficient("Y")
1009 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),Function(self.domain),1))
1010 def test_setCoefficient_y_Scalar(self):
1011 d=self.domain.getDim()
1012 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1013 mypde.setValue(y=1.)
1014 coeff=mypde.getCoefficient("y")
1015 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1))
1016 def test_setCoefficient_d_Scalar(self):
1017 d=self.domain.getDim()
1018 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1019 mypde.setValue(d=1.)
1020 coeff=mypde.getCoefficient("d")
1021 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1,1))
1022 def test_setCoefficient_d_contact_Scalar(self):
1023 d=self.domain.getDim()
1024 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1025 mypde.setValue(d_contact=1.)
1026 coeff=mypde.getCoefficient("d_contact")
1027 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1,1))
1028 def test_setCoefficient_y_contact_Scalar(self):
1029 d=self.domain.getDim()
1030 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1031 mypde.setValue(y_contact=1.)
1032 coeff=mypde.getCoefficient("y_contact")
1033 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1))
1034 def test_setCoefficient_A_reduced_Scalar(self):
1035 d=self.domain.getDim()
1036 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1037 mypde.setValue(A_reduced=numpy.ones((d,d)))
1038 coeff=mypde.getCoefficient("A_reduced")
1039 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
1040 def test_setCoefficient_B_reduced_Scalar(self):
1041 d=self.domain.getDim()
1042 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1043 mypde.setValue(B_reduced=numpy.ones((d,)))
1044 coeff=mypde.getCoefficient("B_reduced")
1045 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1046 def test_setCoefficient_C_reduced_Scalar(self):
1047 d=self.domain.getDim()
1048 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1049 mypde.setValue(C_reduced=numpy.ones((d,)))
1050 coeff=mypde.getCoefficient("C_reduced")
1051 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1052 def test_setCoefficient_D_reduced_Scalar(self):
1053 d=self.domain.getDim()
1054 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1055 mypde.setValue(D_reduced=1.)
1056 coeff=mypde.getCoefficient("D_reduced")
1057 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
1058 def test_setCoefficient_X_reduced_Scalar(self):
1059 d=self.domain.getDim()
1060 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1061 mypde.setValue(X_reduced=numpy.ones((d,)))
1062 coeff=mypde.getCoefficient("X_reduced")
1063 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
1064 def test_setCoefficient_Y_reduced_Scalar(self):
1065 d=self.domain.getDim()
1066 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1067 mypde.setValue(Y_reduced=1.)
1068 coeff=mypde.getCoefficient("Y_reduced")
1069 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
1070 def test_setCoefficient_y_reduced_Scalar(self):
1071 d=self.domain.getDim()
1072 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1073 mypde.setValue(y_reduced=1.)
1074 coeff=mypde.getCoefficient("y_reduced")
1075 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
1076 def test_setCoefficient_d_reduced_Scalar(self):
1077 d=self.domain.getDim()
1078 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1079 mypde.setValue(d_reduced=1.)
1080 coeff=mypde.getCoefficient("d_reduced")
1081 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
1082 def test_setCoefficient_d_contact_reduced_Scalar(self):
1083 d=self.domain.getDim()
1084 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1085 mypde.setValue(d_contact_reduced=1.)
1086 coeff=mypde.getCoefficient("d_contact_reduced")
1087 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
1088 def test_setCoefficient_y_contact_reduced_Scalar(self):
1089 d=self.domain.getDim()
1090 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1091 mypde.setValue(y_contact_reduced=1.)
1092 coeff=mypde.getCoefficient("y_contact_reduced")
1093 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
1094 def test_setCoefficient_r_Scalar(self):
1095 d=self.domain.getDim()
1096 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1097 mypde.setValue(r=1.)
1098 coeff=mypde.getCoefficient("r")
1099 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
1100 def test_setCoefficient_q_Scalar(self):
1101 d=self.domain.getDim()
1102 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1103 mypde.setValue(q=1.)
1104 coeff=mypde.getCoefficient("q")
1105 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
1106 def test_setCoefficient_r_Scalar_reducedOn(self):
1107 d=self.domain.getDim()
1108 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1109 mypde.setReducedOrderOn()
1110 mypde.setValue(r=1.)
1111 coeff=mypde.getCoefficient("r")
1112 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
1113 def test_setCoefficient_q_Scalar_reducedOn(self):
1114 d=self.domain.getDim()
1115 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1116 mypde.setReducedOrderOn()
1117 mypde.setValue(q=1.)
1118 coeff=mypde.getCoefficient("q")
1119 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
1120
1121 def test_setCoefficient_A_reduced_Scalar_usingA(self):
1122 d=self.domain.getDim()
1123 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1124 mypde.setValue(A=Data(numpy.ones((d,d)),ReducedFunction(self.domain)))
1125 coeff=mypde.getCoefficient("A_reduced")
1126 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
1127 def test_setCoefficient_B_reduced_Scalar_usingB(self):
1128 d=self.domain.getDim()
1129 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1130 mypde.setValue(B=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1131 coeff=mypde.getCoefficient("B_reduced")
1132 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1133 def test_setCoefficient_C_reduced_Scalar_usingC(self):
1134 d=self.domain.getDim()
1135 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1136 mypde.setValue(C=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1137 coeff=mypde.getCoefficient("C_reduced")
1138 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1139 def test_setCoefficient_D_reduced_Scalar_usingD(self):
1140 d=self.domain.getDim()
1141 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1142 mypde.setValue(D=Scalar(1.,ReducedFunction(self.domain)))
1143 coeff=mypde.getCoefficient("D_reduced")
1144 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
1145 def test_setCoefficient_X_reduced_Scalar_usingX(self):
1146 d=self.domain.getDim()
1147 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1148 mypde.setValue(X_reduced=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1149 coeff=mypde.getCoefficient("X_reduced")
1150 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
1151 def test_setCoefficient_Y_reduced_Scalar_usingY(self):
1152 d=self.domain.getDim()
1153 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1154 mypde.setValue(Y=Scalar(1.,ReducedFunction(self.domain)))
1155 coeff=mypde.getCoefficient("Y_reduced")
1156 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
1157 def test_setCoefficient_y_reduced_Scalar_using_y(self):
1158 d=self.domain.getDim()
1159 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1160 mypde.setValue(y=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
1161 coeff=mypde.getCoefficient("y_reduced")
1162 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
1163 def test_setCoefficient_d_reduced_Scalar_using_d(self):
1164 d=self.domain.getDim()
1165 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1166 mypde.setValue(d=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
1167 coeff=mypde.getCoefficient("d_reduced")
1168 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
1169 def test_setCoefficient_d_contact_reduced_Scalar_using_d_contact(self):
1170 d=self.domain.getDim()
1171 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1172 mypde.setValue(d_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
1173 coeff=mypde.getCoefficient("d_contact_reduced")
1174 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
1175 def test_setCoefficient_y_contact_reduced_Scalar_using_y_contact(self):
1176 d=self.domain.getDim()
1177 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1178 mypde.setValue(y_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
1179 coeff=mypde.getCoefficient("y_contact_reduced")
1180 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
1181 #
1182 # set coefficients for systems:
1183 #
1184 def test_setCoefficient_A_System(self):
1185 d=self.domain.getDim()
1186 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1187 mypde.setValue(A=numpy.ones((self.N,d,self.N,d)))
1188 coeff=mypde.getCoefficient("A")
1189 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),Function(self.domain),self.N,self.N))
1190 def test_setCoefficient_B_System(self):
1191 d=self.domain.getDim()
1192 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1193 mypde.setValue(B=numpy.ones((self.N,d,self.N)))
1194 coeff=mypde.getCoefficient("B")
1195 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),Function(self.domain),self.N,self.N))
1196 def test_setCoefficient_C_System(self):
1197 d=self.domain.getDim()
1198 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1199 mypde.setValue(C=numpy.ones((self.N,self.N,d)))
1200 coeff=mypde.getCoefficient("C")
1201 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),Function(self.domain),self.N,self.N))
1202 def test_setCoefficient_D_System(self):
1203 d=self.domain.getDim()
1204 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1205 mypde.setValue(D=numpy.ones((self.N,self.N)))
1206 coeff=mypde.getCoefficient("D")
1207 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),Function(self.domain),self.N,self.N))
1208 def test_setCoefficient_X_System(self):
1209 d=self.domain.getDim()
1210 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1211 mypde.setValue(X=numpy.ones((self.N,d)))
1212 coeff=mypde.getCoefficient("X")
1213 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),Function(self.domain),self.N))
1214 def test_setCoefficient_Y_System(self):
1215 d=self.domain.getDim()
1216 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1217 mypde.setValue(Y=numpy.ones((self.N,)))
1218 coeff=mypde.getCoefficient("Y")
1219 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),Function(self.domain),self.N))
1220 def test_setCoefficient_y_System(self):
1221 d=self.domain.getDim()
1222 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1223 mypde.setValue(y=numpy.ones((self.N,)))
1224 coeff=mypde.getCoefficient("y")
1225 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnBoundary(self.domain),self.N))
1226 def test_setCoefficient_d_System(self):
1227 d=self.domain.getDim()
1228 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1229 mypde.setValue(d=numpy.ones((self.N,self.N)))
1230 coeff=mypde.getCoefficient("d")
1231 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnBoundary(self.domain),self.N,self.N))
1232 def test_setCoefficient_d_contact_System(self):
1233 d=self.domain.getDim()
1234 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1235 mypde.setValue(d_contact=numpy.ones((self.N,self.N)))
1236 coeff=mypde.getCoefficient("d_contact")
1237 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnContactZero(self.domain),self.N,self.N))
1238 def test_setCoefficient_y_contact_System(self):
1239 d=self.domain.getDim()
1240 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1241 mypde.setValue(y_contact=numpy.ones((self.N,)))
1242 coeff=mypde.getCoefficient("y_contact")
1243 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnContactZero(self.domain),self.N))
1244 def test_setCoefficient_A_reduced_System(self):
1245 d=self.domain.getDim()
1246 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1247 mypde.setValue(A_reduced=numpy.ones((self.N,d,self.N,d)))
1248 coeff=mypde.getCoefficient("A_reduced")
1249 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1250 def test_setCoefficient_B_reduced_System(self):
1251 d=self.domain.getDim()
1252 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1253 mypde.setValue(B_reduced=numpy.ones((self.N,d,self.N)))
1254 coeff=mypde.getCoefficient("B_reduced")
1255 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
1256 def test_setCoefficient_C_reduced_System(self):
1257 d=self.domain.getDim()
1258 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1259 mypde.setValue(C_reduced=numpy.ones((self.N,self.N,d)))
1260 coeff=mypde.getCoefficient("C_reduced")
1261 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1262 def test_setCoefficient_D_System_reduced(self):
1263 d=self.domain.getDim()
1264 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1265 mypde.setValue(D_reduced=numpy.ones((self.N,self.N)))
1266 coeff=mypde.getCoefficient("D_reduced")
1267 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
1268 def test_setCoefficient_X_System_reduced(self):
1269 d=self.domain.getDim()
1270 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1271 mypde.setValue(X_reduced=numpy.ones((self.N,d)))
1272 coeff=mypde.getCoefficient("X_reduced")
1273 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
1274 def test_setCoefficient_Y_System_reduced(self):
1275 d=self.domain.getDim()
1276 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1277 mypde.setValue(Y_reduced=numpy.ones((self.N,)))
1278 coeff=mypde.getCoefficient("Y_reduced")
1279 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
1280 def test_setCoefficient_y_System_reduced(self):
1281 d=self.domain.getDim()
1282 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1283 mypde.setValue(y_reduced=numpy.ones((self.N,)))
1284 coeff=mypde.getCoefficient("y_reduced")
1285 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
1286 def test_setCoefficient_d_reduced_System(self):
1287 d=self.domain.getDim()
1288 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1289 mypde.setValue(d_reduced=numpy.ones((self.N,self.N)))
1290 coeff=mypde.getCoefficient("d_reduced")
1291 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
1292 def test_setCoefficient_d_contact_reduced_System(self):
1293 d=self.domain.getDim()
1294 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1295 mypde.setValue(d_contact_reduced=numpy.ones((self.N,self.N)))
1296 coeff=mypde.getCoefficient("d_contact_reduced")
1297 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
1298 def test_setCoefficient_y_contact_reduced_System(self):
1299 d=self.domain.getDim()
1300 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1301 mypde.setValue(y_contact_reduced=numpy.ones((self.N,)))
1302 coeff=mypde.getCoefficient("y_contact_reduced")
1303 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
1304 def test_setCoefficient_r_System(self):
1305 d=self.domain.getDim()
1306 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1307 mypde.setValue(r=numpy.ones((self.N,)))
1308 coeff=mypde.getCoefficient("r")
1309 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
1310 def test_setCoefficient_q_System(self):
1311 d=self.domain.getDim()
1312 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1313 mypde.setValue(q=numpy.ones((self.N,)))
1314 coeff=mypde.getCoefficient("q")
1315 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
1316 def test_setCoefficient_r_System_reducedOn(self):
1317 d=self.domain.getDim()
1318 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1319 mypde.setReducedOrderOn()
1320 mypde.setValue(r=numpy.ones((self.N,)))
1321 coeff=mypde.getCoefficient("r")
1322 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
1323 def test_setCoefficient_q_System_reducedOn(self):
1324 d=self.domain.getDim()
1325 mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1326 mypde.setReducedOrderOn()
1327 mypde.setValue(q=numpy.ones((self.N,)))
1328 coeff=mypde.getCoefficient("q")
1329 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
1330
1331 def test_setCoefficient_A_reduced_System_using_A(self):
1332 d=self.domain.getDim()
1333 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1334 mypde.setValue(A=Data(numpy.ones((self.N,d,self.N,d)),ReducedFunction(self.domain)))
1335 coeff=mypde.getCoefficient("A_reduced")
1336 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1337 def test_setCoefficient_B_reduced_System_using_B(self):
1338 d=self.domain.getDim()
1339 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1340 mypde.setValue(B=Data(numpy.ones((self.N,d,self.N)),ReducedFunction(self.domain)))
1341 coeff=mypde.getCoefficient("B_reduced")
1342 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
1343 def test_setCoefficient_C_reduced_System_using_C(self):
1344 d=self.domain.getDim()
1345 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1346 mypde.setValue(C=Data(numpy.ones((self.N,self.N,d)),ReducedFunction(self.domain)))
1347 coeff=mypde.getCoefficient("C_reduced")
1348 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1349 def test_setCoefficient_D_System_reduced_using_D(self):
1350 d=self.domain.getDim()
1351 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1352 mypde.setValue(D=Data(numpy.ones((self.N,self.N)),ReducedFunction(self.domain)))
1353 coeff=mypde.getCoefficient("D_reduced")
1354 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
1355 def test_setCoefficient_X_System_reduced_using_X(self):
1356 d=self.domain.getDim()
1357 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1358 mypde.setValue(X=Data(numpy.ones((self.N,d)),ReducedFunction(self.domain)))
1359 coeff=mypde.getCoefficient("X_reduced")
1360 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
1361 def test_setCoefficient_Y_System_reduced_using_Y(self):
1362 d=self.domain.getDim()
1363 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1364 mypde.setValue(Y=Data(numpy.ones((self.N,)),ReducedFunction(self.domain)))
1365 coeff=mypde.getCoefficient("Y_reduced")
1366 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
1367 def test_setCoefficient_y_reduced_System_using_y(self):
1368 d=self.domain.getDim()
1369 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1370 mypde.setValue(y=Data(numpy.ones((self.N,)),ReducedFunctionOnBoundary(self.domain)))
1371 coeff=mypde.getCoefficient("y_reduced")
1372 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
1373 def test_setCoefficient_d_reduced_System_using_d(self):
1374 d=self.domain.getDim()
1375 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1376 mypde.setValue(d=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnBoundary(self.domain)))
1377 coeff=mypde.getCoefficient("d_reduced")
1378 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
1379 def test_setCoefficient_d_contact_reduced_System_using_d_contact(self):
1380 d=self.domain.getDim()
1381 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1382 mypde.setValue(d_contact=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnContactZero(self.domain)))
1383 coeff=mypde.getCoefficient("d_contact_reduced")
1384 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
1385 def test_setCoefficient_y_contact_reduced_System_using_y_contact(self):
1386 d=self.domain.getDim()
1387 mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1388 mypde.setValue(y_contact=Data(numpy.ones((self.N,)),ReducedFunctionOnContactZero(self.domain)))
1389 coeff=mypde.getCoefficient("y_contact_reduced")
1390 self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
1391 def test_resetCoefficient_HomogeneousConstraint(self):
1392 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1393 x=self.domain.getX()
1394 mypde.setValue(A=kronecker(self.domain),Y=1.,q=whereZero(x[0]))
1395 u1=mypde.getSolution()
1396 mypde.setValue(Y=2.)
1397 u2=mypde.getSolution()
1398 self.failUnless(self.check(u2,2*u1),'solution is wrong.')
1399
1400 def test_resetCoefficient_InHomogeneousConstraint(self):
1401 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1402 mypde.setSymmetryOn()
1403 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1404 x=self.domain.getX()
1405 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.,r=1,q=whereZero(x[0]))
1406 u1=mypde.getSolution()
1407 mypde.setValue(Y=2.,D=2)
1408 u2=mypde.getSolution()
1409 self.failUnless(self.check(u2,u1),'first solution is wrong.')
1410 u2=mypde.getSolution()
1411 self.failUnless(self.check(u2,u1),'first solution is wrong.')
1412 mypde.setValue(r=2,Y=4.)
1413 u2=mypde.getSolution()
1414 self.failUnless(self.check(u2,2*u1),'second solution is wrong.')
1415
1416 def test_Status(self):
1417 DIM=self.domain.getDim()
1418 x=self.domain.getX()
1419 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1420 mypde.getSolverOptions().setSymmetryOn()
1421 mypde.getSolverOptions().setTolerance(self.RES_TOL)
1422 mypde.setValue(A=kronecker(self.domain), q=whereZero(x[0])+whereZero(x[0]-1.), Y=2.)
1423 x1=self.domain.getX()
1424 u1_ref=x1[0]*(1.-x1[0])
1425 u1=mypde.getSolution()
1426 error1=Lsup(u1-u1_ref)/Lsup(u1_ref)
1427 self.failUnless(mypde.getDomainStatus() == mypde.getSystemStatus(), "status of first pde does not match domain status.")
1428
1429 self.domain.setX(x*5)
1430
1431 self.failUnless(mypde.getDomainStatus() != mypde.getSystemStatus(), "status of first pde matches updated domain status.")
1432 x2=self.domain.getX()
1433 u2_ref=x2[0]*(5.-x2[0])
1434 u2=mypde.getSolution()
1435 error2=Lsup(u2-u2_ref)/Lsup(u2_ref)
1436 self.failUnless(error2 <= max(error1,self.RES_TOL)*10., "solution of second PDE wrong.")
1437 self.failUnless(mypde.getDomainStatus() == mypde.getSystemStatus(), "status of second pde does not match domain status.")
1438
1439 def test_symmetryCheckTrue_System(self):
1440 d=self.domain.getDim()
1441 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1442 A=numpy.ones((self.N,d,self.N,d))
1443 C=2*numpy.ones((self.N,self.N,d))
1444 B=2*numpy.ones((self.N,d,self.N))
1445 D=3*numpy.ones((self.N,self.N))
1446 d=4*numpy.ones((self.N,self.N))
1447 d_contact=5*numpy.ones((self.N,self.N))
1448 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)
1449 self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
1450
1451 def test_symmetryCheckFalse_A_System(self):
1452 d=self.domain.getDim()
1453 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1454 A=numpy.ones((self.N,d,self.N,d))
1455 A[1,1,1,0]=0.
1456 mypde.setValue(A=A)
1457 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1458 def test_symmetryCheckFalse_BC_System(self):
1459 d=self.domain.getDim()
1460 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1461 C=2*numpy.ones((self.N,self.N,d))
1462 B=2*numpy.ones((self.N,d,self.N))
1463 B[0,0,1]=1.
1464 mypde.setValue(B=B,C=C)
1465 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1466
1467 def test_symmetryCheckFalse_D_System(self):
1468 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1469 D=3*numpy.ones((self.N,self.N))
1470 D[0,1]=0.
1471 mypde.setValue(D=D)
1472 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1473
1474 def test_symmetryCheckFalse_d_System(self):
1475 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1476 d=4*numpy.ones((self.N,self.N))
1477 d[0,1]=0.
1478 mypde.setValue(d=d)
1479 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1480
1481 def test_symmetryCheckFalse_d_contact_System(self):
1482 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1483 d_contact=5*numpy.ones((self.N,self.N))
1484 d_contact[0,1]=0.
1485 mypde.setValue(d_contact=d_contact)
1486 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1487
1488 def test_symmetryCheckFalse_A_reduced_System(self):
1489 d=self.domain.getDim()
1490 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1491 A=numpy.ones((self.N,d,self.N,d))
1492 A[1,1,1,0]=0.
1493 mypde.setValue(A_reduced=A)
1494 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1495 def test_symmetryCheckFalse_BC_reduced_System(self):
1496 d=self.domain.getDim()
1497 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1498 C=2*numpy.ones((self.N,self.N,d))
1499 B=2*numpy.ones((self.N,d,self.N))
1500 B[0,0,1]=1.
1501 mypde.setValue(B_reduced=B,C_reduced=C)
1502 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1503
1504 def test_symmetryCheckFalse_D_reduced_System(self):
1505 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1506 D=3*numpy.ones((self.N,self.N))
1507 D[0,1]=0.
1508 mypde.setValue(D_reduced=D)
1509 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1510
1511 def test_symmetryCheckFalse_d_reduced_System(self):
1512 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1513 d=4*numpy.ones((self.N,self.N))
1514 d[0,1]=0.
1515 mypde.setValue(d_reduced=d)
1516 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1517
1518 def test_symmetryCheckFalse_d_contact_reduced_System(self):
1519 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1520 d_contact=5*numpy.ones((self.N,self.N))
1521 d_contact[0,1]=0.
1522 mypde.setValue(d_contact_reduced=d_contact)
1523 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1524
1525 def test_symmetryCheckTrue_Scalar(self):
1526 d=self.domain.getDim()
1527 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1528 A=numpy.ones((d,d))
1529 C=2*numpy.ones((d,))
1530 B=2*numpy.ones((d,))
1531 D=3
1532 d=4
1533 d_contact=5
1534 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)
1535 self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
1536
1537 def test_symmetryCheckFalse_A_Scalar(self):
1538 d=self.domain.getDim()
1539 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1540 A=numpy.ones((d,d))
1541 A[1,0]=0.
1542 mypde.setValue(A=A)
1543 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1544 def test_symmetryCheckFalse_BC_Scalar(self):
1545 d=self.domain.getDim()
1546 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1547 C=2*numpy.ones((d,))
1548 B=2*numpy.ones((d,))
1549 B[0]=1.
1550 mypde.setValue(B=B,C=C)
1551 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1552 def test_symmetryCheckFalse_A_reduced_Scalar(self):
1553 d=self.domain.getDim()
1554 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1555 A=numpy.ones((d,d))
1556 A[1,0]=0.
1557 mypde.setValue(A_reduced=A)
1558 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1559 def test_symmetryCheckFalse_BC_reduced_Scalar(self):
1560 d=self.domain.getDim()
1561 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1562 C=2*numpy.ones((d,))
1563 B=2*numpy.ones((d,))
1564 B[0]=1.
1565 mypde.setValue(B_reduced=B,C_reduced=C)
1566 self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1567 #
1568 # solver checks (single PDE)
1569 #
1570 def test_symmetryOnIterative(self):
1571 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1572 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1573 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1574 u=mypde.getSolution()
1575 self.failUnless(self.check(u,1.),'solution is wrong.')
1576 def test_symmetryOnDirect(self):
1577 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1578 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1579 mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1580 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1581 u=mypde.getSolution()
1582 self.failUnless(self.check(u,1.),'solution is wrong.')
1583 def test_PCG_JACOBI(self):
1584 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1585 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1586 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1587 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1588 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1589 u=mypde.getSolution()
1590 self.failUnless(self.check(u,1.),'solution is wrong.')
1591 def test_PCG_AMG(self):
1592 if self.order!=2:
1593 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1594 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1595 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1596 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1597 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1598 u=mypde.getSolution()
1599 self.failUnless(self.check(u,1.),'solution is wrong.')
1600 def test_PCG_ILU0(self):
1601 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1602 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1603 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1604 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1605 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1606 u=mypde.getSolution()
1607 self.failUnless(self.check(u,1.),'solution is wrong.')
1608 def test_PCG_RILU(self):
1609 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1610 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1611 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1612 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1613 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1614 u=mypde.getSolution()
1615 self.failUnless(self.check(u,1.),'solution is wrong.')
1616 def test_PCG_REC_ILU(self):
1617 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1618 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1619 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1620 mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1621 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1622 u=mypde.getSolution()
1623 self.failUnless(self.check(u,1.),'solution is wrong.')
1624 def test_DIRECT(self):
1625 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1626 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1627 mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1628 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1629 u=mypde.getSolution()
1630 self.failUnless(self.check(u,1.),'solution is wrong.')
1631 def test_BICGSTAB_JACOBI(self):
1632 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1633 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1634 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1635 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1636 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1637 u=mypde.getSolution()
1638 self.failUnless(self.check(u,1.),'solution is wrong.')
1639 def test_BICGSTAB_AMG(self):
1640 if self.order!=2:
1641 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1642 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1643 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1644 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1645 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1646 u=mypde.getSolution()
1647 self.failUnless(self.check(u,1.),'solution is wrong.')
1648 def test_BICGSTAB_ILU0(self):
1649 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1650 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1651 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1652 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1653 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1654 u=mypde.getSolution()
1655 self.failUnless(self.check(u,1.),'solution is wrong.')
1656 def test_BICGSTAB_RILU(self):
1657 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1658 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1659 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1660 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1661 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1662 u=mypde.getSolution()
1663 self.failUnless(self.check(u,1.),'solution is wrong.')
1664 def test_BICGSTAB_REC_ILU(self):
1665 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1666 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1667 mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1668 mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1669 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1670 u=mypde.getSolution()
1671 self.failUnless(self.check(u,1.),'solution is wrong.')
1672 def test_MINRES_JACOBI(self):
1673 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1674 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1675 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1676 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1677 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1678 u=mypde.getSolution()
1679 self.failUnless(self.check(u,1.),'solution is wrong.')
1680 def test_MINRES_AMG(self):
1681 if self.order!=2:
1682 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1683 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1684 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1685 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1686 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1687 u=mypde.getSolution()
1688 self.failUnless(self.check(u,1.),'solution is wrong.')
1689 def test_MINRES_ILU0(self):
1690 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1691 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1692 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1693 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1694 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1695 u=mypde.getSolution()
1696 self.failUnless(self.check(u,1.),'solution is wrong.')
1697 def test_MINRES_RILU(self):
1698 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1699 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1700 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1701 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1702 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1703 u=mypde.getSolution()
1704 self.failUnless(self.check(u,1.),'solution is wrong.')
1705 def test_MINRES_REC_ILU(self):
1706 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1707 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1708 mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1709 mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1710 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1711 u=mypde.getSolution()
1712 self.failUnless(self.check(u,1.),'solution is wrong.')
1713 def test_TFQMR_JACOBI(self):
1714 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1715 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1716 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1717 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1718 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1719 u=mypde.getSolution()
1720 self.failUnless(self.check(u,1.),'solution is wrong.')
1721 def test_TFQMR_AMG(self):
1722 if self.order!=2:
1723 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1724 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1725 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1726 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1727 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1728 mypde.getSolverOptions().setVerbosity(True)
1729 u=mypde.getSolution()
1730 self.failUnless(self.check(u,1.),'solution is wrong.')
1731 def test_TFQMR_ILU0(self):
1732 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1733 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1734 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1735 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1736 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1737 u=mypde.getSolution()
1738 self.failUnless(self.check(u,1.),'solution is wrong.')
1739 def test_TFQMR_RILU(self):
1740 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1741 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1742 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1743 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1744 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1745 u=mypde.getSolution()
1746 self.failUnless(self.check(u,1.),'solution is wrong.')
1747 def test_TFQMR_REC_ILU(self):
1748 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1749 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1750 mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1751 mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1752 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1753 u=mypde.getSolution()
1754 self.failUnless(self.check(u,1.),'solution is wrong.')
1755 def test_PRES20_JACOBI(self):
1756 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1757 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1758 mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1759 mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1760 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1761 u=mypde.getSolution()
1762 self.failUnless(self.check(u,1.),'solution is wrong.')
1763 def test_PRES20_AMG(self):
1764 if self.order!=2:
1765 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1766 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1767 mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1768 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1769 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1770 u=mypde.getSolution()
1771 self.failUnless(self.check(u,1.),'solution is wrong.')
1772 def test_PRES20_ILU0(self):
1773 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1774 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1775 mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1776 mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1777 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1778 u=mypde.getSolution()
1779 self.failUnless(self.check(u,1.),'solution is wrong.')
1780 def test_PRES20_RILU(self):
1781 mypde=LinearPDE(self.domain,debug=self.DEBUG)
1782 mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1783 mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1784 mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1785 mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1786 u=mypde.getSolution()
1787 self.failUnless(