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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/escript/py_src/test_linearPDEs.py revision 531 by gross, Wed Feb 15 08:11:10 2006 UTC trunk/escript/test/python/test_linearPDEs.py revision 2817 by artak, Thu Dec 10 02:12:33 2009 UTC
# Line 1  Line 1 
1  # $Id$  
2    ########################################################
3    #
4    # Copyright (c) 2003-2009 by University of Queensland
5    # Earth Systems Science Computational Center (ESSCC)
6    # http://www.uq.edu.au/esscc
7    #
8    # Primary Business: Queensland, Australia
9    # Licensed under the Open Software License version 3.0
10    # http://www.opensource.org/licenses/osl-3.0.php
11    #
12    ########################################################
13    
14    __copyright__="""Copyright (c) 2003-2009 by University of Queensland
15    Earth Systems Science Computational Center (ESSCC)
16    http://www.uq.edu.au/esscc
17    Primary Business: Queensland, Australia"""
18    __license__="""Licensed under the Open Software License version 3.0
19    http://www.opensource.org/licenses/osl-3.0.php"""
20    __url__="https://launchpad.net/escript-finley"
21    
22  """  """
23  Test suite for linearPDEs class  Test suite for linearPDEs class
# Line 9  The tests must be linked with a Domain c Line 28  The tests must be linked with a Domain c
28     class Test_LinearPDEOnFinley(Test_LinearPDE):     class Test_LinearPDEOnFinley(Test_LinearPDE):
29         def setUp(self):         def setUp(self):
30             self.domain = Rectangle(10,10,2)             self.domain = Rectangle(10,10,2)
31           def tearDown(self):
32               del self.domain
33     suite = unittest.TestSuite()     suite = unittest.TestSuite()
34     suite.addTest(unittest.makeSuite(Test_LinearPDEOnFinley))     suite.addTest(unittest.makeSuite(Test_LinearPDEOnFinley))
35     unittest.TextTestRunner(verbosity=2).run(suite)     unittest.TextTestRunner(verbosity=2).run(suite)
36    
37    :var __author__: name of author
38    :var __copyright__: copyrights
39    :var __license__: licence agreement
40    :var __url__: url entry point on documentation
41    :var __version__: version
42    :var __date__: date of the version
43  """  """
44    
45  __author__="Lutz Gross, l.gross@uq.edu.au"  __author__="Lutz Gross, l.gross@uq.edu.au"
 __licence__="contact: esys@access.uq.edu.au"  
 __url__="http://www.iservo.edu.au/esys/escript"  
 __version__="$Revision$"  
 __date__="$Date$"  
   
   
46    
47  from esys.escript.util import Lsup,kronecker,interpolate,whereZero  from esys.escript.util import Lsup,kronecker,interpolate,whereZero, outer, swap_axes
48  from esys.escript import Function,FunctionOnBoundary,FunctionOnContactZero,Solution,ReducedSolution,Vector,ContinuousFunction,Scalar  from esys.escript import Function,FunctionOnBoundary,FunctionOnContactZero,Solution,ReducedSolution,Vector,ContinuousFunction,Scalar, ReducedFunction,ReducedFunctionOnBoundary,ReducedFunctionOnContactZero,Data, Tensor4, Tensor
49  from esys.escript.linearPDEs import LinearPDE,IllegalCoefficientValue,Poisson  from esys.escript.linearPDEs import LinearPDE,IllegalCoefficientValue,Poisson, IllegalCoefficientFunctionSpace, TransportPDE, IllegalCoefficient, Helmholtz, LameEquation, SolverOptions
50  import numarray  import numpy
51  import unittest  import unittest
52    
53  class Test_linearPDEs(unittest.TestCase):  class Test_linearPDEs(unittest.TestCase):
# Line 36  class Test_linearPDEs(unittest.TestCase) Line 57  class Test_linearPDEs(unittest.TestCase)
57      VERBOSE=False      VERBOSE=False
58      def check(self,arg,ref_arg,tol=None):      def check(self,arg,ref_arg,tol=None):
59          """          """
60          checks if arg and ref_arg are nearly identical using the L{Lsup<esys.escript.util.Lsup>}          checks if arg and ref_arg are nearly identical using the `Lsup`
61          """          """
62          if tol==None: tol=self.TOL          if tol==None: tol=self.TOL
63          return Lsup(arg-ref_arg)<=tol*Lsup(ref_arg)          return Lsup(arg-ref_arg)<=tol*Lsup(ref_arg)
64            
65    class Test_LameEquation(Test_linearPDEs):
66    
67        def test_config(self):
68            mypde=LameEquation(self.domain,debug=self.DEBUG)
69            d=self.domain.getDim()
70            self.failUnlessEqual((mypde.getNumEquations(), mypde.getNumSolutions(), mypde.getSolverOptions().isSymmetric()),(d,d,True),"set up incorrect")
71    
72        def test_setCoefficient_q(self):
73            mypde=LameEquation(self.domain,debug=self.DEBUG)
74            x=self.domain.getX()
75            mypde.setValue(q=x)
76    
77            q_ref=interpolate(x,Solution(self.domain))
78            self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
79            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
80            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
81            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
82            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
83            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
84            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
85            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
86            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
87            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
88            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
89            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
90            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
91            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
92            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
93            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
94            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
95            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
96            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
97            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
98            self.failUnless(self.check(mypde.getCoefficient("q"),q_ref),"q is not empty")
99            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
100    
101        def test_setCoefficient_r(self):
102            mypde=LameEquation(self.domain,debug=self.DEBUG)
103            x=self.domain.getX()
104            mypde.setValue(r=x)
105    
106            r_ref=interpolate(x,Solution(self.domain))
107            self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
108            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
109            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
110            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
111            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
112            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
113            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
114            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
115            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
116            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
117            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
118            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
119            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
120            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
121            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
122            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
123            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
124            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
125            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
126            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
127            self.failUnless(self.check(mypde.getCoefficient("r"),r_ref),"r is nor x")
128            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
129    
130    
131        def test_setCoefficient_F(self):
132            mypde=LameEquation(self.domain,debug=self.DEBUG)
133            x=self.domain.getX()
134            mypde.setValue(F=x)
135    
136            Y_ref=interpolate(x,Function(self.domain))
137            self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
138            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
139            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
140            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
141            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
142            self.failUnless(self.check(mypde.getCoefficient("Y"),Y_ref),"Y is not x")
143            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
144            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
145            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
146            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
147            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
148            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
149            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
150            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
151            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
152            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
153            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
154            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
155            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
156            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
157            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
158            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
159    
160        def test_setCoefficient_f(self):
161            mypde=LameEquation(self.domain,debug=self.DEBUG)
162            x=self.domain.getX()
163            mypde.setValue(f=x)
164    
165            y_ref=interpolate(x,FunctionOnBoundary(self.domain))
166            self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
167            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
168            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
169            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
170            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
171            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
172            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
173            self.failUnless(self.check(mypde.getCoefficient("y"),y_ref),"d is not x[0]")
174            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
175            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
176            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
177            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
178            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
179            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
180            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
181            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"X_reduced is not empty")
182            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
183            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
184            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
185            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
186            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
187            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
188    
189        def test_setCoefficient_sigma(self):
190            mypde=LameEquation(self.domain,debug=self.DEBUG)
191            x=self.domain.getX()
192            mypde.setValue(sigma=outer(x,x))
193    
194            X_ref=interpolate(outer(x,x),Function(self.domain))
195            self.failUnless(self.check(mypde.getCoefficient("A"),0),"A is not 0")
196            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
197            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
198            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
199            self.failUnless(self.check(mypde.getCoefficient("X"),X_ref),"X is not x X x")
200            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
201            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
202            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
203            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
204            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
205            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
206            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
207            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
208            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
209            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
210            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"X_reduced is not empty")
211            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
212            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
213            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
214            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
215            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
216            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
217    
218        def test_setCoefficient_lambda(self):
219            mypde=LameEquation(self.domain,debug=self.DEBUG)
220            x=self.domain.getX()
221            mypde.setValue(lame_lambda=x[0])
222    
223    
224            k3=kronecker(Function(self.domain))
225            k3Xk3=outer(k3,k3)
226            A_ref=x[0]*k3Xk3
227    
228            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
229            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
230            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
231            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
232            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
233            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
234            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
235            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
236            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
237            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
238            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
239            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
240            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
241            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
242            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
243            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
244            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
245            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
246            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
247            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
248            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
249            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
250    
251        def test_setCoefficient_mu(self):
252            mypde=LameEquation(self.domain,debug=self.DEBUG)
253            x=self.domain.getX()
254            mypde.setValue(lame_mu=x[0])
255    
256    
257            k3=kronecker(Function(self.domain))
258            k3Xk3=outer(k3,k3)
259            A_ref=x[0]*(swap_axes(k3Xk3,0,3)+swap_axes(k3Xk3,1,3))
260    
261            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
262            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
263            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
264            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
265            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
266            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
267            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
268            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
269            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
270            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
271            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
272            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
273            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
274            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
275            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
276            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
277            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
278            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
279            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
280            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
281            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
282            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
283    
284        def test_setCoefficient_lambdamu(self):
285            mypde=LameEquation(self.domain,debug=self.DEBUG)
286            x=self.domain.getX()
287            mypde.setValue(lame_lambda=x[0], lame_mu=x[1])
288    
289            k3=kronecker(Function(self.domain))
290            k3Xk3=outer(k3,k3)
291            A_ref=x[0]*k3Xk3+x[1]*(swap_axes(k3Xk3,0,3)+swap_axes(k3Xk3,1,3))
292    
293            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
294            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
295            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
296            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
297            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
298            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
299            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
300            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
301            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
302            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
303            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
304            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
305            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
306            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
307            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
308            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
309            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
310            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
311            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
312            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
313            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
314            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
315    
316        def test_solve(self):
317           d=self.domain.getDim()
318           mypde=LameEquation(self.domain)
319           cf=ContinuousFunction(self.domain)
320           x=cf.getX()
321           u_ex=x
322           msk=Vector(0.,cf)
323           for i in range(d): msk[i]=whereZero(x[i])
324           mypde.setValue(q=msk,r=u_ex,lame_mu=3,lame_lambda=50,f=(2*3+50*d)*FunctionOnBoundary(self.domain).getNormal())
325    
326           u=mypde.getSolution()
327           self.failUnless(self.check(u,u_ex,10*self.TOL),"incorrect solution")
328    
329    class Test_Helmholtz(Test_linearPDEs):
330    
331        def test_config(self):
332            mypde=Helmholtz(self.domain,debug=self.DEBUG)
333            self.failUnlessEqual((mypde.getNumEquations(), mypde.getNumSolutions(), mypde.getSolverOptions().isSymmetric()),(1,1,True),"set up incorrect")
334        def test_setCoefficient_q(self):
335            mypde=Helmholtz(self.domain,debug=self.DEBUG)
336            x=self.domain.getX()
337            mypde.setValue(q=whereZero(x[0]))
338    
339            q_ref=interpolate(whereZero(x[0]),Solution(self.domain))
340            A_ref=kronecker(self.domain)
341    
342            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
343            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
344            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
345            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
346            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
347            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
348            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
349            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
350            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
351            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
352            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
353            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
354            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
355            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
356            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
357            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
358            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
359            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
360            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
361            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
362            self.failUnless(self.check(mypde.getCoefficient("q"),q_ref),"q is not empty")
363            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
364    
365        def test_setCoefficient_r(self):
366            mypde=Helmholtz(self.domain,debug=self.DEBUG)
367            x=self.domain.getX()
368            mypde.setValue(r=x[0])
369    
370            r_ref=interpolate(x[0],Solution(self.domain))
371            A_ref=kronecker(self.domain)
372            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
373            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
374            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
375            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
376            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
377            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
378            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
379            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
380            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
381            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
382            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
383            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
384            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
385            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
386            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
387            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
388            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
389            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
390            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
391            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
392            self.failUnless(self.check(mypde.getCoefficient("r"),r_ref),"r is nor x[0]")
393            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
394    
395    
396        def test_setCoefficient_f(self):
397            mypde=Helmholtz(self.domain,debug=self.DEBUG)
398            x=self.domain.getX()
399            mypde.setValue(f=x[0])
400    
401            Y_ref=interpolate(x[0],Function(self.domain))
402            A_ref=kronecker(self.domain)
403            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
404            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
405            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
406            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
407            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
408            self.failUnless(self.check(mypde.getCoefficient("Y"),Y_ref),"Y is not x[0]")
409            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
410            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
411            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
412            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
413            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
414            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
415            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
416            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
417            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
418            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
419            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
420            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
421            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
422            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
423            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
424            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
425    
426        def test_setCoefficient_alpha(self):
427            mypde=Helmholtz(self.domain,debug=self.DEBUG)
428            x=self.domain.getX()
429            mypde.setValue(alpha=x[0])
430    
431            d_ref=interpolate(x[0],FunctionOnBoundary(self.domain))
432            A_ref=kronecker(self.domain)
433            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
434            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
435            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
436            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
437            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
438            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
439            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
440            self.failUnless(self.check(mypde.getCoefficient("d"),d_ref),"d is not x[0]")
441            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
442            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
443            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
444            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
445            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
446            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
447            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
448            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"X_reduced is not empty")
449            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
450            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
451            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
452            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
453            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
454            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
455    
456        def test_setCoefficient_g(self):
457            mypde=Helmholtz(self.domain,debug=self.DEBUG)
458            x=self.domain.getX()
459            mypde.setValue(g=x[0])
460    
461            y_ref=interpolate(x[0],FunctionOnBoundary(self.domain))
462            A_ref=kronecker(self.domain)
463            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
464            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
465            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
466            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
467            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
468            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
469            self.failUnless(self.check(mypde.getCoefficient("y"),y_ref),"y is not x[0]")
470            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
471            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
472            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
473            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
474            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
475            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
476            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
477            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
478            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
479            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
480            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
481            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
482            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
483            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
484            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
485    
486        def test_setCoefficient_omega(self):
487            mypde=Helmholtz(self.domain,debug=self.DEBUG)
488            x=self.domain.getX()
489            mypde.setValue(omega=x[0])
490    
491            D_ref=interpolate(x[0],Function(self.domain))
492            A_ref=kronecker(self.domain)
493            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
494            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
495            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
496            self.failUnless(self.check(mypde.getCoefficient("D"),D_ref),"D is not x[0]")
497            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
498            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
499            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
500            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
501            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
502            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
503            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
504            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
505            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
506            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
507            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
508            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
509            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
510            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
511            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
512            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
513            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
514            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
515    
516        def test_solve(self):
517           d=self.domain.getDim()
518           cf=ContinuousFunction(self.domain)
519           u_ex=Scalar(1.,cf)
520           mypde=Helmholtz(self.domain)
521           mypde.setValue(f=3,omega=3,alpha=2,g=2)
522           u=mypde.getSolution()
523           self.failUnless(self.check(u,u_ex,10*self.TOL),"incorrect solution")
524    
525  class Test_Poisson(Test_linearPDEs):  class Test_Poisson(Test_linearPDEs):
526    
527      def test_config(self):      def test_config(self):
528          mypde=Poisson(self.domain,debug=self.DEBUG)          mypde=Poisson(self.domain,debug=self.DEBUG)
529          self.failUnlessEqual((mypde.getNumEquations(),mypde.getNumSolutions(),mypde.isSymmetric()),(1,1,True),"set up incorrect")          self.failUnlessEqual((mypde.getNumEquations(), mypde.getNumSolutions(), mypde.getSolverOptions().isSymmetric()),(1,1,True),"set up incorrect")
530      def test_setCoefficient_q(self):      def test_setCoefficient_q(self):
531          mypde=Poisson(self.domain,debug=self.DEBUG)          mypde=Poisson(self.domain,debug=self.DEBUG)
532          x=self.domain.getX()          x=self.domain.getX()
533          q_ref=interpolate(whereZero(x[0]),Solution(self.domain))          q_ref=interpolate(whereZero(x[0]),Solution(self.domain))
534          A_ref=kronecker(self.domain)          A_ref=kronecker(self.domain)
535          mypde.setValue(q=whereZero(x[0]))          mypde.setValue(q=whereZero(x[0]))
536          self.failUnless(self.check(mypde.getCoefficientOfGeneralPDE("A"),A_ref),"A is not kronecker")          self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
537          self.failUnless(mypde.getCoefficientOfGeneralPDE("B").isEmpty(),"B is not empty")          self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
538          self.failUnless(mypde.getCoefficientOfGeneralPDE("C").isEmpty(),"C is not empty")          self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
539          self.failUnless(mypde.getCoefficientOfGeneralPDE("D").isEmpty(),"D is not empty")          self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
540          self.failUnless(mypde.getCoefficientOfGeneralPDE("X").isEmpty(),"X is not empty")          self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
541          self.failUnless(mypde.getCoefficientOfGeneralPDE("Y").isEmpty(),"Y is not empty")          self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
542          self.failUnless(mypde.getCoefficientOfGeneralPDE("y").isEmpty(),"y is not empty")          self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
543          self.failUnless(mypde.getCoefficientOfGeneralPDE("d").isEmpty(),"d is not empty")          self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
544          self.failUnless(mypde.getCoefficientOfGeneralPDE("d_contact").isEmpty(),"d_contact is not empty")          self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
545          self.failUnless(mypde.getCoefficientOfGeneralPDE("y_contact").isEmpty(),"y_contact is not empty")          self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
546          self.failUnless(self.check(mypde.getCoefficientOfGeneralPDE("q"),q_ref),"q is not empty")          self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
547          self.failUnless(mypde.getCoefficientOfGeneralPDE("r").isEmpty(),"r is not empty")          self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
548            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
549            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
550            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
551            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
552            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
553            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
554            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
555            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
556            self.failUnless(self.check(mypde.getCoefficient("q"),q_ref),"q is not empty")
557            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
558      def test_setCoefficient_f(self):      def test_setCoefficient_f(self):
559          mypde=Poisson(self.domain,debug=self.DEBUG)          mypde=Poisson(self.domain,debug=self.DEBUG)
560          x=self.domain.getX()          x=self.domain.getX()
561          Y_ref=interpolate(x[0],Function(self.domain))          Y_ref=interpolate(x[0],Function(self.domain))
562          A_ref=kronecker(self.domain)          A_ref=kronecker(self.domain)
563          mypde.setValue(f=x[0])          mypde.setValue(f=x[0])
564          self.failUnless(self.check(mypde.getCoefficientOfGeneralPDE("A"),A_ref),"A is not kronecker")          self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
565          self.failUnless(mypde.getCoefficientOfGeneralPDE("B").isEmpty(),"B is not empty")          self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
566          self.failUnless(mypde.getCoefficientOfGeneralPDE("C").isEmpty(),"C is not empty")          self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
567          self.failUnless(mypde.getCoefficientOfGeneralPDE("D").isEmpty(),"D is not empty")          self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
568          self.failUnless(mypde.getCoefficientOfGeneralPDE("X").isEmpty(),"X is not empty")          self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
569          self.failUnless(self.check(mypde.getCoefficientOfGeneralPDE("Y"),Y_ref),"Y is not x[0]")          self.failUnless(self.check(mypde.getCoefficient("Y"),Y_ref),"Y is not x[0]")
570          self.failUnless(mypde.getCoefficientOfGeneralPDE("y").isEmpty(),"y is not empty")          self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
571          self.failUnless(mypde.getCoefficientOfGeneralPDE("d").isEmpty(),"d is not empty")          self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
572          self.failUnless(mypde.getCoefficientOfGeneralPDE("d_contact").isEmpty(),"d_contact is not empty")          self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
573          self.failUnless(mypde.getCoefficientOfGeneralPDE("y_contact").isEmpty(),"y_contact is not empty")          self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
574          self.failUnless(mypde.getCoefficientOfGeneralPDE("q").isEmpty(),"q is not empty")          self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
575          self.failUnless(mypde.getCoefficientOfGeneralPDE("r").isEmpty(),"r is not empty")          self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
576            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
577            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
578            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
579            self.failUnless(mypde.getCoefficient("Y_reduced").isEmpty(),"Y_reduced is not empty")
580            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
581            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
582            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
583            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
584            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
585            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
586        def test_setCoefficient_f_reduced(self):
587            mypde=Poisson(self.domain,debug=self.DEBUG)
588            x=self.domain.getX()
589            Y_ref=interpolate(x[0],ReducedFunction(self.domain))
590            A_ref=kronecker(self.domain)
591            mypde.setValue(f_reduced=x[0])
592            self.failUnless(self.check(mypde.getCoefficient("A"),A_ref),"A is not kronecker")
593            self.failUnless(mypde.getCoefficient("B").isEmpty(),"B is not empty")
594            self.failUnless(mypde.getCoefficient("C").isEmpty(),"C is not empty")
595            self.failUnless(mypde.getCoefficient("D").isEmpty(),"D is not empty")
596            self.failUnless(mypde.getCoefficient("X").isEmpty(),"X is not empty")
597            self.failUnless(mypde.getCoefficient("Y").isEmpty(),"Y is not empty")
598            self.failUnless(mypde.getCoefficient("y").isEmpty(),"y is not empty")
599            self.failUnless(mypde.getCoefficient("d").isEmpty(),"d is not empty")
600            self.failUnless(mypde.getCoefficient("d_contact").isEmpty(),"d_contact is not empty")
601            self.failUnless(mypde.getCoefficient("y_contact").isEmpty(),"y_contact is not empty")
602            self.failUnless(mypde.getCoefficient("A_reduced").isEmpty(),"A_reduced is not empty")
603            self.failUnless(mypde.getCoefficient("B_reduced").isEmpty(),"B_reduced is not empty")
604            self.failUnless(mypde.getCoefficient("C_reduced").isEmpty(),"C_reduced is not empty")
605            self.failUnless(mypde.getCoefficient("D_reduced").isEmpty(),"D_reduced is not empty")
606            self.failUnless(mypde.getCoefficient("X_reduced").isEmpty(),"X_reduced is not empty")
607            self.failUnless(self.check(mypde.getCoefficient("Y_reduced"),Y_ref),"Y_reduced is not x[0]")
608            self.failUnless(mypde.getCoefficient("y_reduced").isEmpty(),"y_reduced is not empty")
609            self.failUnless(mypde.getCoefficient("d_reduced").isEmpty(),"d_reduced is not empty")
610            self.failUnless(mypde.getCoefficient("d_contact_reduced").isEmpty(),"d_contact_reduced is not empty")
611            self.failUnless(mypde.getCoefficient("y_contact_reduced").isEmpty(),"y_contact_reduced is not empty")
612            self.failUnless(mypde.getCoefficient("q").isEmpty(),"q is not empty")
613            self.failUnless(mypde.getCoefficient("r").isEmpty(),"r is not empty")
614      def test_solve(self):      def test_solve(self):
615         d=self.domain.getDim()         d=self.domain.getDim()
616         cf=ContinuousFunction(self.domain)         cf=ContinuousFunction(self.domain)
# Line 109  class Test_Poisson(Test_linearPDEs): Line 638  class Test_Poisson(Test_linearPDEs):
638         u=mypde.getSolution()         u=mypde.getSolution()
639         self.failUnless(self.check(u,u_ex,10*self.TOL),"incorrect solution")         self.failUnless(self.check(u,u_ex,10*self.TOL),"incorrect solution")
640    
641  class Test_LinearPDE(Test_linearPDEs):  class Test_LinearPDE_noLumping(Test_linearPDEs):
642      N=4      N=4
643        def test_SolverOptions(self):
644            so=SolverOptions()
645    
646            self.failUnless(so.getLevelMax() == 3, "initial  LevelMax is wrong.")
647            self.failUnlessRaises(ValueError,so.setLevelMax,-1)
648            so.setLevelMax(20)
649            self.failUnless(so.getLevelMax() == 20, "LevelMax is wrong.")
650    
651            self.failUnless(so.getCoarseningThreshold() == 0.25, "initial  CoarseningThreshold is wrong.")
652            self.failUnlessRaises(ValueError,so.setCoarseningThreshold,-1)
653            so.setCoarseningThreshold(0.1)
654            self.failUnless(so.getCoarseningThreshold() == 0.1, "CoarseningThreshold is wrong.")
655            
656            self.failUnless(so.getMinCoarseMatrixSize() == 500, "initial  Minimum Coarse Matrix Size is wrong.")
657            self.failUnlessRaises(ValueError,so.setMinCoarseMatrixSize,-1)
658            so.setMinCoarseMatrixSize(1000)
659            self.failUnless(so.getMinCoarseMatrixSize() == 1000, "Minimum Coarse Matrix Size is wrong.")
660    
661            self.failUnless(so.getNumSweeps() == 2, "initial  Sweeps is wrong.")
662            self.failUnlessRaises(ValueError,so.setNumSweeps,-1)
663            so.setNumSweeps(3)
664            self.failUnless(so.getNumSweeps() == 3, "Sweeps is wrong.")
665    
666            self.failUnless(so.getNumPreSweeps() == 2, "initial  PreSweeps is wrong.")
667            self.failUnlessRaises(ValueError,so.setNumPreSweeps,-1)
668            so.setNumPreSweeps(4)
669            self.failUnless(so.getNumPreSweeps() == 4, "PreSweeps is wrong.")
670    
671            self.failUnless(so.getNumPostSweeps() == 2, "initial  PreSweeps is wrong.")
672            self.failUnlessRaises(ValueError,so.setNumPostSweeps,-1)
673            so.setNumPostSweeps(5)
674            self.failUnless(so.getNumPostSweeps() == 5, "PreSweeps is wrong.")
675    
676            self.failUnless(so.getTolerance() == 1.e-8, "initial Tolerance is wrong.")
677            self.failUnlessRaises(ValueError,so.setTolerance,-1)
678            so.setTolerance(0.2)
679            self.failUnless(so.getTolerance() == 0.2, "Tolerance is wrong.")
680    
681            self.failUnless(so.getAbsoluteTolerance() == 0., "initial  AbsoluteTolerance is wrong.")
682            self.failUnlessRaises(ValueError,so.setAbsoluteTolerance,-1)
683            so.setAbsoluteTolerance(0.3)
684            self.failUnless(so.getAbsoluteTolerance() == 0.3, "AbsoluteTolerance is wrong.")
685    
686            self.failUnless(so.getInnerTolerance() == 0.9, "initial InnerTolerance is wrong.")
687            self.failUnlessRaises(ValueError,so.setInnerTolerance,-1)
688            so.setInnerTolerance(0.4)
689            self.failUnless(so.getInnerTolerance() == 0.4, "InnerTolerance is wrong.")
690    
691            self.failUnless(so.getDropTolerance() == 0.01, "initial DropTolerance is wrong.")
692            self.failUnlessRaises(ValueError,so.setDropTolerance,-1)
693            so.setDropTolerance(0.5)
694            self.failUnless(so.getDropTolerance() == 0.5, "DropDropTolerance is wrong.")
695    
696            self.failUnless(so.getDropStorage() == 2., "initial DropStorage is wrong.")
697            self.failUnlessRaises(ValueError,so.setDropStorage,-1)
698            so.setDropStorage(10)
699            self.failUnless(so.getDropStorage() == 10, "DropStorage is wrong.")
700            
701            self.failUnless(so.getRelaxationFactor() == 0.3, "initial RelaxationFactor is wrong.")
702            self.failUnlessRaises(ValueError,so.setRelaxationFactor,-1)
703            so.setRelaxationFactor(0.1)
704            self.failUnless(so.getRelaxationFactor() == 0.1, "Relaxation is wrong.")
705    
706    
707            self.failUnless(so.getIterMax() == 100000, "initial IterMax is wrong.")
708            self.failUnlessRaises(ValueError,so.setIterMax,0)
709            so.setIterMax(11)
710            self.failUnless(so.getIterMax() == 11, "IterMax is wrong.")
711    
712            self.failUnless(so.getInnerIterMax() == 10, "initial InnerIterMax is wrong.")
713            self.failUnlessRaises(ValueError,so.setInnerIterMax,0)
714            so.setInnerIterMax(12)
715            self.failUnless(so.getInnerIterMax() == 12, "InnerIterMax is wrong.")
716    
717            self.failUnless(so.getTruncation() == 20, "initial Truncation is wrong.")
718            self.failUnlessRaises(ValueError,so.setTruncation,0)
719            so.setTruncation(13)
720            self.failUnless(so.getTruncation() == 13, "Truncation is wrong.")
721    
722            self.failUnless(so.getRestart() == None, "initial Truncation is wrong.")
723            self.failUnlessRaises(ValueError,so.setTruncation,0)
724            so.setRestart(14)
725            self.failUnless(so.getRestart() == 14, "Truncation is wrong.")
726            so.setRestart(None)
727            self.failUnless(so.getRestart() == None, "Truncation is wrong.")
728        
729            self.failUnless(not so.isVerbose(), "initial verbosity flag is wrong.")
730            so.setVerbosityOn()
731            self.failUnless(so.isVerbose(), "verbosity (1) flag is wrong.")
732            so.setVerbosityOff()
733            self.failUnless(not so.isVerbose(), "verbosity (2) flag is wrong.")
734            so.setVerbosity(verbose=True)
735            self.failUnless(so.isVerbose(), "verbosity (3) flag is wrong.")
736            so.setVerbosity(verbose=False)
737            self.failUnless(not so.isVerbose(), "verbosity (4) flag is wrong.")
738    
739            self.failUnless(not so.isSymmetric(), "initial symmetry flag is wrong.")
740            so.setSymmetryOn()
741            self.failUnless(so.isSymmetric(), "symmetry (1) flag is wrong.")
742            so.setSymmetryOff()
743            self.failUnless(not so.isSymmetric(), "symmetry (2) flag is wrong.")
744            so.setSymmetry(flag=True)
745            self.failUnless(so.isSymmetric(), "symmetry (3) flag is wrong.")
746            so.setSymmetry(flag=False)
747            self.failUnless(not so.isSymmetric(), "symmetry (4) flag is wrong.")
748    
749            self.failUnless(so.adaptInnerTolerance(), "initial InnerToleranceAdaption flag is wrong.")
750            so.setInnerToleranceAdaptionOn()
751            self.failUnless(so.adaptInnerTolerance(), "InnerToleranceAdaption (1) flag is wrong.")
752            so.setInnerToleranceAdaptionOff()
753            self.failUnless(not so.adaptInnerTolerance(), "InnerToleranceAdaption (2) flag is wrong.")
754            so.setInnerToleranceAdaption(adapt=True)
755            self.failUnless(so.adaptInnerTolerance(), "InnerToleranceAdaption (3) flag is wrong.")
756            so.setInnerToleranceAdaption(adapt=False)
757            self.failUnless(not so.adaptInnerTolerance(), "InnerToleranceAdaption (4) flag is wrong.")
758        
759            self.failUnless(not so.acceptConvergenceFailure(), "initial acceptConvergenceFailure flag is wrong.")
760            so.setAcceptanceConvergenceFailureOn()
761            self.failUnless(so.acceptConvergenceFailure(), "acceptConvergenceFailure (1) flag is wrong.")
762            so.setAcceptanceConvergenceFailureOff()
763            self.failUnless(not so.acceptConvergenceFailure(), "acceptConvergenceFailure (2) flag is wrong.")
764            so.setAcceptanceConvergenceFailure(accept=True)
765            self.failUnless(so.acceptConvergenceFailure(), "acceptConvergenceFailure (3) flag is wrong.")
766            so.setAcceptanceConvergenceFailure(accept=False)
767            self.failUnless(not so.acceptConvergenceFailure(), "acceptConvergenceFailure (4) flag is wrong.")  
768            
769            self.failUnless(so.getReordering() == 30, "initial Reordering is wrong.")
770            self.failUnlessRaises(ValueError,so.setReordering,-1)
771            so.setReordering(so.NO_REORDERING)
772            self.failUnless(so.getReordering() == 17, "NO_REORDERING is not set.")
773            so.setReordering(so.MINIMUM_FILL_IN)
774            self.failUnless(so.getReordering() == 18, "MINIMUM_FILL_IN is not set.")
775            so.setReordering(so.NESTED_DISSECTION)
776            self.failUnless(so.getReordering() == 19, "NESTED_DISSECTION is not set.")
777            so.setReordering(so.DEFAULT_REORDERING)
778            self.failUnless(so.getReordering() == 30, "DEFAULT_REORDERING is not set.")
779            
780            self.failUnless(so.getPackage() == 0, "initial solver package is wrong.")
781            self.failUnlessRaises(ValueError,so.setPackage,-1)
782            so.setPackage(so.PASO)
783            self.failUnless(so.getPackage() == 21, "PASO is not set.")
784            so.setPackage(so.SUPER_LU)
785            self.failUnless(so.getPackage() == 31, "SUPER_LU is not set.")
786            so.setPackage(so.PASTIX)
787            self.failUnless(so.getPackage() == 32, "PASTIX is not set.")
788            so.setPackage(so.MKL)
789            self.failUnless(so.getPackage() == 15, "MKL is not set.")
790            so.setPackage(so.UMFPACK)
791            self.failUnless(so.getPackage() == 16, "UMFPACK is not set.")
792            so.setPackage(so.TRILINOS)
793            self.failUnless(so.getPackage() == 24, "TRILINOS is not set.")
794    
795            self.failUnless(so.getSolverMethod() == 0, "initial SolverMethod is wrong.")
796            self.failUnlessRaises(ValueError,so.setSolverMethod,-1)
797            so.setSolverMethod(so.DIRECT)
798            self.failUnless(so.getSolverMethod() == 1, "DIRECT is not set.")
799            so.setSolverMethod(so.CHOLEVSKY)
800            self.failUnless(so.getSolverMethod() == 2, "CHOLEVSKY is not set.")
801            so.setSolverMethod(so.PCG)
802            self.failUnless(so.getSolverMethod() == 3, "PCG is not set.")
803            so.setSolverMethod(so.CR)
804            self.failUnless(so.getSolverMethod() == 4, "CR is not set.")
805            so.setSolverMethod(so.CGS)
806            self.failUnless(so.getSolverMethod() == 5, "CGS is not set.")
807            so.setSolverMethod(so.BICGSTAB)
808            self.failUnless(so.getSolverMethod() == 6, "BICGSTAB is not set.")
809            so.setSolverMethod(so.SSOR)
810            self.failUnless(so.getSolverMethod() == 7, "SSOR is not set.")
811            so.setSolverMethod(so.GMRES)
812            self.failUnless(so.getSolverMethod() == 11, "GMRES is not set.")
813            so.setSolverMethod(so.PRES20)
814            self.failUnless(so.getSolverMethod() == 12, "PRES20 is not set.")
815            so.setSolverMethod(so.LUMPING)
816            self.failUnless(so.getSolverMethod() == 13, "LUMPING is not set.")
817            so.setSolverMethod(so.ITERATIVE)
818            self.failUnless(so.getSolverMethod() == 20, "ITERATIVE is not set.")
819            so.setSolverMethod(so.AMG)
820            self.failUnless(so.getSolverMethod() == 22, "AMG is not set.")
821            so.setSolverMethod(so.NONLINEAR_GMRES)
822            self.failUnless(so.getSolverMethod() == 25, "NONLINEAR_GMRES is not set.")
823            so.setSolverMethod(so.TFQMR)
824            self.failUnless(so.getSolverMethod() == 26, "TFQMR is not set.")
825            so.setSolverMethod(so.MINRES)
826            self.failUnless(so.getSolverMethod() == 27, "MINRES is not set.")
827            so.setSolverMethod(so.GAUSS_SEIDEL)
828            self.failUnless(so.getSolverMethod() == 28, "GAUSS_SEIDEL is not set.")
829            so.setSolverMethod(so.DEFAULT)
830            self.failUnless(so.getSolverMethod() == 0, "DEFAULT is not set.")
831    
832            self.failUnless(so.getPreconditioner() == 10, "initial Preconditioner is wrong.")
833            self.failUnlessRaises(ValueError,so.setPreconditioner,-1)
834            so.setPreconditioner(so.ILU0)
835            self.failUnless(so.getPreconditioner() == 8, "ILU0 is not set.")
836            so.setPreconditioner(so.SSOR)
837            self.failUnless(so.getPreconditioner() == 7, "SSOR is not set.")
838            so.setPreconditioner(so.ILUT)
839            self.failUnless(so.getPreconditioner() == 9, "ILUT is not set.")
840            so.setPreconditioner(so.JACOBI)
841            self.failUnless(so.getPreconditioner() == 10, "JACOBI is not set.")
842            so.setPreconditioner(so.AMG)
843            self.failUnless(so.getPreconditioner() == 22, "AMG is not set.")
844            so.setPreconditioner(so.REC_ILU)
845            self.failUnless(so.getPreconditioner() == 23, "REC_ILU is not set.")
846            so.setPreconditioner(so.GAUSS_SEIDEL)
847            self.failUnless(so.getPreconditioner() == 28, "GAUSS_SEIDEL is not set.")
848            so.setPreconditioner(so.RILU)
849            self.failUnless(so.getPreconditioner() == 29, "RILU is not set.")
850            so.setPreconditioner(so.NO_PRECONDITIONER)
851            self.failUnless(so.getPreconditioner() == 36, "NO_PRECONDITIONER is not set.")        
852    
853            self.failUnless(so.getCoarsening() == 0, "initial Coarseningr is wrong.")
854            self.failUnlessRaises(ValueError,so.setCoarsening,-1)
855            so.setCoarsening(so.YAIR_SHAPIRA_COARSENING)
856            self.failUnless(so.getCoarsening() == 33, "YAIR_SHAPIRA_COARSENING is not set.")
857            so.setCoarsening(so.RUGE_STUEBEN_COARSENING)
858            self.failUnless(so.getCoarsening() == 34, "RUGE_STUEBEN_COARSENING is not set.")
859            so.setCoarsening(so.AGGREGATION_COARSENING)
860            self.failUnless(so.getCoarsening() == 35, "AGREGATION_COARSENING is not set.")
861            so.setCoarsening(so.STANDARD_COARSENING)
862            self.failUnless(so.getCoarsening() == 39, "STANDARD_COARSENING is not set.")
863            so.setCoarsening(so.DEFAULT)
864            self.failUnless(so.getCoarsening() == 0, "DEFAULT is not set.")
865    
866            self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
867            self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
868            self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
869            self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
870            self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
871            self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
872            self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong.")
873            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 0, "initial cum_num_inner_iter is wrong.")
874            self.failUnless(so.getDiagnostics("cum_num_iter") == 0, "initial cum_num_iter is wrong.")
875            self.failUnless(so.getDiagnostics("cum_time") ==0, "initial cum_time is wrong.")
876            self.failUnless(so.getDiagnostics("cum_set_up_time") == 0, "initial cum_set_up_time is wrong.")
877    
878            so._updateDiagnostics("num_iter",1)
879            so._updateDiagnostics("num_inner_iter",2)
880            so._updateDiagnostics("time",3)
881            so._updateDiagnostics("set_up_time",4)
882            so._updateDiagnostics("residual_norm",5)
883            so._updateDiagnostics("converged",True)
884    
885            self.failUnless(so.getDiagnostics("num_iter") == 1, "num_iter is wrong.")
886            self.failUnless(so.getDiagnostics("num_inner_iter") == 2, "num_inner_iter is wrong.")
887            self.failUnless(so.getDiagnostics("time") == 3, "time is wrong.")
888            self.failUnless(so.getDiagnostics("set_up_time") == 4, "set_up_time is wrong.")
889            self.failUnless(so.getDiagnostics("residual_norm") == 5, "residual_norm is wrong.")
890            self.failUnless(so.getDiagnostics("converged"), "converged is wrong.")
891            self.failUnless(so.hasConverged(), "convergence flag is wrong.")
892            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 2, "cum_num_inner_iter is wrong.")
893            self.failUnless(so.getDiagnostics("cum_num_iter") == 1, "cum_num_iter is wrong.")
894            self.failUnless(so.getDiagnostics("cum_time") ==3, "cum_time is wrong.")
895            self.failUnless(so.getDiagnostics("cum_set_up_time") == 4, "cum_set_up_time is wrong.")  
896            
897            so.resetDiagnostics()
898            self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
899            self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
900            self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
901            self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
902            self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
903            self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
904            self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong")      
905            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 2, "cum_num_inner_iter is wrong.")
906            self.failUnless(so.getDiagnostics("cum_num_iter") == 1, "cum_num_iter is wrong.")
907            self.failUnless(so.getDiagnostics("cum_time") ==3, "cum_time is wrong.")
908            self.failUnless(so.getDiagnostics("cum_set_up_time") == 4, "cum_set_up_time is wrong.")
909    
910            so._updateDiagnostics("num_iter",10)
911            so._updateDiagnostics("num_inner_iter",20)
912            so._updateDiagnostics("time",30)
913            so._updateDiagnostics("set_up_time",40)
914            so._updateDiagnostics("residual_norm",50)
915            so._updateDiagnostics("converged",False)
916    
917            self.failUnless(so.getDiagnostics("num_iter") == 10, "num_iter is wrong.")
918            self.failUnless(so.getDiagnostics("num_inner_iter") == 20, "num_inner_iter is wrong.")
919            self.failUnless(so.getDiagnostics("time") == 30, "time is wrong.")
920            self.failUnless(so.getDiagnostics("set_up_time") == 40, "set_up_time is wrong.")
921            self.failUnless(so.getDiagnostics("residual_norm") == 50, "residual_norm is wrong.")
922            self.failUnless(not so.getDiagnostics("converged"), "converged is wrong.")
923            self.failUnless(not so.hasConverged(), "convergence flag is wrong.")
924            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 22, "cum_num_inner_iter is wrong.")
925            self.failUnless(so.getDiagnostics("cum_num_iter") == 11, "cum_num_iter is wrong.")
926            self.failUnless(so.getDiagnostics("cum_time") ==33, "cum_time is wrong.")
927            self.failUnless(so.getDiagnostics("cum_set_up_time") == 44, "cum_set_up_time is wrong.")  
928    
929            so.resetDiagnostics(all=True)
930            self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
931            self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
932            self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
933            self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
934            self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
935            self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
936            self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong.")
937            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 0, "initial cum_num_inner_iter is wrong.")
938            self.failUnless(so.getDiagnostics("cum_num_iter") == 0, "initial cum_num_iter is wrong.")
939            self.failUnless(so.getDiagnostics("cum_time") ==0, "initial cum_time is wrong.")
940            self.failUnless(so.getDiagnostics("cum_set_up_time") == 0, "initial cum_set_up_time is wrong.")
941            
942      def test_setCoefficient_WithIllegalFunctionSpace(self):      def test_setCoefficient_WithIllegalFunctionSpace(self):
943          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
944          try:          self.failUnlessRaises(IllegalCoefficientFunctionSpace, mypde.setValue, C=Vector(0.,FunctionOnBoundary(self.domain)))
945             success=True  
946             mypde.setValue(C=Vector(0.,FunctionOnBoundary(self.domain)))      def test_setCoefficient_WithWrongName(self):
947          except IllegalCoefficientValue:          mypde=LinearPDE(self.domain,debug=self.DEBUG)
948             success=False          self.failUnlessRaises(IllegalCoefficient, mypde.setValue, ROMA=0.)
949          self.failUnless(not success,'inapropraite function space accepted')  
           
950      def test_resetCoefficient_WithWrongShape(self):      def test_resetCoefficient_WithWrongShape(self):
951          mypde=LinearPDE(self.domain,numEquations=2,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=2,debug=self.DEBUG)
952          try:          self.failUnlessRaises(IllegalCoefficientValue, mypde.setValue, C=0.)
953             success=True  
            mypde.setValue(C=0.)  
         except IllegalCoefficientValue:  
            success=False  
         self.failUnless(not success,'illegal shape accepted')  
954      def test_reducedOn(self):      def test_reducedOn(self):
955          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
956          x=self.domain.getX()          x=self.domain.getX()
# Line 139  class Test_LinearPDE(Test_linearPDEs): Line 962  class Test_LinearPDE(Test_linearPDEs):
962      def test_attemptToChangeOrderAfterDefinedCoefficient(self):      def test_attemptToChangeOrderAfterDefinedCoefficient(self):
963          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
964          mypde.setValue(D=1.)          mypde.setValue(D=1.)
965          try:          self.failUnlessRaises(RuntimeError, mypde.setReducedOrderOn)
            success=True  
            mypde.setReducedOrderOn()  
         except RuntimeError:  
            success=False  
         self.failUnless(not success,'alterion of order after coefficient is changed not detected.')  
966    
967      def test_reducedOnConfig(self):      def test_reducedOnConfig(self):
968          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
969          mypde.setReducedOrderOn()          mypde.setReducedOrderOn()
970          self.failUnlessEqual((mypde.getFunctionSpaceForSolution(),mypde.getFunctionSpaceForEquation()),(ReducedSolution(self.domain),ReducedSolution(self.domain)),"reduced function spaces expected.")          self.failUnlessEqual((mypde.getFunctionSpaceForSolution(), mypde.getFunctionSpaceForEquation()),(ReducedSolution(self.domain),ReducedSolution(self.domain)),"reduced function spaces expected.")
971      #      #
972      #  set coefficients for scalars:      #  set coefficients for scalars:
973      #      #
974      def test_setCoefficient_A_Scalar(self):      def test_setCoefficient_A_Scalar(self):
975          d=self.domain.getDim()          d=self.domain.getDim()
976          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
977          mypde.setValue(A=numarray.ones((d,d)))          mypde.setValue(A=numpy.ones((d,d)))
978          coeff=mypde.getCoefficientOfGeneralPDE("A")          coeff=mypde.getCoefficient("A")
979          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((d,d),Function(self.domain),1,1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),Function(self.domain),1,1))
980      def test_setCoefficient_B_Scalar(self):      def test_setCoefficient_B_Scalar(self):
981          d=self.domain.getDim()          d=self.domain.getDim()
982          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
983          mypde.setValue(B=numarray.ones((d,)))          mypde.setValue(B=numpy.ones((d,)))
984          coeff=mypde.getCoefficientOfGeneralPDE("B")          coeff=mypde.getCoefficient("B")
985          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((d,),Function(self.domain),1,1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
986      def test_setCoefficient_C_Scalar(self):      def test_setCoefficient_C_Scalar(self):
987          d=self.domain.getDim()          d=self.domain.getDim()
988          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
989          mypde.setValue(C=numarray.ones((d,)))          mypde.setValue(C=numpy.ones((d,)))
990          coeff=mypde.getCoefficientOfGeneralPDE("C")          coeff=mypde.getCoefficient("C")
991          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((d,),Function(self.domain),1,1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
992      def test_setCoefficient_D_Scalar(self):      def test_setCoefficient_D_Scalar(self):
993          d=self.domain.getDim()          d=self.domain.getDim()
994          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
995          mypde.setValue(D=1.)          mypde.setValue(D=1.)
996          coeff=mypde.getCoefficientOfGeneralPDE("D")          coeff=mypde.getCoefficient("D")
997          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((),Function(self.domain),1,1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),Function(self.domain),1,1))
998      def test_setCoefficient_X_Scalar(self):      def test_setCoefficient_X_Scalar(self):
999          d=self.domain.getDim()          d=self.domain.getDim()
1000          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1001          mypde.setValue(X=numarray.ones((d,)))          mypde.setValue(X=numpy.ones((d,)))
1002          coeff=mypde.getCoefficientOfGeneralPDE("X")          coeff=mypde.getCoefficient("X")
1003          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((d,),Function(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),Function(self.domain),1))
1004      def test_setCoefficient_Y_Scalar(self):      def test_setCoefficient_Y_Scalar(self):
1005          d=self.domain.getDim()          d=self.domain.getDim()
1006          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1007          mypde.setValue(Y=1.)          mypde.setValue(Y=1.)
1008          coeff=mypde.getCoefficientOfGeneralPDE("Y")          coeff=mypde.getCoefficient("Y")
1009          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((),Function(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),Function(self.domain),1))
1010      def test_setCoefficient_y_Scalar(self):      def test_setCoefficient_y_Scalar(self):
1011          d=self.domain.getDim()          d=self.domain.getDim()
1012          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1013          mypde.setValue(y=1.)          mypde.setValue(y=1.)
1014          coeff=mypde.getCoefficientOfGeneralPDE("y")          coeff=mypde.getCoefficient("y")
1015          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1))
1016      def test_setCoefficient_d_Scalar(self):      def test_setCoefficient_d_Scalar(self):
1017          d=self.domain.getDim()          d=self.domain.getDim()
1018          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1019          mypde.setValue(d=1.)          mypde.setValue(d=1.)
1020          coeff=mypde.getCoefficientOfGeneralPDE("d")          coeff=mypde.getCoefficient("d")
1021          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1,1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1,1))
1022      def test_setCoefficient_d_contact_Scalar(self):      def test_setCoefficient_d_contact_Scalar(self):
1023          d=self.domain.getDim()          d=self.domain.getDim()
1024          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1025          mypde.setValue(d_contact=1.)          mypde.setValue(d_contact=1.)
1026          coeff=mypde.getCoefficientOfGeneralPDE("d_contact")          coeff=mypde.getCoefficient("d_contact")
1027          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1,1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1,1))
1028      def test_setCoefficient_y_contact_Scalar(self):      def test_setCoefficient_y_contact_Scalar(self):
1029          d=self.domain.getDim()          d=self.domain.getDim()
1030          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1031          mypde.setValue(y_contact=1.)          mypde.setValue(y_contact=1.)
1032          coeff=mypde.getCoefficientOfGeneralPDE("y_contact")          coeff=mypde.getCoefficient("y_contact")
1033          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1))
1034        def test_setCoefficient_A_reduced_Scalar(self):
1035            d=self.domain.getDim()
1036            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1037            mypde.setValue(A_reduced=numpy.ones((d,d)))
1038            coeff=mypde.getCoefficient("A_reduced")
1039            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
1040        def test_setCoefficient_B_reduced_Scalar(self):
1041            d=self.domain.getDim()
1042            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1043            mypde.setValue(B_reduced=numpy.ones((d,)))
1044            coeff=mypde.getCoefficient("B_reduced")
1045            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1046        def test_setCoefficient_C_reduced_Scalar(self):
1047            d=self.domain.getDim()
1048            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1049            mypde.setValue(C_reduced=numpy.ones((d,)))
1050            coeff=mypde.getCoefficient("C_reduced")
1051            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1052        def test_setCoefficient_D_reduced_Scalar(self):
1053            d=self.domain.getDim()
1054            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1055            mypde.setValue(D_reduced=1.)
1056            coeff=mypde.getCoefficient("D_reduced")
1057            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
1058        def test_setCoefficient_X_reduced_Scalar(self):
1059            d=self.domain.getDim()
1060            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1061            mypde.setValue(X_reduced=numpy.ones((d,)))
1062            coeff=mypde.getCoefficient("X_reduced")
1063            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
1064        def test_setCoefficient_Y_reduced_Scalar(self):
1065            d=self.domain.getDim()
1066            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1067            mypde.setValue(Y_reduced=1.)
1068            coeff=mypde.getCoefficient("Y_reduced")
1069            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
1070        def test_setCoefficient_y_reduced_Scalar(self):
1071            d=self.domain.getDim()
1072            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1073            mypde.setValue(y_reduced=1.)
1074            coeff=mypde.getCoefficient("y_reduced")
1075            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
1076        def test_setCoefficient_d_reduced_Scalar(self):
1077            d=self.domain.getDim()
1078            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1079            mypde.setValue(d_reduced=1.)
1080            coeff=mypde.getCoefficient("d_reduced")
1081            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
1082        def test_setCoefficient_d_contact_reduced_Scalar(self):
1083            d=self.domain.getDim()
1084            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1085            mypde.setValue(d_contact_reduced=1.)
1086            coeff=mypde.getCoefficient("d_contact_reduced")
1087            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
1088        def test_setCoefficient_y_contact_reduced_Scalar(self):
1089            d=self.domain.getDim()
1090            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1091            mypde.setValue(y_contact_reduced=1.)
1092            coeff=mypde.getCoefficient("y_contact_reduced")
1093            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
1094      def test_setCoefficient_r_Scalar(self):      def test_setCoefficient_r_Scalar(self):
1095          d=self.domain.getDim()          d=self.domain.getDim()
1096          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1097          mypde.setValue(r=1.)          mypde.setValue(r=1.)
1098          coeff=mypde.getCoefficientOfGeneralPDE("r")          coeff=mypde.getCoefficient("r")
1099          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((),Solution(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
1100      def test_setCoefficient_q_Scalar(self):      def test_setCoefficient_q_Scalar(self):
1101          d=self.domain.getDim()          d=self.domain.getDim()
1102          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1103          mypde.setValue(q=1.)          mypde.setValue(q=1.)
1104          coeff=mypde.getCoefficientOfGeneralPDE("q")          coeff=mypde.getCoefficient("q")
1105          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((),Solution(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
1106      def test_setCoefficient_r_Scalar_reducedOn(self):      def test_setCoefficient_r_Scalar_reducedOn(self):
1107          d=self.domain.getDim()          d=self.domain.getDim()
1108          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1109          mypde.setReducedOrderOn()          mypde.setReducedOrderOn()
1110          mypde.setValue(r=1.)          mypde.setValue(r=1.)
1111          coeff=mypde.getCoefficientOfGeneralPDE("r")          coeff=mypde.getCoefficient("r")
1112          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
1113      def test_setCoefficient_q_Scalar_reducedOn(self):      def test_setCoefficient_q_Scalar_reducedOn(self):
1114          d=self.domain.getDim()          d=self.domain.getDim()
1115          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1116          mypde.setReducedOrderOn()          mypde.setReducedOrderOn()
1117          mypde.setValue(q=1.)          mypde.setValue(q=1.)
1118          coeff=mypde.getCoefficientOfGeneralPDE("q")          coeff=mypde.getCoefficient("q")
1119          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
1120    
1121        def test_setCoefficient_A_reduced_Scalar_usingA(self):
1122            d=self.domain.getDim()
1123            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1124            mypde.setValue(A=Data(numpy.ones((d,d)),ReducedFunction(self.domain)))
1125            coeff=mypde.getCoefficient("A_reduced")
1126            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
1127        def test_setCoefficient_B_reduced_Scalar_usingB(self):
1128            d=self.domain.getDim()
1129            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1130            mypde.setValue(B=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1131            coeff=mypde.getCoefficient("B_reduced")
1132            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1133        def test_setCoefficient_C_reduced_Scalar_usingC(self):
1134            d=self.domain.getDim()
1135            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1136            mypde.setValue(C=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1137            coeff=mypde.getCoefficient("C_reduced")
1138            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1139        def test_setCoefficient_D_reduced_Scalar_usingD(self):
1140            d=self.domain.getDim()
1141            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1142            mypde.setValue(D=Scalar(1.,ReducedFunction(self.domain)))
1143            coeff=mypde.getCoefficient("D_reduced")
1144            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
1145        def test_setCoefficient_X_reduced_Scalar_usingX(self):
1146            d=self.domain.getDim()
1147            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1148            mypde.setValue(X_reduced=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1149            coeff=mypde.getCoefficient("X_reduced")
1150            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
1151        def test_setCoefficient_Y_reduced_Scalar_usingY(self):
1152            d=self.domain.getDim()
1153            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1154            mypde.setValue(Y=Scalar(1.,ReducedFunction(self.domain)))
1155            coeff=mypde.getCoefficient("Y_reduced")
1156            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
1157        def test_setCoefficient_y_reduced_Scalar_using_y(self):
1158            d=self.domain.getDim()
1159            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1160            mypde.setValue(y=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
1161            coeff=mypde.getCoefficient("y_reduced")
1162            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
1163        def test_setCoefficient_d_reduced_Scalar_using_d(self):
1164            d=self.domain.getDim()
1165            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1166            mypde.setValue(d=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
1167            coeff=mypde.getCoefficient("d_reduced")
1168            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
1169        def test_setCoefficient_d_contact_reduced_Scalar_using_d_contact(self):
1170            d=self.domain.getDim()
1171            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1172            mypde.setValue(d_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
1173            coeff=mypde.getCoefficient("d_contact_reduced")
1174            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
1175        def test_setCoefficient_y_contact_reduced_Scalar_using_y_contact(self):
1176            d=self.domain.getDim()
1177            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1178            mypde.setValue(y_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
1179            coeff=mypde.getCoefficient("y_contact_reduced")
1180            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
1181      #      #
1182      #  set coefficients for systems:      #  set coefficients for systems:
1183      #      #
1184      def test_setCoefficient_A_System(self):      def test_setCoefficient_A_System(self):
1185          d=self.domain.getDim()          d=self.domain.getDim()
1186          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1187          mypde.setValue(A=numarray.ones((self.N,d,self.N,d)))          mypde.setValue(A=numpy.ones((self.N,d,self.N,d)))
1188          coeff=mypde.getCoefficientOfGeneralPDE("A")          coeff=mypde.getCoefficient("A")
1189          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((self.N,d,self.N,d),Function(self.domain),self.N,self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),Function(self.domain),self.N,self.N))
1190      def test_setCoefficient_B_System(self):      def test_setCoefficient_B_System(self):
1191          d=self.domain.getDim()          d=self.domain.getDim()
1192          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1193          mypde.setValue(B=numarray.ones((self.N,d,self.N)))          mypde.setValue(B=numpy.ones((self.N,d,self.N)))
1194          coeff=mypde.getCoefficientOfGeneralPDE("B")          coeff=mypde.getCoefficient("B")
1195          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((self.N,d,self.N),Function(self.domain),self.N,self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),Function(self.domain),self.N,self.N))
1196      def test_setCoefficient_C_System(self):      def test_setCoefficient_C_System(self):
1197          d=self.domain.getDim()          d=self.domain.getDim()
1198          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1199          mypde.setValue(C=numarray.ones((self.N,self.N,d)))          mypde.setValue(C=numpy.ones((self.N,self.N,d)))
1200          coeff=mypde.getCoefficientOfGeneralPDE("C")          coeff=mypde.getCoefficient("C")
1201          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((self.N,self.N,d),Function(self.domain),self.N,self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),Function(self.domain),self.N,self.N))
1202      def test_setCoefficient_D_System(self):      def test_setCoefficient_D_System(self):
1203          d=self.domain.getDim()          d=self.domain.getDim()
1204          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1205          mypde.setValue(D=numarray.ones((self.N,self.N)))          mypde.setValue(D=numpy.ones((self.N,self.N)))
1206          coeff=mypde.getCoefficientOfGeneralPDE("D")          coeff=mypde.getCoefficient("D")
1207          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((self.N,self.N),Function(self.domain),self.N,self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),Function(self.domain),self.N,self.N))
1208      def test_setCoefficient_X_System(self):      def test_setCoefficient_X_System(self):
1209          d=self.domain.getDim()          d=self.domain.getDim()
1210          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1211          mypde.setValue(X=numarray.ones((self.N,d)))          mypde.setValue(X=numpy.ones((self.N,d)))
1212          coeff=mypde.getCoefficientOfGeneralPDE("X")          coeff=mypde.getCoefficient("X")
1213          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((self.N,d),Function(self.domain),self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),Function(self.domain),self.N))
1214      def test_setCoefficient_Y_System(self):      def test_setCoefficient_Y_System(self):
1215          d=self.domain.getDim()          d=self.domain.getDim()
1216          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1217          mypde.setValue(Y=numarray.ones((self.N,)))          mypde.setValue(Y=numpy.ones((self.N,)))
1218          coeff=mypde.getCoefficientOfGeneralPDE("Y")          coeff=mypde.getCoefficient("Y")
1219          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((self.N,),Function(self.domain),self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),Function(self.domain),self.N))
1220      def test_setCoefficient_y_System(self):      def test_setCoefficient_y_System(self):
1221          d=self.domain.getDim()          d=self.domain.getDim()
1222          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1223          mypde.setValue(y=numarray.ones((self.N,)))          mypde.setValue(y=numpy.ones((self.N,)))
1224          coeff=mypde.getCoefficientOfGeneralPDE("y")          coeff=mypde.getCoefficient("y")
1225          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((self.N,),FunctionOnBoundary(self.domain),self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnBoundary(self.domain),self.N))
1226      def test_setCoefficient_d_System(self):      def test_setCoefficient_d_System(self):
1227          d=self.domain.getDim()          d=self.domain.getDim()
1228          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1229          mypde.setValue(d=numarray.ones((self.N,self.N)))          mypde.setValue(d=numpy.ones((self.N,self.N)))
1230          coeff=mypde.getCoefficientOfGeneralPDE("d")          coeff=mypde.getCoefficient("d")
1231          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((self.N,self.N),FunctionOnBoundary(self.domain),self.N,self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnBoundary(self.domain),self.N,self.N))
1232      def test_setCoefficient_d_contact_System(self):      def test_setCoefficient_d_contact_System(self):
1233          d=self.domain.getDim()          d=self.domain.getDim()
1234          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1235          mypde.setValue(d_contact=numarray.ones((self.N,self.N)))          mypde.setValue(d_contact=numpy.ones((self.N,self.N)))
1236          coeff=mypde.getCoefficientOfGeneralPDE("d_contact")          coeff=mypde.getCoefficient("d_contact")
1237          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions(),mypde.getNumEquations()),((self.N,self.N),FunctionOnContactZero(self.domain),self.N,self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnContactZero(self.domain),self.N,self.N))
1238      def test_setCoefficient_y_contact_System(self):      def test_setCoefficient_y_contact_System(self):
1239          d=self.domain.getDim()          d=self.domain.getDim()
1240          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1241          mypde.setValue(y_contact=numarray.ones((self.N,)))          mypde.setValue(y_contact=numpy.ones((self.N,)))
1242          coeff=mypde.getCoefficientOfGeneralPDE("y_contact")          coeff=mypde.getCoefficient("y_contact")
1243          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((self.N,),FunctionOnContactZero(self.domain),self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnContactZero(self.domain),self.N))
1244        def test_setCoefficient_A_reduced_System(self):
1245            d=self.domain.getDim()
1246            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1247            mypde.setValue(A_reduced=numpy.ones((self.N,d,self.N,d)))
1248            coeff=mypde.getCoefficient("A_reduced")
1249            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1250        def test_setCoefficient_B_reduced_System(self):
1251            d=self.domain.getDim()
1252            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1253            mypde.setValue(B_reduced=numpy.ones((self.N,d,self.N)))
1254            coeff=mypde.getCoefficient("B_reduced")
1255            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
1256        def test_setCoefficient_C_reduced_System(self):
1257            d=self.domain.getDim()
1258            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1259            mypde.setValue(C_reduced=numpy.ones((self.N,self.N,d)))
1260            coeff=mypde.getCoefficient("C_reduced")
1261            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1262        def test_setCoefficient_D_System_reduced(self):
1263            d=self.domain.getDim()
1264            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1265            mypde.setValue(D_reduced=numpy.ones((self.N,self.N)))
1266            coeff=mypde.getCoefficient("D_reduced")
1267            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
1268        def test_setCoefficient_X_System_reduced(self):
1269            d=self.domain.getDim()
1270            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1271            mypde.setValue(X_reduced=numpy.ones((self.N,d)))
1272            coeff=mypde.getCoefficient("X_reduced")
1273            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
1274        def test_setCoefficient_Y_System_reduced(self):
1275            d=self.domain.getDim()
1276            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1277            mypde.setValue(Y_reduced=numpy.ones((self.N,)))
1278            coeff=mypde.getCoefficient("Y_reduced")
1279            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
1280        def test_setCoefficient_y_System_reduced(self):
1281            d=self.domain.getDim()
1282            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1283            mypde.setValue(y_reduced=numpy.ones((self.N,)))
1284            coeff=mypde.getCoefficient("y_reduced")
1285            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
1286        def test_setCoefficient_d_reduced_System(self):
1287            d=self.domain.getDim()
1288            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1289            mypde.setValue(d_reduced=numpy.ones((self.N,self.N)))
1290            coeff=mypde.getCoefficient("d_reduced")
1291            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
1292        def test_setCoefficient_d_contact_reduced_System(self):
1293            d=self.domain.getDim()
1294            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1295            mypde.setValue(d_contact_reduced=numpy.ones((self.N,self.N)))
1296            coeff=mypde.getCoefficient("d_contact_reduced")
1297            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
1298        def test_setCoefficient_y_contact_reduced_System(self):
1299            d=self.domain.getDim()
1300            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1301            mypde.setValue(y_contact_reduced=numpy.ones((self.N,)))
1302            coeff=mypde.getCoefficient("y_contact_reduced")
1303            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
1304      def test_setCoefficient_r_System(self):      def test_setCoefficient_r_System(self):
1305          d=self.domain.getDim()          d=self.domain.getDim()
1306          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1307          mypde.setValue(r=numarray.ones((self.N,)))          mypde.setValue(r=numpy.ones((self.N,)))
1308          coeff=mypde.getCoefficientOfGeneralPDE("r")          coeff=mypde.getCoefficient("r")
1309          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
1310      def test_setCoefficient_q_System(self):      def test_setCoefficient_q_System(self):
1311          d=self.domain.getDim()          d=self.domain.getDim()
1312          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1313          mypde.setValue(q=numarray.ones((self.N,)))          mypde.setValue(q=numpy.ones((self.N,)))
1314          coeff=mypde.getCoefficientOfGeneralPDE("q")          coeff=mypde.getCoefficient("q")
1315          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
1316      def test_setCoefficient_r_System_reducedOn(self):      def test_setCoefficient_r_System_reducedOn(self):
1317          d=self.domain.getDim()          d=self.domain.getDim()
1318          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1319          mypde.setReducedOrderOn()          mypde.setReducedOrderOn()
1320          mypde.setValue(r=numarray.ones((self.N,)))          mypde.setValue(r=numpy.ones((self.N,)))
1321          coeff=mypde.getCoefficientOfGeneralPDE("r")          coeff=mypde.getCoefficient("r")
1322          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
1323      def test_setCoefficient_q_System_reducedOn(self):      def test_setCoefficient_q_System_reducedOn(self):
1324          d=self.domain.getDim()          d=self.domain.getDim()
1325          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1326          mypde.setReducedOrderOn()          mypde.setReducedOrderOn()
1327          mypde.setValue(q=numarray.ones((self.N,)))          mypde.setValue(q=numpy.ones((self.N,)))
1328          coeff=mypde.getCoefficientOfGeneralPDE("q")          coeff=mypde.getCoefficient("q")
1329          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
1330    
1331        def test_setCoefficient_A_reduced_System_using_A(self):
1332            d=self.domain.getDim()
1333            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1334            mypde.setValue(A=Data(numpy.ones((self.N,d,self.N,d)),ReducedFunction(self.domain)))
1335            coeff=mypde.getCoefficient("A_reduced")
1336            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1337        def test_setCoefficient_B_reduced_System_using_B(self):
1338            d=self.domain.getDim()
1339            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1340            mypde.setValue(B=Data(numpy.ones((self.N,d,self.N)),ReducedFunction(self.domain)))
1341            coeff=mypde.getCoefficient("B_reduced")
1342            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
1343        def test_setCoefficient_C_reduced_System_using_C(self):
1344            d=self.domain.getDim()
1345            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1346            mypde.setValue(C=Data(numpy.ones((self.N,self.N,d)),ReducedFunction(self.domain)))
1347            coeff=mypde.getCoefficient("C_reduced")
1348            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1349        def test_setCoefficient_D_System_reduced_using_D(self):
1350            d=self.domain.getDim()
1351            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1352            mypde.setValue(D=Data(numpy.ones((self.N,self.N)),ReducedFunction(self.domain)))
1353            coeff=mypde.getCoefficient("D_reduced")
1354            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
1355        def test_setCoefficient_X_System_reduced_using_X(self):
1356            d=self.domain.getDim()
1357            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1358            mypde.setValue(X=Data(numpy.ones((self.N,d)),ReducedFunction(self.domain)))
1359            coeff=mypde.getCoefficient("X_reduced")
1360            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
1361        def test_setCoefficient_Y_System_reduced_using_Y(self):
1362            d=self.domain.getDim()
1363            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1364            mypde.setValue(Y=Data(numpy.ones((self.N,)),ReducedFunction(self.domain)))
1365            coeff=mypde.getCoefficient("Y_reduced")
1366            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
1367        def test_setCoefficient_y_reduced_System_using_y(self):
1368            d=self.domain.getDim()
1369            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1370            mypde.setValue(y=Data(numpy.ones((self.N,)),ReducedFunctionOnBoundary(self.domain)))
1371            coeff=mypde.getCoefficient("y_reduced")
1372            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
1373        def test_setCoefficient_d_reduced_System_using_d(self):
1374            d=self.domain.getDim()
1375            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1376            mypde.setValue(d=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnBoundary(self.domain)))
1377            coeff=mypde.getCoefficient("d_reduced")
1378            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
1379        def test_setCoefficient_d_contact_reduced_System_using_d_contact(self):
1380            d=self.domain.getDim()
1381            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1382            mypde.setValue(d_contact=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnContactZero(self.domain)))
1383            coeff=mypde.getCoefficient("d_contact_reduced")
1384            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
1385        def test_setCoefficient_y_contact_reduced_System_using_y_contact(self):
1386            d=self.domain.getDim()
1387            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1388            mypde.setValue(y_contact=Data(numpy.ones((self.N,)),ReducedFunctionOnContactZero(self.domain)))
1389            coeff=mypde.getCoefficient("y_contact_reduced")
1390            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
1391      def test_resetCoefficient_HomogeneousConstraint(self):      def test_resetCoefficient_HomogeneousConstraint(self):
1392          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1393          x=self.domain.getX()          x=self.domain.getX()
# Line 342  class Test_LinearPDE(Test_linearPDEs): Line 1400  class Test_LinearPDE(Test_linearPDEs):
1400      def test_resetCoefficient_InHomogeneousConstraint(self):      def test_resetCoefficient_InHomogeneousConstraint(self):
1401          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1402          mypde.setSymmetryOn()          mypde.setSymmetryOn()
1403        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1404          x=self.domain.getX()          x=self.domain.getX()
1405          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.,r=1,q=whereZero(x[0]))          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.,r=1,q=whereZero(x[0]))
1406          u1=mypde.getSolution(verbose=self.VERBOSE)          u1=mypde.getSolution()
1407          mypde.setValue(Y=2.,D=2)          mypde.setValue(Y=2.,D=2)
1408          u2=mypde.getSolution(verbose=self.VERBOSE)          u2=mypde.getSolution()
1409          self.failUnless(self.check(u2,u1),'first solution is wrong.')          self.failUnless(self.check(u2,u1),'first solution is wrong.')
1410          u2=mypde.getSolution(verbose=self.VERBOSE)          u2=mypde.getSolution()
1411          self.failUnless(self.check(u2,u1),'first solution is wrong.')          self.failUnless(self.check(u2,u1),'first solution is wrong.')
1412          mypde.setValue(r=2,Y=4.)          mypde.setValue(r=2,Y=4.)
1413          u2=mypde.getSolution(verbose=self.VERBOSE)          u2=mypde.getSolution()
1414          self.failUnless(self.check(u2,2*u1),'second solution is wrong.')          self.failUnless(self.check(u2,2*u1),'second solution is wrong.')
1415    
1416        def test_Status(self):
1417            DIM=self.domain.getDim()
1418            x=self.domain.getX()
1419            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1420            mypde.getSolverOptions().setSymmetryOn()
1421            mypde.getSolverOptions().setTolerance(self.RES_TOL)
1422            mypde.setValue(A=kronecker(self.domain), q=whereZero(x[0])+whereZero(x[0]-1.), Y=2.)
1423            x1=self.domain.getX()
1424            u1_ref=x1[0]*(1.-x1[0])
1425            u1=mypde.getSolution()
1426            error1=Lsup(u1-u1_ref)/Lsup(u1_ref)
1427            self.failUnless(mypde.getDomainStatus() == mypde.getSystemStatus(), "status of first pde does not match domain status.")
1428    
1429            self.domain.setX(x*5)
1430    
1431            self.failUnless(mypde.getDomainStatus() != mypde.getSystemStatus(), "status of first pde matches updated domain status.")
1432            x2=self.domain.getX()
1433            u2_ref=x2[0]*(5.-x2[0])
1434            u2=mypde.getSolution()
1435            error2=Lsup(u2-u2_ref)/Lsup(u2_ref)
1436            self.failUnless(error2 <= max(error1,self.RES_TOL)*10., "solution of second PDE wrong.")
1437            self.failUnless(mypde.getDomainStatus() == mypde.getSystemStatus(), "status of second pde does not match domain status.")
1438    
1439      def test_symmetryCheckTrue_System(self):      def test_symmetryCheckTrue_System(self):
1440          d=self.domain.getDim()          d=self.domain.getDim()
1441          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1442          A=numarray.ones((self.N,d,self.N,d))          A=numpy.ones((self.N,d,self.N,d))
1443          C=2*numarray.ones((self.N,self.N,d))          C=2*numpy.ones((self.N,self.N,d))
1444          B=2*numarray.ones((self.N,d,self.N))          B=2*numpy.ones((self.N,d,self.N))
1445          D=3*numarray.ones((self.N,self.N))          D=3*numpy.ones((self.N,self.N))
1446          d=4*numarray.ones((self.N,self.N))          d=4*numpy.ones((self.N,self.N))
1447          d_contact=5*numarray.ones((self.N,self.N))          d_contact=5*numpy.ones((self.N,self.N))
1448          mypde.setValue(A=A,B=B,C=C,D=D,d=d,d_contact=d_contact)          mypde.setValue(A=A,B=B,C=C,D=D,d=d,d_contact=d_contact,A_reduced=-A,B_reduced=-B,C_reduced=-C,D_reduced=-D,d_reduced=-d,d_contact_reduced=-d_contact)
1449          self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
1450    
1451      def test_symmetryCheckFalse_A_System(self):      def test_symmetryCheckFalse_A_System(self):
1452          d=self.domain.getDim()          d=self.domain.getDim()
1453          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1454          A=numarray.ones((self.N,d,self.N,d))          A=numpy.ones((self.N,d,self.N,d))
1455          A[1,1,1,0]=0.          A[1,1,1,0]=0.
1456          mypde.setValue(A=A)          mypde.setValue(A=A)
1457          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1458      def test_symmetryCheckFalse_BC_System(self):      def test_symmetryCheckFalse_BC_System(self):
1459          d=self.domain.getDim()          d=self.domain.getDim()
1460          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1461          C=2*numarray.ones((self.N,self.N,d))          C=2*numpy.ones((self.N,self.N,d))
1462          B=2*numarray.ones((self.N,d,self.N))          B=2*numpy.ones((self.N,d,self.N))
1463          B[0,0,1]=1.          B[0,0,1]=1.
1464          mypde.setValue(B=B,C=C)          mypde.setValue(B=B,C=C)
1465          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1466    
1467      def test_symmetryCheckFalse_D_System(self):      def test_symmetryCheckFalse_D_System(self):
1468          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1469          D=3*numarray.ones((self.N,self.N))          D=3*numpy.ones((self.N,self.N))
1470          D[0,1]=0.          D[0,1]=0.
1471          mypde.setValue(D=D)          mypde.setValue(D=D)
1472          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1473    
1474      def test_symmetryCheckFalse_d_System(self):      def test_symmetryCheckFalse_d_System(self):
1475          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1476          d=4*numarray.ones((self.N,self.N))          d=4*numpy.ones((self.N,self.N))
1477          d[0,1]=0.          d[0,1]=0.
1478          mypde.setValue(d=d)          mypde.setValue(d=d)
1479          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1480    
1481      def test_symmetryCheckFalse_d_contact_System(self):      def test_symmetryCheckFalse_d_contact_System(self):
1482          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1483          d_contact=5*numarray.ones((self.N,self.N))          d_contact=5*numpy.ones((self.N,self.N))
1484          d_contact[0,1]=0.          d_contact[0,1]=0.
1485          mypde.setValue(d_contact=d_contact)          mypde.setValue(d_contact=d_contact)
1486          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1487    
1488        def test_symmetryCheckFalse_A_reduced_System(self):
1489            d=self.domain.getDim()
1490            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1491            A=numpy.ones((self.N,d,self.N,d))
1492            A[1,1,1,0]=0.
1493            mypde.setValue(A_reduced=A)
1494            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1495        def test_symmetryCheckFalse_BC_reduced_System(self):
1496            d=self.domain.getDim()
1497            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1498            C=2*numpy.ones((self.N,self.N,d))
1499            B=2*numpy.ones((self.N,d,self.N))
1500            B[0,0,1]=1.
1501            mypde.setValue(B_reduced=B,C_reduced=C)
1502            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1503    
1504        def test_symmetryCheckFalse_D_reduced_System(self):
1505            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1506            D=3*numpy.ones((self.N,self.N))
1507            D[0,1]=0.
1508            mypde.setValue(D_reduced=D)
1509            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1510    
1511        def test_symmetryCheckFalse_d_reduced_System(self):
1512            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1513            d=4*numpy.ones((self.N,self.N))
1514            d[0,1]=0.
1515            mypde.setValue(d_reduced=d)
1516            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1517    
1518        def test_symmetryCheckFalse_d_contact_reduced_System(self):
1519            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1520            d_contact=5*numpy.ones((self.N,self.N))
1521            d_contact[0,1]=0.
1522            mypde.setValue(d_contact_reduced=d_contact)
1523            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1524    
1525      def test_symmetryCheckTrue_Scalar(self):      def test_symmetryCheckTrue_Scalar(self):
1526          d=self.domain.getDim()          d=self.domain.getDim()
1527          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1528          A=numarray.ones((d,d))          A=numpy.ones((d,d))
1529          C=2*numarray.ones((d,))          C=2*numpy.ones((d,))
1530          B=2*numarray.ones((d,))          B=2*numpy.ones((d,))
1531          D=3          D=3
1532          d=4          d=4
1533          d_contact=5          d_contact=5
1534          mypde.setValue(A=A,B=B,C=C,D=D,d=d,d_contact=d_contact)          mypde.setValue(A=A,B=B,C=C,D=D,d=d,d_contact=d_contact,A_reduced=-A,B_reduced=-B,C_reduced=-C,D_reduced=-D,d_reduced=-d,d_contact_reduced=-d_contact)
1535          self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
1536    
1537      def test_symmetryCheckFalse_A_Scalar(self):      def test_symmetryCheckFalse_A_Scalar(self):
1538          d=self.domain.getDim()          d=self.domain.getDim()
1539          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1540          A=numarray.ones((d,d))          A=numpy.ones((d,d))
1541          A[1,0]=0.          A[1,0]=0.
1542          mypde.setValue(A=A)          mypde.setValue(A=A)
1543          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1544      def test_symmetryCheckFalse_BC_Scalar(self):      def test_symmetryCheckFalse_BC_Scalar(self):
1545          d=self.domain.getDim()          d=self.domain.getDim()
1546          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1547          C=2*numarray.ones((d,))          C=2*numpy.ones((d,))
1548          B=2*numarray.ones((d,))          B=2*numpy.ones((d,))
1549          B[0]=1.          B[0]=1.
1550          mypde.setValue(B=B,C=C)          mypde.setValue(B=B,C=C)
1551          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1552        def test_symmetryCheckFalse_A_reduced_Scalar(self):
1553            d=self.domain.getDim()
1554            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1555            A=numpy.ones((d,d))
1556            A[1,0]=0.
1557            mypde.setValue(A_reduced=A)
1558            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1559        def test_symmetryCheckFalse_BC_reduced_Scalar(self):
1560            d=self.domain.getDim()
1561            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1562            C=2*numpy.ones((d,))
1563            B=2*numpy.ones((d,))
1564            B[0]=1.
1565            mypde.setValue(B_reduced=B,C_reduced=C)
1566            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1567      #      #
1568      #   solver checks:      #   solver checks (single PDE)
1569      #      #
1570      def test_symmetryOnIterative(self):      def test_symmetryOnIterative(self):
1571          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1572          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1573          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1574            u=mypde.getSolution()
1575          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1576      def test_symmetryOnDirect(self):      def test_symmetryOnDirect(self):
1577          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1578          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1579          mypde.setSolverMethod(mypde.DIRECT)          mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1580          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1581            u=mypde.getSolution()
1582          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1583      def test_PCG_JACOBI(self):      def test_PCG_JACOBI(self):
1584          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1585          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1586          mypde.setSolverMethod(mypde.PCG,mypde.JACOBI)          mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1587          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1588        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1589            u=mypde.getSolution()
1590          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1591        def test_PCG_AMG(self):
1592            if self.order!=2:
1593                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1594                mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1595                mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1596                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1597                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1598                u=mypde.getSolution()
1599                self.failUnless(self.check(u,1.),'solution is wrong.')
1600      def test_PCG_ILU0(self):      def test_PCG_ILU0(self):
1601          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1602          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1603          mypde.setSolverMethod(mypde.PCG,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1604          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1605        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1606            u=mypde.getSolution()
1607            self.failUnless(self.check(u,1.),'solution is wrong.')
1608        def test_PCG_RILU(self):
1609            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1610            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1611        mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1612        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1613        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1614            u=mypde.getSolution()
1615            self.failUnless(self.check(u,1.),'solution is wrong.')
1616        def test_PCG_REC_ILU(self):
1617            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1618            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1619        mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1620        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1621        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1622            u=mypde.getSolution()
1623          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1624      def test_DIRECT(self):      def test_DIRECT(self):
1625          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1626          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1627          mypde.setSolverMethod(mypde.DIRECT)          mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1628          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1629            u=mypde.getSolution()
1630          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1631      def test_BICGSTAB_JACOBI(self):      def test_BICGSTAB_JACOBI(self):
1632          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1633      mypde.setSolverMethod(mypde.BICGSTAB,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1634        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1635          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1636          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1637            u=mypde.getSolution()
1638          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1639        def test_BICGSTAB_AMG(self):
1640            if self.order!=2:
1641                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1642                mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1643                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1644                mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1645                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1646                u=mypde.getSolution()
1647                self.failUnless(self.check(u,1.),'solution is wrong.')
1648      def test_BICGSTAB_ILU0(self):      def test_BICGSTAB_ILU0(self):
1649          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1650          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1651      mypde.setSolverMethod(mypde.BICGSTAB,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1652          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1653            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1654            u=mypde.getSolution()
1655            self.failUnless(self.check(u,1.),'solution is wrong.')
1656        def test_BICGSTAB_RILU(self):
1657            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1658            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1659        mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1660        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1661            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1662            u=mypde.getSolution()
1663            self.failUnless(self.check(u,1.),'solution is wrong.')
1664        def test_BICGSTAB_REC_ILU(self):
1665            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1666            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1667        mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1668        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1669            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1670            u=mypde.getSolution()
1671            self.failUnless(self.check(u,1.),'solution is wrong.')
1672        def test_MINRES_JACOBI(self):
1673            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1674        mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1675        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1676            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1677            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1678            u=mypde.getSolution()
1679            self.failUnless(self.check(u,1.),'solution is wrong.')
1680        def test_MINRES_AMG(self):
1681            if self.order!=2:
1682                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1683                mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1684                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1685                mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1686                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1687                u=mypde.getSolution()
1688                self.failUnless(self.check(u,1.),'solution is wrong.')
1689        def test_MINRES_ILU0(self):
1690            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1691            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1692        mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1693        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1694            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1695            u=mypde.getSolution()
1696            self.failUnless(self.check(u,1.),'solution is wrong.')
1697        def test_MINRES_RILU(self):
1698            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1699            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1700        mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1701        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1702            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1703            u=mypde.getSolution()
1704            self.failUnless(self.check(u,1.),'solution is wrong.')
1705        def test_MINRES_REC_ILU(self):
1706            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1707            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1708        mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1709        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1710            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1711            u=mypde.getSolution()
1712            self.failUnless(self.check(u,1.),'solution is wrong.')
1713        def test_TFQMR_JACOBI(self):
1714            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1715        mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1716        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1717            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1718            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1719            u=mypde.getSolution()
1720            self.failUnless(self.check(u,1.),'solution is wrong.')
1721        def test_TFQMR_AMG(self):
1722            if self.order!=2:
1723                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1724                mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1725                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1726                mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1727                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1728                mypde.getSolverOptions().setVerbosity(True)
1729                u=mypde.getSolution()
1730                self.failUnless(self.check(u,1.),'solution is wrong.')
1731        def test_TFQMR_ILU0(self):
1732            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1733            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1734        mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1735        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1736            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1737            u=mypde.getSolution()
1738            self.failUnless(self.check(u,1.),'solution is wrong.')
1739        def test_TFQMR_RILU(self):
1740            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1741            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1742        mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1743        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1744            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1745            u=mypde.getSolution()
1746            self.failUnless(self.check(u,1.),'solution is wrong.')
1747        def test_TFQMR_REC_ILU(self):
1748            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1749            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1750        mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1751        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1752            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1753            u=mypde.getSolution()
1754          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1755      def test_PRES20_JACOBI(self):      def test_PRES20_JACOBI(self):
1756          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1757          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1758      mypde.setSolverMethod(mypde.PRES20,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1759          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1760            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1761            u=mypde.getSolution()
1762          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1763        def test_PRES20_AMG(self):
1764            if self.order!=2:
1765                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1766                mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1767                mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1768                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1769                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1770                u=mypde.getSolution()
1771                self.failUnless(self.check(u,1.),'solution is wrong.')
1772      def test_PRES20_ILU0(self):      def test_PRES20_ILU0(self):
1773          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1774          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1775      mypde.setSolverMethod(mypde.PRES20,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1776          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1777            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1778            u=mypde.getSolution()
1779            self.failUnless(self.check(u,1.),'solution is wrong.')
1780        def test_PRES20_RILU(self):
1781            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1782            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1783        mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1784        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1785            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1786            u=mypde.getSolution()
1787            self.failUnless(self.check(u,1.),'solution is wrong.')
1788        def test_PRES20_REC_ILU(self):
1789            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1790            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1791        mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1792        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1793            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1794            u=mypde.getSolution()
1795          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1796      def test_GMRESnoRestart_JACOBI(self):      def test_GMRESnoRestart_JACOBI(self):
1797          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1798          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1799      mypde.setSolverMethod(mypde.GMRES,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1800          # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1801          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1802        mypde.getSolverOptions().setTruncation(50)
1803            u=mypde.getSolution()
1804          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1805        def test_GMRESnoRestart_AMG(self):
1806            if self.order!=2:
1807                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1808                mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1809                mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1810                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1811                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1812                mypde.getSolverOptions().setTruncation(50)
1813                u=mypde.getSolution()
1814                self.failUnless(self.check(u,1.),'solution is wrong.')
1815      def test_GMRESnoRestart_ILU0(self):      def test_GMRESnoRestart_ILU0(self):
1816          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1817          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1818      mypde.setSolverMethod(mypde.GMRES,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1819          # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1820          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1821        mypde.getSolverOptions().setTruncation(50)                        
1822            u=mypde.getSolution()
1823            self.failUnless(self.check(u,1.),'solution is wrong.')
1824        def test_GMRESnoRestart_RILU(self):
1825            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1826            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1827        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1828        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1829        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1830        mypde.getSolverOptions().setTruncation(50)
1831            u=mypde.getSolution()
1832            self.failUnless(self.check(u,1.),'solution is wrong.')
1833        def test_GMRESnoRestart_REC_ILU(self):
1834            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1835            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1836        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1837        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1838        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1839        mypde.getSolverOptions().setTruncation(50)
1840            u=mypde.getSolution()
1841          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1842      def test_GMRES_JACOBI(self):      def test_GMRES_JACOBI(self):
1843          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1844          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1845      mypde.setSolverMethod(mypde.GMRES,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1846          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1847            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1848            u=mypde.getSolution()
1849          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1850        def test_GMRES_AMG(self):
1851            if self.order!=2:
1852                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1853                mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1854                mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1855                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1856                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1857                u=mypde.getSolution()
1858                self.failUnless(self.check(u,1.),'solution is wrong.')        
1859      def test_GMRES_ILU0(self):      def test_GMRES_ILU0(self):
1860          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1861          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1862      mypde.setSolverMethod(mypde.GMRES,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1863          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1864            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1865            u=mypde.getSolution()
1866            self.failUnless(self.check(u,1.),'solution is wrong.')
1867        def test_GMRES_RILU(self):
1868            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1869            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1870        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1871        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1872            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1873            u=mypde.getSolution()
1874            self.failUnless(self.check(u,1.),'solution is wrong.')
1875        def test_GMRES_REC_ILU(self):
1876            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1877            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1878        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1879        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1880            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1881            u=mypde.getSolution()
1882          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1883      def test_GMRES_truncation_restart_JACOBI(self):      def test_GMRES_truncation_restart_JACOBI(self):
1884          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1885          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1886      mypde.setSolverMethod(mypde.GMRES,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1887          u=mypde.getSolution(verbose=self.VERBOSE,truncation=10,restart=20)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1888        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1889        mypde.getSolverOptions().setTruncation(10)
1890        mypde.getSolverOptions().setRestart(20)
1891            u=mypde.getSolution()
1892          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1893        def test_GMRES_truncation_restart_AMG(self):
1894            if self.order!=2:
1895                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1896                mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1897                mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1898                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1899                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1900                mypde.getSolverOptions().setTruncation(10)
1901                mypde.getSolverOptions().setRestart(20)
1902                u=mypde.getSolution()
1903                self.failUnless(self.check(u,1.),'solution is wrong.')
1904      def test_GMRES_truncation_restart_ILU0(self):      def test_GMRES_truncation_restart_ILU0(self):
1905          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1906          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1907      mypde.setSolverMethod(mypde.GMRES,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1908          u=mypde.getSolution(verbose=self.VERBOSE,truncation=10,restart=20)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1909        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1910        mypde.getSolverOptions().setTruncation(10)
1911        mypde.getSolverOptions().setRestart(20)
1912            u=mypde.getSolution()
1913          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1914        def test_GMRES_truncation_restart_RILU(self):
1915            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1916            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1917        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1918        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1919        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1920        mypde.getSolverOptions().setTruncation(10)
1921        mypde.getSolverOptions().setRestart(20)
1922            u=mypde.getSolution()
1923            self.failUnless(self.check(u,1.),'solution is wrong.')
1924        def test_GMRES_truncation_restart_REC_ILU(self):
1925            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1926            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1927        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1928        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1929        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1930        mypde.getSolverOptions().setTruncation(10)
1931        mypde.getSolverOptions().setRestart(20)
1932            u=mypde.getSolution()
1933            self.failUnless(self.check(u,1.),'solution is wrong.')
1934        #
1935        #   solver checks (PDE system)
1936        #
1937        def test_symmetryOnIterative_System(self):
1938            A=Tensor4(0.,Function(self.domain))
1939            D=Tensor(1.,Function(self.domain))
1940            Y=Vector(self.domain.getDim(),Function(self.domain))
1941            for i in range(self.domain.getDim()):
1942                A[i,:,i,:]=kronecker(self.domain)
1943                D[i,i]+=i
1944                Y[i]+=i
1945            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1946            mypde.setValue(A=A,D=D,Y=Y)
1947            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1948            u=mypde.getSolution()
1949            self.failUnless(self.check(u,1.),'solution is wrong.')
1950        def test_symmetryOnDirect_System(self):
1951            A=Tensor4(0.,Function(self.domain))
1952            D=Tensor(1.,Function(self.domain))
1953            Y=Vector(self.domain.getDim(),Function(self.domain))
1954            for i in range(self.domain.getDim()):
1955                A[i,:,i,:]=kronecker(self.domain)
1956                D[i,i]+=i
1957                Y[i]+=i
1958            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1959            mypde.setValue(A=A,D=D,Y=Y)
1960            mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1961            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1962            u=mypde.getSolution()
1963            self.failUnless(self.check(u,1.),'solution is wrong.')
1964        def test_PCG_JACOBI_System(self):
1965            A=Tensor4(0.,Function(self.domain))
1966            D=Tensor(1.,Function(self.domain))
1967            Y=Vector(self.domain.getDim(),Function(self.domain))
1968            for i in range(self.domain.getDim()):
1969                A[i,:,i,:]=kronecker(self.domain)
1970                D[i,i]+=i
1971                Y[i]+=i
1972            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1973            mypde.setValue(A=A,D=D,Y=Y)
1974            mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1975        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1976            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1977            u=mypde.getSolution()
1978            self.failUnless(self.check(u,1.),'solution is wrong.')
1979        def test_PCG_AMG_System(self):
1980            if self.order!=2:
1981                A=Tensor4(0.,Function(self.domain))
1982                D=Tensor(1.,Function(self.domain))
1983                Y=Vector(self.domain.getDim(),Function(self.domain))
1984                for i in range(self.domain.getDim()):
1985                    A[i,:,i,:]=kronecker(self.domain)
1986                    D[i,i]+=i
1987                    Y[i]+=i
1988                mypde=LinearPDE(self.domain,debug=self.DEBUG)
1989                mypde.setValue(A=A,D=D,Y=Y)
1990                mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1991                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
1992                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1993                u=mypde.getSolution()
1994                self.failUnless(self.check(u,1.),'solution is wrong.')
1995        def test_PCG_ILU0_System(self):
1996            A=Tensor4(0.,Function(self.domain))
1997            D=Tensor(1.,Function(self.domain))
1998            Y=Vector(self.domain.getDim(),Function(self.domain))
1999            for i in range(self.domain.getDim()):
2000                A[i,:,i,:]=kronecker(self.domain)
2001                D[i,i]+=i
2002                Y[i]+=i
2003            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2004            mypde.setValue(A=A,D=D,Y=Y)
2005            mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
2006        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
2007            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2008            u=mypde.getSolution()
2009            self.failUnless(self.check(u,1.),'solution is wrong.')
2010        def test_DIRECT_System(self):
2011            A=Tensor4(0.,Function(self.domain))
2012            D=Tensor(1.,Function(self.domain))
2013            Y=Vector(self.domain.getDim(),Function(self.domain))
2014            for i in range(self.domain.getDim()):
2015                A[i,:,i,:]=kronecker(self.domain)
2016                D[i,i]+=i
2017                Y[i]+=i
2018            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2019            mypde.setValue(A=A,D=D,Y=Y)
2020            mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
2021            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2022            u=mypde.getSolution()
2023            self.failUnless(self.check(u,1.),'solution is wrong.')
2024        def test_BICGSTAB_JACOBI_System(self):
2025            A=Tensor4(0.,Function(self.domain))
2026            D=Tensor(1.,Function(self.domain))
2027            Y=Vector(self.domain.getDim(),Function(self.domain))
2028            for i in range(self.domain.getDim()):
2029                A[i,:,i,:]=kronecker(self.domain)
2030                D[i,i]+=i
2031                Y[i]+=i
2032            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2033            mypde.setValue(A=A,D=D,Y=Y)
2034        mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
2035        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
2036            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2037            u=mypde.getSolution()
2038            self.failUnless(self.check(u,1.),'solution is wrong.')
2039        def test_BICGSTAB_AMG_System(self):
2040            if self.order!=2:
2041                A=Tensor4(0.,Function(self.domain))
2042                D=Tensor(1.,Function(self.domain))
2043                Y=Vector(self.domain.getDim(),Function(self.domain))
2044                for i in range(self.domain.getDim()):
2045                    A[i,:,i,:]=kronecker(self.domain)
2046                    D[i,i]+=i
2047                    Y[i]+=i
2048                mypde=LinearPDE(self.domain,debug=self.DEBUG)
2049                mypde.setValue(A=A,D=D,Y=Y)
2050                mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
2051                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
2052                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2053                u=mypde.getSolution()
2054                self.failUnless(self.check(u,1.),'solution is wrong.')
2055        def test_BICGSTAB_ILU0_System(self):
2056            A=Tensor4(0.,Function(self.domain))
2057            D=Tensor(1.,Function(self.domain))
2058            Y=Vector(self.domain.getDim(),Function(self.domain))
2059            for i in range(self.domain.getDim()):
2060                A[i,:,i,:]=kronecker(self.domain)
2061                D[i,i]+=i
2062                Y[i]+=i
2063            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2064            mypde.setValue(A=A,D=D,Y=Y)
2065        mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
2066        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
2067            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2068            u=mypde.getSolution()
2069            self.failUnless(self.check(u,1.),'solution is wrong.')
2070        def test_PRES20_JACOBI_System(self):
2071            A=Tensor4(0.,Function(self.domain))
2072            D=Tensor(1.,Function(self.domain))
2073            Y=Vector(self.domain.getDim(),Function(self.domain))
2074            for i in range(self.domain.getDim()):
2075                A[i,:,i,:]=kronecker(self.domain)
2076                D[i,i]+=i
2077                Y[i]+=i
2078            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2079            mypde.setValue(A=A,D=D,Y=Y)
2080        mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
2081        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
2082            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2083            u=mypde.getSolution()
2084            self.failUnless(self.check(u,1.),'solution is wrong.')
2085        def test_PRES20_AMG_System(self):
2086            if self.order!=2:
2087                A=Tensor4(0.,Function(self.domain))
2088                D=Tensor(1.,Function(self.domain))
2089                Y=Vector(self.domain.getDim(),Function(self.domain))
2090                for i in range(self.domain.getDim()):
2091                    A[i,:,i,:]=kronecker(self.domain)
2092                    D[i,i]+=i
2093                    Y[i]+=i
2094                mypde=LinearPDE(self.domain,debug=self.DEBUG)
2095                mypde.setValue(A=A,D=D,Y=Y)
2096                mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
2097                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
2098                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2099                u=mypde.getSolution()
2100                self.failUnless(self.check(u,1.),'solution is wrong.')
2101        def test_PRES20_ILU0_System(self):
2102            A=Tensor4(0.,Function(self.domain))
2103            D=Tensor(1.,Function(self.domain))
2104            Y=Vector(self.domain.getDim(),Function(self.domain))
2105            for i in range(self.domain.getDim()):
2106                A[i,:,i,:]=kronecker(self.domain)
2107                D[i,i]+=i
2108                Y[i]+=i
2109            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2110            mypde.setValue(A=A,D=D,Y=Y)
2111        mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
2112        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
2113            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2114            u=mypde.getSolution()
2115            self.failUnless(self.check(u,1.),'solution is wrong.')
2116        def test_GMRESnoRestart_JACOBI_System(self):
2117            A=Tensor4(0.,Function(self.domain))
2118            D=Tensor(1.,Function(self.domain))
2119            Y=Vector(self.domain.getDim(),Function(self.domain))
2120            for i in range(self.domain.getDim()):
2121                A[i,:,i,:]=kronecker(self.domain)
2122                D[i,i]+=i
2123                Y[i]+=i
2124            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2125            mypde.setValue(A=A,D=D,Y=Y)
2126        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2127        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
2128            # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)
2129            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2130            u=mypde.getSolution()
2131            self.failUnless(self.check(u,1.),'solution is wrong.')
2132        def test_GMRESnoRestart_AMG_System(self):
2133            if self.order!=2:
2134                A=Tensor4(0.,Function(self.domain))
2135                D=Tensor(1.,Function(self.domain))
2136                Y=Vector(self.domain.getDim(),Function(self.domain))
2137                for i in range(self.domain.getDim()):
2138                    A[i,:,i,:]=kronecker(self.domain)
2139                    D[i,i]+=i
2140                    Y[i]+=i
2141                mypde=LinearPDE(self.domain,debug=self.DEBUG)
2142                mypde.setValue(A=A,D=D,Y=Y)
2143                mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2144                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
2145                # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)
2146                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2147                u=mypde.getSolution()
2148                self.failUnless(self.check(u,1.),'solution is wrong.')
2149        def test_GMRESnoRestart_ILU0_System(self):
2150            A=Tensor4(0.,Function(self.domain))
2151            D=Tensor(1.,Function(self.domain))
2152            Y=Vector(self.domain.getDim(),Function(self.domain))
2153            for i in range(self.domain.getDim()):
2154                A[i,:,i,:]=kronecker(self.domain)
2155                D[i,i]+=i
2156                Y[i]+=i
2157            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2158            mypde.setValue(A=A,D=D,Y=Y)
2159        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2160        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
2161            # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)
2162            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2163            u=mypde.getSolution()
2164            self.failUnless(self.check(u,1.),'solution is wrong.')
2165        def test_GMRES_JACOBI_System(self):
2166            A=Tensor4(0.,Function(self.domain))
2167            D=Tensor(1.,Function(self.domain))
2168            Y=Vector(self.domain.getDim(),Function(self.domain))
2169            for i in range(self.domain.getDim()):
2170                A[i,:,i,:]=kronecker(self.domain)
2171                D[i,i]+=i
2172                Y[i]+=i
2173            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2174            mypde.setValue(A=A,D=D,Y=Y)
2175        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2176        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
2177            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2178            u=mypde.getSolution()
2179            self.failUnless(self.check(u,1.),'solution is wrong.')
2180        def test_GMRES_AMG_System(self):
2181            if self.order!=2:
2182                A=Tensor4(0.,Function(self.domain))
2183                D=Tensor(1.,Function(self.domain))
2184                Y=Vector(self.domain.getDim(),Function(self.domain))
2185                for i in range(self.domain.getDim()):
2186                    A[i,:,i,:]=kronecker(self.domain)
2187                    D[i,i]+=i
2188                    Y[i]+=i
2189                mypde=LinearPDE(self.domain,debug=self.DEBUG)
2190                mypde.setValue(A=A,D=D,Y=Y)
2191                mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2192                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
2193                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2194                u=mypde.getSolution()
2195                self.failUnless(self.check(u,1.),'solution is wrong.')
2196        def test_GMRES_ILU0_System(self):
2197            A=Tensor4(0.,Function(self.domain))
2198            D=Tensor(1.,Function(self.domain))
2199            Y=Vector(self.domain.getDim(),Function(self.domain))
2200            for i in range(self.domain.getDim()):
2201                A[i,:,i,:]=kronecker(self.domain)
2202                D[i,i]+=i
2203                Y[i]+=i
2204            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2205            mypde.setValue(A=A,D=D,Y=Y)
2206        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2207        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
2208            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2209            u=mypde.getSolution()
2210            self.failUnless(self.check(u,1.),'solution is wrong.')
2211        def test_GMRES_truncation_restart_JACOBI_System(self):
2212            A=Tensor4(0.,Function(self.domain))
2213            D=Tensor(1.,Function(self.domain))
2214            Y=Vector(self.domain.getDim(),Function(self.domain))
2215            for i in range(self.domain.getDim()):
2216                A[i,:,i,:]=kronecker(self.domain)
2217                D[i,i]+=i
2218                Y[i]+=i
2219            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2220            mypde.setValue(A=A,D=D,Y=Y)
2221        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2222        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
2223            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2224        mypde.getSolverOptions().setTruncation(10)
2225        mypde.getSolverOptions().setRestart(20)
2226            u=mypde.getSolution()
2227            self.failUnless(self.check(u,1.),'solution is wrong.')
2228        def test_GMRES_truncation_restart_AMG_System(self):
2229            if self.order!=2:
2230                A=Tensor4(0.,Function(self.domain))
2231                D=Tensor(1.,Function(self.domain))
2232                Y=Vector(self.domain.getDim(),Function(self.domain))
2233                for i in range(self.domain.getDim()):
2234                    A[i,:,i,:]=kronecker(self.domain)
2235                    D[i,i]+=i
2236                    Y[i]+=i
2237                mypde=LinearPDE(self.domain,debug=self.DEBUG)
2238                mypde.setValue(A=A,D=D,Y=Y)
2239                mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2240                mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
2241                mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2242                mypde.getSolverOptions().setTruncation(10)
2243                mypde.getSolverOptions().setRestart(20)
2244                u=mypde.getSolution()
2245                self.failUnless(self.check(u,1.),'solution is wrong.')
2246        def test_GMRES_truncation_restart_ILU0_System(self):
2247            A=Tensor4(0.,Function(self.domain))
2248            D=Tensor(1.,Function(self.domain))
2249            Y=Vector(self.domain.getDim(),Function(self.domain))
2250            for i in range(self.domain.getDim()):
2251                A[i,:,i,:]=kronecker(self.domain)
2252                D[i,i]+=i
2253                Y[i]+=i
2254            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2255            mypde.setValue(A=A,D=D,Y=Y)
2256        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2257        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
2258            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2259        mypde.getSolverOptions().setTruncation(10)
2260        mypde.getSolverOptions().setRestart(20)
2261            u=mypde.getSolution()
2262            self.failUnless(self.check(u,1.),'solution is wrong.')
2263    
2264    class Test_LinearPDE(Test_LinearPDE_noLumping):
2265      def test_Lumping_attemptToSetA(self):      def test_Lumping_attemptToSetA(self):
2266          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2267          try:          try:
2268             success=True             success=True
2269         mypde.setSolverMethod(mypde.LUMPING)         mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2270             mypde.setValue(A=kronecker(self.domain))             mypde.setValue(A=kronecker(self.domain))
2271             u=mypde.getSolution(verbose=self.VERBOSE)             mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2272               u=mypde.getSolution()    
2273          except ValueError:          except ValueError:
2274             success=False             success=False
2275          self.failUnless(not success,'error should be issued')          self.failUnless(not success,'error should be issued')
# Line 538  class Test_LinearPDE(Test_linearPDEs): Line 2277  class Test_LinearPDE(Test_linearPDEs):
2277          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2278          try:          try:
2279             success=True             success=True
2280         mypde.setSolverMethod(mypde.LUMPING)         mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2281             mypde.setValue(B=kronecker(self.domain)[0])             mypde.setValue(B=kronecker(self.domain)[0])
2282             u=mypde.getSolution(verbose=self.VERBOSE)             mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2283               u=mypde.getSolution()
2284          except ValueError:          except ValueError:
2285             success=False             success=False
2286          self.failUnless(not success,'error should be issued')          self.failUnless(not success,'error should be issued')
# Line 548  class Test_LinearPDE(Test_linearPDEs): Line 2288  class Test_LinearPDE(Test_linearPDEs):
2288          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2289          try:          try:
2290             success=True             success=True
2291         mypde.setSolverMethod(mypde.LUMPING)         mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2292             mypde.setValue(C=kronecker(self.domain)[0])             mypde.setValue(C=kronecker(self.domain)[0])
2293             u=mypde.getSolution(verbose=self.VERBOSE)             mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2294               u=mypde.getSolution()
2295            except ValueError:
2296               success=False
2297            self.failUnless(not success,'error should be issued')
2298            
2299        def test_Lumping_attemptToSetA_reduced(self):
2300            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2301            try:
2302               success=True
2303           mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2304               mypde.setValue(A_reduced=kronecker(self.domain))
2305               mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2306               u=mypde.getSolution()
2307            except ValueError:
2308               success=False
2309            self.failUnless(not success,'error should be issued')
2310        def test_Lumping_attemptToSetB_reduced(self):
2311            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2312            try:
2313               success=True
2314           mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2315               mypde.setValue(B_reduced=kronecker(self.domain)[0])
2316               mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2317               u=mypde.getSolution()
2318            except ValueError:
2319               success=False
2320            self.failUnless(not success,'error should be issued')
2321        def test_Lumping_attemptToSetC_reduced(self):
2322            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2323            try:
2324               success=True
2325           mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2326               mypde.setValue(C_reduced=kronecker(self.domain)[0])
2327               mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2328               u=mypde.getSolution()
2329          except ValueError:          except ValueError:
2330             success=False             success=False
2331          self.failUnless(not success,'error should be issued')          self.failUnless(not success,'error should be issued')
2332                    
2333      def test_Lumping(self):      def test_Lumping(self):
2334          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2335      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2336          mypde.setValue(D=1.,Y=1.)          mypde.setValue(D=1.,Y=1.)
2337          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2338            u=mypde.getSolution()
2339          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
2340      def test_Constrained_Lumping(self):      def test_Constrained_Lumping(self):
2341          x=self.domain.getX()          x=self.domain.getX()
2342          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2343      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2344          mypde.setValue(D=1.,Y=1.,q=whereZero(x[0]),r=1.)          mypde.setValue(D=1.,Y=1.,q=whereZero(x[0]),r=1.)
2345          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2346            u=mypde.getSolution()
2347          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
2348    
2349      def test_Lumping_System(self):      def test_Lumping_System(self):
2350          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2351      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2352          mypde.setValue(D=numarray.array([[1.,0.],[0.,2.]]),Y=numarray.array([1.,2.]))          mypde.setValue(D=numpy.array([[1.,0.],[0.,2.]]),Y=numpy.array([1.,2.]))
2353          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2354          self.failUnless(self.check(u,numarray.ones((2,))),'solution is wrong.')          u=mypde.getSolution()
2355            self.failUnless(self.check(u,numpy.ones((2,))),'solution is wrong.')
2356      def test_Constrained_Lumping_System(self):      def test_Constrained_Lumping_System(self):
2357          x=self.domain.getX()          x=self.domain.getX()
2358          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2359      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2360          mypde.setValue(D=numarray.array([[1.,0.],[0.,2.]]),Y=numarray.array([1.,2.]), \          mypde.setValue(D=numpy.array([[1.,0.],[0.,2.]]),Y=numpy.array([1.,2.]), \
2361                         q=whereZero(x[0])*[0.,1],r=[0.,1.])                         q=whereZero(x[0])*[0.,1],r=[0.,1.])
2362          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2363          self.failUnless(self.check(u,numarray.ones((2,))),'solution is wrong.')          u=mypde.getSolution()
2364            self.failUnless(self.check(u,numpy.ones((2,))),'solution is wrong.')
2365    
2366      def test_Lumping_updateRHS(self):      def test_Lumping_updateRHS(self):
2367          x=self.domain.getX()          x=self.domain.getX()
2368          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2369      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2370          mypde.setValue(D=1.,Y=1.)          mypde.setValue(D=1.,Y=1.)
2371          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2372            u=mypde.getSolution()
2373          self.failUnless(self.check(u,1.),'first solution is wrong.')          self.failUnless(self.check(u,1.),'first solution is wrong.')
2374          mypde.setValue(Y=2.,q=whereZero(x[0]),r=2.)          mypde.setValue(Y=2.,q=whereZero(x[0]),r=2.)
2375          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2376            u=mypde.getSolution()
2377          self.failUnless(self.check(u,2.),'second solution is wrong.')          self.failUnless(self.check(u,2.),'second solution is wrong.')
2378      def test_Lumping_updateOperator(self):      def test_Lumping_updateOperator(self):
2379          x=self.domain.getX()          x=self.domain.getX()
2380          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2381      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2382          mypde.setValue(D=1.,Y=1.)          mypde.setValue(D=1.,Y=1.)
2383          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2384            u=mypde.getSolution()
2385          mypde.setValue(D=2.)          mypde.setValue(D=2.)
2386          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2387            u=mypde.getSolution()
2388          self.failUnless(self.check(u,0.5),'second solution is wrong.')          self.failUnless(self.check(u,0.5),'second solution is wrong.')
2389    
2390    
2391    class Test_TransportPDE(Test_linearPDEs):
2392        N=4
2393        def test_init_useBackwardEuler(self):
2394            mypde=TransportPDE(self.domain,debug=self.DEBUG, useBackwardEuler=True)
2395            self.failUnless(mypde.useBackwardEuler()==True,'backward Euler should be used')
2396        def test_init_donntUseBackwardEuler(self):
2397            mypde=TransportPDE(self.domain,debug=self.DEBUG, useBackwardEuler=False)
2398            self.failUnless(mypde.useBackwardEuler()==False,'backward Euler should not be used')
2399        def test_setCoefficient_WithWrongName(self):
2400            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2401            self.failUnlessRaises(IllegalCoefficient)
2402        mypde.getSolverOptions().setSolverMethod(SolverOptions.setValue, ROMA=Vector(0.,FunctionOnBoundary(self.domain)))
2403    
2404        def test_setCoefficient_WithIllegalFunctionSpace(self):
2405            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2406            self.failUnlessRaises(IllegalCoefficientFunctionSpace)
2407        mypde.getSolverOptions().setSolverMethod(SolverOptions.setValue,C=Vector(0.,FunctionOnBoundary(self.domain)))
2408            
2409        def test_resetCoefficient_WithWrongShape(self):
2410            mypde=TransportPDE(self.domain,numEquations=2,debug=self.DEBUG)
2411            self.failUnlessRaises(IllegalCoefficientValue, mypde.setValue, C=0.)
2412    
2413        def test_setInitialSolution_scalar(self):
2414            mypde=TransportPDE(self.domain,numSolutions=1,debug=self.DEBUG)
2415            mypde.setInitialSolution(1.)
2416    
2417        def test_setInitialSolution_scalar_negative(self):
2418            mypde=TransportPDE(self.domain,numSolutions=1,debug=self.DEBUG)
2419            self.failUnlessRaises(RuntimeError, mypde.setInitialSolution,-1.)
2420    
2421        def test_setInitialSolution_scalar_WithWrongShape(self):
2422            mypde=TransportPDE(self.domain,numSolutions=1,debug=self.DEBUG)
2423            self.failUnlessRaises(ValueError,mypde.setInitialSolution,[1.,2.])
2424    
2425        def test_setInitialSolution_system(self):
2426            mypde=TransportPDE(self.domain,numSolutions=2,debug=self.DEBUG)
2427            mypde.setInitialSolution([1.,2.])
2428    
2429        def test_setInitialSolution_system(self):
2430            mypde=TransportPDE(self.domain,numSolutions=2,debug=self.DEBUG)
2431            self.failUnlessRaises(RuntimeError, mypde.setInitialSolution,[-1,2.])
2432    
2433        def test_setInitialSolution_system_WithWrongShape(self):
2434            mypde=TransportPDE(self.domain,numSolutions=2,debug=self.DEBUG)
2435            self.failUnlessRaises(ValueError, mypde.setInitialSolution,1.)
2436    
2437    
2438        def test_attemptToChangeOrderAfterDefinedCoefficient(self):
2439            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2440            mypde.setValue(D=1.)
2441            self.failUnlessRaises(RuntimeError, mypde.setReducedOrderOn)
2442    
2443        def test_reducedOnConfig(self):
2444            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2445            mypde.setReducedOrderOn()
2446            self.failUnlessEqual((mypde.getFunctionSpaceForSolution(), mypde.getFunctionSpaceForEquation()),(ReducedSolution(self.domain),ReducedSolution(self.domain)),"reduced function spaces expected.")
2447        #
2448        #  set coefficients for scalars:
2449        #
2450        def test_setCoefficient_M_Scalar(self):
2451            d=self.domain.getDim()
2452            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2453            mypde.setValue(M=1.)
2454            coeff=mypde.getCoefficient("M")
2455            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),Function(self.domain),1,1))
2456        def test_setCoefficient_A_Scalar(self):
2457            d=self.domain.getDim()
2458            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2459            mypde.setValue(A=numpy.ones((d,d)))
2460            coeff=mypde.getCoefficient("A")
2461            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),Function(self.domain),1,1))
2462        def test_setCoefficient_B_Scalar(self):
2463            d=self.domain.getDim()
2464            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2465            mypde.setValue(B=numpy.ones((d,)))
2466            coeff=mypde.getCoefficient("B")
2467            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
2468        def test_setCoefficient_C_Scalar(self):
2469            d=self.domain.getDim()
2470            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2471            mypde.setValue(C=numpy.ones((d,)))
2472            coeff=mypde.getCoefficient("C")
2473            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
2474        def test_setCoefficient_D_Scalar(self):
2475            d=self.domain.getDim()
2476            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2477            mypde.setValue(D=1.)
2478            coeff=mypde.getCoefficient("D")
2479            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),Function(self.domain),1,1))
2480        def test_setCoefficient_X_Scalar(self):
2481            d=self.domain.getDim()
2482            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2483            mypde.setValue(X=numpy.ones((d,)))
2484            coeff=mypde.getCoefficient("X")
2485            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),Function(self.domain),1))
2486        def test_setCoefficient_Y_Scalar(self):
2487            d=self.domain.getDim()
2488            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2489            mypde.setValue(Y=1.)
2490            coeff=mypde.getCoefficient("Y")
2491            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),Function(self.domain),1))
2492        def test_setCoefficient_y_Scalar(self):
2493            d=self.domain.getDim()
2494            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2495            mypde.setValue(y=1.)
2496            coeff=mypde.getCoefficient("y")
2497            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1))
2498        def test_setCoefficient_d_Scalar(self):
2499            d=self.domain.getDim()
2500            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2501            mypde.setValue(d=1.)
2502            coeff=mypde.getCoefficient("d")
2503            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1,1))
2504        def test_setCoefficient_m_Scalar(self):
2505            d=self.domain.getDim()
2506            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2507            mypde.setValue(m=1.)
2508            coeff=mypde.getCoefficient("m")
2509            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1,1))
2510        def test_setCoefficient_d_contact_Scalar(self):
2511            d=self.domain.getDim()
2512            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2513            mypde.setValue(d_contact=1.)
2514            coeff=mypde.getCoefficient("d_contact")
2515            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1,1))
2516        def test_setCoefficient_y_contact_Scalar(self):
2517            d=self.domain.getDim()
2518            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2519            mypde.setValue(y_contact=1.)
2520            coeff=mypde.getCoefficient("y_contact")
2521            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1))
2522    
2523        def test_setCoefficient_M_reduced_Scalar(self):
2524            d=self.domain.getDim()
2525            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2526            mypde.setValue(M_reduced=1.)
2527            coeff=mypde.getCoefficient("M_reduced")
2528            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
2529        def test_setCoefficient_A_reduced_Scalar(self):
2530            d=self.domain.getDim()
2531            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2532            mypde.setValue(A_reduced=numpy.ones((d,d)))
2533            coeff=mypde.getCoefficient("A_reduced")
2534            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
2535        def test_setCoefficient_B_reduced_Scalar(self):
2536            d=self.domain.getDim()
2537            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2538            mypde.setValue(B_reduced=numpy.ones((d,)))
2539            coeff=mypde.getCoefficient("B_reduced")
2540            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
2541        def test_setCoefficient_C_reduced_Scalar(self):
2542            d=self.domain.getDim()
2543            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2544            mypde.setValue(C_reduced=numpy.ones((d,)))
2545            coeff=mypde.getCoefficient("C_reduced")
2546            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
2547        def test_setCoefficient_D_reduced_Scalar(self):
2548            d=self.domain.getDim()
2549            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2550            mypde.setValue(D_reduced=1.)
2551            coeff=mypde.getCoefficient("D_reduced")
2552            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
2553        def test_setCoefficient_X_reduced_Scalar(self):
2554            d=self.domain.getDim()
2555            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2556            mypde.setValue(X_reduced=numpy.ones((d,)))
2557            coeff=mypde.getCoefficient("X_reduced")
2558            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
2559        def test_setCoefficient_Y_reduced_Scalar(self):
2560            d=self.domain.getDim()
2561            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2562            mypde.setValue(Y_reduced=1.)
2563            coeff=mypde.getCoefficient("Y_reduced")
2564            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
2565        def test_setCoefficient_y_reduced_Scalar(self):
2566            d=self.domain.getDim()
2567            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2568            mypde.setValue(y_reduced=1.)
2569            coeff=mypde.getCoefficient("y_reduced")
2570            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
2571        def test_setCoefficient_m_reduced_Scalar(self):
2572            d=self.domain.getDim()
2573            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2574            mypde.setValue(m_reduced=1.)
2575            coeff=mypde.getCoefficient("m_reduced")
2576            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
2577        def test_setCoefficient_d_reduced_Scalar(self):
2578            d=self.domain.getDim()
2579            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2580            mypde.setValue(d_reduced=1.)
2581            coeff=mypde.getCoefficient("d_reduced")
2582            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
2583        def test_setCoefficient_d_contact_reduced_Scalar(self):
2584            d=self.domain.getDim()
2585            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2586            mypde.setValue(d_contact_reduced=1.)
2587            coeff=mypde.getCoefficient("d_contact_reduced")
2588            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
2589        def test_setCoefficient_y_contact_reduced_Scalar(self):
2590            d=self.domain.getDim()
2591            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2592            mypde.setValue(y_contact_reduced=1.)
2593            coeff=mypde.getCoefficient("y_contact_reduced")
2594            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
2595        def test_setCoefficient_r_Scalar(self):
2596            d=self.domain.getDim()
2597            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2598            mypde.setValue(r=1.)
2599            coeff=mypde.getCoefficient("r")
2600            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
2601        def test_setCoefficient_q_Scalar(self):
2602            d=self.domain.getDim()
2603            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2604            mypde.setValue(q=1.)
2605            coeff=mypde.getCoefficient("q")
2606            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
2607        def test_setCoefficient_r_Scalar_reducedOn(self):
2608            d=self.domain.getDim()
2609            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2610            mypde.setReducedOrderOn()
2611            mypde.setValue(r=1.)
2612            coeff=mypde.getCoefficient("r")
2613            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
2614        def test_setCoefficient_q_Scalar_reducedOn(self):
2615            d=self.domain.getDim()
2616            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2617            mypde.setReducedOrderOn()
2618            mypde.setValue(q=1.)
2619            coeff=mypde.getCoefficient("q")
2620            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
2621    
2622        def test_setCoefficient_M_reduced_Scalar_usingM(self):
2623            d=self.domain.getDim()
2624            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2625            mypde.setValue(M=Scalar(1.,ReducedFunction(self.domain)))
2626            coeff=mypde.getCoefficient("M_reduced")
2627            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
2628        def test_setCoefficient_A_reduced_Scalar_usingA(self):
2629            d=self.domain.getDim()
2630            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2631            mypde.setValue(A=Data(numpy.ones((d,d)),ReducedFunction(self.domain)))
2632            coeff=mypde.getCoefficient("A_reduced")
2633            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
2634        def test_setCoefficient_B_reduced_Scalar_usingB(self):
2635            d=self.domain.getDim()
2636            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2637            mypde.setValue(B=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
2638            coeff=mypde.getCoefficient("B_reduced")
2639            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
2640        def test_setCoefficient_C_reduced_Scalar_usingC(self):
2641            d=self.domain.getDim()
2642            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2643            mypde.setValue(C=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
2644            coeff=mypde.getCoefficient("C_reduced")
2645            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
2646        def test_setCoefficient_D_reduced_Scalar_usingD(self):
2647            d=self.domain.getDim()
2648            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2649            mypde.setValue(D=Scalar(1.,ReducedFunction(self.domain)))
2650            coeff=mypde.getCoefficient("D_reduced")
2651            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
2652        def test_setCoefficient_X_reduced_Scalar_usingX(self):
2653            d=self.domain.getDim()
2654            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2655            mypde.setValue(X_reduced=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
2656            coeff=mypde.getCoefficient("X_reduced")
2657            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
2658        def test_setCoefficient_Y_reduced_Scalar_usingY(self):
2659            d=self.domain.getDim()
2660            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2661            mypde.setValue(Y=Scalar(1.,ReducedFunction(self.domain)))
2662            coeff=mypde.getCoefficient("Y_reduced")
2663            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
2664        def test_setCoefficient_y_reduced_Scalar_using_y(self):
2665            d=self.domain.getDim()
2666            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2667            mypde.setValue(y=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
2668            coeff=mypde.getCoefficient("y_reduced")
2669            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
2670        def test_setCoefficient_m_reduced_Scalar_using_m(self):
2671            d=self.domain.getDim()
2672            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2673            mypde.setValue(d=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
2674            coeff=mypde.getCoefficient("d_reduced")
2675            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
2676        def test_setCoefficient_d_reduced_Scalar_using_d(self):
2677            d=self.domain.getDim()
2678            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2679            mypde.setValue(m=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
2680            coeff=mypde.getCoefficient("m_reduced")
2681            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
2682        def test_setCoefficient_d_contact_reduced_Scalar_using_d_contact(self):
2683            d=self.domain.getDim()
2684            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2685            mypde.setValue(d_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
2686            coeff=mypde.getCoefficient("d_contact_reduced")
2687            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
2688        def test_setCoefficient_y_contact_reduced_Scalar_using_y_contact(self):
2689            d=self.domain.getDim()
2690            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2691            mypde.setValue(y_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
2692            coeff=mypde.getCoefficient("y_contact_reduced")
2693            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
2694        #
2695        #  set coefficients for systems:
2696        #
2697        def test_setCoefficient_M_System(self):
2698            d=self.domain.getDim()
2699            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2700            mypde.setValue(M=numpy.ones((self.N,self.N)))
2701            coeff=mypde.getCoefficient("M")
2702            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),Function(self.domain),self.N,self.N))
2703        def test_setCoefficient_A_System(self):
2704            d=self.domain.getDim()
2705            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2706            mypde.setValue(A=numpy.ones((self.N,d,self.N,d)))
2707            coeff=mypde.getCoefficient("A")
2708            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),Function(self.domain),self.N,self.N))
2709        def test_setCoefficient_B_System(self):
2710            d=self.domain.getDim()
2711            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2712            mypde.setValue(B=numpy.ones((self.N,d,self.N)))
2713            coeff=mypde.getCoefficient("B")
2714            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),Function(self.domain),self.N,self.N))
2715        def test_setCoefficient_C_System(self):
2716            d=self.domain.getDim()
2717            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2718            mypde.setValue(C=numpy.ones((self.N,self.N,d)))
2719            coeff=mypde.getCoefficient("C")
2720            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),Function(self.domain),self.N,self.N))
2721        def test_setCoefficient_D_System(self):
2722            d=self.domain.getDim()
2723            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2724            mypde.setValue(D=numpy.ones((self.N,self.N)))
2725            coeff=mypde.getCoefficient("D")
2726            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),Function(self.domain),self.N,self.N))
2727        def test_setCoefficient_X_System(self):
2728            d=self.domain.getDim()
2729            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2730            mypde.setValue(X=numpy.ones((self.N,d)))
2731            coeff=mypde.getCoefficient("X")
2732            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),Function(self.domain),self.N))
2733        def test_setCoefficient_Y_System(self):
2734            d=self.domain.getDim()
2735            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2736            mypde.setValue(Y=numpy.ones((self.N,)))
2737            coeff=mypde.getCoefficient("Y")
2738            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),Function(self.domain),self.N))
2739        def test_setCoefficient_y_System(self):
2740            d=self.domain.getDim()
2741            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2742            mypde.setValue(y=numpy.ones((self.N,)))
2743            coeff=mypde.getCoefficient("y")
2744            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnBoundary(self.domain),self.N))
2745        def test_setCoefficient_m_System(self):
2746            d=self.domain.getDim()
2747            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2748            mypde.setValue(m=numpy.ones((self.N,self.N)))
2749            coeff=mypde.getCoefficient("m")
2750            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnBoundary(self.domain),self.N,self.N))
2751        def test_setCoefficient_d_System(self):
2752            d=self.domain.getDim()
2753            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2754            mypde.setValue(d=numpy.ones((self.N,self.N)))
2755            coeff=mypde.getCoefficient("d")
2756            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnBoundary(self.domain),self.N,self.N))
2757        def test_setCoefficient_d_contact_System(self):
2758            d=self.domain.getDim()
2759            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2760            mypde.setValue(d_contact=numpy.ones((self.N,self.N)))
2761            coeff=mypde.getCoefficient("d_contact")
2762            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnContactZero(self.domain),self.N,self.N))
2763        def test_setCoefficient_y_contact_System(self):
2764            d=self.domain.getDim()
2765            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2766            mypde.setValue(y_contact=numpy.ones((self.N,)))
2767            coeff=mypde.getCoefficient("y_contact")
2768            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnContactZero(self.domain),self.N))
2769        def test_setCoefficient_M_System_reduced(self):
2770            d=self.domain.getDim()
2771            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2772            mypde.setValue(M_reduced=numpy.ones((self.N,self.N)))
2773            coeff=mypde.getCoefficient("M_reduced")
2774            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
2775        def test_setCoefficient_A_reduced_System(self):
2776            d=self.domain.getDim()
2777            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2778            mypde.setValue(A_reduced=numpy.ones((self.N,d,self.N,d)))
2779            coeff=mypde.getCoefficient("A_reduced")
2780            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
2781        def test_setCoefficient_B_reduced_System(self):
2782            d=self.domain.getDim()
2783            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2784            mypde.setValue(B_reduced=numpy.ones((self.N,d,self.N)))
2785            coeff=mypde.getCoefficient("B_reduced")
2786            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
2787        def test_setCoefficient_C_reduced_System(self):
2788            d=self.domain.getDim()
2789            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2790            mypde.setValue(C_reduced=numpy.ones((self.N,self.N,d)))
2791            coeff=mypde.getCoefficient("C_reduced")
2792            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
2793        def test_setCoefficient_D_System_reduced(self):
2794            d=self.domain.getDim()
2795            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2796            mypde.setValue(D_reduced=numpy.ones((self.N,self.N)))
2797            coeff=mypde.getCoefficient("D_reduced")
2798            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
2799        def test_setCoefficient_X_System_reduced(self):
2800            d=self.domain.getDim()
2801            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2802            mypde.setValue(X_reduced=numpy.ones((self.N,d)))
2803            coeff=mypde.getCoefficient("X_reduced")
2804            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
2805        def test_setCoefficient_Y_System_reduced(self):
2806            d=self.domain.getDim()
2807            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2808            mypde.setValue(Y_reduced=numpy.ones((self.N,)))
2809            coeff=mypde.getCoefficient("Y_reduced")
2810            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
2811        def test_setCoefficient_y_System_reduced(self):
2812            d=self.domain.getDim()
2813            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2814            mypde.setValue(y_reduced=numpy.ones((self.N,)))
2815            coeff=mypde.getCoefficient("y_reduced")
2816            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
2817        def test_setCoefficient_m_reduced_System(self):
2818            d=self.domain.getDim()
2819            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2820            mypde.setValue(m_reduced=numpy.ones((self.N,self.N)))
2821            coeff=mypde.getCoefficient("m_reduced")
2822            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
2823        def test_setCoefficient_d_reduced_System(self):
2824            d=self.domain.getDim()
2825            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2826            mypde.setValue(d_reduced=numpy.ones((self.N,self.N)))
2827            coeff=mypde.getCoefficient("d_reduced")
2828            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
2829        def test_setCoefficient_d_contact_reduced_System(self):
2830            d=self.domain.getDim()
2831            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2832            mypde.setValue(d_contact_reduced=numpy.ones((self.N,self.N)))
2833            coeff=mypde.getCoefficient("d_contact_reduced")
2834            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
2835        def test_setCoefficient_y_contact_reduced_System(self):
2836            d=self.domain.getDim()
2837            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2838            mypde.setValue(y_contact_reduced=numpy.ones((self.N,)))
2839            coeff=mypde.getCoefficient("y_contact_reduced")
2840            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
2841        def test_setCoefficient_r_System(self):
2842            d=self.domain.getDim()
2843            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2844            mypde.setValue(r=numpy.ones((self.N,)))
2845            coeff=mypde.getCoefficient("r")
2846            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
2847        def test_setCoefficient_q_System(self):
2848            d=self.domain.getDim()
2849            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2850            mypde.setValue(q=numpy.ones((self.N,)))
2851            coeff=mypde.getCoefficient("q")
2852            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
2853        def test_setCoefficient_r_System_reducedOn(self):
2854            d=self.domain.getDim()
2855            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2856            mypde.setReducedOrderOn()
2857            mypde.setValue(r=numpy.ones((self.N,)))
2858            coeff=mypde.getCoefficient("r")
2859            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
2860        def test_setCoefficient_q_System_reducedOn(self):
2861            d=self.domain.getDim()
2862            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2863            mypde.setReducedOrderOn()
2864            mypde.setValue(q=numpy.ones((self.N,)))
2865            coeff=mypde.getCoefficient("q")
2866            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
2867    
2868        def test_setCoefficient_M_System_reduced_using_D(self):
2869            d=self.domain.getDim()
2870            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2871            mypde.setValue(M=Data(numpy.ones((self.N,self.N)),ReducedFunction(self.domain)))
2872            coeff=mypde.getCoefficient("M_reduced")
2873            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
2874        def test_setCoefficient_A_reduced_System_using_A(self):
2875            d=self.domain.getDim()
2876            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2877            mypde.setValue(A=Data(numpy.ones((self.N,d,self.N,d)),ReducedFunction(self.domain)))
2878            coeff=mypde.getCoefficient("A_reduced")
2879            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
2880        def test_setCoefficient_B_reduced_System_using_B(self):
2881            d=self.domain.getDim()
2882            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2883            mypde.setValue(B=Data(numpy.ones((self.N,d,self.N)),ReducedFunction(self.domain)))
2884            coeff=mypde.getCoefficient("B_reduced")
2885            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
2886        def test_setCoefficient_C_reduced_System_using_C(self):
2887            d=self.domain.getDim()
2888            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2889            mypde.setValue(C=Data(numpy.ones((self.N,self.N,d)),ReducedFunction(self.domain)))
2890            coeff=mypde.getCoefficient("C_reduced")
2891            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
2892        def test_setCoefficient_D_System_reduced_using_D(self):
2893            d=self.domain.getDim()
2894            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2895            mypde.setValue(D=Data(numpy.ones((self.N,self.N)),ReducedFunction(self.domain)))
2896            coeff=mypde.getCoefficient("D_reduced")
2897            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
2898        def test_setCoefficient_X_System_reduced_using_X(self):
2899            d=self.domain.getDim()
2900            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2901            mypde.setValue(X=Data(numpy.ones((self.N,d)),ReducedFunction(self.domain)))
2902            coeff=mypde.getCoefficient("X_reduced")
2903            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
2904        def test_setCoefficient_Y_System_reduced_using_Y(self):
2905            d=self.domain.getDim()
2906            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2907            mypde.setValue(Y=Data(numpy.ones((self.N,)),ReducedFunction(self.domain)))
2908            coeff=mypde.getCoefficient("Y_reduced")
2909            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
2910        def test_setCoefficient_y_reduced_System_using_y(self):