Changeset 996

Timestamp:

Mar 3, 2005, 4:53:13 PM (20 years ago)

Author:

duncan

Message:

now able to save tsh files as NetCDF files, use the extension .msh

Location:

inundation/ga/storm_surge/pmesh

Files:

• load_mesh/loadASCII.py (modified) (5 diffs)
• load_mesh/test_loadASCII.py (modified) (6 diffs)
• mesh.py (modified) (6 diffs)
• meshHarness.py (modified) (3 diffs)
• pmesh.py (modified) (7 diffs)

inundation/ga/storm_surge/pmesh/load_mesh/loadASCII.py

@@ -62 +62 @@
 class TitleAmountError(exceptions.Exception): pass
 
+NOMAXAREA=-999
+
 def mesh_file_to_mesh_dictionary(fileName):
     """Load a pmesh file.  Returning the mesh dictionary.
@@ -94 +96 @@
         fd.close()
     elif ofile[-4:]== ".msh":
-        dict = read_tsh_file(ofile)
+        dict = read_msh_file(ofile)
     else:      
         msg = 'Extension %s is unknown' %ofile[-4:]
@@ -625 +627 @@
     outfile.createDimension('num_of_triangle_faces', 3)
     outfile.createDimension('num_of_region_max_area', 1)
-    
-    # dimension definitions - variable
-    #trianglulation
-    outfile.createDimension('num_of_vertices', mesh['vertices'].shape[0])
-    outfile.createDimension('num_of_vertex_attributes',
-                            mesh['vertex_attributes'].shape[1])
-    outfile.createDimension('num_of_vertex_attribute_title_chars',
-                            mesh['vertex_attribute_titles'].shape[1])
-    
-    outfile.createDimension('num_of_segments',
-                            mesh['segments'].shape[0])
-    outfile.createDimension('num_of_segment_tag_chars',
-                            mesh['segment_tags'].shape[1])
-    outfile.createDimension('num_of_triangles',
-                            mesh['triangles'].shape[0])
-    outfile.createDimension('num_of_triangle_tag_chars',
-                            mesh['triangle_tags'].shape[2]) 
-    outfile.createDimension('num_of_triangle_tag_per_triangle',
-                            mesh['triangle_tags'].shape[1])
-
-    #outline
-    outfile.createDimension('num_of_points', mesh['points'].shape[0])
-    outfile.createDimension('num_of_point_attributes',
-                            mesh['point_attributes'].shape[1])
-    outfile.createDimension('num_of_outline_segments',
-                            mesh['outline_segments'].shape[0])
-    outfile.createDimension('num_of_outline_segment_tag_chars',
-                            mesh['outline_segment_tags'].shape[1])
-    outfile.createDimension('num_of_holes', mesh['holes'].shape[0])
-    outfile.createDimension('num_of_regions', mesh['regions'].shape[0])
-    outfile.createDimension('num_of_region_tag_chars',
-                            mesh['region_tags'].shape[1])
-    
-    
-    # variable definitions
+
+    # Create dimensions, variables and set the variables
+    
     # trianglulation
-    outfile.createVariable('vertices', Float, ('num_of_vertices',
-                                             'num_of_dimensions'))
-    outfile.createVariable('vertex_attributes', Float, ('num_of_vertices',
-                                             'num_of_vertex_attributes'))
-    outfile.createVariable('vertex_attribute_titles',
-                           Character,
-                           ( 'num_of_vertex_attributes','num_of_vertex_attribute_title_chars' ))
-    outfile.createVariable('segments',
-                           IntType,
-                           ('num_of_segments', 'num_of_segment_ends'))
-    outfile.createVariable('segment_tags',
-                           Character,
-                           ('num_of_segments',
-                            'num_of_segment_tag_chars'))
-    outfile.createVariable('triangles',
-                           IntType,
-                           ('num_of_triangles', 'num_of_triangle_vertices'))
-    outfile.createVariable('triangle_tags',
-                           Character,
-                           ('num_of_triangles',
-                            'num_of_triangle_tag_per_triangle',
-                            'num_of_triangle_tag_chars'))
-    outfile.createVariable('triangle_neighbors',
-                           IntType,
-                           ('num_of_triangles', 'num_of_triangle_faces'))
-    
-    
+    # vertices
+    if (mesh['vertices'].shape[0] > 0):
+        outfile.createDimension('num_of_vertices', mesh['vertices'].shape[0])
+        outfile.createVariable('vertices', Float, ('num_of_vertices',
+                                                   'num_of_dimensions'))
+        outfile.variables['vertices'][:] = mesh['vertices']
+        if (mesh['vertex_attributes'].shape[0] > 0 and mesh['vertex_attributes'].shape[1] > 0):
+            outfile.createDimension('num_of_vertex_attributes',
+                                    mesh['vertex_attributes'].shape[1])
+            outfile.createDimension('num_of_vertex_attribute_title_chars',
+                                    mesh['vertex_attribute_titles'].shape[1])
+            outfile.createVariable('vertex_attributes',
+                                   Float,
+                                   ('num_of_vertices',
+                                    'num_of_vertex_attributes'))   
+            outfile.createVariable('vertex_attribute_titles',
+                                   Character,
+                                   ( 'num_of_vertex_attributes',
+                                     'num_of_vertex_attribute_title_chars' ))
+            outfile.variables['vertex_attributes'][:] = \
+                                                      mesh['vertex_attributes']
+            outfile.variables['vertex_attribute_titles'][:] = \
+                                     mesh['vertex_attribute_titles']
+    # segments
+    if (mesh['segments'].shape[0] > 0):       
+        outfile.createDimension('num_of_segments',
+                                mesh['segments'].shape[0])
+        outfile.createVariable('segments',
+                               IntType,
+                               ('num_of_segments', 'num_of_segment_ends'))
+        outfile.variables['segments'][:] = mesh['segments']
+        if (mesh['segment_tags'].shape[1] > 0):
+            outfile.createDimension('num_of_segment_tag_chars',
+                                    mesh['segment_tags'].shape[1])
+            outfile.createVariable('segment_tags',
+                                   Character,
+                                   ('num_of_segments',
+                                    'num_of_segment_tag_chars'))
+            outfile.variables['segment_tags'][:] = mesh['segment_tags']
+    # triangles    
+    if (mesh['triangles'].shape[0] > 0):
+        outfile.createDimension('num_of_triangles',
+                                mesh['triangles'].shape[0])
+        outfile.createVariable('triangles',
+                               IntType,
+                               ('num_of_triangles',
+                                'num_of_triangle_vertices'))
+        outfile.createVariable('triangle_neighbors',
+                               IntType,
+                               ('num_of_triangles',
+                                'num_of_triangle_faces'))
+        outfile.variables['triangles'][:] = mesh['triangles']
+        outfile.variables['triangle_neighbors'][:] = mesh['triangle_neighbors']
+        if (mesh['triangle_tags'].shape[2] > 0):
+            outfile.createDimension('num_of_triangle_tag_chars',
+                                    mesh['triangle_tags'].shape[2]) 
+            outfile.createDimension('num_of_triangle_tag_per_triangle',
+                                    mesh['triangle_tags'].shape[1])
+            outfile.createVariable('triangle_tags',
+                                   Character,
+                                   ('num_of_triangles',
+                                    'num_of_triangle_tag_per_triangle',
+                                    'num_of_triangle_tag_chars'))
+            outfile.variables['triangle_tags'][:] = mesh['triangle_tags']
+    
+
     # outline
-    outfile.createVariable('points', Float, ('num_of_points',
-                                             'num_of_dimensions'))
-    outfile.createVariable('point_attributes', Float, ('num_of_points',
-                                             'num_of_point_attributes'))
-    
-    outfile.createVariable('outline_segments',
-                           IntType,
-                           ('num_of_outline_segments', 'num_of_segment_ends'))
-    outfile.createVariable('outline_segment_tags',
-                           Character,
-                           ('num_of_outline_segments',
-                            'num_of_outline_segment_tag_chars'))
-    outfile.createVariable('holes', Float, ('num_of_holes',
-                                             'num_of_dimensions'))
-    outfile.createVariable('regions', Float, ('num_of_regions',
-                                             'num_of_dimensions'))
-    outfile.createVariable('region_tags',
-                           Character,
-                           ('num_of_regions',
-                            'num_of_region_tag_chars'))
-    outfile.createVariable('region_max_areas',
-                           Float,
-                           ('num_of_regions',)) #'num_of_region_max_area'))
-
-    # Setting the variables
-    #triangulation
-    outfile.variables['vertices'][:] = mesh['vertices']
-    outfile.variables['vertex_attributes'][:] = mesh['vertex_attributes']
-    outfile.variables['vertex_attribute_titles'][:] = mesh['vertex_attribute_titles']
-    outfile.variables['segments'][:] = mesh['segments']
-    outfile.variables['segment_tags'][:] = mesh['segment_tags']
-    outfile.variables['triangles'][:] = mesh['triangles']
-    outfile.variables['triangle_tags'][:] = mesh['triangle_tags']
-    outfile.variables['triangle_neighbors'][:] = mesh['triangle_neighbors']
-    
-    # Outline
-    outfile.variables['points'][:] = mesh['points'] 
-    outfile.variables['point_attributes'][:] = mesh['point_attributes']
-    outfile.variables['outline_segments'][:] = mesh['outline_segments']
-    outfile.variables['outline_segment_tags'][:] = mesh['outline_segment_tags']
-    outfile.variables['holes'][:] = mesh['holes']
-    outfile.variables['regions'][:] = mesh['regions']
-    outfile.variables['region_tags'][:] = mesh['region_tags']
-    outfile.variables['region_max_areas'][:] = mesh['region_max_areas']
-    
+    # points
+    if (mesh['points'].shape[0] > 0):
+        outfile.createDimension('num_of_points', mesh['points'].shape[0])
+        outfile.createVariable('points', Float, ('num_of_points',
+                                                 'num_of_dimensions'))
+        outfile.variables['points'][:] = mesh['points'] 
+        if (mesh['point_attributes'].shape[0] > 0  and mesh['point_attributes'].shape[1] > 0):
+            outfile.createDimension('num_of_point_attributes',
+                                    mesh['point_attributes'].shape[1])
+            outfile.createVariable('point_attributes',
+                                   Float,
+                                   ('num_of_points',
+                                    'num_of_point_attributes'))
+            outfile.variables['point_attributes'][:] = mesh['point_attributes']
+    # outline_segments 
+    if (mesh['outline_segments'].shape[0] > 0):
+        outfile.createDimension('num_of_outline_segments',
+                                mesh['outline_segments'].shape[0])
+        outfile.createVariable('outline_segments',
+                               IntType,
+                               ('num_of_outline_segments',
+                                'num_of_segment_ends'))
+        outfile.variables['outline_segments'][:] = mesh['outline_segments']
+        if (mesh['outline_segment_tags'].shape[1] > 0):
+            outfile.createDimension('num_of_outline_segment_tag_chars',
+                                    mesh['outline_segment_tags'].shape[1])
+            outfile.createVariable('outline_segment_tags',
+                                   Character,
+                                   ('num_of_outline_segments',
+                                    'num_of_outline_segment_tag_chars'))
+            outfile.variables['outline_segment_tags'][:] = mesh['outline_segment_tags']
+    # holes
+    if (mesh['holes'].shape[0] > 0):
+        outfile.createDimension('num_of_holes', mesh['holes'].shape[0])
+        outfile.createVariable('holes', Float, ('num_of_holes',
+                                                'num_of_dimensions'))
+        outfile.variables['holes'][:] = mesh['holes']
+    # regions
+    if (mesh['regions'].shape[0] > 0):
+        outfile.createDimension('num_of_regions', mesh['regions'].shape[0])
+        outfile.createVariable('regions', Float, ('num_of_regions',
+                                                  'num_of_dimensions'))
+        outfile.createVariable('region_max_areas',
+                               Float,
+                               ('num_of_regions',))
+        outfile.variables['regions'][:] = mesh['regions']
+        outfile.variables['region_max_areas'][:] = mesh['region_max_areas']
+        if (mesh['region_tags'].shape[1] > 0):
+            outfile.createDimension('num_of_region_tag_chars',
+                                    mesh['region_tags'].shape[1])
+            outfile.createVariable('region_tags',
+                                   Character,
+                                   ('num_of_regions',
+                                    'num_of_region_tag_chars'))
+            outfile.variables['region_tags'][:] = mesh['region_tags']
+        
     outfile.close()
 
@@ -745 +765 @@
         
     from Scientific.IO.NetCDF import NetCDFFile         
-            
+           
     #Check contents
     #Get NetCDF
@@ -753 +773 @@
     # Get the variables
     # the triangulation
-    mesh['vertices'] = fid.variables['vertices'][:]
-    mesh['vertex_attributes'] = fid.variables['vertex_attributes'][:]
-    titles = fid.variables['vertex_attribute_titles'][:]
+    try:
+        mesh['vertices'] = fid.variables['vertices'][:]
+    except KeyError:
+        mesh['vertices'] = array([])
+    try:
+        mesh['vertex_attributes'] = fid.variables['vertex_attributes'][:]
+    except KeyError:
+        mesh['vertex_attributes'] = []
+        for ob in mesh['vertices']:
+            mesh['vertex_attributes'].append([])
     mesh['vertex_attribute_titles'] = []
-    for i, title in enumerate(titles):
-        mesh['vertex_attribute_titles'].append(titles[i].tostring().strip())
-    mesh['segments'] = fid.variables['segments'][:]
-    tags = fid.variables['segment_tags'][:]
+    try:
+        titles = fid.variables['vertex_attribute_titles'][:]
+        for i, title in enumerate(titles):
+            mesh['vertex_attribute_titles'].append(titles[i].tostring().strip())
+    except KeyError:
+        pass  
+    try:
+        mesh['segments'] = fid.variables['segments'][:]
+    except KeyError:
+        mesh['segments'] = array([])
     mesh['segment_tags'] =[]
-    for i, tag in enumerate(tags):
-        mesh['segment_tags'].append(tags[i].tostring().strip())
-    mesh['triangles'] = fid.variables['triangles'][:]
-    tags = fid.variables['triangle_tags'][:]
+    try:
+        tags = fid.variables['segment_tags'][:]
+        for i, tag in enumerate(tags):
+            mesh['segment_tags'].append(tags[i].tostring().strip())
+    except KeyError:
+        for ob in mesh['segments']:
+            mesh['segment_tags'].append('')
+    try:
+        mesh['triangles'] = fid.variables['triangles'][:]
+        mesh['triangle_neighbors'] = fid.variables['triangle_neighbors'][:]
+    except KeyError:
+        mesh['triangles'] = array([])
+        mesh['triangle_neighbors'] = array([])
     mesh['triangle_tags'] =[]
-    for i, tag in enumerate(tags):
-        mesh['triangle_tags'].append(tags[i].tostring().strip())
-    mesh['triangle_neighbors'] = fid.variables['triangle_neighbors'][:]
+    try:
+        tags = fid.variables['triangle_tags'][:]
+        for i, tag in enumerate(tags):
+            mesh['triangle_tags'].append([tags[i].tostring().strip()])
+    except KeyError:
+        for ob in mesh['triangles']:
+            mesh['triangle_tags'].append([''])
     
     #the outline 
-    mesh['points'] = fid.variables['points'][:]
-    mesh['point_attributes'] = fid.variables['point_attributes'][:]
-    mesh['outline_segments'] = fid.variables['outline_segments'][:]
-    tags = fid.variables['outline_segment_tags'][:]
+    try:
+        mesh['points'] = fid.variables['points'][:]
+    except KeyError:
+        mesh['points'] = []
+    try:
+        mesh['point_attributes'] = fid.variables['point_attributes'][:]
+    except KeyError:
+        mesh['point_attributes'] = []
+        for point in mesh['points']:
+            mesh['point_attributes'].append([])
+    try:
+        mesh['outline_segments'] = fid.variables['outline_segments'][:]
+    except KeyError:
+        mesh['outline_segments'] = array([])
     mesh['outline_segment_tags'] =[]
-    for i, tag in enumerate(tags):
-        mesh['outline_segment_tags'].append(tags[i].tostring().strip())
-    
-    mesh['holes'] = fid.variables['holes'][:]
-    mesh['regions'] = fid.variables['regions'][:]
-    tags = fid.variables['region_tags'][:]
+    try:
+        tags = fid.variables['outline_segment_tags'][:]
+        for i, tag in enumerate(tags):
+            mesh['outline_segment_tags'].append(tags[i].tostring().strip())
+    except KeyError:
+        for ob in mesh['outline_segments']:
+            mesh['outline_segment_tags'].append('')
+    try:
+        mesh['holes'] = fid.variables['holes'][:]
+    except KeyError:
+        mesh['holes'] = array([])
+    try:
+        mesh['regions'] = fid.variables['regions'][:]
+    except KeyError:
+        mesh['regions'] = array([])
     mesh['region_tags'] =[]
-    for i, tag in enumerate(tags):
-        mesh['region_tags'].append(tags[i].tostring().strip())
-    mesh['region_max_areas'] = fid.variables['region_max_areas'][:]
+    try:
+        tags = fid.variables['region_tags'][:]
+        for i, tag in enumerate(tags):
+            mesh['region_tags'].append(tags[i].tostring().strip())
+    except KeyError:
+        for ob in mesh['regions']:
+            mesh['region_tags'].append('')
+    try:
+        mesh['region_max_areas'] = fid.variables['region_max_areas'][:]
+    except KeyError:
+        mesh['region_max_areas'] = array([])
     #mesh[''] = fid.variables[''][:]
-    
+       
     fid.close()
-    
+      
     return mesh
            

inundation/ga/storm_surge/pmesh/load_mesh/test_loadASCII.py

@@ -35 +35 @@
         self.dict['region_max_areas'] = [36.0,-7.1]
         self.dict['points'] = [(0.0, 0.0), (0.0, 4.0), (4.0, 0.0), (1.0, 1.0)]
-
         self.dict['vertices'] = [(0.0, 0.0), (0.0, 4.0),
-                                          (4.0, 0.0), (1.0, 1.0), (2.0, 2.0)]
+                                 (4.0, 0.0), (1.0, 1.0), (2.0, 2.0)]
         self.dict['triangles'] = [(3, 2, 4), (1, 0, 3),
                                              (3, 4,1), (2, 3, 0)]
@@ -43 +42 @@
                                             (0, 3), (4, 2)]
         self.dict['triangle_tags'] = [['1.3'], ['1.3'],
-                                                      ['1.3'], ['1.3']]
-        self.dict['vertex_attributes'] = [[1.2,2.], [1.2,2.], [1.2,2.], [1.2,2.], [1.2,3.]]
+                                      ['1.3'], ['1.3']]
+        self.dict['vertex_attributes'] = [[1.2,2.], [1.2,2.],
+                                          [1.2,2.], [1.2,2.], [1.2,3.]]
         self.dict['triangle_neighbors'] = [[-1, 2, 3], [3, 2, -1],
-                                                     [-1, 1, 0], [1, -1, 0]]
+                                           [-1, 1, 0], [1, -1, 0]]
         self.dict['segment_tags'] = ['50', '40', '30', '20', '40']
         self.dict['vertex_attribute_titles'] = ['bed elevation', 'height']
+        
+        self.sparse_dict ={}
+        self.sparse_dict['outline_segments'] = []
+        self.sparse_dict['outline_segment_tags'] = []
+        self.sparse_dict['holes'] = []
+        self.sparse_dict['points'] = [(0.0, 0.0),(9,8)]
+        self.sparse_dict['point_attributes'] = [[],[]] # points don't have to have
+                                                    # attributes
+        self.sparse_dict['regions'] = []
+        self.sparse_dict['region_tags'] = []
+        self.sparse_dict['region_max_areas'] = []
+
+        self.sparse_dict['vertices'] = []
+        self.sparse_dict['triangles'] = []
+        self.sparse_dict['segments'] = []
+        self.sparse_dict['triangle_tags'] = []
+        self.sparse_dict['vertex_attributes'] = []
+        self.sparse_dict['triangle_neighbors'] = []
+        self.sparse_dict['segment_tags'] = []
+        self.sparse_dict['vertex_attribute_titles'] = []
+        
+        self.blank_dict ={}
+        self.blank_dict['outline_segments'] = []
+        self.blank_dict['outline_segment_tags'] = []
+        self.blank_dict['holes'] = []
+        self.blank_dict['points'] = []
+        self.blank_dict['point_attributes'] = [] 
+        self.blank_dict['regions'] = []
+        self.blank_dict['region_tags'] = []
+        self.blank_dict['region_max_areas'] = []
+        self.blank_dict['vertices'] = []
+        self.blank_dict['triangles'] = []
+        self.blank_dict['segments'] = []
+        self.blank_dict['triangle_tags'] = []
+        self.blank_dict['vertex_attributes'] = []
+        self.blank_dict['triangle_neighbors'] = []
+        self.blank_dict['segment_tags'] = []
+        self.blank_dict['vertex_attribute_titles'] = []
+        
+        self.tri_dict ={}
+        self.tri_dict['outline_segments'] = [[0,1]]
+        self.tri_dict['outline_segment_tags'] = ['']
+        self.tri_dict['holes'] = []
+        self.tri_dict['points'] = [(9,8),(7,8)]
+        self.tri_dict['point_attributes'] = [[],[]] 
+        self.tri_dict['regions'] = []
+        self.tri_dict['region_tags'] = []
+        self.tri_dict['region_max_areas'] = []
+        self.tri_dict['vertices'] = [[9,8],[7,8], [4,5]]
+        self.tri_dict['triangles'] = [[0,1,2]]
+        self.tri_dict['segments'] = [[0,1]]
+        self.tri_dict['triangle_tags'] = [['']]
+        self.tri_dict['vertex_attributes'] = [[],[],[]]
+        self.tri_dict['triangle_neighbors'] = [[0,0,0]]
+        self.tri_dict['segment_tags'] = ['']
+        self.tri_dict['vertex_attribute_titles'] = []
+        
+        self.seg_dict ={}
+        self.seg_dict['outline_segments'] = [[0,1]]
+        self.seg_dict['outline_segment_tags'] = ['']
+        self.seg_dict['holes'] = []
+        self.seg_dict['points'] = [(9,8),(7,8)]
+        self.seg_dict['point_attributes'] = [[],[]]  
+        self.seg_dict['regions'] = [(5,4)]
+        self.seg_dict['region_tags'] = [''] 
+        self.seg_dict['region_max_areas'] = [-999]
+        self.seg_dict['vertices'] = [(9,8),(7,8)]
+        self.seg_dict['triangles'] = []
+        self.seg_dict['segments'] = [[0,1]]
+        self.seg_dict['triangle_tags'] = []
+        self.seg_dict['vertex_attributes'] = [[],[]]
+        self.seg_dict['triangle_neighbors'] = []
+        self.seg_dict['segment_tags'] = ['']
+        self.seg_dict['vertex_attribute_titles'] = []
+        
+        self.reg_dict ={}
+        self.reg_dict['outline_segments'] = [[0,1]]
+        self.reg_dict['outline_segment_tags'] = ['']
+        self.reg_dict['holes'] = []
+        self.reg_dict['points'] = [(9,8),(7,8)]
+        self.reg_dict['point_attributes'] = [[],[]] 
+        self.reg_dict['regions'] = [(5,4)]
+        self.reg_dict['region_tags'] = ['']
+        self.reg_dict['region_max_areas'] = []
+        self.reg_dict['vertices'] = [(9,8),(7,8)]
+        self.reg_dict['triangles'] = []
+        self.reg_dict['segments'] = [[0,1]]
+        self.reg_dict['triangle_tags'] = []
+        self.reg_dict['vertex_attributes'] = [[],[]]
+        self.reg_dict['triangle_neighbors'] = []
+        self.reg_dict['segment_tags'] = ['']
+        self.reg_dict['vertex_attribute_titles'] = []
+        
     def tearDown(self):
         pass
@@ -141 +234 @@
  
     def test_read_write_msh_file(self):
-        
         dict = self.dict.copy()
         fileName = tempfile.mktemp(".txt")
@@ -147 +239 @@
         loaded_dict = read_msh_file(fileName)
         os.remove(fileName)
-
-        
         dict = self.dict
         #print "*********************"
@@ -155 +245 @@
         #print loaded_dict
         #print "*********************"
-
-        
-        self.failUnless(array(loaded_dict['points'])  ==
-                        array(dict['points']),
-                         'test_import_mesh failed. Test 1')
-        self.failUnless(array(loaded_dict['point_attributes'])  ==
-                        array(dict['point_attributes']),
-                         'test_import_mesh failed. Test 2')
+        self.check_mesh_dicts(loaded_dict,dict,'test_read_write_msh_file') 
+
+    def test_read_write_msh_fileII(self):
+        dict = self.sparse_dict.copy()
+        fileName = tempfile.mktemp(".txt")
+        write_msh_file(fileName,dict)
+        loaded_dict = read_msh_file(fileName)
+        os.remove(fileName)
+        dict = self.sparse_dict
+        #print "*********************"
+        #print dict
+        #print "**loaded_dict*******************"
+        #print loaded_dict
+        #print "*********************"       
+        self.check_mesh_dicts(loaded_dict,dict, 'test_read_write_msh_fileII')
+              
+    def test_read_write_msh_fileIII(self):
+        dict = self.blank_dict.copy()
+        fileName = tempfile.mktemp(".txt")
+        write_msh_file(fileName,dict)
+        loaded_dict = read_msh_file(fileName)
+        os.remove(fileName)
+        dict = self.blank_dict
+        #print "*********************"
+        #print dict
+        #print "**loaded_dict*******************"
+        #print loaded_dict
+        #print "*********************"       
+        self.check_mesh_dicts(loaded_dict,dict, 'test_read_write_msh_fileIII')
+       
+    def test_read_write_msh_file4(self):
+        dict = self.seg_dict.copy()
+        fileName = tempfile.mktemp(".txt")
+        write_msh_file(fileName,dict)
+        loaded_dict = read_msh_file(fileName)
+        os.remove(fileName)
+        dict = self.seg_dict
+        #print "*********************"
+        #print dict
+        #print "**loaded_dict*******************"
+        #print loaded_dict
+        #print "*********************" 
+        self.check_mesh_dicts(loaded_dict,dict, 'test_read_write_msh_fileIII')
+                         
+        
+    def test_read_write_msh_file5(self):
+        dict = self.tri_dict.copy()
+        fileName = tempfile.mktemp(".txt")
+        write_msh_file(fileName,dict)
+        loaded_dict = read_msh_file(fileName)
+        os.remove(fileName)
+        dict = self.tri_dict
+        #print "*********************"
+        #print dict
+        #print "**loaded_dict*******************"
+        #print loaded_dict
+        #print "*********************" 
+        self.check_mesh_dicts(loaded_dict,dict, 'test_read_write_msh_fileIII')
+                         
+    def check_mesh_dicts(self, loaded_dict, dict, fail_string ):
+        assert allclose(array(loaded_dict['points']),
+                        array(dict['points']))
+                        
+        assert allclose(array(loaded_dict['point_attributes']),
+                        array(dict['point_attributes']))
+        assert allclose(array(loaded_dict['outline_segments']),
+                        array(dict['outline_segments']))
+        
+        self.failUnless(loaded_dict['outline_segment_tags']  ==
+                        dict['outline_segment_tags'],
+                        fail_string + ' failed!! Test 4')
+        
+            
+        assert allclose(array(loaded_dict['regions']),
+                        array(dict['regions']))
+        self.failUnless(loaded_dict['region_tags']  ==
+                        dict['region_tags'],
+                        fail_string + ' failed!! Test 5')
+        
+        assert allclose(array(loaded_dict['region_max_areas']),
+                        array(dict['region_max_areas']))
+ 
+        assert allclose(array(loaded_dict['holes']),
+                        array(dict['holes']))
+ 
+        assert allclose(array(dict['vertices']),
+                        array(loaded_dict['vertices']))
+ 
+        assert allclose(array(dict['triangles']),
+                        array(loaded_dict['triangles']))
+ 
+        assert allclose(array(dict['segments']),
+                        array(loaded_dict['segments']))
+        for ob, ldob in map(None,dict['triangle_tags'],
+                              loaded_dict['triangle_tags']):
+            self.failUnless(ob[0]  == ldob[0],
+                        fail_string + ' failed!! Test triangle_tags')
+        self.failUnless(loaded_dict['vertex_attributes']  ==
+                        dict['vertex_attributes'],
+                        fail_string + ' failed!! Test vertex_attributes')
+ 
+        assert allclose(array(dict['triangle_neighbors']),
+                        array(loaded_dict['triangle_neighbors']))
+
+        for seg, ldseg in map(None,dict['segment_tags'],
+                              loaded_dict['segment_tags']):
+            self.failUnless(seg  == ldseg,
+                        fail_string + ' failed!! Test 8')
+        try:
+            assert allclose(array(dict['vertex_attribute_titles']),
+                            array(loaded_dict['vertex_attribute_titles']))
+        except TypeError:
+            self.failUnless(array(loaded_dict['vertex_attribute_titles'])  ==
+                        array(dict['vertex_attribute_titles']),
+                        fail_string + ' failed!! Test 8')
+ 
+    def baaaad(self):
+        
+        assert allclose(array(loaded_dict['point_attributes']),
+                        array(dict['point_attributes']))
         self.failUnless(array(loaded_dict['outline_segments'])  ==
                         array(dict['outline_segments']),
-                         'test_import_mesh failed. Test 3')
+                          fail_string + ' failed. Test 3')
         self.failUnless(array(loaded_dict['outline_segment_tags'])  ==
                         array(dict['outline_segment_tags']),
-                         'test_import_mesh failed. Test 4')
+                          fail_string + ' failed! Test 4')
         self.failUnless(array(loaded_dict['regions'])  ==
                         array(dict['regions']),
-                         'test_import_mesh failed. Test 5')
+                          fail_string + ' failed. Test 5')
         self.failUnless(array(loaded_dict['region_tags'])  ==
                         array(dict['region_tags']),
-                         'test_import_mesh failed. Test 5')
+                          fail_string + ' failed. Test 5')
         self.failUnless(array(loaded_dict['region_max_areas'])  ==
                         array(dict['region_max_areas']),
-                         'test_import_mesh failed. Test 5')
-
+                          fail_string + ' failed. Test 5')
         self.failUnless(array(loaded_dict['holes'])  ==
                         array(dict['holes']),
-                         'test_import_mesh failed. Test 6')
-   
+                          fail_string + ' failed. Test 6')
         self.failUnless(array(dict['vertices'])  ==
                         array(loaded_dict['vertices']),
-                         'test_export_triangulation_file failed. Test 1')
+                          fail_string + ' failed. Test 7')
         self.failUnless(array(dict['triangles'])  ==
                         array(loaded_dict['triangles']),
-                         'test_export_triangulation_file failed. Test 2')
+                          fail_string + ' failed. Test 8')
         self.failUnless(array(dict['segments'])  ==
                         array(loaded_dict['segments']),
-                         'test_export_triangulation_file failed. Test 3')
+                          fail_string + ' failed. Test 9')
         self.failUnless(array(dict['triangle_tags'])  ==
                         array(loaded_dict['triangle_tags']),
-                         'test_export_triangulation_file failed. Test 4')
-        
+                          fail_string + ' failed. Test 10')
         self.failUnless(dict['vertex_attributes']  ==
                         loaded_dict['vertex_attributes'],
-                         'test_export_triangulation_file failed. Test 5')
+                          fail_string + ' failed. Test 11')
         self.failUnless(array(dict['triangle_neighbors'])  ==
                         array(loaded_dict['triangle_neighbors']),
-                         'test_export_triangulation_file failed. Test 6')
+                          fail_string + ' failed. Test 12')
         self.failUnless(array(dict['segment_tags'])  ==
                         array(loaded_dict['segment_tags']),
-                         'test_export_triangulation_file failed. Test 7')
+                          fail_string + ' failed. Test 13')
         self.failUnless(array(dict['vertex_attribute_titles'])  ==
                         array(loaded_dict['vertex_attribute_titles']),
-                         'test_export_triangulation_file failed. Test 8')
+                          fail_string + ' failed. Test 14')
         
     def test_loadpts(self):
@@ -422 +621 @@
 
     suite = unittest.makeSuite(loadASCIITestCase,'test')
-    runner = unittest.TextTestRunner() #verbosity=2)
+    runner = unittest.TextTestRunner(verbosity=2)
     runner.run(suite)
     

inundation/ga/storm_surge/pmesh/mesh.py

@@ -29 +29 @@
 
 SET_COLOUR='red'
-NOMAXAREA=-999
-
-
-#for alpha shapes boundary type
-RAW = 0
-REMOVE_HOLES = 1
-REMOVE_SHARP_INDENTS = 2
-REMOVE_PINCH_OFF = 3
-
 
     
@@ -1534 +1525 @@
             #Most probably, the Tkinter module is not available.
             #"""
-            
-    # Is this used by anything?  
-    def exportASCIItriangulationfile(self,ofile):
+             
+    def export_triangulation_file(self,ofile):
         """
         export a file, ofile, with the format
@@ -1548 +1538 @@
         Following lines:  <segment #> <vertex #>  <vertex #> [boundary tag]
         """
-        fd = open(ofile,'w')
-        gen_dict = self.Mesh2IOTriangulationDict()
-        load_mesh.loadASCII.write_ASCII_triangulation(fd,gen_dict)
-        self.writeASCIImesh(fd,
-                            self.userVertices,
-                            self.getUserSegments(),
-                            self.holes,
-                            self.regions)    
-        fd.close()
-
+        gen_dict = self.Mesh2IODict()
+        if (ofile[-4:] == ".tsh"):
+            fd = open(ofile,'w')
+            load_mesh.loadASCII.write_ASCII_triangulation(fd,gen_dict)
+            self.writeASCIImesh(fd,
+                                self.userVertices,
+                                self.getUserSegments(),
+                                self.holes,
+                                self.regions)    
+            fd.close()
+        elif (ofile[-4:] == ".msh"):
+            print "mesh gen_dict",gen_dict 
+            load_mesh.loadASCII.write_msh_file(ofile, gen_dict)
+            
     def exportASCIIsegmentoutlinefile(self,ofile):
         """
@@ -1865 +1859 @@
                 regionmaxarealist.append(region.getMaxArea())
             else:
-                regionmaxarealist.append( NOMAXAREA)
+                regionmaxarealist.append( load_mesh.loadASCII.NOMAXAREA)
         meshDict['regions'] = regionlist
         meshDict['region_tags'] = regiontaglist
@@ -2002 +1996 @@
                                    genDict['region_tags'],
                                    genDict['region_max_areas']):
-            Object = Region( reg[0],
-                             reg[1],
-                             tag = att,
-                             maxArea = maxArea)
+            if maxArea > 0:  # maybe I should ref NOMAXAREA? Prob' not though
+                Object = Region( reg[0],
+                                 reg[1],
+                                 tag = att,
+                                 maxArea = maxArea)
+            else:
+                Object = Region( reg[0],
+                                 reg[1],
+                                 tag = att)
+                
             #Object.index = index
             #index +=1
@@ -2263 +2263 @@
         if (counter >0):
             print "%i duplicate vertices removed from dataset" % (counter)  
-    elif ofile[-4:]== ".tsh":
+    elif (ofile[-4:]== ".tsh" or ofile[-4:]== ".msh"):
         dict = load_mesh.loadASCII.import_triangulation(ofile)
+        print "********"
+        print "dict",dict
+        print "********" 
         newmesh= Mesh()
         newmesh.IOOutline2Mesh(dict)

inundation/ga/storm_surge/pmesh/meshHarness.py

@@ -478 +478 @@
         seg = m.getMeshSegments()
         
-        fileName = tempfile.mktemp(".txt")
-        m.exportASCIItriangulationfile(fileName)
+        fileName = tempfile.mktemp(".tsh")
+        m.export_triangulation_file(fileName)
         file = open(fileName)
         lFile = file.read().split('\n')
@@ -552 +552 @@
         seg = m.getMeshSegments()
         
-        fileName = tempfile.mktemp(".txt")
-        m.exportASCIItriangulationfile(fileName)
+        fileName = tempfile.mktemp(".tsh")
+        m.export_triangulation_file(fileName)
         file = open(fileName)
         lFile = file.read().split('\n')
@@ -684 +684 @@
         #print "dgs!!!"
         #print "****************** fileName", fileName
-        m.exportASCIItriangulationfile(fileName)
+        m.export_triangulation_file(fileName)
         #print "******************"
         #print "m", m

inundation/ga/storm_surge/pmesh/pmesh.py

@@ -1171 +1171 @@
                 ofile = ofile + addOn
             try:
-                self.mesh.exportASCIItriangulationfile(ofile)
+                self.mesh.export_triangulation_file(ofile)
             except IOError:
                 showerror('Export ASCII file',
@@ -1179 +1179 @@
                                    'No triangulation to export.')
                 
+    
+    def export_tsh(self):
+        fileType = "tsh"
+        fileTypeDesc = "text Mesh"
+        
+        ofile = tkFileDialog.asksaveasfilename(initialdir=self.currentPath,
+                                         filetypes=[(fileTypeDesc, fileType),
+                                                ("All Files", "*")])
+        if ofile:
+            addOn = "." + fileType
+            jumpback = - len(addOn)
+            if ofile[jumpback:] != addOn:  
+                ofile = ofile + addOn
+            try:
+                self.mesh.exportASCIImeshfile(ofile)
+            except IOError:
+                showerror('Export ASCII file',
+                                   'Can not write to file.')
+            except RuntimeError:
+                showerror('Export ASCII file',
+                                   'No mesh to export.')
     
     def exportMesh(self):
@@ -1207 +1228 @@
         print "self.currentPath",self.currentPath
         ofile = tkFileDialog.askopenfilename(initialdir=self.currentPath,
-                                             filetypes=[ ("text Mesh", "tsh"),
+                                             filetypes=[ ("text Mesh", "*.tsh *.msh"),
                                                          ("points", "*.xya *.pts"),
                                            ("All Files", "*")])
@@ -1288 +1309 @@
         """
         #print "dsg!!! self.currentFilePathName ",self.currentFilePathName
-        if (self.currentFilePathName[-4:] != ".tsh"):
+        if (self.currentFilePathName[-4:] != ".tsh" or
+            self.currentFilePathName[-4:] != ".msh"):
             # force user to choose a name
             self.saveAsDrawing()
@@ -1299 +1321 @@
         """
         ofile = tkFileDialog.asksaveasfilename(initialdir=self.currentPath,
-                                               filetypes=[("text mesh", "tsh"),
+                                               filetypes=[("mesh", "*.tsh *.msh"),
                                              ("All Files", "*")])
-        print "aa"
+           
         if ofile:
-            if ofile[-4:] == ".tsh":  
+            if (ofile[-4:] == ".tsh" or ofile[-4:] == ".msh"):  
                 self.currentFilePathName = ofile
             else:
@@ -1328 +1350 @@
                                    type=YESNOCANCEL)
             if m == "no":
-                self.mesh.exportASCIItriangulationfile(currentFilePathName)
+                self.mesh.export_triangulation_file(currentFilePathName)
                 self.UserMeshChanged = False
             elif m == "cancel":
@@ -1334 +1356 @@
             elif m == "yes":
                 self.windowMeshGen(None)
-                self.mesh.exportASCIItriangulationfile(currentFilePathName)
+                self.mesh.export_triangulation_file(currentFilePathName)
         else:
-            self.mesh.exportASCIItriangulationfile(currentFilePathName)
+            self.mesh.export_triangulation_file(currentFilePathName)
             self.UserMeshChanged = False