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

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

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

trunk/escript/py_src/test_linearPDEs.py revision 614 by elspeth, Wed Mar 22 01:37:07 2006 UTC trunk/escript/test/python/test_linearPDEs.py revision 2474 by gross, Tue Jun 16 06:32:15 2009 UTC
# Line 1  Line 1 
1  # $Id$  
2    ########################################################
3    #
4    # Copyright (c) 2003-2008 by University of Queensland
5    # Earth Systems Science Computational Center (ESSCC)
6    # http://www.uq.edu.au/esscc
7    #
8    # Primary Business: Queensland, Australia
9    # Licensed under the Open Software License version 3.0
10    # http://www.opensource.org/licenses/osl-3.0.php
11    #
12    ########################################################
13    
14    __copyright__="""Copyright (c) 2003-2008 by University of Queensland
15    Earth Systems Science Computational Center (ESSCC)
16    http://www.uq.edu.au/esscc
17    Primary Business: Queensland, Australia"""
18    __license__="""Licensed under the Open Software License version 3.0
19    http://www.opensource.org/licenses/osl-3.0.php"""
20    __url__="https://launchpad.net/escript-finley"
21    
22  """  """
23  Test suite for linearPDEs class  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"
 __copyright__="""  Copyright (c) 2006 by ACcESS MNRF  
                     http://www.access.edu.au  
                 Primary Business: Queensland, Australia"""  
 __license__="""Licensed under the Open Software License version 3.0  
              http://www.opensource.org/licenses/osl-3.0.php"""  
 __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 45  class Test_linearPDEs(unittest.TestCase) Line 62  class Test_linearPDEs(unittest.TestCase)
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 113  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() == 10, "initial  LevelMax is wrong.")
647            self.failUnlessRaises(ValueError,so.setLevelMax,-1)
648            so.setLevelMax(3)
649            self.failUnless(so.getLevelMax() == 3, "LevelMax is wrong.")
650    
651            self.failUnless(so.getCoarseningThreshold() == 0.05, "initial  CoarseningThreshold is wrong.")
652            self.failUnlessRaises(ValueError,so.setCoarseningThreshold,-1)
653            so.setCoarseningThreshold(0.1)
654            self.failUnless(so.getCoarseningThreshold() == 0.1, "CoarseningThreshold is wrong.")
655    
656            self.failUnless(so.getNumSweeps() == 2, "initial  Sweeps is wrong.")
657            self.failUnlessRaises(ValueError,so.setNumSweeps,-1)
658            so.setNumSweeps(3)
659            self.failUnless(so.getNumSweeps() == 3, "Sweeps is wrong.")
660    
661            self.failUnless(so.getNumPreSweeps() == 2, "initial  PreSweeps is wrong.")
662            self.failUnlessRaises(ValueError,so.setNumPreSweeps,-1)
663            so.setNumPreSweeps(4)
664            self.failUnless(so.getNumPreSweeps() == 4, "PreSweeps is wrong.")
665    
666            self.failUnless(so.getNumPostSweeps() == 2, "initial  PreSweeps is wrong.")
667            self.failUnlessRaises(ValueError,so.setNumPostSweeps,-1)
668            so.setNumPostSweeps(5)
669            self.failUnless(so.getNumPostSweeps() == 5, "PreSweeps is wrong.")
670    
671            self.failUnless(so.getTolerance() == 1.e-8, "initial Tolerance is wrong.")
672            self.failUnlessRaises(ValueError,so.setTolerance,-1)
673            so.setTolerance(0.2)
674            self.failUnless(so.getTolerance() == 0.2, "Tolerance is wrong.")
675    
676            self.failUnless(so.getAbsoluteTolerance() == 0., "initial  AbsoluteTolerance is wrong.")
677            self.failUnlessRaises(ValueError,so.setAbsoluteTolerance,-1)
678            so.setAbsoluteTolerance(0.3)
679            self.failUnless(so.getAbsoluteTolerance() == 0.3, "AbsoluteTolerance is wrong.")
680    
681            self.failUnless(so.getInnerTolerance() == 0.9, "initial InnerTolerance is wrong.")
682            self.failUnlessRaises(ValueError,so.setInnerTolerance,-1)
683            so.setInnerTolerance(0.4)
684            self.failUnless(so.getInnerTolerance() == 0.4, "InnerTolerance is wrong.")
685    
686            self.failUnless(so.getDropTolerance() == 0.01, "initial DropTolerance is wrong.")
687            self.failUnlessRaises(ValueError,so.setDropTolerance,-1)
688            so.setDropTolerance(0.5)
689            self.failUnless(so.getDropTolerance() == 0.5, "DropDropTolerance is wrong.")
690    
691            self.failUnless(so.getDropStorage() == 2., "initial DropStorage is wrong.")
692            self.failUnlessRaises(ValueError,so.setDropStorage,-1)
693            so.setDropStorage(10)
694            self.failUnless(so.getDropStorage() == 10, "DropStorage is wrong.")
695            
696            self.failUnless(so.getRelaxationFactor() == 0.3, "initial RelaxationFactor is wrong.")
697            self.failUnlessRaises(ValueError,so.setRelaxationFactor,-1)
698            so.setRelaxationFactor(0.1)
699            self.failUnless(so.getRelaxationFactor() == 0.1, "Relaxation is wrong.")
700    
701    
702            self.failUnless(so.getIterMax() == 10000, "initial IterMax is wrong.")
703            self.failUnlessRaises(ValueError,so.setIterMax,0)
704            so.setIterMax(11)
705            self.failUnless(so.getIterMax() == 11, "IterMax is wrong.")
706    
707            self.failUnless(so.getInnerIterMax() == 10, "initial InnerIterMax is wrong.")
708            self.failUnlessRaises(ValueError,so.setInnerIterMax,0)
709            so.setInnerIterMax(12)
710            self.failUnless(so.getInnerIterMax() == 12, "InnerIterMax is wrong.")
711    
712            self.failUnless(so.getTruncation() == 20, "initial Truncation is wrong.")
713            self.failUnlessRaises(ValueError,so.setTruncation,0)
714            so.setTruncation(13)
715            self.failUnless(so.getTruncation() == 13, "Truncation is wrong.")
716    
717            self.failUnless(so.getRestart() == None, "initial Truncation is wrong.")
718            self.failUnlessRaises(ValueError,so.setTruncation,0)
719            so.setRestart(14)
720            self.failUnless(so.getRestart() == 14, "Truncation is wrong.")
721            so.setRestart(None)
722            self.failUnless(so.getRestart() == None, "Truncation is wrong.")
723        
724            self.failUnless(not so.isVerbose(), "initial verbosity flag is wrong.")
725            so.setVerbosityOn()
726            self.failUnless(so.isVerbose(), "verbosity (1) flag is wrong.")
727            so.setVerbosityOff()
728            self.failUnless(not so.isVerbose(), "verbosity (2) flag is wrong.")
729            so.setVerbosity(verbose=True)
730            self.failUnless(so.isVerbose(), "verbosity (3) flag is wrong.")
731            so.setVerbosity(verbose=False)
732            self.failUnless(not so.isVerbose(), "verbosity (4) flag is wrong.")
733    
734            self.failUnless(not so.isSymmetric(), "initial symmetry flag is wrong.")
735            so.setSymmetryOn()
736            self.failUnless(so.isSymmetric(), "symmetry (1) flag is wrong.")
737            so.setSymmetryOff()
738            self.failUnless(not so.isSymmetric(), "symmetry (2) flag is wrong.")
739            so.setSymmetry(flag=True)
740            self.failUnless(so.isSymmetric(), "symmetry (3) flag is wrong.")
741            so.setSymmetry(flag=False)
742            self.failUnless(not so.isSymmetric(), "symmetry (4) flag is wrong.")
743    
744            self.failUnless(so.adaptInnerTolerance(), "initial InnerToleranceAdaption flag is wrong.")
745            so.setInnerToleranceAdaptionOn()
746            self.failUnless(so.adaptInnerTolerance(), "InnerToleranceAdaption (1) flag is wrong.")
747            so.setInnerToleranceAdaptionOff()
748            self.failUnless(not so.adaptInnerTolerance(), "InnerToleranceAdaption (2) flag is wrong.")
749            so.setInnerToleranceAdaption(adapt=True)
750            self.failUnless(so.adaptInnerTolerance(), "InnerToleranceAdaption (3) flag is wrong.")
751            so.setInnerToleranceAdaption(adapt=False)
752            self.failUnless(not so.adaptInnerTolerance(), "InnerToleranceAdaption (4) flag is wrong.")
753        
754            self.failUnless(not so.acceptConvergenceFailure(), "initial acceptConvergenceFailure flag is wrong.")
755            so.setAcceptanceConvergenceFailureOn()
756            self.failUnless(so.acceptConvergenceFailure(), "acceptConvergenceFailure (1) flag is wrong.")
757            so.setAcceptanceConvergenceFailureOff()
758            self.failUnless(not so.acceptConvergenceFailure(), "acceptConvergenceFailure (2) flag is wrong.")
759            so.setAcceptanceConvergenceFailure(accept=True)
760            self.failUnless(so.acceptConvergenceFailure(), "acceptConvergenceFailure (3) flag is wrong.")
761            so.setAcceptanceConvergenceFailure(accept=False)
762            self.failUnless(not so.acceptConvergenceFailure(), "acceptConvergenceFailure (4) flag is wrong.")  
763            
764            self.failUnless(so.getReordering() == 30, "initial Reordering is wrong.")
765            self.failUnlessRaises(ValueError,so.setReordering,-1)
766            so.setReordering(so.NO_REORDERING)
767            self.failUnless(so.getReordering() == 17, "NO_REORDERING is not set.")
768            so.setReordering(so.MINIMUM_FILL_IN)
769            self.failUnless(so.getReordering() == 18, "MINIMUM_FILL_IN is not set.")
770            so.setReordering(so.NESTED_DISSECTION)
771            self.failUnless(so.getReordering() == 19, "NESTED_DISSECTION is not set.")
772            so.setReordering(so.DEFAULT_REORDERING)
773            self.failUnless(so.getReordering() == 30, "DEFAULT_REORDERING is not set.")
774            
775            self.failUnless(so.getPackage() == 0, "initial solver package is wrong.")
776            self.failUnlessRaises(ValueError,so.setPackage,-1)
777            so.setPackage(so.PASO)
778            self.failUnless(so.getPackage() == 21, "PASO is not set.")
779            so.setPackage(so.SUPER_LU)
780            self.failUnless(so.getPackage() == 31, "SUPER_LU is not set.")
781            so.setPackage(so.PASTIX)
782            self.failUnless(so.getPackage() == 32, "PASTIX is not set.")
783            so.setPackage(so.MKL)
784            self.failUnless(so.getPackage() == 15, "MKL is not set.")
785            so.setPackage(so.UMFPACK)
786            self.failUnless(so.getPackage() == 16, "UMFPACK is not set.")
787            so.setPackage(so.TRILINOS)
788            self.failUnless(so.getPackage() == 24, "TRILINOS is not set.")
789    
790            self.failUnless(so.getSolverMethod() == 0, "initial SolverMethod is wrong.")
791            self.failUnlessRaises(ValueError,so.setSolverMethod,-1)
792            so.setSolverMethod(so.DIRECT)
793            self.failUnless(so.getSolverMethod() == 1, "DIRECT is not set.")
794            so.setSolverMethod(so.CHOLEVSKY)
795            self.failUnless(so.getSolverMethod() == 2, "CHOLEVSKY is not set.")
796            so.setSolverMethod(so.PCG)
797            self.failUnless(so.getSolverMethod() == 3, "PCG is not set.")
798            so.setSolverMethod(so.CR)
799            self.failUnless(so.getSolverMethod() == 4, "CR is not set.")
800            so.setSolverMethod(so.CGS)
801            self.failUnless(so.getSolverMethod() == 5, "CGS is not set.")
802            so.setSolverMethod(so.BICGSTAB)
803            self.failUnless(so.getSolverMethod() == 6, "BICGSTAB is not set.")
804            so.setSolverMethod(so.SSOR)
805            self.failUnless(so.getSolverMethod() == 7, "SSOR is not set.")
806            so.setSolverMethod(so.GMRES)
807            self.failUnless(so.getSolverMethod() == 11, "GMRES is not set.")
808            so.setSolverMethod(so.PRES20)
809            self.failUnless(so.getSolverMethod() == 12, "PRES20 is not set.")
810            so.setSolverMethod(so.LUMPING)
811            self.failUnless(so.getSolverMethod() == 13, "LUMPING is not set.")
812            so.setSolverMethod(so.ITERATIVE)
813            self.failUnless(so.getSolverMethod() == 20, "ITERATIVE is not set.")
814            so.setSolverMethod(so.AMG)
815            self.failUnless(so.getSolverMethod() == 22, "AMG is not set.")
816            so.setSolverMethod(so.NONLINEAR_GMRES)
817            self.failUnless(so.getSolverMethod() == 25, "NONLINEAR_GMRES is not set.")
818            so.setSolverMethod(so.TFQMR)
819            self.failUnless(so.getSolverMethod() == 26, "TFQMR is not set.")
820            so.setSolverMethod(so.MINRES)
821            self.failUnless(so.getSolverMethod() == 27, "MINRES is not set.")
822            so.setSolverMethod(so.GAUSS_SEIDEL)
823            self.failUnless(so.getSolverMethod() == 28, "GAUSS_SEIDEL is not set.")
824            so.setSolverMethod(so.DEFAULT)
825            self.failUnless(so.getSolverMethod() == 0, "DEFAULT is not set.")
826    
827            self.failUnless(so.getPreconditioner() == 10, "initial Preconditioner is wrong.")
828            self.failUnlessRaises(ValueError,so.setPreconditioner,-1)
829            so.setPreconditioner(so.ILU0)
830            self.failUnless(so.getPreconditioner() == 8, "ILU0 is not set.")
831            so.setPreconditioner(so.SSOR)
832            self.failUnless(so.getPreconditioner() == 7, "SSOR is not set.")
833            so.setPreconditioner(so.ILUT)
834            self.failUnless(so.getPreconditioner() == 9, "ILUT is not set.")
835            so.setPreconditioner(so.JACOBI)
836            self.failUnless(so.getPreconditioner() == 10, "JACOBI is not set.")
837            so.setPreconditioner(so.AMG)
838            self.failUnless(so.getPreconditioner() == 22, "AMG is not set.")
839            so.setPreconditioner(so.REC_ILU)
840            self.failUnless(so.getPreconditioner() == 23, "REC_ILU is not set.")
841            so.setPreconditioner(so.GAUSS_SEIDEL)
842            self.failUnless(so.getPreconditioner() == 28, "GAUSS_SEIDEL is not set.")
843            so.setPreconditioner(so.RILU)
844            self.failUnless(so.getPreconditioner() == 29, "RILU is not set.")
845            so.setPreconditioner(so.NO_PRECONDITIONER)
846            self.failUnless(so.getPreconditioner() == 36, "NO_PRECONDITIONER is not set.")        
847    
848            self.failUnless(so.getCoarsening() == 0, "initial Coarseningr is wrong.")
849            self.failUnlessRaises(ValueError,so.setCoarsening,-1)
850            so.setCoarsening(so.YAIR_SHAPIRA_COARSENING)
851            self.failUnless(so.getCoarsening() == 33, "YAIR_SHAPIRA_COARSENING is not set.")
852            so.setCoarsening(so.RUGE_STUEBEN_COARSENING)
853            self.failUnless(so.getCoarsening() == 34, "RUGE_STUEBEN_COARSENING is not set.")
854            so.setCoarsening(so.AGGREGATION_COARSENING)
855            self.failUnless(so.getCoarsening() == 35, "AGREGATION_COARSENING is not set.")
856            so.setCoarsening(so.DEFAULT)
857            self.failUnless(so.getCoarsening() == 0, "DEFAULT is not set.")
858    
859            self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
860            self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
861            self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
862            self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
863            self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
864            self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
865            self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong.")
866            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 0, "initial cum_num_inner_iter is wrong.")
867            self.failUnless(so.getDiagnostics("cum_num_iter") == 0, "initial cum_num_iter is wrong.")
868            self.failUnless(so.getDiagnostics("cum_time") ==0, "initial cum_time is wrong.")
869            self.failUnless(so.getDiagnostics("cum_set_up_time") == 0, "initial cum_set_up_time is wrong.")
870    
871            so._updateDiagnostics("num_iter",1)
872            so._updateDiagnostics("num_inner_iter",2)
873            so._updateDiagnostics("time",3)
874            so._updateDiagnostics("set_up_time",4)
875            so._updateDiagnostics("residual_norm",5)
876            so._updateDiagnostics("converged",True)
877    
878            self.failUnless(so.getDiagnostics("num_iter") == 1, "num_iter is wrong.")
879            self.failUnless(so.getDiagnostics("num_inner_iter") == 2, "num_inner_iter is wrong.")
880            self.failUnless(so.getDiagnostics("time") == 3, "time is wrong.")
881            self.failUnless(so.getDiagnostics("set_up_time") == 4, "set_up_time is wrong.")
882            self.failUnless(so.getDiagnostics("residual_norm") == 5, "residual_norm is wrong.")
883            self.failUnless(so.getDiagnostics("converged"), "converged is wrong.")
884            self.failUnless(so.hasConverged(), "convergence flag is wrong.")
885            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 2, "cum_num_inner_iter is wrong.")
886            self.failUnless(so.getDiagnostics("cum_num_iter") == 1, "cum_num_iter is wrong.")
887            self.failUnless(so.getDiagnostics("cum_time") ==3, "cum_time is wrong.")
888            self.failUnless(so.getDiagnostics("cum_set_up_time") == 4, "cum_set_up_time is wrong.")  
889            
890            so.resetDiagnostics()
891            self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
892            self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
893            self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
894            self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
895            self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
896            self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
897            self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong")      
898            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 2, "cum_num_inner_iter is wrong.")
899            self.failUnless(so.getDiagnostics("cum_num_iter") == 1, "cum_num_iter is wrong.")
900            self.failUnless(so.getDiagnostics("cum_time") ==3, "cum_time is wrong.")
901            self.failUnless(so.getDiagnostics("cum_set_up_time") == 4, "cum_set_up_time is wrong.")
902    
903            so._updateDiagnostics("num_iter",10)
904            so._updateDiagnostics("num_inner_iter",20)
905            so._updateDiagnostics("time",30)
906            so._updateDiagnostics("set_up_time",40)
907            so._updateDiagnostics("residual_norm",50)
908            so._updateDiagnostics("converged",False)
909    
910            self.failUnless(so.getDiagnostics("num_iter") == 10, "num_iter is wrong.")
911            self.failUnless(so.getDiagnostics("num_inner_iter") == 20, "num_inner_iter is wrong.")
912            self.failUnless(so.getDiagnostics("time") == 30, "time is wrong.")
913            self.failUnless(so.getDiagnostics("set_up_time") == 40, "set_up_time is wrong.")
914            self.failUnless(so.getDiagnostics("residual_norm") == 50, "residual_norm is wrong.")
915            self.failUnless(not so.getDiagnostics("converged"), "converged is wrong.")
916            self.failUnless(not so.hasConverged(), "convergence flag is wrong.")
917            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 22, "cum_num_inner_iter is wrong.")
918            self.failUnless(so.getDiagnostics("cum_num_iter") == 11, "cum_num_iter is wrong.")
919            self.failUnless(so.getDiagnostics("cum_time") ==33, "cum_time is wrong.")
920            self.failUnless(so.getDiagnostics("cum_set_up_time") == 44, "cum_set_up_time is wrong.")  
921    
922            so.resetDiagnostics(all=True)
923            self.failUnless(so.getDiagnostics("num_iter") == None, "initial num_iter is wrong.")
924            self.failUnless(so.getDiagnostics("num_inner_iter") == None, "initial num_inner_iter is wrong.")
925            self.failUnless(so.getDiagnostics("time") == None, "initial time is wrong.")
926            self.failUnless(so.getDiagnostics("set_up_time") == None, "initial set_up_time is wrong.")
927            self.failUnless(so.getDiagnostics("residual_norm") == None, "initial residual_norm is wrong.")
928            self.failUnless(so.getDiagnostics("converged") == None, "initial converged is wrong.")
929            self.failUnless(so.hasConverged() == None, "initial convergence flag is wrong.")
930            self.failUnless(so.getDiagnostics("cum_num_inner_iter") == 0, "initial cum_num_inner_iter is wrong.")
931            self.failUnless(so.getDiagnostics("cum_num_iter") == 0, "initial cum_num_iter is wrong.")
932            self.failUnless(so.getDiagnostics("cum_time") ==0, "initial cum_time is wrong.")
933            self.failUnless(so.getDiagnostics("cum_set_up_time") == 0, "initial cum_set_up_time is wrong.")
934            
935      def test_setCoefficient_WithIllegalFunctionSpace(self):      def test_setCoefficient_WithIllegalFunctionSpace(self):
936          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
937          try:          self.failUnlessRaises(IllegalCoefficientFunctionSpace, mypde.setValue, C=Vector(0.,FunctionOnBoundary(self.domain)))
938             success=True  
939             mypde.setValue(C=Vector(0.,FunctionOnBoundary(self.domain)))      def test_setCoefficient_WithWrongName(self):
940          except IllegalCoefficientValue:          mypde=LinearPDE(self.domain,debug=self.DEBUG)
941             success=False          self.failUnlessRaises(IllegalCoefficient, mypde.setValue, ROMA=0.)
942          self.failUnless(not success,'inapropraite function space accepted')  
           
943      def test_resetCoefficient_WithWrongShape(self):      def test_resetCoefficient_WithWrongShape(self):
944          mypde=LinearPDE(self.domain,numEquations=2,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=2,debug=self.DEBUG)
945          try:          self.failUnlessRaises(IllegalCoefficientValue, mypde.setValue, C=0.)
946             success=True  
            mypde.setValue(C=0.)  
         except IllegalCoefficientValue:  
            success=False  
         self.failUnless(not success,'illegal shape accepted')  
947      def test_reducedOn(self):      def test_reducedOn(self):
948          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
949          x=self.domain.getX()          x=self.domain.getX()
# Line 143  class Test_LinearPDE(Test_linearPDEs): Line 955  class Test_LinearPDE(Test_linearPDEs):
955      def test_attemptToChangeOrderAfterDefinedCoefficient(self):      def test_attemptToChangeOrderAfterDefinedCoefficient(self):
956          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
957          mypde.setValue(D=1.)          mypde.setValue(D=1.)
958          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.')  
959    
960      def test_reducedOnConfig(self):      def test_reducedOnConfig(self):
961          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
962          mypde.setReducedOrderOn()          mypde.setReducedOrderOn()
963          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.")
964      #      #
965      #  set coefficients for scalars:      #  set coefficients for scalars:
966      #      #
967      def test_setCoefficient_A_Scalar(self):      def test_setCoefficient_A_Scalar(self):
968          d=self.domain.getDim()          d=self.domain.getDim()
969          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
970          mypde.setValue(A=numarray.ones((d,d)))          mypde.setValue(A=numpy.ones((d,d)))
971          coeff=mypde.getCoefficientOfGeneralPDE("A")          coeff=mypde.getCoefficient("A")
972          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))
973      def test_setCoefficient_B_Scalar(self):      def test_setCoefficient_B_Scalar(self):
974          d=self.domain.getDim()          d=self.domain.getDim()
975          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
976          mypde.setValue(B=numarray.ones((d,)))          mypde.setValue(B=numpy.ones((d,)))
977          coeff=mypde.getCoefficientOfGeneralPDE("B")          coeff=mypde.getCoefficient("B")
978          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))
979      def test_setCoefficient_C_Scalar(self):      def test_setCoefficient_C_Scalar(self):
980          d=self.domain.getDim()          d=self.domain.getDim()
981          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
982          mypde.setValue(C=numarray.ones((d,)))          mypde.setValue(C=numpy.ones((d,)))
983          coeff=mypde.getCoefficientOfGeneralPDE("C")          coeff=mypde.getCoefficient("C")
984          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))
985      def test_setCoefficient_D_Scalar(self):      def test_setCoefficient_D_Scalar(self):
986          d=self.domain.getDim()          d=self.domain.getDim()
987          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
988          mypde.setValue(D=1.)          mypde.setValue(D=1.)
989          coeff=mypde.getCoefficientOfGeneralPDE("D")          coeff=mypde.getCoefficient("D")
990          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))
991      def test_setCoefficient_X_Scalar(self):      def test_setCoefficient_X_Scalar(self):
992          d=self.domain.getDim()          d=self.domain.getDim()
993          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
994          mypde.setValue(X=numarray.ones((d,)))          mypde.setValue(X=numpy.ones((d,)))
995          coeff=mypde.getCoefficientOfGeneralPDE("X")          coeff=mypde.getCoefficient("X")
996          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))
997      def test_setCoefficient_Y_Scalar(self):      def test_setCoefficient_Y_Scalar(self):
998          d=self.domain.getDim()          d=self.domain.getDim()
999          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1000          mypde.setValue(Y=1.)          mypde.setValue(Y=1.)
1001          coeff=mypde.getCoefficientOfGeneralPDE("Y")          coeff=mypde.getCoefficient("Y")
1002          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((),Function(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),Function(self.domain),1))
1003      def test_setCoefficient_y_Scalar(self):      def test_setCoefficient_y_Scalar(self):
1004          d=self.domain.getDim()          d=self.domain.getDim()
1005          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1006          mypde.setValue(y=1.)          mypde.setValue(y=1.)
1007          coeff=mypde.getCoefficientOfGeneralPDE("y")          coeff=mypde.getCoefficient("y")
1008          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1))
1009      def test_setCoefficient_d_Scalar(self):      def test_setCoefficient_d_Scalar(self):
1010          d=self.domain.getDim()          d=self.domain.getDim()
1011          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1012          mypde.setValue(d=1.)          mypde.setValue(d=1.)
1013          coeff=mypde.getCoefficientOfGeneralPDE("d")          coeff=mypde.getCoefficient("d")
1014          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))
1015      def test_setCoefficient_d_contact_Scalar(self):      def test_setCoefficient_d_contact_Scalar(self):
1016          d=self.domain.getDim()          d=self.domain.getDim()
1017          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1018          mypde.setValue(d_contact=1.)          mypde.setValue(d_contact=1.)
1019          coeff=mypde.getCoefficientOfGeneralPDE("d_contact")          coeff=mypde.getCoefficient("d_contact")
1020          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))
1021      def test_setCoefficient_y_contact_Scalar(self):      def test_setCoefficient_y_contact_Scalar(self):
1022          d=self.domain.getDim()          d=self.domain.getDim()
1023          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1024          mypde.setValue(y_contact=1.)          mypde.setValue(y_contact=1.)
1025          coeff=mypde.getCoefficientOfGeneralPDE("y_contact")          coeff=mypde.getCoefficient("y_contact")
1026          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1))
1027        def test_setCoefficient_A_reduced_Scalar(self):
1028            d=self.domain.getDim()
1029            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1030            mypde.setValue(A_reduced=numpy.ones((d,d)))
1031            coeff=mypde.getCoefficient("A_reduced")
1032            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
1033        def test_setCoefficient_B_reduced_Scalar(self):
1034            d=self.domain.getDim()
1035            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1036            mypde.setValue(B_reduced=numpy.ones((d,)))
1037            coeff=mypde.getCoefficient("B_reduced")
1038            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1039        def test_setCoefficient_C_reduced_Scalar(self):
1040            d=self.domain.getDim()
1041            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1042            mypde.setValue(C_reduced=numpy.ones((d,)))
1043            coeff=mypde.getCoefficient("C_reduced")
1044            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1045        def test_setCoefficient_D_reduced_Scalar(self):
1046            d=self.domain.getDim()
1047            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1048            mypde.setValue(D_reduced=1.)
1049            coeff=mypde.getCoefficient("D_reduced")
1050            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
1051        def test_setCoefficient_X_reduced_Scalar(self):
1052            d=self.domain.getDim()
1053            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1054            mypde.setValue(X_reduced=numpy.ones((d,)))
1055            coeff=mypde.getCoefficient("X_reduced")
1056            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
1057        def test_setCoefficient_Y_reduced_Scalar(self):
1058            d=self.domain.getDim()
1059            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1060            mypde.setValue(Y_reduced=1.)
1061            coeff=mypde.getCoefficient("Y_reduced")
1062            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
1063        def test_setCoefficient_y_reduced_Scalar(self):
1064            d=self.domain.getDim()
1065            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1066            mypde.setValue(y_reduced=1.)
1067            coeff=mypde.getCoefficient("y_reduced")
1068            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
1069        def test_setCoefficient_d_reduced_Scalar(self):
1070            d=self.domain.getDim()
1071            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1072            mypde.setValue(d_reduced=1.)
1073            coeff=mypde.getCoefficient("d_reduced")
1074            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
1075        def test_setCoefficient_d_contact_reduced_Scalar(self):
1076            d=self.domain.getDim()
1077            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1078            mypde.setValue(d_contact_reduced=1.)
1079            coeff=mypde.getCoefficient("d_contact_reduced")
1080            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
1081        def test_setCoefficient_y_contact_reduced_Scalar(self):
1082            d=self.domain.getDim()
1083            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1084            mypde.setValue(y_contact_reduced=1.)
1085            coeff=mypde.getCoefficient("y_contact_reduced")
1086            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
1087      def test_setCoefficient_r_Scalar(self):      def test_setCoefficient_r_Scalar(self):
1088          d=self.domain.getDim()          d=self.domain.getDim()
1089          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1090          mypde.setValue(r=1.)          mypde.setValue(r=1.)
1091          coeff=mypde.getCoefficientOfGeneralPDE("r")          coeff=mypde.getCoefficient("r")
1092          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((),Solution(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
1093      def test_setCoefficient_q_Scalar(self):      def test_setCoefficient_q_Scalar(self):
1094          d=self.domain.getDim()          d=self.domain.getDim()
1095          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1096          mypde.setValue(q=1.)          mypde.setValue(q=1.)
1097          coeff=mypde.getCoefficientOfGeneralPDE("q")          coeff=mypde.getCoefficient("q")
1098          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((),Solution(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
1099      def test_setCoefficient_r_Scalar_reducedOn(self):      def test_setCoefficient_r_Scalar_reducedOn(self):
1100          d=self.domain.getDim()          d=self.domain.getDim()
1101          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1102          mypde.setReducedOrderOn()          mypde.setReducedOrderOn()
1103          mypde.setValue(r=1.)          mypde.setValue(r=1.)
1104          coeff=mypde.getCoefficientOfGeneralPDE("r")          coeff=mypde.getCoefficient("r")
1105          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(),mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))          self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
1106      def test_setCoefficient_q_Scalar_reducedOn(self):      def test_setCoefficient_q_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(q=1.)          mypde.setValue(q=1.)
1111          coeff=mypde.getCoefficientOfGeneralPDE("q")          coeff=mypde.getCoefficient("q")
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    
1114        def test_setCoefficient_A_reduced_Scalar_usingA(self):
1115            d=self.domain.getDim()
1116            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1117            mypde.setValue(A=Data(numpy.ones((d,d)),ReducedFunction(self.domain)))
1118            coeff=mypde.getCoefficient("A_reduced")
1119            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
1120        def test_setCoefficient_B_reduced_Scalar_usingB(self):
1121            d=self.domain.getDim()
1122            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1123            mypde.setValue(B=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1124            coeff=mypde.getCoefficient("B_reduced")
1125            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1126        def test_setCoefficient_C_reduced_Scalar_usingC(self):
1127            d=self.domain.getDim()
1128            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1129            mypde.setValue(C=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1130            coeff=mypde.getCoefficient("C_reduced")
1131            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
1132        def test_setCoefficient_D_reduced_Scalar_usingD(self):
1133            d=self.domain.getDim()
1134            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1135            mypde.setValue(D=Scalar(1.,ReducedFunction(self.domain)))
1136            coeff=mypde.getCoefficient("D_reduced")
1137            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
1138        def test_setCoefficient_X_reduced_Scalar_usingX(self):
1139            d=self.domain.getDim()
1140            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1141            mypde.setValue(X_reduced=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
1142            coeff=mypde.getCoefficient("X_reduced")
1143            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
1144        def test_setCoefficient_Y_reduced_Scalar_usingY(self):
1145            d=self.domain.getDim()
1146            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1147            mypde.setValue(Y=Scalar(1.,ReducedFunction(self.domain)))
1148            coeff=mypde.getCoefficient("Y_reduced")
1149            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
1150        def test_setCoefficient_y_reduced_Scalar_using_y(self):
1151            d=self.domain.getDim()
1152            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1153            mypde.setValue(y=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
1154            coeff=mypde.getCoefficient("y_reduced")
1155            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
1156        def test_setCoefficient_d_reduced_Scalar_using_d(self):
1157            d=self.domain.getDim()
1158            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1159            mypde.setValue(d=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
1160            coeff=mypde.getCoefficient("d_reduced")
1161            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
1162        def test_setCoefficient_d_contact_reduced_Scalar_using_d_contact(self):
1163            d=self.domain.getDim()
1164            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1165            mypde.setValue(d_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
1166            coeff=mypde.getCoefficient("d_contact_reduced")
1167            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
1168        def test_setCoefficient_y_contact_reduced_Scalar_using_y_contact(self):
1169            d=self.domain.getDim()
1170            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1171            mypde.setValue(y_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
1172            coeff=mypde.getCoefficient("y_contact_reduced")
1173            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
1174      #      #
1175      #  set coefficients for systems:      #  set coefficients for systems:
1176      #      #
1177      def test_setCoefficient_A_System(self):      def test_setCoefficient_A_System(self):
1178          d=self.domain.getDim()          d=self.domain.getDim()
1179          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1180          mypde.setValue(A=numarray.ones((self.N,d,self.N,d)))          mypde.setValue(A=numpy.ones((self.N,d,self.N,d)))
1181          coeff=mypde.getCoefficientOfGeneralPDE("A")          coeff=mypde.getCoefficient("A")
1182          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))
1183      def test_setCoefficient_B_System(self):      def test_setCoefficient_B_System(self):
1184          d=self.domain.getDim()          d=self.domain.getDim()
1185          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1186          mypde.setValue(B=numarray.ones((self.N,d,self.N)))          mypde.setValue(B=numpy.ones((self.N,d,self.N)))
1187          coeff=mypde.getCoefficientOfGeneralPDE("B")          coeff=mypde.getCoefficient("B")
1188          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))
1189      def test_setCoefficient_C_System(self):      def test_setCoefficient_C_System(self):
1190          d=self.domain.getDim()          d=self.domain.getDim()
1191          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1192          mypde.setValue(C=numarray.ones((self.N,self.N,d)))          mypde.setValue(C=numpy.ones((self.N,self.N,d)))
1193          coeff=mypde.getCoefficientOfGeneralPDE("C")          coeff=mypde.getCoefficient("C")
1194          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))
1195      def test_setCoefficient_D_System(self):      def test_setCoefficient_D_System(self):
1196          d=self.domain.getDim()          d=self.domain.getDim()
1197          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1198          mypde.setValue(D=numarray.ones((self.N,self.N)))          mypde.setValue(D=numpy.ones((self.N,self.N)))
1199          coeff=mypde.getCoefficientOfGeneralPDE("D")          coeff=mypde.getCoefficient("D")
1200          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))
1201      def test_setCoefficient_X_System(self):      def test_setCoefficient_X_System(self):
1202          d=self.domain.getDim()          d=self.domain.getDim()
1203          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1204          mypde.setValue(X=numarray.ones((self.N,d)))          mypde.setValue(X=numpy.ones((self.N,d)))
1205          coeff=mypde.getCoefficientOfGeneralPDE("X")          coeff=mypde.getCoefficient("X")
1206          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))
1207      def test_setCoefficient_Y_System(self):      def test_setCoefficient_Y_System(self):
1208          d=self.domain.getDim()          d=self.domain.getDim()
1209          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1210          mypde.setValue(Y=numarray.ones((self.N,)))          mypde.setValue(Y=numpy.ones((self.N,)))
1211          coeff=mypde.getCoefficientOfGeneralPDE("Y")          coeff=mypde.getCoefficient("Y")
1212          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))
1213      def test_setCoefficient_y_System(self):      def test_setCoefficient_y_System(self):
1214          d=self.domain.getDim()          d=self.domain.getDim()
1215          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1216          mypde.setValue(y=numarray.ones((self.N,)))          mypde.setValue(y=numpy.ones((self.N,)))
1217          coeff=mypde.getCoefficientOfGeneralPDE("y")          coeff=mypde.getCoefficient("y")
1218          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))
1219      def test_setCoefficient_d_System(self):      def test_setCoefficient_d_System(self):
1220          d=self.domain.getDim()          d=self.domain.getDim()
1221          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1222          mypde.setValue(d=numarray.ones((self.N,self.N)))          mypde.setValue(d=numpy.ones((self.N,self.N)))
1223          coeff=mypde.getCoefficientOfGeneralPDE("d")          coeff=mypde.getCoefficient("d")
1224          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))
1225      def test_setCoefficient_d_contact_System(self):      def test_setCoefficient_d_contact_System(self):
1226          d=self.domain.getDim()          d=self.domain.getDim()
1227          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1228          mypde.setValue(d_contact=numarray.ones((self.N,self.N)))          mypde.setValue(d_contact=numpy.ones((self.N,self.N)))
1229          coeff=mypde.getCoefficientOfGeneralPDE("d_contact")          coeff=mypde.getCoefficient("d_contact")
1230          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))
1231      def test_setCoefficient_y_contact_System(self):      def test_setCoefficient_y_contact_System(self):
1232          d=self.domain.getDim()          d=self.domain.getDim()
1233          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1234          mypde.setValue(y_contact=numarray.ones((self.N,)))          mypde.setValue(y_contact=numpy.ones((self.N,)))
1235          coeff=mypde.getCoefficientOfGeneralPDE("y_contact")          coeff=mypde.getCoefficient("y_contact")
1236          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))
1237        def test_setCoefficient_A_reduced_System(self):
1238            d=self.domain.getDim()
1239            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1240            mypde.setValue(A_reduced=numpy.ones((self.N,d,self.N,d)))
1241            coeff=mypde.getCoefficient("A_reduced")
1242            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1243        def test_setCoefficient_B_reduced_System(self):
1244            d=self.domain.getDim()
1245            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1246            mypde.setValue(B_reduced=numpy.ones((self.N,d,self.N)))
1247            coeff=mypde.getCoefficient("B_reduced")
1248            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
1249        def test_setCoefficient_C_reduced_System(self):
1250            d=self.domain.getDim()
1251            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1252            mypde.setValue(C_reduced=numpy.ones((self.N,self.N,d)))
1253            coeff=mypde.getCoefficient("C_reduced")
1254            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1255        def test_setCoefficient_D_System_reduced(self):
1256            d=self.domain.getDim()
1257            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1258            mypde.setValue(D_reduced=numpy.ones((self.N,self.N)))
1259            coeff=mypde.getCoefficient("D_reduced")
1260            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
1261        def test_setCoefficient_X_System_reduced(self):
1262            d=self.domain.getDim()
1263            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1264            mypde.setValue(X_reduced=numpy.ones((self.N,d)))
1265            coeff=mypde.getCoefficient("X_reduced")
1266            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
1267        def test_setCoefficient_Y_System_reduced(self):
1268            d=self.domain.getDim()
1269            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1270            mypde.setValue(Y_reduced=numpy.ones((self.N,)))
1271            coeff=mypde.getCoefficient("Y_reduced")
1272            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
1273        def test_setCoefficient_y_System_reduced(self):
1274            d=self.domain.getDim()
1275            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1276            mypde.setValue(y_reduced=numpy.ones((self.N,)))
1277            coeff=mypde.getCoefficient("y_reduced")
1278            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
1279        def test_setCoefficient_d_reduced_System(self):
1280            d=self.domain.getDim()
1281            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1282            mypde.setValue(d_reduced=numpy.ones((self.N,self.N)))
1283            coeff=mypde.getCoefficient("d_reduced")
1284            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
1285        def test_setCoefficient_d_contact_reduced_System(self):
1286            d=self.domain.getDim()
1287            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1288            mypde.setValue(d_contact_reduced=numpy.ones((self.N,self.N)))
1289            coeff=mypde.getCoefficient("d_contact_reduced")
1290            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
1291        def test_setCoefficient_y_contact_reduced_System(self):
1292            d=self.domain.getDim()
1293            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1294            mypde.setValue(y_contact_reduced=numpy.ones((self.N,)))
1295            coeff=mypde.getCoefficient("y_contact_reduced")
1296            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
1297      def test_setCoefficient_r_System(self):      def test_setCoefficient_r_System(self):
1298          d=self.domain.getDim()          d=self.domain.getDim()
1299          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1300          mypde.setValue(r=numarray.ones((self.N,)))          mypde.setValue(r=numpy.ones((self.N,)))
1301          coeff=mypde.getCoefficientOfGeneralPDE("r")          coeff=mypde.getCoefficient("r")
1302          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))
1303      def test_setCoefficient_q_System(self):      def test_setCoefficient_q_System(self):
1304          d=self.domain.getDim()          d=self.domain.getDim()
1305          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1306          mypde.setValue(q=numarray.ones((self.N,)))          mypde.setValue(q=numpy.ones((self.N,)))
1307          coeff=mypde.getCoefficientOfGeneralPDE("q")          coeff=mypde.getCoefficient("q")
1308          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))
1309      def test_setCoefficient_r_System_reducedOn(self):      def test_setCoefficient_r_System_reducedOn(self):
1310          d=self.domain.getDim()          d=self.domain.getDim()
1311          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)          mypde=LinearPDE(self.domain,numEquations=3,debug=self.DEBUG)
1312          mypde.setReducedOrderOn()          mypde.setReducedOrderOn()
1313          mypde.setValue(r=numarray.ones((self.N,)))          mypde.setValue(r=numpy.ones((self.N,)))
1314          coeff=mypde.getCoefficientOfGeneralPDE("r")          coeff=mypde.getCoefficient("r")
1315          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))
1316      def test_setCoefficient_q_System_reducedOn(self):      def test_setCoefficient_q_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(q=numarray.ones((self.N,)))          mypde.setValue(q=numpy.ones((self.N,)))
1321          coeff=mypde.getCoefficientOfGeneralPDE("q")          coeff=mypde.getCoefficient("q")
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    
1324        def test_setCoefficient_A_reduced_System_using_A(self):
1325            d=self.domain.getDim()
1326            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1327            mypde.setValue(A=Data(numpy.ones((self.N,d,self.N,d)),ReducedFunction(self.domain)))
1328            coeff=mypde.getCoefficient("A_reduced")
1329            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1330        def test_setCoefficient_B_reduced_System_using_B(self):
1331            d=self.domain.getDim()
1332            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1333            mypde.setValue(B=Data(numpy.ones((self.N,d,self.N)),ReducedFunction(self.domain)))
1334            coeff=mypde.getCoefficient("B_reduced")
1335            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
1336        def test_setCoefficient_C_reduced_System_using_C(self):
1337            d=self.domain.getDim()
1338            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1339            mypde.setValue(C=Data(numpy.ones((self.N,self.N,d)),ReducedFunction(self.domain)))
1340            coeff=mypde.getCoefficient("C_reduced")
1341            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
1342        def test_setCoefficient_D_System_reduced_using_D(self):
1343            d=self.domain.getDim()
1344            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1345            mypde.setValue(D=Data(numpy.ones((self.N,self.N)),ReducedFunction(self.domain)))
1346            coeff=mypde.getCoefficient("D_reduced")
1347            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
1348        def test_setCoefficient_X_System_reduced_using_X(self):
1349            d=self.domain.getDim()
1350            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1351            mypde.setValue(X=Data(numpy.ones((self.N,d)),ReducedFunction(self.domain)))
1352            coeff=mypde.getCoefficient("X_reduced")
1353            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
1354        def test_setCoefficient_Y_System_reduced_using_Y(self):
1355            d=self.domain.getDim()
1356            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1357            mypde.setValue(Y=Data(numpy.ones((self.N,)),ReducedFunction(self.domain)))
1358            coeff=mypde.getCoefficient("Y_reduced")
1359            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
1360        def test_setCoefficient_y_reduced_System_using_y(self):
1361            d=self.domain.getDim()
1362            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1363            mypde.setValue(y=Data(numpy.ones((self.N,)),ReducedFunctionOnBoundary(self.domain)))
1364            coeff=mypde.getCoefficient("y_reduced")
1365            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
1366        def test_setCoefficient_d_reduced_System_using_d(self):
1367            d=self.domain.getDim()
1368            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1369            mypde.setValue(d=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnBoundary(self.domain)))
1370            coeff=mypde.getCoefficient("d_reduced")
1371            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
1372        def test_setCoefficient_d_contact_reduced_System_using_d_contact(self):
1373            d=self.domain.getDim()
1374            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1375            mypde.setValue(d_contact=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnContactZero(self.domain)))
1376            coeff=mypde.getCoefficient("d_contact_reduced")
1377            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
1378        def test_setCoefficient_y_contact_reduced_System_using_y_contact(self):
1379            d=self.domain.getDim()
1380            mypde=LinearPDE(self.domain,numSolutions=3,debug=self.DEBUG)
1381            mypde.setValue(y_contact=Data(numpy.ones((self.N,)),ReducedFunctionOnContactZero(self.domain)))
1382            coeff=mypde.getCoefficient("y_contact_reduced")
1383            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
1384      def test_resetCoefficient_HomogeneousConstraint(self):      def test_resetCoefficient_HomogeneousConstraint(self):
1385          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1386          x=self.domain.getX()          x=self.domain.getX()
# Line 346  class Test_LinearPDE(Test_linearPDEs): Line 1393  class Test_LinearPDE(Test_linearPDEs):
1393      def test_resetCoefficient_InHomogeneousConstraint(self):      def test_resetCoefficient_InHomogeneousConstraint(self):
1394          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1395          mypde.setSymmetryOn()          mypde.setSymmetryOn()
1396        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1397          x=self.domain.getX()          x=self.domain.getX()
1398          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]))
1399          u1=mypde.getSolution(verbose=self.VERBOSE)          u1=mypde.getSolution()
1400          mypde.setValue(Y=2.,D=2)          mypde.setValue(Y=2.,D=2)
1401          u2=mypde.getSolution(verbose=self.VERBOSE)          u2=mypde.getSolution()
1402          self.failUnless(self.check(u2,u1),'first solution is wrong.')          self.failUnless(self.check(u2,u1),'first solution is wrong.')
1403          u2=mypde.getSolution(verbose=self.VERBOSE)          u2=mypde.getSolution()
1404          self.failUnless(self.check(u2,u1),'first solution is wrong.')          self.failUnless(self.check(u2,u1),'first solution is wrong.')
1405          mypde.setValue(r=2,Y=4.)          mypde.setValue(r=2,Y=4.)
1406          u2=mypde.getSolution(verbose=self.VERBOSE)          u2=mypde.getSolution()
1407          self.failUnless(self.check(u2,2*u1),'second solution is wrong.')          self.failUnless(self.check(u2,2*u1),'second solution is wrong.')
1408    
1409      def test_symmetryCheckTrue_System(self):      def test_symmetryCheckTrue_System(self):
1410          d=self.domain.getDim()          d=self.domain.getDim()
1411          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1412          A=numarray.ones((self.N,d,self.N,d))          A=numpy.ones((self.N,d,self.N,d))
1413          C=2*numarray.ones((self.N,self.N,d))          C=2*numpy.ones((self.N,self.N,d))
1414          B=2*numarray.ones((self.N,d,self.N))          B=2*numpy.ones((self.N,d,self.N))
1415          D=3*numarray.ones((self.N,self.N))          D=3*numpy.ones((self.N,self.N))
1416          d=4*numarray.ones((self.N,self.N))          d=4*numpy.ones((self.N,self.N))
1417          d_contact=5*numarray.ones((self.N,self.N))          d_contact=5*numpy.ones((self.N,self.N))
1418          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)
1419          self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
1420    
1421      def test_symmetryCheckFalse_A_System(self):      def test_symmetryCheckFalse_A_System(self):
1422          d=self.domain.getDim()          d=self.domain.getDim()
1423          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1424          A=numarray.ones((self.N,d,self.N,d))          A=numpy.ones((self.N,d,self.N,d))
1425          A[1,1,1,0]=0.          A[1,1,1,0]=0.
1426          mypde.setValue(A=A)          mypde.setValue(A=A)
1427          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1428      def test_symmetryCheckFalse_BC_System(self):      def test_symmetryCheckFalse_BC_System(self):
1429          d=self.domain.getDim()          d=self.domain.getDim()
1430          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1431          C=2*numarray.ones((self.N,self.N,d))          C=2*numpy.ones((self.N,self.N,d))
1432          B=2*numarray.ones((self.N,d,self.N))          B=2*numpy.ones((self.N,d,self.N))
1433          B[0,0,1]=1.          B[0,0,1]=1.
1434          mypde.setValue(B=B,C=C)          mypde.setValue(B=B,C=C)
1435          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1436    
1437      def test_symmetryCheckFalse_D_System(self):      def test_symmetryCheckFalse_D_System(self):
1438          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1439          D=3*numarray.ones((self.N,self.N))          D=3*numpy.ones((self.N,self.N))
1440          D[0,1]=0.          D[0,1]=0.
1441          mypde.setValue(D=D)          mypde.setValue(D=D)
1442          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1443    
1444      def test_symmetryCheckFalse_d_System(self):      def test_symmetryCheckFalse_d_System(self):
1445          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1446          d=4*numarray.ones((self.N,self.N))          d=4*numpy.ones((self.N,self.N))
1447          d[0,1]=0.          d[0,1]=0.
1448          mypde.setValue(d=d)          mypde.setValue(d=d)
1449          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1450    
1451      def test_symmetryCheckFalse_d_contact_System(self):      def test_symmetryCheckFalse_d_contact_System(self):
1452          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1453          d_contact=5*numarray.ones((self.N,self.N))          d_contact=5*numpy.ones((self.N,self.N))
1454          d_contact[0,1]=0.          d_contact[0,1]=0.
1455          mypde.setValue(d_contact=d_contact)          mypde.setValue(d_contact=d_contact)
1456          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1457    
1458        def test_symmetryCheckFalse_A_reduced_System(self):
1459            d=self.domain.getDim()
1460            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1461            A=numpy.ones((self.N,d,self.N,d))
1462            A[1,1,1,0]=0.
1463            mypde.setValue(A_reduced=A)
1464            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1465        def test_symmetryCheckFalse_BC_reduced_System(self):
1466            d=self.domain.getDim()
1467            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1468            C=2*numpy.ones((self.N,self.N,d))
1469            B=2*numpy.ones((self.N,d,self.N))
1470            B[0,0,1]=1.
1471            mypde.setValue(B_reduced=B,C_reduced=C)
1472            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1473    
1474        def test_symmetryCheckFalse_D_reduced_System(self):
1475            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1476            D=3*numpy.ones((self.N,self.N))
1477            D[0,1]=0.
1478            mypde.setValue(D_reduced=D)
1479            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1480    
1481        def test_symmetryCheckFalse_d_reduced_System(self):
1482            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1483            d=4*numpy.ones((self.N,self.N))
1484            d[0,1]=0.
1485            mypde.setValue(d_reduced=d)
1486            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1487    
1488        def test_symmetryCheckFalse_d_contact_reduced_System(self):
1489            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1490            d_contact=5*numpy.ones((self.N,self.N))
1491            d_contact[0,1]=0.
1492            mypde.setValue(d_contact_reduced=d_contact)
1493            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1494    
1495      def test_symmetryCheckTrue_Scalar(self):      def test_symmetryCheckTrue_Scalar(self):
1496          d=self.domain.getDim()          d=self.domain.getDim()
1497          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1498          A=numarray.ones((d,d))          A=numpy.ones((d,d))
1499          C=2*numarray.ones((d,))          C=2*numpy.ones((d,))
1500          B=2*numarray.ones((d,))          B=2*numpy.ones((d,))
1501          D=3          D=3
1502          d=4          d=4
1503          d_contact=5          d_contact=5
1504          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)
1505          self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
1506    
1507      def test_symmetryCheckFalse_A_Scalar(self):      def test_symmetryCheckFalse_A_Scalar(self):
1508          d=self.domain.getDim()          d=self.domain.getDim()
1509          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1510          A=numarray.ones((d,d))          A=numpy.ones((d,d))
1511          A[1,0]=0.          A[1,0]=0.
1512          mypde.setValue(A=A)          mypde.setValue(A=A)
1513          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1514      def test_symmetryCheckFalse_BC_Scalar(self):      def test_symmetryCheckFalse_BC_Scalar(self):
1515          d=self.domain.getDim()          d=self.domain.getDim()
1516          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1517          C=2*numarray.ones((d,))          C=2*numpy.ones((d,))
1518          B=2*numarray.ones((d,))          B=2*numpy.ones((d,))
1519          B[0]=1.          B[0]=1.
1520          mypde.setValue(B=B,C=C)          mypde.setValue(B=B,C=C)
1521          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")          self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1522        def test_symmetryCheckFalse_A_reduced_Scalar(self):
1523            d=self.domain.getDim()
1524            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1525            A=numpy.ones((d,d))
1526            A[1,0]=0.
1527            mypde.setValue(A_reduced=A)
1528            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1529        def test_symmetryCheckFalse_BC_reduced_Scalar(self):
1530            d=self.domain.getDim()
1531            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1532            C=2*numpy.ones((d,))
1533            B=2*numpy.ones((d,))
1534            B[0]=1.
1535            mypde.setValue(B_reduced=B,C_reduced=C)
1536            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
1537      #      #
1538      #   solver checks:      #   solver checks (single PDE)
1539      #      #
1540      def test_symmetryOnIterative(self):      def test_symmetryOnIterative(self):
1541          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1542          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1543          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1544            u=mypde.getSolution()
1545          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1546      def test_symmetryOnDirect(self):      def test_symmetryOnDirect(self):
1547          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1548          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1549          mypde.setSolverMethod(mypde.DIRECT)          mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1550          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1551            u=mypde.getSolution()
1552          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1553      def test_PCG_JACOBI(self):      def test_PCG_JACOBI(self):
1554          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1555          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1556          mypde.setSolverMethod(mypde.PCG,mypde.JACOBI)          mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1557          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1558        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1559            u=mypde.getSolution()
1560          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1561      def test_PCG_ILU0(self):      def test_PCG_ILU0(self):
1562          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1563          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1564          mypde.setSolverMethod(mypde.PCG,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1565          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1566        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1567            u=mypde.getSolution()
1568            self.failUnless(self.check(u,1.),'solution is wrong.')
1569        def test_PCG_RILU(self):
1570            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1571            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1572        mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1573        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1574        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1575            u=mypde.getSolution()
1576            self.failUnless(self.check(u,1.),'solution is wrong.')
1577        def test_PCG_REC_ILU(self):
1578            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1579            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1580        mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1581        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1582        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1583            u=mypde.getSolution()
1584          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1585      def test_DIRECT(self):      def test_DIRECT(self):
1586          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1587          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1588          mypde.setSolverMethod(mypde.DIRECT)          mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1589          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1590            u=mypde.getSolution()
1591          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1592      def test_BICGSTAB_JACOBI(self):      def test_BICGSTAB_JACOBI(self):
1593          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1594      mypde.setSolverMethod(mypde.BICGSTAB,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1595        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1596          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1597          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1598            u=mypde.getSolution()
1599          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1600      def test_BICGSTAB_ILU0(self):      def test_BICGSTAB_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.BICGSTAB,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
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_BICGSTAB_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.BICGSTAB)
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_BICGSTAB_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.BICGSTAB)
1620        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1621            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1622            u=mypde.getSolution()
1623            self.failUnless(self.check(u,1.),'solution is wrong.')
1624        def test_MINRES_JACOBI(self):
1625            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1626        mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1627        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1628            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1629            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1630            u=mypde.getSolution()
1631            self.failUnless(self.check(u,1.),'solution is wrong.')
1632        def test_MINRES_ILU0(self):
1633            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1634            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1635        mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1636        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1637            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1638            u=mypde.getSolution()
1639            self.failUnless(self.check(u,1.),'solution is wrong.')
1640        def test_MINRES_RILU(self):
1641            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1642            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1643        mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1644        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1645            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1646            u=mypde.getSolution()
1647            self.failUnless(self.check(u,1.),'solution is wrong.')
1648        def test_MINRES_REC_ILU(self):
1649            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1650            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1651        mypde.getSolverOptions().setSolverMethod(SolverOptions.MINRES)
1652        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1653            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1654            u=mypde.getSolution()
1655            self.failUnless(self.check(u,1.),'solution is wrong.')
1656        def test_TFQMR_JACOBI(self):
1657            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1658        mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1659        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1660            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1661            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1662            u=mypde.getSolution()
1663            self.failUnless(self.check(u,1.),'solution is wrong.')
1664        def test_TFQMR_ILU0(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.TFQMR)
1668        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1669            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1670            u=mypde.getSolution()
1671            self.failUnless(self.check(u,1.),'solution is wrong.')
1672        def test_TFQMR_RILU(self):
1673            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1674            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1675        mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1676        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1677            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1678            u=mypde.getSolution()
1679            self.failUnless(self.check(u,1.),'solution is wrong.')
1680        def test_TFQMR_REC_ILU(self):
1681            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1682            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1683        mypde.getSolverOptions().setSolverMethod(SolverOptions.TFQMR)
1684        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1685            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1686            u=mypde.getSolution()
1687          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1688      def test_PRES20_JACOBI(self):      def test_PRES20_JACOBI(self):
1689          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1690          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1691      mypde.setSolverMethod(mypde.PRES20,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1692          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1693            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1694            u=mypde.getSolution()
1695          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1696      def test_PRES20_ILU0(self):      def test_PRES20_ILU0(self):
1697          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1698          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1699      mypde.setSolverMethod(mypde.PRES20,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1700          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1701            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1702            u=mypde.getSolution()
1703            self.failUnless(self.check(u,1.),'solution is wrong.')
1704        def test_PRES20_RILU(self):
1705            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1706            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1707        mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1708        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1709            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1710            u=mypde.getSolution()
1711            self.failUnless(self.check(u,1.),'solution is wrong.')
1712        def test_PRES20_REC_ILU(self):
1713            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1714            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1715        mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1716        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1717            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1718            u=mypde.getSolution()
1719          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1720      def test_GMRESnoRestart_JACOBI(self):      def test_GMRESnoRestart_JACOBI(self):
1721          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1722          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1723      mypde.setSolverMethod(mypde.GMRES,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1724          # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1725          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1726        mypde.getSolverOptions().setTruncation(50)
1727            u=mypde.getSolution()
1728          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1729      def test_GMRESnoRestart_ILU0(self):      def test_GMRESnoRestart_ILU0(self):
1730          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1731          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1732      mypde.setSolverMethod(mypde.GMRES,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1733          # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1734          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1735        mypde.getSolverOptions().setTruncation(50)                        
1736            u=mypde.getSolution()
1737            self.failUnless(self.check(u,1.),'solution is wrong.')
1738        def test_GMRESnoRestart_RILU(self):
1739            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1740            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1741        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1742        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1743        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1744        mypde.getSolverOptions().setTruncation(50)
1745            u=mypde.getSolution()
1746            self.failUnless(self.check(u,1.),'solution is wrong.')
1747        def test_GMRESnoRestart_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.GMRES)
1751        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1752        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1753        mypde.getSolverOptions().setTruncation(50)
1754            u=mypde.getSolution()
1755          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1756      def test_GMRES_JACOBI(self):      def test_GMRES_JACOBI(self):
1757          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1758          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1759      mypde.setSolverMethod(mypde.GMRES,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1760          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1761            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1762            u=mypde.getSolution()
1763          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1764      def test_GMRES_ILU0(self):      def test_GMRES_ILU0(self):
1765          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1766          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1767      mypde.setSolverMethod(mypde.GMRES,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1768          u=mypde.getSolution(verbose=self.VERBOSE)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1769            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1770            u=mypde.getSolution()
1771            self.failUnless(self.check(u,1.),'solution is wrong.')
1772        def test_GMRES_RILU(self):
1773            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1774            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1775        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1776        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1777            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1778            u=mypde.getSolution()
1779            self.failUnless(self.check(u,1.),'solution is wrong.')
1780        def test_GMRES_REC_ILU(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.GMRES)
1784        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1785            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1786            u=mypde.getSolution()
1787          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1788      def test_GMRES_truncation_restart_JACOBI(self):      def test_GMRES_truncation_restart_JACOBI(self):
1789          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1790          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1791      mypde.setSolverMethod(mypde.GMRES,mypde.JACOBI)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1792          u=mypde.getSolution(verbose=self.VERBOSE,truncation=10,restart=20)      mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1793        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1794        mypde.getSolverOptions().setTruncation(10)
1795        mypde.getSolverOptions().setRestart(20)
1796            u=mypde.getSolution()
1797          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1798      def test_GMRES_truncation_restart_ILU0(self):      def test_GMRES_truncation_restart_ILU0(self):
1799          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
1800          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)          mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1801      mypde.setSolverMethod(mypde.GMRES,mypde.ILU0)      mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1802          u=mypde.getSolution(verbose=self.VERBOSE,truncation=10,restart=20)      mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1803        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1804        mypde.getSolverOptions().setTruncation(10)
1805        mypde.getSolverOptions().setRestart(20)
1806            u=mypde.getSolution()
1807            self.failUnless(self.check(u,1.),'solution is wrong.')
1808        def test_GMRES_truncation_restart_RILU(self):
1809            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1810            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1811        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1812        mypde.getSolverOptions().setPreconditioner(SolverOptions.RILU)
1813        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1814        mypde.getSolverOptions().setTruncation(10)
1815        mypde.getSolverOptions().setRestart(20)
1816            u=mypde.getSolution()
1817            self.failUnless(self.check(u,1.),'solution is wrong.')
1818        def test_GMRES_truncation_restart_REC_ILU(self):
1819            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1820            mypde.setValue(A=kronecker(self.domain),D=1.,Y=1.)
1821        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1822        mypde.getSolverOptions().setPreconditioner(SolverOptions.REC_ILU)
1823        mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1824        mypde.getSolverOptions().setTruncation(10)
1825        mypde.getSolverOptions().setRestart(20)
1826            u=mypde.getSolution()
1827            self.failUnless(self.check(u,1.),'solution is wrong.')
1828        #
1829        #   solver checks (PDE system)
1830        #
1831        def test_symmetryOnIterative_System(self):
1832            A=Tensor4(0.,Function(self.domain))
1833            D=Tensor(1.,Function(self.domain))
1834            Y=Vector(self.domain.getDim(),Function(self.domain))
1835            for i in range(self.domain.getDim()):
1836                A[i,:,i,:]=kronecker(self.domain)
1837                D[i,i]+=i
1838                Y[i]+=i
1839            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1840            mypde.setValue(A=A,D=D,Y=Y)
1841            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1842            u=mypde.getSolution()
1843          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
1844        def test_symmetryOnDirect_System(self):
1845            A=Tensor4(0.,Function(self.domain))
1846            D=Tensor(1.,Function(self.domain))
1847            Y=Vector(self.domain.getDim(),Function(self.domain))
1848            for i in range(self.domain.getDim()):
1849                A[i,:,i,:]=kronecker(self.domain)
1850                D[i,i]+=i
1851                Y[i]+=i
1852            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1853            mypde.setValue(A=A,D=D,Y=Y)
1854            mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1855            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1856            u=mypde.getSolution()
1857            self.failUnless(self.check(u,1.),'solution is wrong.')
1858        def test_PCG_JACOBI_System(self):
1859            A=Tensor4(0.,Function(self.domain))
1860            D=Tensor(1.,Function(self.domain))
1861            Y=Vector(self.domain.getDim(),Function(self.domain))
1862            for i in range(self.domain.getDim()):
1863                A[i,:,i,:]=kronecker(self.domain)
1864                D[i,i]+=i
1865                Y[i]+=i
1866            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1867            mypde.setValue(A=A,D=D,Y=Y)
1868            mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1869        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1870            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1871            u=mypde.getSolution()
1872            self.failUnless(self.check(u,1.),'solution is wrong.')
1873        def test_PCG_ILU0_System(self):
1874            A=Tensor4(0.,Function(self.domain))
1875            D=Tensor(1.,Function(self.domain))
1876            Y=Vector(self.domain.getDim(),Function(self.domain))
1877            for i in range(self.domain.getDim()):
1878                A[i,:,i,:]=kronecker(self.domain)
1879                D[i,i]+=i
1880                Y[i]+=i
1881            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1882            mypde.setValue(A=A,D=D,Y=Y)
1883            mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
1884        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1885            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1886            u=mypde.getSolution()
1887            self.failUnless(self.check(u,1.),'solution is wrong.')
1888        def test_DIRECT_System(self):
1889            A=Tensor4(0.,Function(self.domain))
1890            D=Tensor(1.,Function(self.domain))
1891            Y=Vector(self.domain.getDim(),Function(self.domain))
1892            for i in range(self.domain.getDim()):
1893                A[i,:,i,:]=kronecker(self.domain)
1894                D[i,i]+=i
1895                Y[i]+=i
1896            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1897            mypde.setValue(A=A,D=D,Y=Y)
1898            mypde.getSolverOptions().setSolverMethod(SolverOptions.DIRECT)
1899            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1900            u=mypde.getSolution()
1901            self.failUnless(self.check(u,1.),'solution is wrong.')
1902        def test_BICGSTAB_JACOBI_System(self):
1903            A=Tensor4(0.,Function(self.domain))
1904            D=Tensor(1.,Function(self.domain))
1905            Y=Vector(self.domain.getDim(),Function(self.domain))
1906            for i in range(self.domain.getDim()):
1907                A[i,:,i,:]=kronecker(self.domain)
1908                D[i,i]+=i
1909                Y[i]+=i
1910            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1911            mypde.setValue(A=A,D=D,Y=Y)
1912        mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1913        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1914            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1915            u=mypde.getSolution()
1916            self.failUnless(self.check(u,1.),'solution is wrong.')
1917        def test_BICGSTAB_ILU0_System(self):
1918            A=Tensor4(0.,Function(self.domain))
1919            D=Tensor(1.,Function(self.domain))
1920            Y=Vector(self.domain.getDim(),Function(self.domain))
1921            for i in range(self.domain.getDim()):
1922                A[i,:,i,:]=kronecker(self.domain)
1923                D[i,i]+=i
1924                Y[i]+=i
1925            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1926            mypde.setValue(A=A,D=D,Y=Y)
1927        mypde.getSolverOptions().setSolverMethod(SolverOptions.BICGSTAB)
1928        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1929            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1930            u=mypde.getSolution()
1931            self.failUnless(self.check(u,1.),'solution is wrong.')
1932        def test_PRES20_JACOBI_System(self):
1933            A=Tensor4(0.,Function(self.domain))
1934            D=Tensor(1.,Function(self.domain))
1935            Y=Vector(self.domain.getDim(),Function(self.domain))
1936            for i in range(self.domain.getDim()):
1937                A[i,:,i,:]=kronecker(self.domain)
1938                D[i,i]+=i
1939                Y[i]+=i
1940            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1941            mypde.setValue(A=A,D=D,Y=Y)
1942        mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1943        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1944            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1945            u=mypde.getSolution()
1946            self.failUnless(self.check(u,1.),'solution is wrong.')
1947        def test_PRES20_ILU0_System(self):
1948            A=Tensor4(0.,Function(self.domain))
1949            D=Tensor(1.,Function(self.domain))
1950            Y=Vector(self.domain.getDim(),Function(self.domain))
1951            for i in range(self.domain.getDim()):
1952                A[i,:,i,:]=kronecker(self.domain)
1953                D[i,i]+=i
1954                Y[i]+=i
1955            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1956            mypde.setValue(A=A,D=D,Y=Y)
1957        mypde.getSolverOptions().setSolverMethod(SolverOptions.PRES20)
1958        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1959            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1960            u=mypde.getSolution()
1961            self.failUnless(self.check(u,1.),'solution is wrong.')
1962        def test_GMRESnoRestart_JACOBI_System(self):
1963            A=Tensor4(0.,Function(self.domain))
1964            D=Tensor(1.,Function(self.domain))
1965            Y=Vector(self.domain.getDim(),Function(self.domain))
1966            for i in range(self.domain.getDim()):
1967                A[i,:,i,:]=kronecker(self.domain)
1968                D[i,i]+=i
1969                Y[i]+=i
1970            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1971            mypde.setValue(A=A,D=D,Y=Y)
1972        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1973        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
1974            # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)
1975            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1976            u=mypde.getSolution()
1977            self.failUnless(self.check(u,1.),'solution is wrong.')
1978        def test_GMRESnoRestart_ILU0_System(self):
1979            A=Tensor4(0.,Function(self.domain))
1980            D=Tensor(1.,Function(self.domain))
1981            Y=Vector(self.domain.getDim(),Function(self.domain))
1982            for i in range(self.domain.getDim()):
1983                A[i,:,i,:]=kronecker(self.domain)
1984                D[i,i]+=i
1985                Y[i]+=i
1986            mypde=LinearPDE(self.domain,debug=self.DEBUG)
1987            mypde.setValue(A=A,D=D,Y=Y)
1988        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
1989        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
1990            # u=mypde.getSolution(verbose=self.VERBOSE,truncation=5)
1991            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
1992            u=mypde.getSolution()
1993            self.failUnless(self.check(u,1.),'solution is wrong.')
1994        def test_GMRES_JACOBI_System(self):
1995            A=Tensor4(0.,Function(self.domain))
1996            D=Tensor(1.,Function(self.domain))
1997            Y=Vector(self.domain.getDim(),Function(self.domain))
1998            for i in range(self.domain.getDim()):
1999                A[i,:,i,:]=kronecker(self.domain)
2000                D[i,i]+=i
2001                Y[i]+=i
2002            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2003            mypde.setValue(A=A,D=D,Y=Y)
2004        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2005        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
2006            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2007            u=mypde.getSolution()
2008            self.failUnless(self.check(u,1.),'solution is wrong.')
2009        def test_GMRES_ILU0_System(self):
2010            A=Tensor4(0.,Function(self.domain))
2011            D=Tensor(1.,Function(self.domain))
2012            Y=Vector(self.domain.getDim(),Function(self.domain))
2013            for i in range(self.domain.getDim()):
2014                A[i,:,i,:]=kronecker(self.domain)
2015                D[i,i]+=i
2016                Y[i]+=i
2017            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2018            mypde.setValue(A=A,D=D,Y=Y)
2019        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2020        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
2021            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2022            u=mypde.getSolution()
2023            self.failUnless(self.check(u,1.),'solution is wrong.')
2024        def test_GMRES_truncation_restart_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.GMRES)
2035        mypde.getSolverOptions().setPreconditioner(SolverOptions.JACOBI)
2036            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2037        mypde.getSolverOptions().setTruncation(10)
2038        mypde.getSolverOptions().setRestart(20)
2039            u=mypde.getSolution()
2040            self.failUnless(self.check(u,1.),'solution is wrong.')
2041        def test_GMRES_truncation_restart_ILU0_System(self):
2042            A=Tensor4(0.,Function(self.domain))
2043            D=Tensor(1.,Function(self.domain))
2044            Y=Vector(self.domain.getDim(),Function(self.domain))
2045            for i in range(self.domain.getDim()):
2046                A[i,:,i,:]=kronecker(self.domain)
2047                D[i,i]+=i
2048                Y[i]+=i
2049            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2050            mypde.setValue(A=A,D=D,Y=Y)
2051        mypde.getSolverOptions().setSolverMethod(SolverOptions.GMRES)
2052        mypde.getSolverOptions().setPreconditioner(SolverOptions.ILU0)
2053            mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2054        mypde.getSolverOptions().setTruncation(10)
2055        mypde.getSolverOptions().setRestart(20)
2056            u=mypde.getSolution()
2057            self.failUnless(self.check(u,1.),'solution is wrong.')
2058    
2059    class Test_LinearPDE(Test_LinearPDE_noLumping):
2060      def test_Lumping_attemptToSetA(self):      def test_Lumping_attemptToSetA(self):
2061          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2062          try:          try:
2063             success=True             success=True
2064         mypde.setSolverMethod(mypde.LUMPING)         mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2065             mypde.setValue(A=kronecker(self.domain))             mypde.setValue(A=kronecker(self.domain))
2066             u=mypde.getSolution(verbose=self.VERBOSE)             mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2067               u=mypde.getSolution()    
2068          except ValueError:          except ValueError:
2069             success=False             success=False
2070          self.failUnless(not success,'error should be issued')          self.failUnless(not success,'error should be issued')
# Line 542  class Test_LinearPDE(Test_linearPDEs): Line 2072  class Test_LinearPDE(Test_linearPDEs):
2072          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2073          try:          try:
2074             success=True             success=True
2075         mypde.setSolverMethod(mypde.LUMPING)         mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2076             mypde.setValue(B=kronecker(self.domain)[0])             mypde.setValue(B=kronecker(self.domain)[0])
2077             u=mypde.getSolution(verbose=self.VERBOSE)             mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2078               u=mypde.getSolution()
2079          except ValueError:          except ValueError:
2080             success=False             success=False
2081          self.failUnless(not success,'error should be issued')          self.failUnless(not success,'error should be issued')
# Line 552  class Test_LinearPDE(Test_linearPDEs): Line 2083  class Test_LinearPDE(Test_linearPDEs):
2083          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2084          try:          try:
2085             success=True             success=True
2086         mypde.setSolverMethod(mypde.LUMPING)         mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2087             mypde.setValue(C=kronecker(self.domain)[0])             mypde.setValue(C=kronecker(self.domain)[0])
2088             u=mypde.getSolution(verbose=self.VERBOSE)             mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2089               u=mypde.getSolution()
2090            except ValueError:
2091               success=False
2092            self.failUnless(not success,'error should be issued')
2093            
2094        def test_Lumping_attemptToSetA_reduced(self):
2095            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2096            try:
2097               success=True
2098           mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2099               mypde.setValue(A_reduced=kronecker(self.domain))
2100               mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2101               u=mypde.getSolution()
2102            except ValueError:
2103               success=False
2104            self.failUnless(not success,'error should be issued')
2105        def test_Lumping_attemptToSetB_reduced(self):
2106            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2107            try:
2108               success=True
2109           mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2110               mypde.setValue(B_reduced=kronecker(self.domain)[0])
2111               mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2112               u=mypde.getSolution()
2113            except ValueError:
2114               success=False
2115            self.failUnless(not success,'error should be issued')
2116        def test_Lumping_attemptToSetC_reduced(self):
2117            mypde=LinearPDE(self.domain,debug=self.DEBUG)
2118            try:
2119               success=True
2120           mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2121               mypde.setValue(C_reduced=kronecker(self.domain)[0])
2122               mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2123               u=mypde.getSolution()
2124          except ValueError:          except ValueError:
2125             success=False             success=False
2126          self.failUnless(not success,'error should be issued')          self.failUnless(not success,'error should be issued')
2127                    
2128      def test_Lumping(self):      def test_Lumping(self):
2129          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2130      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2131          mypde.setValue(D=1.,Y=1.)          mypde.setValue(D=1.,Y=1.)
2132          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2133            u=mypde.getSolution()
2134          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
2135      def test_Constrained_Lumping(self):      def test_Constrained_Lumping(self):
2136          x=self.domain.getX()          x=self.domain.getX()
2137          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2138      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2139          mypde.setValue(D=1.,Y=1.,q=whereZero(x[0]),r=1.)          mypde.setValue(D=1.,Y=1.,q=whereZero(x[0]),r=1.)
2140          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2141            u=mypde.getSolution()
2142          self.failUnless(self.check(u,1.),'solution is wrong.')          self.failUnless(self.check(u,1.),'solution is wrong.')
2143    
2144      def test_Lumping_System(self):      def test_Lumping_System(self):
2145          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2146      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2147          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.]))
2148          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2149          self.failUnless(self.check(u,numarray.ones((2,))),'solution is wrong.')          u=mypde.getSolution()
2150            self.failUnless(self.check(u,numpy.ones((2,))),'solution is wrong.')
2151      def test_Constrained_Lumping_System(self):      def test_Constrained_Lumping_System(self):
2152          x=self.domain.getX()          x=self.domain.getX()
2153          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2154      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2155          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.]), \
2156                         q=whereZero(x[0])*[0.,1],r=[0.,1.])                         q=whereZero(x[0])*[0.,1],r=[0.,1.])
2157          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2158          self.failUnless(self.check(u,numarray.ones((2,))),'solution is wrong.')          u=mypde.getSolution()
2159            self.failUnless(self.check(u,numpy.ones((2,))),'solution is wrong.')
2160    
2161      def test_Lumping_updateRHS(self):      def test_Lumping_updateRHS(self):
2162          x=self.domain.getX()          x=self.domain.getX()
2163          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2164      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2165          mypde.setValue(D=1.,Y=1.)          mypde.setValue(D=1.,Y=1.)
2166          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2167            u=mypde.getSolution()
2168          self.failUnless(self.check(u,1.),'first solution is wrong.')          self.failUnless(self.check(u,1.),'first solution is wrong.')
2169          mypde.setValue(Y=2.,q=whereZero(x[0]),r=2.)          mypde.setValue(Y=2.,q=whereZero(x[0]),r=2.)
2170          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2171            u=mypde.getSolution()
2172          self.failUnless(self.check(u,2.),'second solution is wrong.')          self.failUnless(self.check(u,2.),'second solution is wrong.')
2173      def test_Lumping_updateOperator(self):      def test_Lumping_updateOperator(self):
2174          x=self.domain.getX()          x=self.domain.getX()
2175          mypde=LinearPDE(self.domain,debug=self.DEBUG)          mypde=LinearPDE(self.domain,debug=self.DEBUG)
2176      mypde.setSolverMethod(mypde.LUMPING)      mypde.getSolverOptions().setSolverMethod(SolverOptions.LUMPING)
2177          mypde.setValue(D=1.,Y=1.)          mypde.setValue(D=1.,Y=1.)
2178          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2179            u=mypde.getSolution()
2180          mypde.setValue(D=2.)          mypde.setValue(D=2.)
2181          u=mypde.getSolution(verbose=self.VERBOSE)          mypde.getSolverOptions().setVerbosity(self.VERBOSE)
2182            u=mypde.getSolution()
2183          self.failUnless(self.check(u,0.5),'second solution is wrong.')          self.failUnless(self.check(u,0.5),'second solution is wrong.')
2184    
2185    
2186    class Test_TransportPDE(Test_linearPDEs):
2187        N=4
2188        def test_init_useBackwardEuler(self):
2189            mypde=TransportPDE(self.domain,debug=self.DEBUG, useBackwardEuler=True)
2190            self.failUnless(mypde.useBackwardEuler()==True,'backward Euler should be used')
2191        def test_init_donntUseBackwardEuler(self):
2192            mypde=TransportPDE(self.domain,debug=self.DEBUG, useBackwardEuler=False)
2193            self.failUnless(mypde.useBackwardEuler()==False,'backward Euler should not be used')
2194        def test_setCoefficient_WithWrongName(self):
2195            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2196            self.failUnlessRaises(IllegalCoefficient)
2197        mypde.getSolverOptions().setSolverMethod(SolverOptions.setValue, ROMA=Vector(0.,FunctionOnBoundary(self.domain)))
2198    
2199        def test_setCoefficient_WithIllegalFunctionSpace(self):
2200            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2201            self.failUnlessRaises(IllegalCoefficientFunctionSpace)
2202        mypde.getSolverOptions().setSolverMethod(SolverOptions.setValue,C=Vector(0.,FunctionOnBoundary(self.domain)))
2203            
2204        def test_resetCoefficient_WithWrongShape(self):
2205            mypde=TransportPDE(self.domain,numEquations=2,debug=self.DEBUG)
2206            self.failUnlessRaises(IllegalCoefficientValue, mypde.setValue, C=0.)
2207    
2208        def test_setInitialSolution_scalar(self):
2209            mypde=TransportPDE(self.domain,numSolutions=1,debug=self.DEBUG)
2210            mypde.setInitialSolution(1.)
2211    
2212        def test_setInitialSolution_scalar_negative(self):
2213            mypde=TransportPDE(self.domain,numSolutions=1,debug=self.DEBUG)
2214            self.failUnlessRaises(RuntimeError, mypde.setInitialSolution,-1.)
2215    
2216        def test_setInitialSolution_scalar_WithWrongShape(self):
2217            mypde=TransportPDE(self.domain,numSolutions=1,debug=self.DEBUG)
2218            self.failUnlessRaises(ValueError,mypde.setInitialSolution,[1.,2.])
2219    
2220        def test_setInitialSolution_system(self):
2221            mypde=TransportPDE(self.domain,numSolutions=2,debug=self.DEBUG)
2222            mypde.setInitialSolution([1.,2.])
2223    
2224        def test_setInitialSolution_system(self):
2225            mypde=TransportPDE(self.domain,numSolutions=2,debug=self.DEBUG)
2226            self.failUnlessRaises(RuntimeError, mypde.setInitialSolution,[-1,2.])
2227    
2228        def test_setInitialSolution_system_WithWrongShape(self):
2229            mypde=TransportPDE(self.domain,numSolutions=2,debug=self.DEBUG)
2230            self.failUnlessRaises(ValueError, mypde.setInitialSolution,1.)
2231    
2232    
2233        def test_attemptToChangeOrderAfterDefinedCoefficient(self):
2234            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2235            mypde.setValue(D=1.)
2236            self.failUnlessRaises(RuntimeError, mypde.setReducedOrderOn)
2237    
2238        def test_reducedOnConfig(self):
2239            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2240            mypde.setReducedOrderOn()
2241            self.failUnlessEqual((mypde.getFunctionSpaceForSolution(), mypde.getFunctionSpaceForEquation()),(ReducedSolution(self.domain),ReducedSolution(self.domain)),"reduced function spaces expected.")
2242        #
2243        #  set coefficients for scalars:
2244        #
2245        def test_setCoefficient_M_Scalar(self):
2246            d=self.domain.getDim()
2247            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2248            mypde.setValue(M=1.)
2249            coeff=mypde.getCoefficient("M")
2250            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),Function(self.domain),1,1))
2251        def test_setCoefficient_A_Scalar(self):
2252            d=self.domain.getDim()
2253            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2254            mypde.setValue(A=numpy.ones((d,d)))
2255            coeff=mypde.getCoefficient("A")
2256            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),Function(self.domain),1,1))
2257        def test_setCoefficient_B_Scalar(self):
2258            d=self.domain.getDim()
2259            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2260            mypde.setValue(B=numpy.ones((d,)))
2261            coeff=mypde.getCoefficient("B")
2262            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
2263        def test_setCoefficient_C_Scalar(self):
2264            d=self.domain.getDim()
2265            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2266            mypde.setValue(C=numpy.ones((d,)))
2267            coeff=mypde.getCoefficient("C")
2268            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),Function(self.domain),1,1))
2269        def test_setCoefficient_D_Scalar(self):
2270            d=self.domain.getDim()
2271            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2272            mypde.setValue(D=1.)
2273            coeff=mypde.getCoefficient("D")
2274            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),Function(self.domain),1,1))
2275        def test_setCoefficient_X_Scalar(self):
2276            d=self.domain.getDim()
2277            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2278            mypde.setValue(X=numpy.ones((d,)))
2279            coeff=mypde.getCoefficient("X")
2280            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),Function(self.domain),1))
2281        def test_setCoefficient_Y_Scalar(self):
2282            d=self.domain.getDim()
2283            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2284            mypde.setValue(Y=1.)
2285            coeff=mypde.getCoefficient("Y")
2286            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),Function(self.domain),1))
2287        def test_setCoefficient_y_Scalar(self):
2288            d=self.domain.getDim()
2289            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2290            mypde.setValue(y=1.)
2291            coeff=mypde.getCoefficient("y")
2292            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1))
2293        def test_setCoefficient_d_Scalar(self):
2294            d=self.domain.getDim()
2295            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2296            mypde.setValue(d=1.)
2297            coeff=mypde.getCoefficient("d")
2298            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1,1))
2299        def test_setCoefficient_m_Scalar(self):
2300            d=self.domain.getDim()
2301            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2302            mypde.setValue(m=1.)
2303            coeff=mypde.getCoefficient("m")
2304            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnBoundary(self.domain),1,1))
2305        def test_setCoefficient_d_contact_Scalar(self):
2306            d=self.domain.getDim()
2307            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2308            mypde.setValue(d_contact=1.)
2309            coeff=mypde.getCoefficient("d_contact")
2310            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1,1))
2311        def test_setCoefficient_y_contact_Scalar(self):
2312            d=self.domain.getDim()
2313            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2314            mypde.setValue(y_contact=1.)
2315            coeff=mypde.getCoefficient("y_contact")
2316            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),FunctionOnContactZero(self.domain),1))
2317    
2318        def test_setCoefficient_M_reduced_Scalar(self):
2319            d=self.domain.getDim()
2320            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2321            mypde.setValue(M_reduced=1.)
2322            coeff=mypde.getCoefficient("M_reduced")
2323            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
2324        def test_setCoefficient_A_reduced_Scalar(self):
2325            d=self.domain.getDim()
2326            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2327            mypde.setValue(A_reduced=numpy.ones((d,d)))
2328            coeff=mypde.getCoefficient("A_reduced")
2329            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
2330        def test_setCoefficient_B_reduced_Scalar(self):
2331            d=self.domain.getDim()
2332            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2333            mypde.setValue(B_reduced=numpy.ones((d,)))
2334            coeff=mypde.getCoefficient("B_reduced")
2335            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
2336        def test_setCoefficient_C_reduced_Scalar(self):
2337            d=self.domain.getDim()
2338            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2339            mypde.setValue(C_reduced=numpy.ones((d,)))
2340            coeff=mypde.getCoefficient("C_reduced")
2341            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
2342        def test_setCoefficient_D_reduced_Scalar(self):
2343            d=self.domain.getDim()
2344            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2345            mypde.setValue(D_reduced=1.)
2346            coeff=mypde.getCoefficient("D_reduced")
2347            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
2348        def test_setCoefficient_X_reduced_Scalar(self):
2349            d=self.domain.getDim()
2350            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2351            mypde.setValue(X_reduced=numpy.ones((d,)))
2352            coeff=mypde.getCoefficient("X_reduced")
2353            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
2354        def test_setCoefficient_Y_reduced_Scalar(self):
2355            d=self.domain.getDim()
2356            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2357            mypde.setValue(Y_reduced=1.)
2358            coeff=mypde.getCoefficient("Y_reduced")
2359            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
2360        def test_setCoefficient_y_reduced_Scalar(self):
2361            d=self.domain.getDim()
2362            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2363            mypde.setValue(y_reduced=1.)
2364            coeff=mypde.getCoefficient("y_reduced")
2365            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
2366        def test_setCoefficient_m_reduced_Scalar(self):
2367            d=self.domain.getDim()
2368            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2369            mypde.setValue(m_reduced=1.)
2370            coeff=mypde.getCoefficient("m_reduced")
2371            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
2372        def test_setCoefficient_d_reduced_Scalar(self):
2373            d=self.domain.getDim()
2374            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2375            mypde.setValue(d_reduced=1.)
2376            coeff=mypde.getCoefficient("d_reduced")
2377            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
2378        def test_setCoefficient_d_contact_reduced_Scalar(self):
2379            d=self.domain.getDim()
2380            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2381            mypde.setValue(d_contact_reduced=1.)
2382            coeff=mypde.getCoefficient("d_contact_reduced")
2383            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
2384        def test_setCoefficient_y_contact_reduced_Scalar(self):
2385            d=self.domain.getDim()
2386            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2387            mypde.setValue(y_contact_reduced=1.)
2388            coeff=mypde.getCoefficient("y_contact_reduced")
2389            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
2390        def test_setCoefficient_r_Scalar(self):
2391            d=self.domain.getDim()
2392            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2393            mypde.setValue(r=1.)
2394            coeff=mypde.getCoefficient("r")
2395            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
2396        def test_setCoefficient_q_Scalar(self):
2397            d=self.domain.getDim()
2398            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2399            mypde.setValue(q=1.)
2400            coeff=mypde.getCoefficient("q")
2401            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),Solution(self.domain),1))
2402        def test_setCoefficient_r_Scalar_reducedOn(self):
2403            d=self.domain.getDim()
2404            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2405            mypde.setReducedOrderOn()
2406            mypde.setValue(r=1.)
2407            coeff=mypde.getCoefficient("r")
2408            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
2409        def test_setCoefficient_q_Scalar_reducedOn(self):
2410            d=self.domain.getDim()
2411            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2412            mypde.setReducedOrderOn()
2413            mypde.setValue(q=1.)
2414            coeff=mypde.getCoefficient("q")
2415            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((),ReducedSolution(self.domain),1))
2416    
2417        def test_setCoefficient_M_reduced_Scalar_usingM(self):
2418            d=self.domain.getDim()
2419            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2420            mypde.setValue(M=Scalar(1.,ReducedFunction(self.domain)))
2421            coeff=mypde.getCoefficient("M_reduced")
2422            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
2423        def test_setCoefficient_A_reduced_Scalar_usingA(self):
2424            d=self.domain.getDim()
2425            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2426            mypde.setValue(A=Data(numpy.ones((d,d)),ReducedFunction(self.domain)))
2427            coeff=mypde.getCoefficient("A_reduced")
2428            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,d),ReducedFunction(self.domain),1,1))
2429        def test_setCoefficient_B_reduced_Scalar_usingB(self):
2430            d=self.domain.getDim()
2431            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2432            mypde.setValue(B=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
2433            coeff=mypde.getCoefficient("B_reduced")
2434            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
2435        def test_setCoefficient_C_reduced_Scalar_usingC(self):
2436            d=self.domain.getDim()
2437            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2438            mypde.setValue(C=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
2439            coeff=mypde.getCoefficient("C_reduced")
2440            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1,1))
2441        def test_setCoefficient_D_reduced_Scalar_usingD(self):
2442            d=self.domain.getDim()
2443            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2444            mypde.setValue(D=Scalar(1.,ReducedFunction(self.domain)))
2445            coeff=mypde.getCoefficient("D_reduced")
2446            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1,1))
2447        def test_setCoefficient_X_reduced_Scalar_usingX(self):
2448            d=self.domain.getDim()
2449            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2450            mypde.setValue(X_reduced=Data(numpy.ones((d,)),ReducedFunction(self.domain)))
2451            coeff=mypde.getCoefficient("X_reduced")
2452            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((d,),ReducedFunction(self.domain),1))
2453        def test_setCoefficient_Y_reduced_Scalar_usingY(self):
2454            d=self.domain.getDim()
2455            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2456            mypde.setValue(Y=Scalar(1.,ReducedFunction(self.domain)))
2457            coeff=mypde.getCoefficient("Y_reduced")
2458            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunction(self.domain),1))
2459        def test_setCoefficient_y_reduced_Scalar_using_y(self):
2460            d=self.domain.getDim()
2461            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2462            mypde.setValue(y=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
2463            coeff=mypde.getCoefficient("y_reduced")
2464            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1))
2465        def test_setCoefficient_m_reduced_Scalar_using_m(self):
2466            d=self.domain.getDim()
2467            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2468            mypde.setValue(d=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
2469            coeff=mypde.getCoefficient("d_reduced")
2470            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
2471        def test_setCoefficient_d_reduced_Scalar_using_d(self):
2472            d=self.domain.getDim()
2473            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2474            mypde.setValue(m=Scalar(1.,ReducedFunctionOnBoundary(self.domain)))
2475            coeff=mypde.getCoefficient("m_reduced")
2476            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnBoundary(self.domain),1,1))
2477        def test_setCoefficient_d_contact_reduced_Scalar_using_d_contact(self):
2478            d=self.domain.getDim()
2479            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2480            mypde.setValue(d_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
2481            coeff=mypde.getCoefficient("d_contact_reduced")
2482            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1,1))
2483        def test_setCoefficient_y_contact_reduced_Scalar_using_y_contact(self):
2484            d=self.domain.getDim()
2485            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2486            mypde.setValue(y_contact=Scalar(1.,ReducedFunctionOnContactZero(self.domain)))
2487            coeff=mypde.getCoefficient("y_contact_reduced")
2488            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((),ReducedFunctionOnContactZero(self.domain),1))
2489        #
2490        #  set coefficients for systems:
2491        #
2492        def test_setCoefficient_M_System(self):
2493            d=self.domain.getDim()
2494            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2495            mypde.setValue(M=numpy.ones((self.N,self.N)))
2496            coeff=mypde.getCoefficient("M")
2497            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),Function(self.domain),self.N,self.N))
2498        def test_setCoefficient_A_System(self):
2499            d=self.domain.getDim()
2500            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2501            mypde.setValue(A=numpy.ones((self.N,d,self.N,d)))
2502            coeff=mypde.getCoefficient("A")
2503            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),Function(self.domain),self.N,self.N))
2504        def test_setCoefficient_B_System(self):
2505            d=self.domain.getDim()
2506            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2507            mypde.setValue(B=numpy.ones((self.N,d,self.N)))
2508            coeff=mypde.getCoefficient("B")
2509            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),Function(self.domain),self.N,self.N))
2510        def test_setCoefficient_C_System(self):
2511            d=self.domain.getDim()
2512            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2513            mypde.setValue(C=numpy.ones((self.N,self.N,d)))
2514            coeff=mypde.getCoefficient("C")
2515            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),Function(self.domain),self.N,self.N))
2516        def test_setCoefficient_D_System(self):
2517            d=self.domain.getDim()
2518            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2519            mypde.setValue(D=numpy.ones((self.N,self.N)))
2520            coeff=mypde.getCoefficient("D")
2521            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),Function(self.domain),self.N,self.N))
2522        def test_setCoefficient_X_System(self):
2523            d=self.domain.getDim()
2524            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2525            mypde.setValue(X=numpy.ones((self.N,d)))
2526            coeff=mypde.getCoefficient("X")
2527            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),Function(self.domain),self.N))
2528        def test_setCoefficient_Y_System(self):
2529            d=self.domain.getDim()
2530            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2531            mypde.setValue(Y=numpy.ones((self.N,)))
2532            coeff=mypde.getCoefficient("Y")
2533            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),Function(self.domain),self.N))
2534        def test_setCoefficient_y_System(self):
2535            d=self.domain.getDim()
2536            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2537            mypde.setValue(y=numpy.ones((self.N,)))
2538            coeff=mypde.getCoefficient("y")
2539            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnBoundary(self.domain),self.N))
2540        def test_setCoefficient_m_System(self):
2541            d=self.domain.getDim()
2542            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2543            mypde.setValue(m=numpy.ones((self.N,self.N)))
2544            coeff=mypde.getCoefficient("m")
2545            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnBoundary(self.domain),self.N,self.N))
2546        def test_setCoefficient_d_System(self):
2547            d=self.domain.getDim()
2548            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2549            mypde.setValue(d=numpy.ones((self.N,self.N)))
2550            coeff=mypde.getCoefficient("d")
2551            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnBoundary(self.domain),self.N,self.N))
2552        def test_setCoefficient_d_contact_System(self):
2553            d=self.domain.getDim()
2554            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2555            mypde.setValue(d_contact=numpy.ones((self.N,self.N)))
2556            coeff=mypde.getCoefficient("d_contact")
2557            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),FunctionOnContactZero(self.domain),self.N,self.N))
2558        def test_setCoefficient_y_contact_System(self):
2559            d=self.domain.getDim()
2560            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2561            mypde.setValue(y_contact=numpy.ones((self.N,)))
2562            coeff=mypde.getCoefficient("y_contact")
2563            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),FunctionOnContactZero(self.domain),self.N))
2564        def test_setCoefficient_M_System_reduced(self):
2565            d=self.domain.getDim()
2566            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2567            mypde.setValue(M_reduced=numpy.ones((self.N,self.N)))
2568            coeff=mypde.getCoefficient("M_reduced")
2569            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
2570        def test_setCoefficient_A_reduced_System(self):
2571            d=self.domain.getDim()
2572            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2573            mypde.setValue(A_reduced=numpy.ones((self.N,d,self.N,d)))
2574            coeff=mypde.getCoefficient("A_reduced")
2575            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
2576        def test_setCoefficient_B_reduced_System(self):
2577            d=self.domain.getDim()
2578            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2579            mypde.setValue(B_reduced=numpy.ones((self.N,d,self.N)))
2580            coeff=mypde.getCoefficient("B_reduced")
2581            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
2582        def test_setCoefficient_C_reduced_System(self):
2583            d=self.domain.getDim()
2584            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2585            mypde.setValue(C_reduced=numpy.ones((self.N,self.N,d)))
2586            coeff=mypde.getCoefficient("C_reduced")
2587            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
2588        def test_setCoefficient_D_System_reduced(self):
2589            d=self.domain.getDim()
2590            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2591            mypde.setValue(D_reduced=numpy.ones((self.N,self.N)))
2592            coeff=mypde.getCoefficient("D_reduced")
2593            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
2594        def test_setCoefficient_X_System_reduced(self):
2595            d=self.domain.getDim()
2596            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2597            mypde.setValue(X_reduced=numpy.ones((self.N,d)))
2598            coeff=mypde.getCoefficient("X_reduced")
2599            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
2600        def test_setCoefficient_Y_System_reduced(self):
2601            d=self.domain.getDim()
2602            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2603            mypde.setValue(Y_reduced=numpy.ones((self.N,)))
2604            coeff=mypde.getCoefficient("Y_reduced")
2605            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
2606        def test_setCoefficient_y_System_reduced(self):
2607            d=self.domain.getDim()
2608            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2609            mypde.setValue(y_reduced=numpy.ones((self.N,)))
2610            coeff=mypde.getCoefficient("y_reduced")
2611            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
2612        def test_setCoefficient_m_reduced_System(self):
2613            d=self.domain.getDim()
2614            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2615            mypde.setValue(m_reduced=numpy.ones((self.N,self.N)))
2616            coeff=mypde.getCoefficient("m_reduced")
2617            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
2618        def test_setCoefficient_d_reduced_System(self):
2619            d=self.domain.getDim()
2620            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2621            mypde.setValue(d_reduced=numpy.ones((self.N,self.N)))
2622            coeff=mypde.getCoefficient("d_reduced")
2623            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
2624        def test_setCoefficient_d_contact_reduced_System(self):
2625            d=self.domain.getDim()
2626            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2627            mypde.setValue(d_contact_reduced=numpy.ones((self.N,self.N)))
2628            coeff=mypde.getCoefficient("d_contact_reduced")
2629            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
2630        def test_setCoefficient_y_contact_reduced_System(self):
2631            d=self.domain.getDim()
2632            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2633            mypde.setValue(y_contact_reduced=numpy.ones((self.N,)))
2634            coeff=mypde.getCoefficient("y_contact_reduced")
2635            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
2636        def test_setCoefficient_r_System(self):
2637            d=self.domain.getDim()
2638            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2639            mypde.setValue(r=numpy.ones((self.N,)))
2640            coeff=mypde.getCoefficient("r")
2641            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
2642        def test_setCoefficient_q_System(self):
2643            d=self.domain.getDim()
2644            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2645            mypde.setValue(q=numpy.ones((self.N,)))
2646            coeff=mypde.getCoefficient("q")
2647            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),Solution(self.domain),self.N))
2648        def test_setCoefficient_r_System_reducedOn(self):
2649            d=self.domain.getDim()
2650            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2651            mypde.setReducedOrderOn()
2652            mypde.setValue(r=numpy.ones((self.N,)))
2653            coeff=mypde.getCoefficient("r")
2654            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
2655        def test_setCoefficient_q_System_reducedOn(self):
2656            d=self.domain.getDim()
2657            mypde=TransportPDE(self.domain,numEquations=3,debug=self.DEBUG)
2658            mypde.setReducedOrderOn()
2659            mypde.setValue(q=numpy.ones((self.N,)))
2660            coeff=mypde.getCoefficient("q")
2661            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions()),((self.N,),ReducedSolution(self.domain),self.N))
2662    
2663        def test_setCoefficient_M_System_reduced_using_D(self):
2664            d=self.domain.getDim()
2665            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2666            mypde.setValue(M=Data(numpy.ones((self.N,self.N)),ReducedFunction(self.domain)))
2667            coeff=mypde.getCoefficient("M_reduced")
2668            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
2669        def test_setCoefficient_A_reduced_System_using_A(self):
2670            d=self.domain.getDim()
2671            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2672            mypde.setValue(A=Data(numpy.ones((self.N,d,self.N,d)),ReducedFunction(self.domain)))
2673            coeff=mypde.getCoefficient("A_reduced")
2674            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N,d),ReducedFunction(self.domain),self.N,self.N))
2675        def test_setCoefficient_B_reduced_System_using_B(self):
2676            d=self.domain.getDim()
2677            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2678            mypde.setValue(B=Data(numpy.ones((self.N,d,self.N)),ReducedFunction(self.domain)))
2679            coeff=mypde.getCoefficient("B_reduced")
2680            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,d,self.N),ReducedFunction(self.domain),self.N,self.N))
2681        def test_setCoefficient_C_reduced_System_using_C(self):
2682            d=self.domain.getDim()
2683            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2684            mypde.setValue(C=Data(numpy.ones((self.N,self.N,d)),ReducedFunction(self.domain)))
2685            coeff=mypde.getCoefficient("C_reduced")
2686            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N,d),ReducedFunction(self.domain),self.N,self.N))
2687        def test_setCoefficient_D_System_reduced_using_D(self):
2688            d=self.domain.getDim()
2689            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2690            mypde.setValue(D=Data(numpy.ones((self.N,self.N)),ReducedFunction(self.domain)))
2691            coeff=mypde.getCoefficient("D_reduced")
2692            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunction(self.domain),self.N,self.N))
2693        def test_setCoefficient_X_System_reduced_using_X(self):
2694            d=self.domain.getDim()
2695            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2696            mypde.setValue(X=Data(numpy.ones((self.N,d)),ReducedFunction(self.domain)))
2697            coeff=mypde.getCoefficient("X_reduced")
2698            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,d),ReducedFunction(self.domain),self.N))
2699        def test_setCoefficient_Y_System_reduced_using_Y(self):
2700            d=self.domain.getDim()
2701            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2702            mypde.setValue(Y=Data(numpy.ones((self.N,)),ReducedFunction(self.domain)))
2703            coeff=mypde.getCoefficient("Y_reduced")
2704            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunction(self.domain),self.N))
2705        def test_setCoefficient_y_reduced_System_using_y(self):
2706            d=self.domain.getDim()
2707            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2708            mypde.setValue(y=Data(numpy.ones((self.N,)),ReducedFunctionOnBoundary(self.domain)))
2709            coeff=mypde.getCoefficient("y_reduced")
2710            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnBoundary(self.domain),self.N))
2711        def test_setCoefficient_m_reduced_System_using_m(self):
2712            d=self.domain.getDim()
2713            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2714            mypde.setValue(m=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnBoundary(self.domain)))
2715            coeff=mypde.getCoefficient("m_reduced")
2716            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
2717        def test_setCoefficient_d_reduced_System_using_d(self):
2718            d=self.domain.getDim()
2719            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2720            mypde.setValue(d=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnBoundary(self.domain)))
2721            coeff=mypde.getCoefficient("d_reduced")
2722            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnBoundary(self.domain),self.N,self.N))
2723        def test_setCoefficient_d_contact_reduced_System_using_d_contact(self):
2724            d=self.domain.getDim()
2725            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2726            mypde.setValue(d_contact=Data(numpy.ones((self.N,self.N)),ReducedFunctionOnContactZero(self.domain)))
2727            coeff=mypde.getCoefficient("d_contact_reduced")
2728            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumSolutions(), mypde.getNumEquations()),((self.N,self.N),ReducedFunctionOnContactZero(self.domain),self.N,self.N))
2729        def test_setCoefficient_y_contact_reduced_System_using_y_contact(self):
2730            d=self.domain.getDim()
2731            mypde=TransportPDE(self.domain,numSolutions=3,debug=self.DEBUG)
2732            mypde.setValue(y_contact=Data(numpy.ones((self.N,)),ReducedFunctionOnContactZero(self.domain)))
2733            coeff=mypde.getCoefficient("y_contact_reduced")
2734            self.failUnlessEqual((coeff.getShape(),coeff.getFunctionSpace(), mypde.getNumEquations()),((self.N,),ReducedFunctionOnContactZero(self.domain),self.N))
2735    
2736        def test_symmetryCheckTrue_System(self):
2737            d=self.domain.getDim()
2738            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2739            M=100*numpy.ones((self.N,self.N))
2740            A=numpy.ones((self.N,d,self.N,d))
2741            C=2*numpy.ones((self.N,self.N,d))
2742            B=2*numpy.ones((self.N,d,self.N))
2743            D=3*numpy.ones((self.N,self.N))
2744            d=4*numpy.ones((self.N,self.N))
2745            m=64*numpy.ones((self.N,self.N))
2746            d_contact=5*numpy.ones((self.N,self.N))
2747            mypde.setValue(M=M,A=A,B=B,C=C,D=D,d=d,d_contact=d_contact,m=m,M_reduced=-M,A_reduced=-A,B_reduced=-B,C_reduced=-C,D_reduced=-D,d_reduced=-d,d_contact_reduced=-d_contact, m_reduced=-m)
2748            self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
2749    
2750        def test_symmetryCheckFalse_M_System(self):
2751            d=self.domain.getDim()
2752            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2753            M=numpy.ones((self.N,self.N))
2754            M[1,0]=0.
2755            mypde.setValue(M=M)
2756            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2757    
2758        def test_symmetryCheckFalse_A_System(self):
2759            d=self.domain.getDim()
2760            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2761            A=numpy.ones((self.N,d,self.N,d))
2762            A[1,1,1,0]=0.
2763            mypde.setValue(A=A)
2764            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2765    
2766        def test_symmetryCheckFalse_BC_System(self):
2767            d=self.domain.getDim()
2768            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2769            C=2*numpy.ones((self.N,self.N,d))
2770            B=2*numpy.ones((self.N,d,self.N))
2771            B[0,0,1]=1.
2772            mypde.setValue(B=B,C=C)
2773            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2774    
2775        def test_symmetryCheckFalse_D_System(self):
2776            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2777            D=3*numpy.ones((self.N,self.N))
2778            D[0,1]=0.
2779            mypde.setValue(D=D)
2780            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2781    
2782        def test_symmetryCheckFalse_m_System(self):
2783            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2784            m=4*numpy.ones((self.N,self.N))
2785            m[0,1]=0.
2786            mypde.setValue(m=m)
2787            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2788    
2789        def test_symmetryCheckFalse_d_System(self):
2790            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2791            d=4*numpy.ones((self.N,self.N))
2792            d[0,1]=0.
2793            mypde.setValue(d=d)
2794            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2795    
2796        def test_symmetryCheckFalse_d_contact_System(self):
2797            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2798            d_contact=5*numpy.ones((self.N,self.N))
2799            d_contact[0,1]=0.
2800            mypde.setValue(d_contact=d_contact)
2801            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2802    
2803        def test_symmetryCheckFalse_M_reduced_System(self):
2804            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2805            M=3*numpy.ones((self.N,self.N))
2806            M[0,1]=0.
2807            mypde.setValue(M_reduced=M)
2808            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2809    
2810        def test_symmetryCheckFalse_A_reduced_System(self):
2811            d=self.domain.getDim()
2812            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2813            A=numpy.ones((self.N,d,self.N,d))
2814            A[1,1,1,0]=0.
2815            mypde.setValue(A_reduced=A)
2816            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2817    
2818        def test_symmetryCheckFalse_BC_reduced_System(self):
2819            d=self.domain.getDim()
2820            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2821            C=2*numpy.ones((self.N,self.N,d))
2822            B=2*numpy.ones((self.N,d,self.N))
2823            B[0,0,1]=1.
2824            mypde.setValue(B_reduced=B,C_reduced=C)
2825            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2826    
2827        def test_symmetryCheckFalse_D_reduced_System(self):
2828            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2829            D=3*numpy.ones((self.N,self.N))
2830            D[0,1]=0.
2831            mypde.setValue(D_reduced=D)
2832            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2833    
2834        def test_symmetryCheckFalse_m_reduced_System(self):
2835            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2836            m=4*numpy.ones((self.N,self.N))
2837            m[0,1]=0.
2838            mypde.setValue(m_reduced=m)
2839            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2840    
2841        def test_symmetryCheckFalse_d_reduced_System(self):
2842            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2843            d=4*numpy.ones((self.N,self.N))
2844            d[0,1]=0.
2845            mypde.setValue(d_reduced=d)
2846            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2847    
2848        def test_symmetryCheckFalse_d_contact_reduced_System(self):
2849            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2850            d_contact=5*numpy.ones((self.N,self.N))
2851            d_contact[0,1]=0.
2852            mypde.setValue(d_contact_reduced=d_contact)
2853            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2854    
2855        #==============================================================
2856        def test_symmetryCheckTrue_Scalar(self):
2857            d=self.domain.getDim()
2858            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2859            M=100
2860            A=numpy.ones((d,d))
2861            C=2*numpy.ones((d,))
2862            B=2*numpy.ones((d,))
2863            D=3
2864            m=10
2865            d=4
2866            d_contact=5
2867            mypde.setValue(M=M,A=A,B=B,C=C,D=D,d=d,m=m,d_contact=d_contact,M_reduced=-M,A_reduced=-A,B_reduced=-B,C_reduced=-C,D_reduced=-D,d_reduced=-d,d_contact_reduced=-d_contact,m_reduced=-m)
2868            self.failUnless(mypde.checkSymmetry(verbose=False),"symmetry detected")
2869    
2870        def test_symmetryCheckFalse_A_Scalar(self):
2871            d=self.domain.getDim()
2872            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2873            A=numpy.ones((d,d))
2874            A[1,0]=0.
2875            mypde.setValue(A=A)
2876            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2877        def test_symmetryCheckFalse_BC_Scalar(self):
2878            d=self.domain.getDim()
2879            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2880            C=2*numpy.ones((d,))
2881            B=2*numpy.ones((d,))
2882            B[0]=1.
2883            mypde.setValue(B=B,C=C)
2884            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2885        def test_symmetryCheckFalse_A_reduced_Scalar(self):
2886            d=self.domain.getDim()
2887            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2888            A=numpy.ones((d,d))
2889            A[1,0]=0.
2890            mypde.setValue(A_reduced=A)
2891            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2892        def test_symmetryCheckFalse_BC_reduced_Scalar(self):
2893            d=self.domain.getDim()
2894            mypde=TransportPDE(self.domain,debug=self.DEBUG)
2895            C=2*numpy.ones((d,))
2896            B=2*numpy.ones((d,))
2897            B[0]=1.
2898            mypde.setValue(B_reduced=B,C_reduced=C)
2899            self.failUnless(not mypde.checkSymmetry(verbose=False),"symmetry detected")
2900    
2901        def test_reducedOn(self):
2902            dt=0.1
2903            mypde=TransportPDE(self.domain,numSolutions=1,debug=self.DEBUG)
2904            mypde.setReducedOrderOn()
2905            mypde.setInitialSolution(10.)
2906            mypde.setValue(M=1.,Y=1)
2907            u=mypde.getSolution(dt)
2908            self.failUnless(u.getFunctionSpace() == ReducedSolution(self.domain), "wrong function space")
2909            self.failUnless(self.check(u,10.+dt),'solution is wrong.')
2910    
2911        def Off_test_reducedOff(self):
2912            dt=0.1
2913            mypde=TransportPDE(self.domain,numSolutions=1,debug=self.DEBUG)
2914            mypde.setInitialSolution(10.)
2915            mypde.setValue(M=1.,Y=1.)
2916            u=mypde.getSolution(0.1)
2917            self.failUnless(u.getFunctionSpace() == Solution(self.domain), "wrong function space")
2918            self.failUnless(self.check(u,10.+dt),'solution is wrong.')

Legend:
Removed from v.614