Changeset 5910

Timestamp:

Nov 6, 2008, 4:29:25 PM (15 years ago)

Author:

rwilson

Message:

NumPy? conversion.

Location:

anuga_core/source_numpy_conversion/anuga/load_mesh

Files:

• loadASCII.py (modified) (24 diffs)
• test_loadASCII.py (modified) (6 diffs)

anuga_core/source_numpy_conversion/anuga/load_mesh/loadASCII.py

@@ -57 +57 @@
 
 from string import  find, rfind
-from Numeric import array, Float, Int16, Int32, Character,reshape, concatenate, take
+import numpy
 from os.path import splitext
 
@@ -644 +644 @@
     # in more detail.
     
-    IntType = Int32
+    IntType = numpy.int32
     #IntType = Int
     
     # 
     #the triangulation
-    mesh['vertices'] = array(mesh['vertices']).astype(Float)
+    mesh['vertices'] = numpy.array(mesh['vertices']).astype(numpy.float)
     if mesh['vertex_attributes'] != None:
         mesh['vertex_attributes'] = \
-               array(mesh['vertex_attributes']).astype(Float)
-    mesh['vertex_attribute_titles'] = array(mesh['vertex_attribute_titles']).astype(Character) 
-    mesh['segments'] = array(mesh['segments']).astype(IntType)
-    mesh['segment_tags'] = array(mesh['segment_tags']).astype(Character)
-    mesh['triangles'] = array(mesh['triangles']).astype(IntType)
-    mesh['triangle_tags'] = array(mesh['triangle_tags']) #.astype(Character)
-    mesh['triangle_neighbors'] = array(mesh['triangle_neighbors']).astype(IntType) 
+               numpy.array(mesh['vertex_attributes']).astype(numpy.float)
+    mesh['vertex_attribute_titles'] = numpy.array(mesh['vertex_attribute_titles']).astype(numpy.character) 
+    mesh['segments'] = numpy.array(mesh['segments']).astype(IntType)
+    mesh['segment_tags'] = numpy.array(mesh['segment_tags']).astype(numpy.character)
+    mesh['triangles'] = numpy.array(mesh['triangles']).astype(IntType)
+    mesh['triangle_tags'] = numpy.array(mesh['triangle_tags']) #.astype(numpy.character)
+    mesh['triangle_neighbors'] = numpy.array(mesh['triangle_neighbors']).astype(IntType) 
     
     #the outline 
-    mesh['points'] = array(mesh['points']).astype(Float)
-    mesh['point_attributes'] = array(mesh['point_attributes']).astype(Float)
-    mesh['outline_segments'] = array(mesh['outline_segments']).astype(IntType)
-    mesh['outline_segment_tags'] = array(mesh['outline_segment_tags']).astype(Character)
-    mesh['holes'] = array(mesh['holes']).astype(Float)
-    mesh['regions'] = array(mesh['regions']).astype(Float)
-    mesh['region_tags'] = array(mesh['region_tags']).astype(Character)
-    mesh['region_max_areas'] = array(mesh['region_max_areas']).astype(Float)
+    mesh['points'] = numpy.array(mesh['points']).astype(numpy.float)
+    mesh['point_attributes'] = numpy.array(mesh['point_attributes']).astype(numpy.float)
+    mesh['outline_segments'] = numpy.array(mesh['outline_segments']).astype(IntType)
+    mesh['outline_segment_tags'] = numpy.array(mesh['outline_segment_tags']).astype(numpy.character)
+    mesh['holes'] = numpy.array(mesh['holes']).astype(numpy.float)
+    mesh['regions'] = numpy.array(mesh['regions']).astype(numpy.float)
+    mesh['region_tags'] = numpy.array(mesh['region_tags']).astype(numpy.character)
+    mesh['region_max_areas'] = numpy.array(mesh['region_max_areas']).astype(numpy.float)
     
     #mesh = mesh_dict2array(mesh)
@@ -699 +699 @@
     if (mesh['vertices'].shape[0] > 0):
         outfile.createDimension('num_of_vertices', mesh['vertices'].shape[0])
-        outfile.createVariable('vertices', Float, ('num_of_vertices',
+        outfile.createVariable('vertices', numpy.float, ('num_of_vertices',
                                                    'num_of_dimensions'))
         outfile.variables['vertices'][:] = mesh['vertices']
@@ -709 +709 @@
                                     mesh['vertex_attribute_titles'].shape[1])
             outfile.createVariable('vertex_attributes',
-                                   Float,
+                                   numpy.float,
                                    ('num_of_vertices',
                                     'num_of_vertex_attributes'))   
             outfile.createVariable('vertex_attribute_titles',
-                                   Character,
+                                   numpy.character,
                                    ( 'num_of_vertex_attributes',
                                      'num_of_vertex_attribute_title_chars' ))
@@ -732 +732 @@
                                     mesh['segment_tags'].shape[1])
             outfile.createVariable('segment_tags',
-                                   Character,
+                                   numpy.character,
                                    ('num_of_segments',
                                     'num_of_segment_tag_chars'))
@@ -755 +755 @@
                                     mesh['triangle_tags'].shape[1]) 
             outfile.createVariable('triangle_tags',
-                                   Character,
+                                   numpy.character,
                                    ('num_of_triangles',
                                     'num_of_triangle_tag_chars'))
@@ -765 +765 @@
     if (mesh['points'].shape[0] > 0):
         outfile.createDimension('num_of_points', mesh['points'].shape[0])
-        outfile.createVariable('points', Float, ('num_of_points',
+        outfile.createVariable('points', numpy.float, ('num_of_points',
                                                  'num_of_dimensions'))
         outfile.variables['points'][:] = mesh['points'] 
@@ -772 +772 @@
                                     mesh['point_attributes'].shape[1])
             outfile.createVariable('point_attributes',
-                                   Float,
+                                   numpy.float,
                                    ('num_of_points',
                                     'num_of_point_attributes'))
@@ -789 +789 @@
                                     mesh['outline_segment_tags'].shape[1])
             outfile.createVariable('outline_segment_tags',
-                                   Character,
+                                   numpy.character,
                                    ('num_of_outline_segments',
                                     'num_of_outline_segment_tag_chars'))
@@ -796 +796 @@
     if (mesh['holes'].shape[0] > 0):
         outfile.createDimension('num_of_holes', mesh['holes'].shape[0])
-        outfile.createVariable('holes', Float, ('num_of_holes',
+        outfile.createVariable('holes', numpy.float, ('num_of_holes',
                                                 'num_of_dimensions'))
         outfile.variables['holes'][:] = mesh['holes']
@@ -802 +802 @@
     if (mesh['regions'].shape[0] > 0):
         outfile.createDimension('num_of_regions', mesh['regions'].shape[0])
-        outfile.createVariable('regions', Float, ('num_of_regions',
+        outfile.createVariable('regions', numpy.float, ('num_of_regions',
                                                   'num_of_dimensions'))
         outfile.createVariable('region_max_areas',
-                               Float,
+                               numpy.float,
                                ('num_of_regions',))
         outfile.variables['regions'][:] = mesh['regions']
@@ -813 +813 @@
                                     mesh['region_tags'].shape[1])
             outfile.createVariable('region_tags',
-                                   Character,
+                                   numpy.character,
                                    ('num_of_regions',
                                     'num_of_region_tag_chars'))
@@ -848 +848 @@
         mesh['vertices'] = fid.variables['vertices'][:]
     except KeyError:
-        mesh['vertices'] = array([])
+        mesh['vertices'] = numpy.array([])
     try:
         mesh['vertex_attributes'] = fid.variables['vertex_attributes'][:]
@@ -866 +866 @@
         mesh['segments'] = fid.variables['segments'][:]
     except KeyError:
-        mesh['segments'] = array([])
+        mesh['segments'] = numpy.array([])
     mesh['segment_tags'] =[]
     try:
@@ -879 +879 @@
         mesh['triangle_neighbors'] = fid.variables['triangle_neighbors'][:]
     except KeyError:
-        mesh['triangles'] = array([])
-        mesh['triangle_neighbors'] = array([])
+        mesh['triangles'] = numpy.array([])
+        mesh['triangle_neighbors'] = numpy.array([])
     mesh['triangle_tags'] =[]
     try:
@@ -904 +904 @@
         mesh['outline_segments'] = fid.variables['outline_segments'][:]
     except KeyError:
-        mesh['outline_segments'] = array([])
+        mesh['outline_segments'] = numpy.array([])
     mesh['outline_segment_tags'] =[]
     try:
@@ -916 +916 @@
         mesh['holes'] = fid.variables['holes'][:]
     except KeyError:
-        mesh['holes'] = array([])
+        mesh['holes'] = numpy.array([])
     try:
         mesh['regions'] = fid.variables['regions'][:]
     except KeyError:
-        mesh['regions'] = array([])
+        mesh['regions'] = numpy.array([])
     mesh['region_tags'] =[]
     try:
@@ -932 +932 @@
         mesh['region_max_areas'] = fid.variables['region_max_areas'][:]
     except KeyError:
-        mesh['region_max_areas'] = array([])
+        mesh['region_max_areas'] = numpy.array([])
     #mesh[''] = fid.variables[''][:]
       
@@ -985 +985 @@
     
 def extent(points):
-    points = array(points).astype(Float)
+    points = numpy.array(points).astype(numpy.float)
     max_x = min_x = points[0][0]
     max_y = min_y = points[0][1]
@@ -995 +995 @@
         if y > max_y: max_y = y
         if y < min_y: min_y = y
-    extent = array([[min_x,min_y],[max_x,min_y],[max_x,max_y],[min_x,max_y]])
+    extent = numpy.array([[min_x,min_y],[max_x,min_y],[max_x,max_y],[min_x,max_y]])
     #print "extent",extent 
     return extent
@@ -1027 +1027 @@
     
 def point_atts2array(point_atts):
-    point_atts['pointlist'] = array(point_atts['pointlist']).astype(Float)
+    point_atts['pointlist'] = numpy.array(point_atts['pointlist']).astype(numpy.float)
     
     for key in point_atts['attributelist'].keys():
-        point_atts['attributelist'][key]= array(point_atts['attributelist'][key]).astype(Float)
+        point_atts['attributelist'][key]= numpy.array(point_atts['attributelist'][key]).astype(numpy.float)
     return point_atts
     
@@ -1046 +1046 @@
     return list of attribute titles, array of attributes 
     """
-    point_attributes = array([]).astype(Float)
+    point_attributes = numpy.array([]).astype(numpy.float)
     keys = dic.keys()
     key = keys.pop(0)
-    point_attributes = reshape(dic[key],(dic[key].shape[0],1))
+    point_attributes = numpy.reshape(dic[key],(dic[key].shape[0],1))
     for key in keys:
-        #point_attributes = concatenate([point_attributes, dic[key]], axis=1)
-        reshaped = reshape(dic[key],(dic[key].shape[0],1))
-        point_attributes = concatenate([point_attributes, reshaped], axis=1)
+        #point_attributes = numpy.concatenate([point_attributes, dic[key]], axis=1)
+        reshaped = numpy.reshape(dic[key],(dic[key].shape[0],1))
+        point_attributes = numpy.concatenate([point_attributes, reshaped], axis=1)
     return dic.keys(), point_attributes
 
@@ -1060 +1060 @@
     dict = point_atts2array(dict)
     #FIXME maybe the points data structure should become a class?
-    dict['pointlist'] = take(dict['pointlist'],indices_to_keep)
+    dict['pointlist'] = numpy.take(dict['pointlist'],indices_to_keep)
 
     for key in dict['attributelist'].keys():
-        dict['attributelist'][key]= take(dict['attributelist'][key],
+        dict['attributelist'][key]= numpy.take(dict['attributelist'][key],
                                          indices_to_keep)
     return dict
@@ -1074 +1074 @@
     
     combined = {}  
-    combined['pointlist'] = concatenate((dict2['pointlist'],
+    combined['pointlist'] = numpy.concatenate((dict2['pointlist'],
                                          dict1['pointlist']),axis=0)   
     atts = {}   
     for key in dict2['attributelist'].keys():
-        atts[key]= concatenate((dict2['attributelist'][key],
+        atts[key]= numpy.concatenate((dict2['attributelist'][key],
                                 dict1['attributelist'][key]), axis=0)
     combined['attributelist']=atts

anuga_core/source_numpy_conversion/anuga/load_mesh/test_loadASCII.py

@@ -10 +10 @@
 from os.path import splitext
 
-from Numeric import array, allclose, alltrue 
-    
+import numpy
+
 from anuga.load_mesh.loadASCII import *
 from anuga.coordinate_transforms.geo_reference import Geo_reference
@@ -179 +179 @@
         #print "*(*("
         
-        self.failUnless(alltrue(array(meshDict['vertices'])  ==
-                        array(loadedDict['vertices'])),
+        self.failUnless(numpy.array(meshDict['vertices'])  ==
+                        numpy.array(loadedDict['vertices']),
                          'test_export_mesh_file failed. Test 1')
-        self.failUnless(alltrue(array(meshDict['triangles'])  ==
-                        array(loadedDict['triangles'])),
+        self.failUnless(numpy.array(meshDict['triangles'])  ==
+                        numpy.array(loadedDict['triangles']),
                          'test_export_mesh_file failed. Test 2')
-        self.failUnless(alltrue(array(meshDict['segments'])  ==
-                        array(loadedDict['segments'])),
+        self.failUnless(numpy.array(meshDict['segments'])  ==
+                        numpy.array(loadedDict['segments']),
                          'test_export_mesh_file failed. Test 3')
-        self.failUnless(alltrue(array(meshDict['triangle_tags'])  ==
-                        array(loadedDict['triangle_tags'])),
+        self.failUnless(numpy.array(meshDict['triangle_tags'])  ==
+                        numpy.array(loadedDict['triangle_tags']),
                          'test_export_mesh_file failed. Test 4')
-
+        
         self.failUnless(meshDict['vertex_attributes']  ==
                         loadedDict['vertex_attributes'],
                          'test_export_mesh_file failed. Test 5')
-        self.failUnless(alltrue(array(meshDict['triangle_neighbors'])  ==
-                        array(loadedDict['triangle_neighbors'])),
+        self.failUnless(numpy.array(meshDict['triangle_neighbors'])  ==
+                        numpy.array(loadedDict['triangle_neighbors']),
                          'test_export_mesh_file failed. Test 6')
-        self.failUnless(alltrue(array(meshDict['segment_tags'])  ==
-                        array(loadedDict['segment_tags'])),
+        self.failUnless(numpy.array(meshDict['segment_tags'])  ==
+                        numpy.array(loadedDict['segment_tags']),
                          'test_export_mesh_file failed. Test 7')
-        self.failUnless(alltrue(array(meshDict['vertex_attribute_titles'])  ==
-                        array(loadedDict['vertex_attribute_titles'])),
+        self.failUnless(numpy.array(meshDict['vertex_attribute_titles'])  ==
+                        numpy.array(loadedDict['vertex_attribute_titles']),
                          'test_export_mesh_file failed. Test 8')
-        self.failUnless(alltrue(array(meshDict['geo_reference'])  ==
-                        array(loadedDict['geo_reference'])),
+        self.failUnless(numpy.array(meshDict['geo_reference'])  ==
+                        numpy.array(loadedDict['geo_reference']),
                          'test_export_mesh_file failed. Test 9')
             
@@ -439 +439 @@
                          
     def check_mesh_dicts(self, loaded_dict, dict, fail_string ):
-        assert allclose(array(loaded_dict['points']),
-                        array(dict['points']))
+        assert numpy.allclose(numpy.array(loaded_dict['points']),
+                        numpy.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']))
+        assert numpy.allclose(numpy.array(loaded_dict['point_attributes']),
+                        numpy.array(dict['point_attributes']))
+        assert numpy.allclose(numpy.array(loaded_dict['outline_segments']),
+                        numpy.array(dict['outline_segments']))
         
         self.failUnless(loaded_dict['outline_segment_tags']  ==
@@ -452 +452 @@
         
             
-        assert allclose(array(loaded_dict['regions']),
-                        array(dict['regions']))
-                        
+        assert numpy.allclose(numpy.array(loaded_dict['regions']),
+                        numpy.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 numpy.allclose(numpy.array(loaded_dict['region_max_areas']),
+                        numpy.array(dict['region_max_areas']))
  
-        assert allclose(array(loaded_dict['holes']),
-                        array(dict['holes']))
+        assert numpy.allclose(numpy.array(loaded_dict['holes']),
+                        numpy.array(dict['holes']))
  
-        assert allclose(array(dict['vertices']),
-                        array(loaded_dict['vertices']))
+        assert numpy.allclose(numpy.array(dict['vertices']),
+                        numpy.array(loaded_dict['vertices']))
  
-        assert allclose(array(dict['triangles']),
-                        array(loaded_dict['triangles']))
+        assert numpy.allclose(numpy.array(dict['triangles']),
+                        numpy.array(loaded_dict['triangles']))
  
-        assert allclose(array(dict['segments']),
-                        array(loaded_dict['segments']))
+        assert numpy.allclose(numpy.array(dict['segments']),
+                        numpy.array(loaded_dict['segments']))
         for ob, ldob in map(None,dict['triangle_tags'],
                               loaded_dict['triangle_tags']):
-            self.failUnless(ob == ldob,
+            self.failUnless(ob  == ldob,
                         fail_string + ' failed!! Test triangle_tags')
         # A bit hacky
@@ -484 +483 @@
                         fail_string + ' failed!! Test vertex_attributes')
  
-        assert allclose(array(dict['triangle_neighbors']),
-                        array(loaded_dict['triangle_neighbors']))
+        assert numpy.allclose(numpy.array(dict['triangle_neighbors']),
+                        numpy.array(loaded_dict['triangle_neighbors']))
 
         for seg, ldseg in map(None,dict['segment_tags'],
@@ -492 +491 @@
                         fail_string + ' failed!! Test 8')
         try:
-            assert allclose(array(dict['vertex_attribute_titles']),
-                            array(loaded_dict['vertex_attribute_titles']))
+            assert numpy.allclose(numpy.array(dict['vertex_attribute_titles']),
+                            numpy.array(loaded_dict['vertex_attribute_titles']))
         except TypeError:
-            self.failUnless(alltrue(array(loaded_dict['vertex_attribute_titles']) == array(dict['vertex_attribute_titles'])),
+            self.failUnless(numpy.array(loaded_dict['vertex_attribute_titles'])  ==
+                        numpy.array(dict['vertex_attribute_titles']),
                         fail_string + ' failed!! Test 8')
         try: