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