← Back to branch summary

~vcs-imports/escript-finley/trunk

« back to all changes in this revision

Viewing changes to dudley/test/python/run_escriptOnDudley.py

  • Committer: jfenwick
  • Date: 2010-10-11 01:48:14 UTC
  • Revision ID: svn-v4:77569008-7704-0410-b7a0-a92fef0b09fd:trunk:3259
Merging dudley and scons updates from branches

Show diffs side-by-side

added added

removed removed

Lines of Context:
dudley/test/python/run_escriptOnDudley.py
 
1
 
 
2
########################################################
 
3
#
 
4
# Copyright (c) 2003-2010 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-2010 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
import unittest
 
23
import tempfile
 
24
 
 
25
from esys.escript import *
 
26
from esys.dudley import Rectangle
 
27
import sys
 
28
import os
 
29
from test_objects import Test_Dump, Test_SetDataPointValue, Test_saveCSV, Test_TableInterpolation
 
30
from test_objects import Test_Domain, Test_GlobalMinMax, Test_Lazy
 
31
 
 
32
from test_shared import Test_Shared
 
33
 
 
34
try:
 
35
     DUDLEY_WORKDIR=os.environ['DUDLEY_WORKDIR']
 
36
except KeyError:
 
37
     DUDLEY_WORKDIR='.'
 
38
 
 
39
NE=4 # number elements, must be even
 
40
 
 
41
class Test_SharedOnDudley(Test_Shared):
 
42
  def setUp(self):
 
43
        self.domain=Rectangle(NE,NE)
 
44
        self.tol=0.001
 
45
  def tearDown(self):
 
46
        del self.domain
 
47
        del self.tol
 
48
 
 
49
class Test_DomainOnDudley(Test_Domain):
 
50
   def setUp(self):
 
51
       self.boundary_tag_list = [1, 2, 10, 20]
 
52
       self.domain =Rectangle(NE,NE+1,2)
 
53
   def tearDown(self):
 
54
       del self.domain
 
55
       del self.boundary_tag_list 
 
56
 
 
57
   def test_tagsContinuousFunction(self):
 
58
       ref_tags=[0]
 
59
       tags=ContinuousFunction(self.domain).getListOfTags()
 
60
       self.failUnless(len(tags)==len(ref_tags), "tags list has wrong length.")
 
61
       for i in ref_tags: self.failUnless(i in tags,"tag %s is missing."%i)
 
62
 
 
63
   def test_tagsFunction(self):
 
64
       ref_tags=[0]
 
65
       tags=Function(self.domain).getListOfTags()
 
66
       self.failUnless(len(tags)==len(ref_tags), "tags list has wrong length.")
 
67
       for i in ref_tags: self.failUnless(i in tags,"tag %s is missing."%i)
 
68
   def test_tagsReducedFunction(self):
 
69
       ref_tags=[0]
 
70
       tags=ReducedFunction(self.domain).getListOfTags()
 
71
       self.failUnless(len(tags)==len(ref_tags), "tags list has wrong length.")
 
72
       for i in ref_tags: self.failUnless(i in tags,"tag %s is missing."%i)
 
73
   def test_tagsFunctionOnBoundary(self):
 
74
       ref_tags=[1, 2, 10, 20]
 
75
       tags=FunctionOnBoundary(self.domain).getListOfTags()
 
76
       # For an MPI-distributed domain some tags may be missing
 
77
       if getMPISizeWorld() == 1: self.failUnless(len(tags)==len(ref_tags), "tags list has wrong length.")
 
78
       for i in tags: self.failUnless(i in ref_tags,"tag %s is missing."%i)
 
79
   def test_tagsReducedFunctionOnBoundary(self):
 
80
       ref_tags=[1, 2, 10, 20]
 
81
       tags=ReducedFunctionOnBoundary(self.domain).getListOfTags()
 
82
       # For an MPI-distributed domain some tags may be missing
 
83
       if getMPISizeWorld() == 1: self.failUnless(len(tags)==len(ref_tags), "tags list has wrong length.")
 
84
       for i in tags: self.failUnless(i in ref_tags,"tag %s is missing."%i)
 
85
 
 
86
class Test_DataOpsOnDudley(Test_Dump, Test_SetDataPointValue, Test_GlobalMinMax, Test_Lazy):
 
87
   def setUp(self):
 
88
       self.domain =Rectangle(NE,NE+1,2)
 
89
       self.domain_with_different_number_of_samples =Rectangle(2*NE,NE+1,2)
 
90
       self.domain_with_different_number_of_data_points_per_sample =Rectangle(2*NE,NE+1,2,integrationOrder=2)
 
91
       self.domain_with_different_sample_ordering =Rectangle(NE,NE+1,2, optimize=True)
 
92
       self.filename_base=DUDLEY_WORKDIR
 
93
       self.mainfs=Function(self.domain)
 
94
       self.otherfs=Solution(self.domain)
 
95
 
 
96
   def tearDown(self):
 
97
       del self.domain
 
98
       del self.domain_with_different_number_of_samples
 
99
       del self.domain_with_different_number_of_data_points_per_sample
 
100
       del self.domain_with_different_sample_ordering
 
101
       del self.mainfs
 
102
       del self.otherfs
 
103
       
 
104
 
 
105
 
 
106
class Test_TableInterpolationOnDudley(Test_TableInterpolation):
 
107
    def setUp(self):
 
108
        self.domain=Rectangle(4,4)
 
109
        self.functionspaces=[ContinuousFunction(self.domain), Function(self.domain), ReducedFunction(self.domain),
 
110
            FunctionOnBoundary(self.domain), ReducedFunctionOnBoundary(self.domain)]
 
111
            #We aren't testing DiracDeltaFunction
 
112
        self.xn=3       # number of grids on x axis
 
113
        self.yn=3       # number of grids on y axis
 
114
 
 
115
    def tearDown(self):
 
116
        del self.domain
 
117
        del self.functionspaces
 
118
 
 
119
        
 
120
                
 
121
                
 
122
class Test_CSVOnDudley(Test_saveCSV):
 
123
   def setUp(self):
 
124
       self.domain =Rectangle(NE,NE+1)
 
125
       self.linecount1=31               #see test_save1 for the meaning of these params
 
126
       self.linecount2=25
 
127
       self.line_expected=[0.25, 0., 0.25]
 
128
       
 
129
   def tearDown(self):
 
130
       del self.domain
 
131
       
 
132
   #This test checks to see that all FunctionSpaces can be saved
 
133
   def test_singleFS(self):
 
134
        fname="test_singlefs.csv"
 
135
        fss=[ContinuousFunction(self.domain), Function(self.domain), ReducedFunction(self.domain),
 
136
        FunctionOnBoundary(self.domain), ReducedFunctionOnBoundary(self.domain), 
 
137
        DiracDeltaFunction(self.domain)]
 
138
        for f in fss:
 
139
                d=Data(7,f)
 
140
                print "Testing "+str(f)+"\n"
 
141
                saveDataCSV(fname, D=d)
 
142
 
 
143
   def test_multiFS(self):
 
144
        fname="test_multifs.csv"
 
145
        sol=Data(8,Solution(self.domain))
 
146
        ctsfn=Data(9,ContinuousFunction(self.domain))
 
147
        #test line 0
 
148
        dirac=Data(-1,DiracDeltaFunction(self.domain))
 
149
        saveDataCSV(fname, A=sol, B=ctsfn, C=dirac)
 
150
        #test line 1
 
151
        fun=Data(5,Function(self.domain))
 
152
        rfun=Data(3,ReducedFunction(self.domain))
 
153
        saveDataCSV(fname, A=sol,B=ctsfn,C=fun, D=rfun)
 
154
        #test line 2
 
155
        bound=Data(1,FunctionOnBoundary(self.domain))
 
156
        rbound=Data(3,ReducedFunctionOnBoundary(self.domain))
 
157
        saveDataCSV(fname,A=sol,B=ctsfn,C=bound, D=rbound)
 
158
 
 
159
        
 
160
if __name__ == '__main__':
 
161
   suite = unittest.TestSuite()
 
162
   #suite.addTest(unittest.makeSuite(Test_SharedOnDudley))
 
163
   #suite.addTest(unittest.makeSuite(Test_DataOpsOnDudley))
 
164
   #suite.addTest(unittest.makeSuite(Test_DomainOnDudley))
 
165
   #suite.addTest(unittest.makeSuite(Test_TableInterpolationOnDudley))
 
166
   suite.addTest(unittest.makeSuite(Test_CSVOnDudley))
 
167
   s=unittest.TextTestRunner(verbosity=2).run(suite)
 
168
   if not s.wasSuccessful(): sys.exit(1)
 
169