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

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

Ongoing conversion changes.

File size: 20.0 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_msh_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_msh_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_msh_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_msh_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_msh_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        try:
263            dict = import_mesh_file(fileName)
264        except IOError:
265            pass
266        else:
267            self.failUnless(0 == 1, 'imaginary file did not raise error!')
268
269    def test_read_write_tsh_file_bad(self):
270        dict = self.tri_dict.copy()
271        fileName = tempfile.mktemp('.xxx')
272        try:
273            export_mesh_file(fileName, dict)
274        except IOError:
275            pass
276        else:
277            self.failUnless(0 == 1, 'bad tsh file did not raise error!')
278
279    def test_import_tsh_bad(self):
280        fileName = tempfile.mktemp('.tsh')
281        file = open(fileName, 'w')
282        #   this is  a bad tsh file
283        file.write('elevn\n\
2841.0 what \n\
2850.0 the \n\
2861.0 !!! \n')
287        file.close()
288        try:
289            dict = import_mesh_file(fileName)
290        except IOError:
291            pass
292        else:
293            self.failUnless(0 == 1, 'bad tsh file did not raise error!')
294        os.remove(fileName)
295
296    def test_import_tsh3(self):
297        fileName = tempfile.mktemp('.tsh')
298        file = open(fileName, 'w')
299        file.write('1.0 \n\
300showme1.0 0.0 10.0 \n\
3010.0 1.0\n\
30213.0 \n')
303        file.close()
304        try:
305            dict = import_mesh_file(fileName)
306        except IOError:
307            pass
308        else:
309            self.failUnless(0 == 1, 'bad tsh file did not raise error!')
310        os.remove(fileName)
311
312  ############### .MSH ##########
313
314    def test_read_write_msh_file(self):
315        dict = self.dict.copy()
316        fileName = tempfile.mktemp('.msh')
317        export_mesh_file(fileName, dict)
318        loaded_dict = loadASCII._read_msh_file(fileName)
319        os.remove(fileName)
320        dict = self.dict
321        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file')
322
323    def test_read_write_msh_fileII(self):
324        dict = self.sparse_dict.copy()
325        fileName = tempfile.mktemp('.msh')
326        export_mesh_file(fileName, dict)
327        loaded_dict = loadASCII._read_msh_file(fileName)
328        os.remove(fileName)
329        dict = self.sparse_dict
330        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_fileII')
331
332    def test_read_write_msh_fileIII(self):
333        dict = self.blank_dict.copy()
334        fileName = tempfile.mktemp('.msh')
335        export_mesh_file(fileName, dict)
336        loaded_dict = loadASCII._read_msh_file(fileName)
337        os.remove(fileName)
338        dict = self.blank_dict
339        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_fileIII')
340
341    def test_read_write_msh_file4(self):
342        dict = self.seg_dict.copy()
343        fileName = tempfile.mktemp('.msh')
344        export_mesh_file(fileName, dict)
345        loaded_dict = loadASCII._read_msh_file(fileName)
346        os.remove(fileName)
347        dict = self.seg_dict
348        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file4')
349
350    def test_read_write_msh_file5(self):
351        dict = self.triangle_tags_dict.copy()
352        fileName = tempfile.mktemp('.msh')
353        export_mesh_file(fileName, dict)
354        loaded_dict = loadASCII._read_msh_file(fileName)
355        os.remove(fileName)
356        dict = self.triangle_tags_dict
357        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file5')
358
359    def test_read_write_msh_file6(self):
360        dict = self.tri_dict.copy()
361        fileName = tempfile.mktemp('.msh')
362        export_mesh_file(fileName, dict)
363        loaded_dict = loadASCII._read_msh_file(fileName)
364        os.remove(fileName)
365        dict = self.tri_dict
366        self.check_mesh_dicts(loaded_dict, dict, 'test_read_write_msh_file6')
367
368    def check_mesh_dicts(self, loaded_dict, dict, fail_string):
369        assert num.allclose(num.array(loaded_dict['points']),
370                            num.array(dict['points']))
371        assert num.allclose(num.array(loaded_dict['point_attributes']),
372                            num.array(dict['point_attributes']))
373        assert num.allclose(num.array(loaded_dict['outline_segments']),
374                            num.array(dict['outline_segments']))
375
376        self.failUnless(loaded_dict['outline_segment_tags'] ==
377                        dict['outline_segment_tags'],
378                        fail_string + ' failed!! Test 4')
379
380        assert num.allclose(num.array(loaded_dict['regions']),
381                            num.array(dict['regions']))
382
383        self.failUnless(loaded_dict['region_tags'] == dict['region_tags'],
384                        fail_string + ' failed!! Test 5')
385
386        assert num.allclose(num.array(loaded_dict['region_max_areas']),
387                            num.array(dict['region_max_areas']))
388
389        assert num.allclose(num.array(loaded_dict['holes']),
390                            num.array(dict['holes']))
391
392        assert num.allclose(num.array(dict['vertices']),
393                            num.array(loaded_dict['vertices']))
394
395        assert num.allclose(num.array(dict['triangles']),
396                            num.array(loaded_dict['triangles']))
397
398        assert num.allclose(num.array(dict['segments']),
399                            num.array(loaded_dict['segments']))
400
401        for ob, ldob in map(None, dict['triangle_tags'],
402                            loaded_dict['triangle_tags']):
403            self.failUnless(ob == ldob,
404                            fail_string + ' failed!! Test triangle_tags')
405
406        # A bit hacky
407        self.failUnless((loaded_dict['vertex_attributes'] ==
408                         dict['vertex_attributes']) or \
409                        (loaded_dict['vertex_attributes'] == None and \
410                         dict['vertex_attributes'] == []),
411                        fail_string + ' failed!! Test vertex_attributes')
412
413        assert num.allclose(num.array(dict['triangle_neighbors']),
414                            num.array(loaded_dict['triangle_neighbors']))
415
416        for seg, ldseg in map(None, dict['segment_tags'],
417                              loaded_dict['segment_tags']):
418            self.failUnless(seg == ldseg,
419                            fail_string + ' failed!! Test 8')
420
421        dict_array = num.array(dict['vertex_attribute_titles'])
422        loaded_dict_array = num.array(loaded_dict['vertex_attribute_titles'])
423        try:
424            assert num.allclose(dict_array, loaded_dict_array)
425        #except TypeError:      #??#
426        except IndexError:
427            self.failUnless(num.alltrue(loaded_dict_array == dict_array),
428                            fail_string + ' failed!! Test 8')
429
430        try:
431            self.failUnless(loaded_dict['geo_reference'] ==
432                            dict['geo_reference'],
433                            fail_string + ' failed!! Test geo_reference')
434        except KeyError:        #??# 2 lines below??
435#           self.failUnless(not dict.has_key('geo_reference' and
436#                               loaded_dict['geo_reference'] == None),
437#                           fail_string + ' failed!! Test geo_reference')
438            self.failUnless(not dict.has_key('geo_reference') and
439                                loaded_dict['geo_reference'] == None,
440                            fail_string + ' failed!! Test geo_reference')
441
442########################## BAD .MSH ##########################
443
444    def test_load_bad_no_file_msh(self):
445        fileName = tempfile.mktemp('.msh')
446        try:
447            dict = import_mesh_file(fileName)
448        except IOError:
449            pass
450        else:
451            self.failUnless(0 == 1, 'imaginary file did not raise error!')
452
453    def throws_error_2_screen_test_import_mesh_bad(self):
454        fileName = tempfile.mktemp('.msh')
455        file = open(fileName, 'w')
456        # this is  a bad tsh file
457        file.write('elevn\n\
4581.0 what \n\
4590.0 the \n\
4601.0 !!! \n')
461        file.close()
462        try:
463            dict = import_mesh_file(fileName)
464        except IOError:
465            pass
466        else:
467            self.failUnless(0 == 1, 'bad msh file did not raise error!')
468        os.remove(fileName)
469
470################################################################################
471
472if __name__ == '__main__':
473    suite = unittest.makeSuite(loadASCIITestCase,'test')
474    #suite = unittest.makeSuite(loadASCIITestCase,'test_read_write_msh_file6')
475    runner = unittest.TextTestRunner() #verbosity=2)
476    runner.run(suite)
477
Note: See TracBrowser for help on using the repository browser.