/[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 3837 - (show annotations)
Thu Feb 16 03:58:58 2012 UTC (7 years, 8 months ago) by caltinay
Original Path: trunk/escript/test/python/test_linearPDEs.py
File MIME type: text/x-python
File size: 194309 byte(s)
Test cleanup.

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