Changeset 1752

Timestamp:

Aug 24, 2005, 12:34:00 PM (19 years ago)

Author:

ole

Message:

Refactored quantity.set_values

Location:

inundation/pyvolution

Files:

• domain.py (modified) (2 diffs)
• quantity.py (modified) (10 diffs)
• test_quantity.py (modified) (2 diffs)

inundation/pyvolution/domain.py

@@ -143 +143 @@
     def set_quantity(self, name,
                      X,
-                     location='vertices',
+                     location = 'vertices',
                      indices = None):
         """Set values for named quantity
@@ -195 +195 @@
 
         #Set value
+        #FIXME: use **kwargs
         self.quantities[name].set_values(X,
-                                         location,
+                                         location = location,
                                          indices = indices)
 

inundation/pyvolution/quantity.py

@@ -82 +82 @@
 
     #New leaner interface to setting values
-    def set_values_new(self,
+    def set_values(self,
                    numeric = None,  #List, numeric array or constant
                    quantity = None, #Another quantity 
@@ -89 +89 @@
                    filename = None, attribute_name = None, #Input from file
                    alpha = None,
-                   location = None,                   
+                   location = 'vertices',                   
                    indices = None,
                    verbose = None):
@@ -169 +169 @@
               'must be present.'
         L = [numeric, quantity, function, points, filename]
+
         assert L.count(None) == len(L)-1, msg
 
@@ -216 +217 @@
         else:
             raise 'This can\'t happen :-)'
+
+
+        #Update all locations in triangles
+        if location == 'vertices' or location == 'unique vertices':
+            #Intialise centroid and edge_values
+            self.interpolate()
+
+        if location == 'centroids':
+            #Extrapolate 1st order - to capture notion of area being specified
+            self.extrapolate_first_order()
+
                 
 
+    #Specific functions for setting values
+    def set_values_from_constant(self, X,
+                                 location, indices, verbose):
+        """Set quantity values from specified constant X
+        """
+
+
+        if location == 'centroids':
+            if (indices ==  None):
+                self.centroid_values[:] = X
+            else:
+                #Brute force
+                for i in indices:
+                    self.centroid_values[i,:] = X
+
+        elif location == 'edges':
+            if (indices ==  None):
+                self.edge_values[:] = X
+            else:
+                #Brute force
+                for i in indices:
+                    self.edge_values[i,:] = X
+
+        elif location == 'unique vertices':
+            if (indices ==  None):
+                self.edge_values[:] = X
+            else:
+
+                #Go through list of unique vertices
+                for unique_vert_id in indices:
+                    triangles = self.domain.vertexlist[unique_vert_id]
+
+                    #In case there are unused points
+                    if triangles is None: continue
+
+                    #Go through all triangle, vertex pairs
+                    #and set corresponding vertex value
+                    for triangle_id, vertex_id in triangles:
+                        self.vertex_values[triangle_id, vertex_id] = X
+
+                    #Intialise centroid and edge_values
+                    self.interpolate()
+        else:
+            if (indices ==  None):
+                self.vertex_values[:] = X
+            else:
+                #Brute force
+                for i_vertex in indices:
+                    self.vertex_values[i_vertex,:] = X
+
     
-    #Specific functions for setting values
-    def set_values_from_function(self, function,
+
+    
+
+
+    def set_values_from_array(self, values,
+                              location, indices, verbose):
+        """Set values for quantity
+
+        values: Numeric array
+        location: Where values are to be stored.
+        Permissible options are: vertices, edges, centroid, unique vertices
+        Default is "vertices"
+
+        indices - if this action is carried out on a subset of
+        elements or unique vertices
+        The element/unique vertex indices are specified here.
+
+        In case of location == 'centroid' the dimension values must
+        be a list of a Numerical array of length N, N being the number
+        of elements.
+
+        Otherwise it must be of dimension Nx3
+
+        The values will be stored in elements following their
+        internal ordering.
+
+        If selected location is vertices, values for centroid and edges
+        will be assigned interpolated values.
+        In any other case, only values for the specified locations
+        will be assigned and the others will be left undefined.
+        """
+
+        from Numeric import array, Float, Int, allclose
+
+        values = array(values).astype(Float)
+
+        if indices is not None:
+            indices = array(indices).astype(Int)
+            msg = 'Number of values must match number of indices'
+            assert values.shape[0] == indices.shape[0], msg
+
+        N = self.centroid_values.shape[0]
+
+        if location == 'centroids':
+            assert len(values.shape) == 1, 'Values array must be 1d'
+
+            if indices is None:
+                msg = 'Number of values must match number of elements'
+                assert values.shape[0] == N, msg
+
+                self.centroid_values = values
+            else:
+                msg = 'Number of values must match number of indices'
+                assert values.shape[0] == indices.shape[0], msg
+
+                #Brute force
+                for i in range(len(indices)):
+                    self.centroid_values[indices[i]] = values[i]
+
+        elif location == 'edges':
+            assert len(values.shape) == 2, 'Values array must be 2d'
+
+            msg = 'Number of values must match number of elements'
+            assert values.shape[0] == N, msg
+
+            msg = 'Array must be N x 3'
+            assert values.shape[1] == 3, msg
+
+            self.edge_values = values
+
+        elif location == 'unique vertices':
+            assert len(values.shape) == 1 or allclose(values.shape[1:], 1),\
+                   'Values array must be 1d'
+
+            self.set_vertex_values(values.flat, indices = indices)
+        else:
+            if len(values.shape) == 1:
+                self.set_vertex_values(values, indices = indices)
+                #if indices == None:
+                    #Values are being specified once for each unique vertex
+                #    msg = 'Number of values must match number of vertices'
+                #    assert values.shape[0] == self.domain.coordinates.shape[0], msg
+                 #   self.set_vertex_values(values)
+                #else:
+                #    for element_index, value in map(None, indices, values):
+                #        self.vertex_values[element_index, :] = value
+
+            elif len(values.shape) == 2:
+                #Vertex values are given as a triplet for each triangle
+
+                msg = 'Array must be N x 3'
+                assert values.shape[1] == 3, msg
+
+                if indices == None:
+                    self.vertex_values = values
+                else:
+                    for element_index, value in map(None, indices, values):
+                        self.vertex_values[element_index] = value
+            else:
+                msg = 'Values array must be 1d or 2d'
+                raise msg
+
+    def set_values_from_quantity(self, q,
+                                 location, indices, verbose):
+        """Set quantity values from specified quantity instance q
+        """
+
+
+        raise 'not yet implemented'
+
+    def set_values_from_function(self, f,
                                  location, indices, verbose):
         """Set values for quantity using specified function
@@ -241 +412 @@
         else:
             is_subset = True
+            
         if location == 'centroids':
-            P = take(self.domain.centroid_coordinates,indices)
+            P = take(self.domain.centroid_coordinates, indices)
             if is_subset:
-                self.set_values(f(P[:,0], P[:,1]), location, indices = indices)
+                self.set_values(f(P[:,0], P[:,1]),
+                                location = location,
+                                indices = indices)
             else:
-                self.set_values(f(P[:,0], P[:,1]), location)
+                self.set_values(f(P[:,0], P[:,1]), location = location)
         elif location == 'vertices':
             P = self.domain.vertex_coordinates
@@ -259 +433 @@
         else:
             raise 'Not implemented: %s' %location
-
-
-    def set_array_values(self, values, location='vertices', indices = None):
-        """Set values for quantity
-
-        values: Numeric array
-        location: Where values are to be stored.
-        Permissible options are: vertices, edges, centroid, unique vertices
-        Default is "vertices"
-
-        indices - if this action is carried out on a subset of
-        elements or unique vertices
-        The element/unique vertex indices are specified here.
-
-        In case of location == 'centroid' the dimension values must
-        be a list of a Numerical array of length N, N being the number
-        of elements.
-
-        Otherwise it must be of dimension Nx3
-
-        The values will be stored in elements following their
-        internal ordering.
-
-        If selected location is vertices, values for centroid and edges
-        will be assigned interpolated values.
-        In any other case, only values for the specified locations
-        will be assigned and the others will be left undefined.
-        """
-
-        from Numeric import array, Float, Int, allclose
-
-        values = array(values).astype(Float)
-
-        if (indices <> None):
-            indices = array(indices).astype(Int)
-            msg = 'Number of values must match number of indices'
-            assert values.shape[0] == indices.shape[0], msg
-
-        N = self.centroid_values.shape[0]
-
-        if location == 'centroids':
-            assert len(values.shape) == 1, 'Values array must be 1d'
-
-            if indices == None:
-                msg = 'Number of values must match number of elements'
-                assert values.shape[0] == N, msg
-
-                self.centroid_values = values
-            else:
-                msg = 'Number of values must match number of indices'
-                assert values.shape[0] == indices.shape[0], msg
-
-                #Brute force
-                for i in range(len(indices)):
-                    self.centroid_values[indices[i]] = values[i]
-
-        elif location == 'edges':
-            assert len(values.shape) == 2, 'Values array must be 2d'
-
-            msg = 'Number of values must match number of elements'
-            assert values.shape[0] == N, msg
-
-            msg = 'Array must be N x 3'
-            assert values.shape[1] == 3, msg
-
-            self.edge_values = values
-
-        elif location == 'unique vertices':
-            assert len(values.shape) == 1 or allclose(values.shape[1:], 1),\
-                   'Values array must be 1d'
-
-            self.set_vertex_values(values.flat, indices = indices)
-        else:
-            if len(values.shape) == 1:
-                self.set_vertex_values(values, indices = indices)
-                #if indices == None:
-                    #Values are being specified once for each unique vertex
-                #    msg = 'Number of values must match number of vertices'
-                #    assert values.shape[0] == self.domain.coordinates.shape[0], msg
-                 #   self.set_vertex_values(values)
-                #else:
-                #    for element_index, value in map(None, indices, values):
-                #        self.vertex_values[element_index, :] = value
-
-            elif len(values.shape) == 2:
-                #Vertex values are given as a triplet for each triangle
-
-                msg = 'Array must be N x 3'
-                assert values.shape[1] == 3, msg
-
-                if indices == None:
-                    self.vertex_values = values
-                else:
-                    for element_index, value in map(None, indices, values):
-                        self.vertex_values[element_index] = value
-            else:
-                msg = 'Values array must be 1d or 2d'
-                raise msg
 
 
@@ -438 +514 @@
         self.set_values_from_points(points, z, alpha,
                                     location, indices, verbose)
-
-
-
-
-
-    #Old interface to setting values
-    def set_values(self, X,
-                   location='vertices',
-                   indices = None):
-        """Set values for quantity
-
-        X: Compatible list, Numeric array (see below), constant or function
-        location: Where values are to be stored.
-                  Permissible options are: vertices, edges, centroids
-                  Default is "vertices"
-
-        In case of location == 'centroids' the dimension values must
-        be a list of a Numerical array of length N, N being the number
-        of elements. Otherwise it must be of dimension Nx3
-
-        The values will be stored in elements following their
-        internal ordering.
-
-        If values are described a function, it will be evaluated at
-        specified points
-
-        If indexex is not 'unique vertices' Indices is the set of element ids
-        that the operation applies to.
-        If indexex is 'unique vertices' Indices is the set of vertex ids
-        that the operation applies to.
-
-        If selected location is 'vertices', values for centroid and edges
-        will be assigned interpolated values.
-        In any other case, only values for the specified locations
-        will be assigned and the others will be left undefined.
-
-        """
-
-        if location not in ['vertices', 'centroids', 'edges',
-                            'unique vertices']:
-            msg = 'Invalid location: %s' %location
-            raise msg
-
-
-        if X is None:
-            msg = 'Given values are None'
-            raise msg
-
-        import types, Numeric
-        assert type(indices) in [types.ListType, types.NoneType,
-                                 Numeric.ArrayType],\
-                                 'Indices must be a list or None'
-
-
-        if callable(X):
-            #Use function specific method
-            self.set_function_values(X, location, indices = indices)
-        elif type(X) in [types.FloatType, types.IntType, types.LongType]:
-            if location == 'centroids':
-                if (indices ==  None):
-                    self.centroid_values[:] = X
-                else:
-                    #Brute force
-                    for i in indices:
-                        self.centroid_values[i,:] = X
-
-            elif location == 'edges':
-                if (indices ==  None):
-                    self.edge_values[:] = X
-                else:
-                    #Brute force
-                    for i in indices:
-                        self.edge_values[i,:] = X
-
-            elif location == 'unique vertices':
-                if (indices ==  None):
-                    self.edge_values[:] = X
-                else:
-
-                    #Go through list of unique vertices
-                    for unique_vert_id in indices:
-                        triangles = self.domain.vertexlist[unique_vert_id]
-
-                        #In case there are unused points
-                        if triangles is None: continue
-
-                        #Go through all triangle, vertex pairs
-                        #and set corresponding vertex value
-                        for triangle_id, vertex_id in triangles:
-                            self.vertex_values[triangle_id, vertex_id] = X
-
-                        #Intialise centroid and edge_values
-                        self.interpolate()
-            else:
-                if (indices ==  None):
-                    self.vertex_values[:] = X
-                else:
-                    #Brute force
-                    for i_vertex in indices:
-                        self.vertex_values[i_vertex,:] = X
-
-        elif type(X) in [Numeric.ArrayType, types.ListType]:
-            #Use array specific method
-            self.set_array_values(X, location, indices = indices)
-        elif type(X) == types.StringType:
-            #Assume X is a filename
-            self.set_values_from_file(X) #FIXME: More parameters
-
-
-        if location == 'vertices' or location == 'unique vertices':
-            #Intialise centroid and edge_values
-            self.interpolate()
-
-        if location == 'centroids':
-            #Extrapolate 1st order - to capture notion of area being specified
-            self.extrapolate_first_order()
 
 
@@ -621 +581 @@
 
 
-    def set_function_values(self, f, location='vertices', indices = None):
-        """Set values for quantity using specified function
-
-        f: x, y -> z Function where x, y and z are arrays
-        location: Where values are to be stored.
-                  Permissible options are: vertices, centroid
-                  Default is "vertices"
-        """
-
-        #FIXME: Should check that function returns something sensible and
-        #raise a meaningfol exception if it returns None for example
-
-        from Numeric import take
-
-        if (indices ==  None):
-            indices = range(len(self))
-            is_subset = False
-        else:
-            is_subset = True
-        if location == 'centroids':
-            P = take(self.domain.centroid_coordinates,indices)
-            if is_subset:
-                self.set_values(f(P[:,0], P[:,1]), location, indices = indices)
-            else:
-                self.set_values(f(P[:,0], P[:,1]), location)
-        elif location == 'vertices':
-            P = self.domain.vertex_coordinates
-            if is_subset:
-                #Brute force
-                for e in indices:
-                    for i in range(3):
-                        self.vertex_values[e,i] = f(P[e,2*i], P[e,2*i+1])
-            else:
-                for i in range(3):
-                    self.vertex_values[:,i] = f(P[:,2*i], P[:,2*i+1])
-        else:
-            raise 'Not implemented: %s' %location
-
-
-    def set_array_values(self, values, location='vertices', indices = None):
-        """Set values for quantity
-
-        values: Numeric array
-        location: Where values are to be stored.
-        Permissible options are: vertices, edges, centroid, unique vertices
-        Default is "vertices"
-
-        indices - if this action is carried out on a subset of
-        elements or unique vertices
-        The element/unique vertex indices are specified here.
-
-        In case of location == 'centroid' the dimension values must
-        be a list of a Numerical array of length N, N being the number
-        of elements.
-
-        Otherwise it must be of dimension Nx3
-
-        The values will be stored in elements following their
-        internal ordering.
-
-        If selected location is vertices, values for centroid and edges
-        will be assigned interpolated values.
-        In any other case, only values for the specified locations
-        will be assigned and the others will be left undefined.
-        """
-
-        from Numeric import array, Float, Int, allclose
-
-        values = array(values).astype(Float)
-
-        if (indices <> None):
-            indices = array(indices).astype(Int)
-            msg = 'Number of values must match number of indices'
-            assert values.shape[0] == indices.shape[0], msg
-
-        N = self.centroid_values.shape[0]
-
-        if location == 'centroids':
-            assert len(values.shape) == 1, 'Values array must be 1d'
-
-            if indices == None:
-                msg = 'Number of values must match number of elements'
-                assert values.shape[0] == N, msg
-
-                self.centroid_values = values
-            else:
-                msg = 'Number of values must match number of indices'
-                assert values.shape[0] == indices.shape[0], msg
-
-                #Brute force
-                for i in range(len(indices)):
-                    self.centroid_values[indices[i]] = values[i]
-
-        elif location == 'edges':
-            assert len(values.shape) == 2, 'Values array must be 2d'
-
-            msg = 'Number of values must match number of elements'
-            assert values.shape[0] == N, msg
-
-            msg = 'Array must be N x 3'
-            assert values.shape[1] == 3, msg
-
-            self.edge_values = values
-
-        elif location == 'unique vertices':
-            assert len(values.shape) == 1 or allclose(values.shape[1:], 1),\
-                   'Values array must be 1d'
-
-            self.set_vertex_values(values.flat, indices = indices)
-        else:
-            if len(values.shape) == 1:
-                self.set_vertex_values(values, indices = indices)
-                #if indices == None:
-                    #Values are being specified once for each unique vertex
-                #    msg = 'Number of values must match number of vertices'
-                #    assert values.shape[0] == self.domain.coordinates.shape[0], msg
-                 #   self.set_vertex_values(values)
-                #else:
-                #    for element_index, value in map(None, indices, values):
-                #        self.vertex_values[element_index, :] = value
-
-            elif len(values.shape) == 2:
-                #Vertex values are given as a triplet for each triangle
-
-                msg = 'Array must be N x 3'
-                assert values.shape[1] == 3, msg
-
-                if indices == None:
-                    self.vertex_values = values
-                else:
-                    for element_index, value in map(None, indices, values):
-                        self.vertex_values[element_index] = value
-            else:
-                msg = 'Values array must be 1d or 2d'
-                raise msg
-
-
-
-
-
-
-
-    # FIXME have a get_vertex_values as well, so the 'stage' quantity can be
-    # set, based on the elevation
+
     def set_vertex_values(self, A, indices = None):
         """Set vertex values for all unique vertices based on input array A
@@ -773 +590 @@
         indices is the list of vertex_id's that will be set.
 
-        Note: Functions not allowed
+        This function is used by set_values_from_array
         """
 
@@ -804 +621 @@
         #Intialise centroid and edge_values
         self.interpolate()
+
 
     def smooth_vertex_values(self, value_array='field_values',

inundation/pyvolution/test_quantity.py

@@ -171 +171 @@
         assert allclose(quantity.vertex_values,
                         [[1,1,1], [1,1,1], [1,1,1], [1, 1, 1]])
+
         assert allclose(quantity.centroid_values, [1, 1, 1, 1]) #Centroid
         assert allclose(quantity.edge_values, [[1, 1, 1],
@@ -1020 +1021 @@
     suite = unittest.makeSuite(Test_Quantity,'test')
     #print "restricted test"
-    #suite = unittest.makeSuite(Test_Quantity,'test_set_vertex_values_subset')
+    #suite = unittest.makeSuite(Test_Quantity,'test_set_values_func')
     runner = unittest.TextTestRunner()
     runner.run(suite)