Changeset 7751

Timestamp:

May 28, 2010, 1:24:10 PM (14 years ago)

Author:

hudson

Message:

Refactorings from May ANUGA meeting.

Location:

anuga_core/source/anuga

Files:

• __init__.py (modified) (1 diff)
• abstract_2d_finite_volumes/util.py (modified) (1 diff)
• file_conversion/__init__.py (modified) (1 diff)
• fit_interpolate/benchmark_least_squares.py (added)
• fit_interpolate/fit.py (modified) (1 diff)
• fit_interpolate/general_fit_interpolate.py (modified) (1 diff)
• geometry/aabb.py (modified) (4 diffs)
• geometry/quad.py (modified) (10 diffs)
• pmesh/mesh_quadtree.py (copied) (copied from anuga_core/source/anuga/geometry/mesh_quadtree.py) (3 diffs)
• pmesh/test_meshquad.py (copied) (copied from anuga_core/source/anuga/geometry/test_meshquad.py)
• shallow_water/data_manager.py (modified) (1 diff)
• utilities/file_utils.py (modified) (1 diff)
• utilities/interp.py (modified) (1 diff)

anuga_core/source/anuga/__init__.py

@@ -7 +7 @@
 import sys
 sys.path += __path__
+
+
+# Make selected classes available directly
+
+# Boundaries specific to shallow water domain.
+from anuga.shallow_water.boundaries import Reflective_boundary,\
+     Transmissive_momentum_set_stage_boundary,\
+     Dirichlet_discharge_boundary,\
+     Field_boundary,\
+     Transmissive_stage_zero_momentum_boundary,\
+     Transmissive_n_momentum_zero_t_momentum_set_stage_boundary
+
+# Boundaries generic across all forms of domain.
+from anuga.abstract_2d_finite_volumes.generic_boundary_conditions\
+     import Transmissive_boundary, Dirichlet_boundary, \
+            Time_boundary, File_boundary, AWI_boundary
+
+# Shallow water domain is the standard
+from anuga.shallow_water.shallow_water_domain import Domain

anuga_core/source/anuga/abstract_2d_finite_volumes/util.py

@@ -308 +308 @@
     return degrees(angle([uh, vh], [0, -1]))   
 
-
-def copy_code_files(dir_name, filename1, filename2, verbose=False):
-    """Copies "filename1" and "filename2" to "dir_name".
-
-    Each 'filename' may be a string or list of filename strings.
-
-    Filenames must be absolute pathnames
-    """
-
-    ##
-    # @brief copies a file or sequence to destination directory.
-    # @param dest The destination directory to copy to.
-    # @param file A filename string or sequence of filename strings.
-    def copy_file_or_sequence(dest, file):
-        if hasattr(file, '__iter__'):
-            for f in file:
-                shutil.copy(f, dir_name)
-                if verbose:
-                    log.critical('File %s copied' % f)
-        else:
-            shutil.copy(file, dir_name)
-            if verbose:
-                log.critical('File %s copied' % file)
-
-    # check we have a destination directory, create if necessary
-    if not os.path.isdir(dir_name):
-        if verbose:
-            log.critical('Make directory %s' % dir_name)
-        mkdir(dir_name, 0777)
-
-    if verbose:
-        log.critical('Output directory: %s' % dir_name)        
-
-    copy_file_or_sequence(dir_name, filename1)
-
-    if not filename2 is None:
-        copy_file_or_sequence(dir_name, filename2)
 
 ##

anuga_core/source/anuga/file_conversion/__init__.py

@@ -6 +6 @@
 sys.path += __path__
 
-# Make selected classes available directly
-from boundaries import Reflective_boundary,\
-     Transmissive_momentum_set_stage_boundary,\
-     Dirichlet_discharge_boundary,\
-     Field_boundary,\
-     Transmissive_stage_zero_momentum_boundary,\
-     Transmissive_n_momentum_zero_t_momentum_set_stage_boundary
-
-from anuga.abstract_2d_finite_volumes.generic_boundary_conditions\
-     import Transmissive_boundary, Dirichlet_boundary, \
-            Time_boundary, File_boundary, AWI_boundary
-
-from shallow_water_domain import Domain
-
 
 #from shallow_water_balanced_domain import Swb_domain

anuga_core/source/anuga/fit_interpolate/fit.py

@@ -35 +35 @@
 from anuga.utilities.sparse import Sparse, Sparse_CSR
 from anuga.geometry.polygon import inside_polygon, is_inside_polygon
-from anuga.geometry.mesh_quadtree import MeshQuadtree
+from anuga.pmesh.mesh_quadtree import MeshQuadtree
 
 from anuga.utilities.cg_solve import conjugate_gradient

anuga_core/source/anuga/fit_interpolate/general_fit_interpolate.py

@@ -31 +31 @@
 from anuga.geospatial_data.geospatial_data import Geospatial_data, \
      ensure_absolute
-from anuga.geometry.mesh_quadtree import MeshQuadtree
+from anuga.pmesh.mesh_quadtree import MeshQuadtree
 import anuga.utilities.log as log
 

anuga_core/source/anuga/geometry/aabb.py

@@ -1 @@
-# Allow children to be slightly bigger than their parents to prevent straddling of a boundary
+"""
+    Axially aligned bounding box.
+    Contains a class describing a bounding box. It contains methods
+    to split itself and return child boxes.
+"""
+
+# Allow children to be slightly bigger than their parents to prevent
+# straddling of a boundary
 SPLIT_BORDER_RATIO    = 0.55
 
@@ -23 +30 @@
     def __repr__(self):
         return 'AABB(xmin:%f, xmax:%f, ymin:%f, ymax:%f)' \
-               % (round(self.xmin,1), round(self.xmax,1), round(self.ymin,1), round(self.ymax, 1)) 
+               % (round(self.xmin,1), round(self.xmax,1), \
+                  round(self.ymin,1), round(self.ymax, 1)) 
 
 
@@ -56 +64 @@
         if (width > height):
             # split vertically
-            return AABB(self.xmin, self.xmin+width*border, self.ymin, self.ymax), \
-                   AABB(self.xmax-width*border, self.xmax, self.ymin, self.ymax)
+            split1 = self.xmin+width*border
+            split2 = self.xmax-width*border
+            return AABB(self.xmin, split1, self.ymin, self.ymax), \
+                   AABB(split2, self.xmax, self.ymin, self.ymax)
         else:
             # split horizontally       
-            return AABB(self.xmin, self.xmax, self.ymin, self.ymin+height*border), \
-                   AABB(self.xmin, self.xmax, self.ymax-height*border, self.ymax)    
+            split1 = self.ymin+height*border
+            split2 = self.ymax-height*border
+            return AABB(self.xmin, self.xmax, self.ymin, split1), \
+                   AABB(self.xmin, self.xmax, split2, self.ymax)    
 
     
@@ -76 +88 @@
         return True
  
-    def contains(self, x):
+    def contains(self, point):
         """ is point within box
-            x is a test point
+            point is a test point
             return True if the point is contained within the box.
         """
-        return (self.xmin <= x[0] <= self.xmax) and (self.ymin <= x[1] <= self.ymax)
+        return (self.xmin <= point[0] <= self.xmax) \
+                and (self.ymin <= point[1] <= self.ymax)
         

anuga_core/source/anuga/geometry/quad.py

@@ -1 +1 @@
 """quad.py - quad tree data structure for fast indexing of regions in the plane.
 
-This is a generic structure that can be used to store any geometry in a quadtree.
-It is naive, and does not exploit any coherency - it merely tests a bounding
-box against all other bounding boxes in its heirarchy.
-
-It returns a list of bounding boxes which intersect with the test box, which
-must then be iterated over to detect actual intersections.
+This generic structure can be used to store any geometry in a quadtree.
+It is naive, and does not exploit any coherency - it merely tests a point
+against all bounding boxes in its heirarchy.
+
+It returns a list of bounding boxes which intersect with the test point, which
+may then be iterated over with a proper intersection test to detect actual
+geometry intersections.
 
 """
 
 from anuga.utilities.treenode import TreeNode
-import string, types, sys
 import anuga.utilities.log as log
-from aabb import AABB
 
             
@@ -30 +29 @@
   
         # Initialise base classes
-        TreeNode.__init__(self, string.lower(name))
+        TreeNode.__init__(self, name)
     
         self.extents = extents
@@ -41 +40 @@
     
     def __repr__(self):
-        str = '%s: leaves: %d' \
+        ret_str = '%s: leaves: %d' \
                % (self.name , len(self.leaves))    
         if self.children:
-            str += ', children: %d' % (len(self.children))
-        return str
+            ret_str += ', children: %d' % (len(self.children))
+        return ret_str
 
    
 
     def clear(self):
+        """ Remove all leaves from this node.
+        """
         self.Prune()   # TreeNode method
 
 
     def clear_leaf_node(self):
-        """Clears storage in leaf node.
-    Called from Treenode.
-    Must exist.    
-    """
+        """ Clears storage in leaf node.
+            Called from Treenode.
+            Must exist.    
+        """
         self.leaves = []
     
@@ -75 +76 @@
         if type(new_leaf)==type(list()):
             for leaf in new_leaf:
-                self._insert(leaf)
+                self.insert_item(leaf)
         else:
-            self._insert(new_leaf)
-
-
-    def _insert(self, new_leaf):   
-        """ Internal recursive insert.
+            self.insert_item(new_leaf)
+
+
+    def insert_item(self, new_leaf):   
+        """ Internal recursive insert a single item.
             new_leaf is a tuple of (AABB extents, data), where data can
                      be any user data (geometry, triangle index, etc.).       
         """
-        new_region, data = new_leaf
+        new_region, _ = new_leaf
         
         # recurse down to any children until we get an intersection
@@ -91 +92 @@
             for child in self.children:
                 if child.extents.is_trivial_in(new_region):
-                    child._insert(new_leaf)
+                    child.insert_item(new_leaf)
                     return
         else:            
@@ -98 +99 @@
             
             # option 1 - try splitting 4 ways
-            #subregion11, subregion12 = subregion1.split()                                
+            #subregion11, subregion12 = subregion1.split()    
             #subregion21, subregion22 = subregion2.split()
             #regions = [subregion11, subregion12, subregion21, subregion22]
@@ -104 +105 @@
                 #if region.is_trivial_in(new_region):
                     #self.children = [Cell(x, parent=self) for x in regions]
-                    #self._insert(new_leaf)
+                    #self.insert_item(new_leaf)
                     #return               
 
             # option 2 - try splitting 2 ways - no diff noticed in practise
             if subregion1.is_trivial_in(new_region):
-                self.children = [Cell(subregion1, self), Cell(subregion2, self)]    
-                self.children[0]._insert(new_leaf)
+                self.children = [Cell(subregion1, self), \
+                                 Cell(subregion2, self)]    
+                self.children[0].insert_item(new_leaf)
                 return
             elif subregion2.is_trivial_in(new_region):
-                self.children = [Cell(subregion1, self), Cell(subregion2, self)]    
-                self.children[1]._insert(new_leaf)
+                self.children = [Cell(subregion1, self), \
+                                 Cell(subregion2, self)]    
+                self.children[1].insert_item(new_leaf)
                 return                
     
@@ -156 +159 @@
         if depth == 0:
             log.critical() 
-        print '%s%s'  % ('  '*depth, self.name), self.extents,' [', self.leaves, ']'
+        print '%s%s'  % ('  '*depth, self.name), self.extents, ' [', \
+            self.leaves, ']'
         if self.children:
             log.critical()
@@ -162 +166 @@
                 child.show(depth+1)
 
-    def search(self, x):
-        """return a list of possible intersections with geometry"""
-      
-        intersecting_regions = self.test_leaves(x)
+    def search(self, point):
+        """
+            Search the tree for intersection with leaves
+            point is a test point.
+            return a list of possible intersections with geometry.
+        """
+        intersecting_regions = self.test_leaves(point)
         
         # recurse down into nodes that the point passes through
         if self.children:
             for child in self.children:    
-                if child.extents.contains(x):
-                    intersecting_regions.extend(child.search(x))
+                if child.extents.contains(point):
+                    intersecting_regions.extend(child.search(point))
              
         return intersecting_regions
  
  
-    def test_leaves(self, x):
+    def test_leaves(self, point):
         """ Test all leaves to see if they intersect x.
             x is a point to test
@@ -186 +193 @@
         for leaf in self.leaves:
             aabb, data = leaf
-            if aabb.contains(x):
+            if aabb.contains(point):
                 intersecting_regions.append([data, self])
                 

anuga_core/source/anuga/pmesh/mesh_quadtree.py

@@ -71 +71 @@
 
             # insert a tuple with an AABB, and the triangle index as data
-            self._insert((AABB(min([x0, x1, x2]), max([x0, x1, x2]), \
+            self.insert_item((AABB(min([x0, x1, x2]), max([x0, x1, x2]), \
                              min([y0, y1, y2]), max([y0, y1, y2])), \
                              node_data))
@@ -146 +146 @@
 
         for node_data in triangles:             
-            if bool(_is_inside_triangle(x, node_data[0][1], int(True), 1.0e-12, 1.0e-12)):
+            if bool(_is_inside_triangle(x, node_data[0][1], \
+                        int(True), 1.0e-12, 1.0e-12)):
                 normals = node_data[0][2]      
                 n0 = normals[0:2]
@@ -155 +156 @@
                 sigma0 = num.dot((x-xi1), n0)/num.dot((xi0-xi1), n0)
                 sigma1 = num.dot((x-xi2), n1)/num.dot((xi1-xi2), n1)
-                sigma2 = num.dot((x-xi0), n2)/num.dot((xi2-xi0), n2)              
+                sigma2 = num.dot((x-xi0), n2)/num.dot((xi2-xi0), n2)
 
                 # Don't look for any other triangles in the triangle list
                 self.last_triangle = [node_data]
-                return True, sigma0, sigma1, sigma2, node_data[0][0] # tri index                      
+                return True, sigma0, sigma1, sigma2, node_data[0][0] # tri index
         return False, -1, -1, -1, -10
 

anuga_core/source/anuga/shallow_water/data_manager.py

@@ -79 +79 @@
 from anuga.utilities.numerical_tools import ensure_numeric,  mean
 from anuga.caching.caching import myhash
-from anuga.shallow_water import Domain
+from anuga.shallow_water.shallow_water_domain import Domain
 from anuga.abstract_2d_finite_volumes.pmesh2domain import \
      pmesh_to_domain_instance

anuga_core/source/anuga/utilities/file_utils.py

@@ -393 +393 @@
 
 
+
+def copy_code_files(dir_name, filename1, filename2, verbose=False):
+    """Copies "filename1" and "filename2" to "dir_name".
+
+    Each 'filename' may be a string or list of filename strings.
+
+    Filenames must be absolute pathnames
+    """
+
+    ##
+    # @brief copies a file or sequence to destination directory.
+    # @param dest The destination directory to copy to.
+    # @param file A filename string or sequence of filename strings.
+    def copy_file_or_sequence(dest, file):
+        if hasattr(file, '__iter__'):
+            for f in file:
+                shutil.copy(f, dir_name)
+                if verbose:
+                    log.critical('File %s copied' % f)
+        else:
+            shutil.copy(file, dir_name)
+            if verbose:
+                log.critical('File %s copied' % file)
+
+    # check we have a destination directory, create if necessary
+    if not os.path.isdir(dir_name):
+        if verbose:
+            log.critical('Make directory %s' % dir_name)
+        mkdir(dir_name, 0777)
+
+    if verbose:
+        log.critical('Output directory: %s' % dir_name)        
+
+    copy_file_or_sequence(dir_name, filename1)
+
+    if not filename2 is None:
+        copy_file_or_sequence(dir_name, filename2)

anuga_core/source/anuga/utilities/interp.py

@@ -138 +138 @@
     """
     import arrayfns
-    import numpy.ma MA
+    import numpy.ma as MA
     import numpy as N
     from where_close import where_close