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

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

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

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

Legend:
Removed from v.149  
changed lines
  Added in v.2470

  ViewVC Help
Powered by ViewVC 1.1.26