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

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

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

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