source: branches/numpy/anuga/load_mesh/test_loadASCII.py @ 7035

Last change on this file since 7035 was 7035, checked in by rwilson, 15 years ago

Back-merge from Numeric trunk.

File size: 20.3 KB
Line 
1#!/usr/bin/env python
2
3import tempfile
4import unittest
5import os
6import tempfile
7from os.path import splitext
8
9import numpy as num
10
11from anuga.load_mesh.loadASCII import *
12from anuga.coordinate_transforms.geo_reference import Geo_reference
13import loadASCII
14
15
16class loadASCIITestCase(unittest.TestCase):
17    def setUp(self):
18        self.dict = {}
19        self.dict['outline_segments'] = [(0, 1), (1, 2), (0, 2), (0, 3)]
20        self.dict['outline_segment_tags'] = ['50', '40', '30', '20']
21        self.dict['holes'] = [(0.2, 0.6)]
22        self.dict['point_attributes'] = [[5, 2], [4, 2], [3, 2], [2, 2]]
23        self.dict['regions'] = [(0.3, 0.3), (0.3, 0.4)]
24        self.dict['region_tags'] = ['1.3', 'yeah']
25        self.dict['region_max_areas'] = [36.0, -7.1]
26        self.dict['points'] = [(0.0, 0.0), (0.0, 4.0), (4.0, 0.0), (1.0, 1.0)]
27        self.dict['vertices'] = [(0.0, 0.0), (0.0, 4.0), (4.0, 0.0),
28                                 (1.0, 1.0), (2.0, 2.0)]
29        self.dict['triangles'] = [(3, 2, 4), (1, 0, 3), (3, 4,1), (2, 3, 0)]
30        self.dict['segments'] = [(0, 1), (1, 4), (2, 0), (0, 3), (4, 2)]
31        self.dict['triangle_tags'] = ['1.3', '1.3', '1.3', '1.3']
32        self.dict['vertex_attributes'] = [[1.2, 2.], [1.2, 2.], [1.2, 2.],
33                                          [1.2, 2.], [1.2, 3.]]
34        self.dict['triangle_neighbors'] = [[-1, 2, 3], [3, 2, -1],
35                                           [-1, 1, 0], [1, -1, 0]]
36        self.dict['segment_tags'] = ['50', '40', '30', '20', '40']
37        self.dict['vertex_attribute_titles'] = ['bed elevation', 'height']
38        self.dict['geo_reference'] = Geo_reference(56, 1.9, 1.9)
39
40        self.sparse_dict = {}
41        self.sparse_dict['outline_segments'] = []
42        self.sparse_dict['outline_segment_tags'] = []
43        self.sparse_dict['holes'] = []
44        self.sparse_dict['points'] = [(0.0, 0.0), (9, 8)]
45        self.sparse_dict['point_attributes'] = [[], []] # points don't have to
46                                                        # have attributes
47        self.sparse_dict['regions'] = []
48        self.sparse_dict['region_tags'] = []
49        self.sparse_dict['region_max_areas'] = []
50
51        self.sparse_dict['vertices'] = []
52        self.sparse_dict['triangles'] = []
53        self.sparse_dict['segments'] = []
54        self.sparse_dict['triangle_tags'] = []
55        self.sparse_dict['vertex_attributes'] = []
56        self.sparse_dict['triangle_neighbors'] = []
57        self.sparse_dict['segment_tags'] = []
58        self.sparse_dict['vertex_attribute_titles'] = []
59
60        self.blank_dict = {}
61        self.blank_dict['outline_segments'] = []
62        self.blank_dict['outline_segment_tags'] = []
63        self.blank_dict['holes'] = []
64        self.blank_dict['points'] = []
65        self.blank_dict['point_attributes'] = []
66        self.blank_dict['regions'] = []
67        self.blank_dict['region_tags'] = []
68        self.blank_dict['region_max_areas'] = []
69        self.blank_dict['vertices'] = []
70        self.blank_dict['triangles'] = []
71        self.blank_dict['segments'] = []
72        self.blank_dict['triangle_tags'] = []
73        self.blank_dict['vertex_attributes'] = []
74        self.blank_dict['triangle_neighbors'] = []
75        self.blank_dict['segment_tags'] = []
76        self.blank_dict['vertex_attribute_titles'] = []
77
78        self.tri_dict = {}
79        self.tri_dict['outline_segments'] = [[0, 1]]
80        self.tri_dict['outline_segment_tags'] = ['']
81        self.tri_dict['holes'] = []
82        self.tri_dict['points'] = [(9, 8), (7, 8)]
83        self.tri_dict['point_attributes'] = [[], []]
84        self.tri_dict['regions'] = []
85        self.tri_dict['region_tags'] = []
86        self.tri_dict['region_max_areas'] = []
87        self.tri_dict['vertices'] = [[9, 8], [7, 8], [4, 5]]
88        self.tri_dict['triangles'] = [[0, 1, 2]]
89        self.tri_dict['segments'] = [[0, 1]]
90        self.tri_dict['triangle_tags'] = ['']
91        self.tri_dict['vertex_attributes'] = None
92        self.tri_dict['triangle_neighbors'] = [[0, 0, 0]]
93        self.tri_dict['segment_tags'] = ['']
94        self.tri_dict['vertex_attribute_titles'] = []
95
96        self.seg_dict = {}
97        self.seg_dict['outline_segments'] = [[0, 1]]
98        self.seg_dict['outline_segment_tags'] = ['']
99        self.seg_dict['holes'] = []
100        self.seg_dict['points'] = [(9, 8), (7, 8)]
101        self.seg_dict['point_attributes'] = [[], []]
102        self.seg_dict['regions'] = [(5, 4)]
103        self.seg_dict['region_tags'] = ['']
104        self.seg_dict['region_max_areas'] = [-999]
105        self.seg_dict['vertices'] = [(9, 8), (7, 8)]
106        self.seg_dict['triangles'] = []
107        self.seg_dict['segments'] = [[0, 1]]
108        self.seg_dict['triangle_tags'] = []
109        self.seg_dict['vertex_attributes'] = None
110        self.seg_dict['triangle_neighbors'] = []
111        self.seg_dict['segment_tags'] = ['']
112        self.seg_dict['vertex_attribute_titles'] = []
113
114        self.reg_dict = {}
115        self.reg_dict['outline_segments'] = [[0, 1]]
116        self.reg_dict['outline_segment_tags'] = ['']
117        self.reg_dict['holes'] = []
118        self.reg_dict['points'] = [(9, 8), (7, 8)]
119        self.reg_dict['point_attributes'] = [[], []]
120        self.reg_dict['regions'] = [(5, 4)]
121        self.reg_dict['region_tags'] = ['']
122        self.reg_dict['region_max_areas'] = []
123        self.reg_dict['vertices'] = [(9, 8), (7, 8)]
124        self.reg_dict['triangles'] = []
125        self.reg_dict['segments'] = [[0, 1]]
126        self.reg_dict['triangle_tags'] = []
127        self.reg_dict['vertex_attributes'] = [[], []]
128        self.reg_dict['triangle_neighbors'] = []
129        self.reg_dict['segment_tags'] = ['']
130        self.reg_dict['vertex_attribute_titles'] = []
131
132        self.triangle_tags_dict = {}
133        self.triangle_tags_dict['outline_segments'] = [(0, 1), (1, 2),
134                                                       (0, 2), (0, 3)]
135        self.triangle_tags_dict['outline_segment_tags'] = ['50', '40',
136                                                           '30', '20']
137        self.triangle_tags_dict['holes'] = [(0.2, 0.6)]
138        self.triangle_tags_dict['point_attributes'] = [[5, 2], [4, 2],
139                                                       [3, 2], [2,2]]
140        self.triangle_tags_dict['regions'] = [(0.3, 0.3), (0.3, 0.4)]
141        self.triangle_tags_dict['region_tags'] = ['1.3', 'yeah']
142        self.triangle_tags_dict['region_max_areas'] = [36.0, -7.1]
143        self.triangle_tags_dict['points'] = [(0.0, 0.0), (0.0, 4.0),
144                                             (4.0, 0.0), (1.0, 1.0)]
145        self.triangle_tags_dict['vertices'] = [(0.0, 0.0), (0.0, 4.0),
146                                               (4.0, 0.0), (1.0, 1.0),
147                                               (2.0, 2.0)]
148        self.triangle_tags_dict['triangles'] = [(3, 2, 4), (1, 0, 3),
149                                                (3, 4, 1), (2, 3, 0)]
150        self.triangle_tags_dict['segments'] = [(0, 1), (1, 4), (2, 0),
151                                               (0, 3), (4, 2)]
152        self.triangle_tags_dict['triangle_tags'] = ['yeah', '1.3', '1.3', '']
153        self.triangle_tags_dict['vertex_attributes'] = [[1.2,2.], [1.2,2.],
154                                                        [1.2,2.], [1.2,2.],
155                                                        [1.2,3.]]
156        self.triangle_tags_dict['triangle_neighbors'] = [[-1, 2, 3], [3, 2, -1],
157                                                         [-1, 1, 0], [1, -1, 0]]
158        self.triangle_tags_dict['segment_tags'] = ['50', '40', '30', '20', '40']
159        self.triangle_tags_dict['vertex_attribute_titles'] = ['bed elevation',
160                                                              'height']
161        self.triangle_tags_dict['geo_reference'] = Geo_reference(56, 1.9, 1.9)
162
163    def tearDown(self):
164        pass
165
166  ############### .TSH ##########
167    def test_export_mesh_file(self):
168        meshDict = self.dict
169        fileName = tempfile.mktemp('.tsh')
170        export_mesh_file(fileName, meshDict)
171        loadedDict = import_mesh_file(fileName)
172
173        self.failUnless(num.alltrue(num.array(meshDict['vertices']) ==
174                                    num.array(loadedDict['vertices'])),
175                        'test_export_mesh_file failed. Test 1')
176        self.failUnless(num.alltrue(num.array(meshDict['triangles']) ==
177                                    num.array(loadedDict['triangles'])),
178                        'test_export_mesh_file failed. Test 2')
179        self.failUnless(num.alltrue(num.array(meshDict['segments']) ==
180                                    num.array(loadedDict['segments'])),
181                        'test_export_mesh_file failed. Test 3')
182        self.failUnless(num.alltrue(num.array(meshDict['triangle_tags']) ==
183                                    num.array(loadedDict['triangle_tags'])),
184                        'test_export_mesh_file failed. Test 4')
185
186        self.failUnless(meshDict['vertex_attributes'] ==
187                        loadedDict['vertex_attributes'],
188                        'test_export_mesh_file failed. Test 5')
189        self.failUnless(num.alltrue(num.array(meshDict['triangle_neighbors']) ==
190                                    num.array(loadedDict['triangle_neighbors'])),
191                        'test_export_mesh_file failed. Test 6')
192        self.failUnless(num.alltrue(num.array(meshDict['segment_tags']) ==
193                                    num.array(loadedDict['segment_tags'])),
194                        'test_export_mesh_file failed. Test 7')
195        self.failUnless(num.alltrue(num.array(meshDict['vertex_attribute_titles']) ==
196                                    num.array(loadedDict['vertex_attribute_titles'])),
197                        'test_export_mesh_file failed. Test 8')
198        self.failUnless(num.alltrue(num.array(meshDict['geo_reference']) ==
199                                    num.array(loadedDict['geo_reference'])),
200                        'test_export_mesh_file failed. Test 9')
201
202        os.remove(fileName)
203
204    def test_read_write_tsh_file(self):
205        dict = self.dict.copy()
206        fileName = tempfile.mktemp('.tsh')
207        export_mesh_file(fileName, dict)
208        loaded_dict = import_mesh_file(fileName)
209        os.remove(fileName)
210        dict = self.dict
211        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_file')
212
213    def test_read_write_tsh_fileII(self):
214        dict = self.sparse_dict.copy()
215        fileName = tempfile.mktemp('.tsh')
216        export_mesh_file(fileName, dict)
217        loaded_dict = import_mesh_file(fileName)
218        dict = self.sparse_dict
219        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_fileII')
220        os.remove(fileName)
221
222    def test_read_write_tsh_fileIII(self):
223        dict = self.blank_dict.copy()
224        fileName = tempfile.mktemp('.tsh')
225        export_mesh_file(fileName, dict)
226        loaded_dict = import_mesh_file(fileName)
227        os.remove(fileName)
228        dict = self.blank_dict
229        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_fileIII')
230
231    def test_read_write_tsh_file4(self):
232        dict = self.seg_dict.copy()
233        fileName = tempfile.mktemp('.tsh')
234        export_mesh_file(fileName, dict)
235        loaded_dict = import_mesh_file(fileName)
236        os.remove(fileName)
237        dict = self.seg_dict
238        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_file4')
239
240    def test_read_write_tsh_file5(self):
241        dict = self.triangle_tags_dict.copy()
242        fileName = tempfile.mktemp('.tsh')
243        export_mesh_file(fileName, dict)
244        loaded_dict = import_mesh_file(fileName)
245        dict = self.triangle_tags_dict
246        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_file5')
247        os.remove(fileName)
248
249    def test_read_write_tsh_file6(self):
250        dict = self.tri_dict.copy()
251        fileName = tempfile.mktemp('.tsh')
252        export_mesh_file(fileName, dict)
253        loaded_dict = import_mesh_file(fileName)
254        dict = self.tri_dict
255        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_tsh_file6')
256        os.remove(fileName)
257
258########################## BAD .TSH ##########################
259
260    def test_load_bad_no_file_tsh(self):
261        fileName = tempfile.mktemp('.tsh')
262        # use self.faileUnlessRaises(IOError, import_mesh_file(fileName))
263        try:
264            dict = import_mesh_file(fileName)
265        except IOError:
266            pass
267        else:
268            self.failUnless(0 == 1, 'imaginary file did not raise error!')
269
270    def test_read_write_tsh_file_bad(self):
271        dict = self.tri_dict.copy()
272        fileName = tempfile.mktemp('.xxx')
273        try:
274            export_mesh_file(fileName, dict)
275        except IOError:
276            pass
277        else:
278            self.failUnless(0 == 1, 'bad tsh file did not raise error!')
279
280    def test_import_tsh_bad(self):
281        fileName = tempfile.mktemp('.tsh')
282        file = open(fileName, 'w')
283        #   this is  a bad tsh file
284        file.write('elevn\n\
2851.0 what \n\
2860.0 the \n\
2871.0 !!! \n')
288        file.close()
289        try:
290            dict = import_mesh_file(fileName)
291        except IOError:
292            pass
293        else:
294            self.fail('bad tsh file did not raise error!')
295        os.remove(fileName)
296
297    def test_import_tsh3(self):
298        fileName = tempfile.mktemp('.tsh')
299        file = open(fileName, 'w')
300        file.write('1.0 \n\
301showme1.0 0.0 10.0 \n\
3020.0 1.0\n\
30313.0 \n')
304        file.close()
305        try:
306            dict = import_mesh_file(fileName)
307        except IOError:
308            pass
309        else:
310            self.fail('bad tsh file did not raise error!')
311        os.remove(fileName)
312
313  ############### .MSH ##########
314
315    def test_read_write_msh_file1(self):
316        dict = self.dict.copy()
317        fileName = tempfile.mktemp('.msh')
318        export_mesh_file(fileName, dict)
319        loaded_dict = loadASCII._read_msh_file(fileName)
320        os.remove(fileName)
321        dict = self.dict
322        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file1')
323
324    def test_read_write_msh_fileII(self):
325        dict = self.sparse_dict.copy()
326        fileName = tempfile.mktemp('.msh')
327        export_mesh_file(fileName, dict)
328        loaded_dict = loadASCII._read_msh_file(fileName)
329        os.remove(fileName)
330        dict = self.sparse_dict
331        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_fileII')
332
333    def test_read_write_msh_fileIII(self):
334        dict = self.blank_dict.copy()
335        fileName = tempfile.mktemp('.msh')
336        export_mesh_file(fileName, dict)
337        loaded_dict = loadASCII._read_msh_file(fileName)
338        os.remove(fileName)
339        dict = self.blank_dict
340        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_fileIII')
341
342    def test_read_write_msh_file4(self):
343        dict = self.seg_dict.copy()
344        fileName = tempfile.mktemp('.msh')
345        export_mesh_file(fileName, dict)
346        loaded_dict = loadASCII._read_msh_file(fileName)
347        os.remove(fileName)
348        dict = self.seg_dict
349        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file4')
350
351    def test_read_write_msh_file5(self):
352        dict = self.triangle_tags_dict.copy()
353        fileName = tempfile.mktemp('.msh')
354        export_mesh_file(fileName, dict)
355        loaded_dict = loadASCII._read_msh_file(fileName)
356        os.remove(fileName)
357        dict = self.triangle_tags_dict
358        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file5')
359
360    def test_read_write_msh_file6(self):
361        dict = self.tri_dict.copy()
362        fileName = tempfile.mktemp('.msh')
363        export_mesh_file(fileName, dict)
364        loaded_dict = loadASCII._read_msh_file(fileName)
365        os.remove(fileName)
366        dict = self.tri_dict
367        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file6')
368
369    def check_mesh_dicts(self, loaded_dict, dict, fail_string):
370        assert num.allclose(num.array(loaded_dict['points']),
371                            num.array(dict['points']))
372        assert num.allclose(num.array(loaded_dict['point_attributes']),
373                            num.array(dict['point_attributes']))
374        assert num.allclose(num.array(loaded_dict['outline_segments']),
375                            num.array(dict['outline_segments']))
376
377        self.failUnless(loaded_dict['outline_segment_tags'] ==
378                        dict['outline_segment_tags'],
379                        fail_string + ' failed!! Test 4')
380
381        assert num.allclose(num.array(loaded_dict['regions']),
382                            num.array(dict['regions']))
383
384        self.failUnless(loaded_dict['region_tags'] == dict['region_tags'],
385                        fail_string + ' failed!! Test 5')
386
387        assert num.allclose(num.array(loaded_dict['region_max_areas']),
388                            num.array(dict['region_max_areas']))
389
390        assert num.allclose(num.array(loaded_dict['holes']),
391                            num.array(dict['holes']))
392
393        assert num.allclose(num.array(dict['vertices']),
394                            num.array(loaded_dict['vertices']))
395
396        assert num.allclose(num.array(dict['triangles']),
397                            num.array(loaded_dict['triangles']))
398
399        assert num.allclose(num.array(dict['segments']),
400                            num.array(loaded_dict['segments']))
401        for ob, ldob in map(None, dict['triangle_tags'],
402                            loaded_dict['triangle_tags']):
403            msg = ('ob=\n%s\nshould be same as ldob=\n%s' % (str(ob), str(ldob)))
404            self.failUnless(ob == ldob,
405                            fail_string + ' failed\n' + msg)
406
407        # A bit hacky
408        self.failUnless(num.alltrue(loaded_dict['vertex_attributes'] ==
409                                    dict['vertex_attributes']) or
410                                    (loaded_dict['vertex_attributes'] ==
411                                    None and
412                                    dict['vertex_attributes'] == []),
413                        fail_string + ' failed!! Test vertex_attributes')
414
415        assert num.allclose(num.array(dict['triangle_neighbors']),
416                            num.array(loaded_dict['triangle_neighbors']))
417
418        for seg, ldseg in map(None, dict['segment_tags'],
419                              loaded_dict['segment_tags']):
420            msg = ('seg=\n"%s"\nshould be same as ldseg=\n"%s"'
421                   % (str(seg), str(ldseg)))
422            self.failUnless(seg == ldseg, fail_string + ' failed\n' + msg)
423
424        try:
425            assert num.allclose(num.array(dict['vertex_attribute_titles']),
426                                num.array(loaded_dict['vertex_attribute_titles']))
427        except IndexError:
428            self.failUnless(num.alltrue(num.array(loaded_dict['vertex_attribute_titles'])
429                            == num.array(dict['vertex_attribute_titles'])),
430                            fail_string + ' failed!! Test 8')
431
432        try:
433            msg = ("loaded_dict['geo_reference']=\n%s\n"
434                   "should be same as dict['geo_reference']=%s"
435                  % (str(loaded_dict['geo_reference']),
436                     str(dict['geo_reference'])))
437            self.failUnless(loaded_dict['geo_reference'] ==
438                            dict['geo_reference'],
439                            fail_string + ' failed\n' + msg)
440        except KeyError:        #??# 2 lines below??
441            msg = ("'dict' has no key 'geo_reference' "
442                   "but loaded_dict['geo_reference'] isn't None")
443            self.failUnless(not dict.has_key('geo_reference') and
444                                loaded_dict['geo_reference'] == None,
445                            fail_string + ' failed\n' + msg)
446
447########################## BAD .MSH ##########################
448
449    def test_load_bad_no_file_msh(self):
450        fileName = tempfile.mktemp('.msh')
451        try:
452            dict = import_mesh_file(fileName)
453        except IOError:
454            pass
455        else:
456            self.fail('imaginary file did not raise error!')
457
458    def throws_error_2_screen_test_import_mesh_bad(self):
459        fileName = tempfile.mktemp('.msh')
460        file = open(fileName, 'w')
461        # this is  a bad tsh file
462        file.write('elevn\n\
4631.0 what \n\
4640.0 the \n\
4651.0 !!! \n')
466        file.close()
467        try:
468            dict = import_mesh_file(fileName)
469        except IOError:
470            pass
471        else:
472            self.fail('bad msh file did not raise error!')
473        os.remove(fileName)
474
475################################################################################
476
477if __name__ == '__main__':
478    suite = unittest.makeSuite(loadASCIITestCase,'test')
479    runner = unittest.TextTestRunner() #verbosity=2)
480    runner.run(suite)
481
Note: See TracBrowser for help on using the repository browser.