anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/mesh_interface.py

@@ -0,0 +1,373 @@
+
+from anuga.coordinate_transforms.geo_reference import Geo_reference,DEFAULT_ZONE
+from anuga.geometry.polygon import  point_in_polygon ,populate_polygon
+from anuga.utilities.numerical_tools import ensure_numeric
+import numpy as num
+from anuga.geometry.polygon import inside_polygon
+from anuga.geometry.polygon import polylist2points_verts
+import anuga.utilities.log as log
+import datetime
+
+# This is due to pmesh being a package and a module and
+# the current dir being unknown 
+try:
+    from anuga.pmesh.mesh import Mesh
+except ImportError:  
+    from mesh import Mesh
+
+import exceptions
+class PolygonError(exceptions.Exception): pass
+class SegmentError(exceptions.Exception): pass
+
+def create_mesh_from_regions(bounding_polygon,
+                             boundary_tags,
+                             maximum_triangle_area=None,
+                             filename=None,
+                             interior_regions=None,
+                             interior_holes=None,
+                             hole_tags=None,
+                             poly_geo_reference=None,
+                             mesh_geo_reference=None,
+                             minimum_triangle_angle=28.0,
+                             fail_if_polygons_outside=True,
+                             breaklines=None,
+                             use_cache=False,
+                             verbose=True,
+                             regionPtArea=None):
+    """Create mesh from bounding polygons, and resolutions.
+
+    bounding_polygon is a list of points in Eastings and Northings,
+    relative to the poly_geo_reference.
+
+    Boundary tags is a dictionary of symbolic tags. For every tag there
+    is a list of indices referring to segments associated with that tag.
+    If a segment is omitted an Exception will be raised.
+
+    maximum_triangle_area is the maximal area per triangle
+    for the bounding polygon, excluding the  interior regions.
+
+    Interior_regions is a list of tuples consisting of (polygon,
+    resolution) for each region to be separately refined. Do not have
+    polygon lines cross or be on-top of each other.  Also do not have
+    polygon close to each other.
+    
+    NOTE: If a interior_region is outside the bounding_polygon it should 
+    throw an error
+    
+    Interior_holes is a list of polygons for each hole.
+    hole_tags is an optional list of boundary tags for the holes, see
+                boundary_tags parameter.
+
+    This function does not allow segments to share points - use underlying
+    pmesh functionality for that
+
+    poly_geo_reference is the geo_reference of the bounding polygon and
+    the interior polygons.
+    If none, assume absolute.  Please pass one though, since absolute
+    references have a zone.
+    
+    mesh_geo_reference is the geo_reference of the mesh to be created.
+    If none is given one will be automatically generated.  It was use
+    the lower left hand corner of  bounding_polygon (absolute)
+    as the x and y values for the geo_ref.
+
+    breaklines is a list of polygons. These lines will be preserved by the
+               triangulation algorithm - useful for coastlines, walls, etc.
+               The polygons are not closed.			   
+    
+    Returns the mesh instance if no filename is given
+
+    Note, interior regions should be fully nested, as overlaps may cause
+    unintended resolutions. 
+
+    fail_if_polygons_outside: If True (the default) Exception in thrown
+    where interior polygons fall outside bounding polygon. If False, these
+    will be ignored and execution continued.
+        
+    
+    """
+    
+    
+    if verbose: log.resource_usage_timing(log.logging.INFO, "start_")
+    if verbose: log.timingInfo("maximum_triangle_area, " + str(maximum_triangle_area))
+    if verbose: log.timingInfo("minimum_triangle_angle, " + str(minimum_triangle_angle))
+    if verbose: log.timingInfo("startMesh, '%s'" % log.CurrentDateTime())
+    
+    # Build arguments and keyword arguments for use with caching or apply.
+    args = (bounding_polygon,
+            boundary_tags)
+    
+    kwargs = {'maximum_triangle_area': maximum_triangle_area,
+              'filename': filename,
+              'interior_regions': interior_regions,
+              'interior_holes': interior_holes,
+              'hole_tags': hole_tags,
+              'poly_geo_reference': poly_geo_reference,
+              'mesh_geo_reference': mesh_geo_reference,
+              'minimum_triangle_angle': minimum_triangle_angle,
+              'fail_if_polygons_outside': fail_if_polygons_outside,
+              'breaklines': breaklines,
+              'verbose': verbose,
+              'regionPtArea': regionPtArea}   # FIXME (Ole): Should be bypassed one day. See ticket:14
+
+    # Call underlying engine with or without caching
+    if use_cache is True:
+        try:
+            from anuga.caching import cache
+        except:
+            msg = 'Caching was requested, but caching module'+\
+                  'could not be imported'
+            raise Exception(msg)
+
+
+        m = cache(_create_mesh_from_regions,
+                  args, kwargs,
+                  verbose=verbose,
+                  compression=False)
+    else:
+        m = apply(_create_mesh_from_regions,
+                  args, kwargs)
+
+
+    
+    return m    
+        
+
+
+def _create_mesh_from_regions(bounding_polygon,
+                              boundary_tags,
+                              maximum_triangle_area=None,
+                              filename=None,                              
+                              interior_regions=None,
+                              interior_holes=None,
+                              hole_tags=None,
+                              poly_geo_reference=None,
+                              mesh_geo_reference=None,
+                              minimum_triangle_angle=28.0,
+                              fail_if_polygons_outside=True,
+                              breaklines=None,
+                              verbose=True,
+                              regionPtArea=None):
+    """_create_mesh_from_regions - internal function.
+
+    See create_mesh_from_regions for documentation.
+    """
+
+    # check the segment indexes - throw an error if they are out of bounds
+    if boundary_tags is not None:
+        max_points = len(bounding_polygon)
+        for key in boundary_tags.keys():
+            if len([x for x in boundary_tags[key] if x > max_points-1]) >= 1:
+                msg = 'Boundary tag %s has segment out of bounds. '\
+                      %(str(key))
+                msg += 'Number of points in bounding polygon = %d' % max_points
+                raise SegmentError(msg)
+
+        for i in range(max_points):
+            found = False
+            for tag in boundary_tags:
+                if i in boundary_tags[tag]:
+                    found = True
+            if found is False:
+                msg = 'Segment %d was not assigned a boundary_tag.' % i
+                msg +=  'Default tag "exterior" will be assigned to missing segment'
+                #raise Exception(msg)
+                # Fixme: Use proper Python warning
+                if verbose: log.critical('WARNING: %s' % msg)
+                
+
+    
+    #In addition I reckon the polygons could be of class Geospatial_data 
+    #(DSG) If polygons were classes caching would break in places.
+
+    # Simple check
+    bounding_polygon = ensure_numeric(bounding_polygon, num.float)
+    msg = 'Bounding polygon must be a list of points or an Nx2 array'
+    assert len(bounding_polygon.shape) == 2, msg
+    assert bounding_polygon.shape[1] == 2, msg    
+
+    # 
+    if interior_regions is not None:
+        
+        # Test that all the interior polygons are inside the
+        # bounding_poly and throw out those that aren't fully
+        # included.  #Note, Both poly's have the same geo_ref,
+        # therefore don't take into account # geo_ref
+
+
+        polygons_inside_boundary = []
+        for interior_polygon, res in interior_regions:
+            indices = inside_polygon(interior_polygon, bounding_polygon,
+                                     closed = True, verbose = False)
+    
+            if len(indices) <> len(interior_polygon): 
+                msg = 'Interior polygon %s is not fully inside'\
+                      %(str(interior_polygon))
+                msg += ' bounding polygon: %s.' %(str(bounding_polygon))
+
+                if fail_if_polygons_outside is True:
+                    raise PolygonError(msg)
+                else:
+                    msg += ' I will ignore it.'
+                    log.critical(msg)
+
+            else:
+                polygons_inside_boundary.append([interior_polygon, res])
+                
+        # Record only those that were fully contained        
+        interior_regions = polygons_inside_boundary
+
+            
+    
+# the following segment of code could be used to Test that all the 
+# interior polygons are inside the bounding_poly... however it might need 
+# to be change a bit   
+#
+#count = 0
+#for i in range(len(interior_regions)):
+#    region = interior_regions[i]
+#    interior_polygon = region[0]
+#    if len(inside_polygon(interior_polygon, bounding_polygon,
+#                   closed = True, verbose = False)) <> len(interior_polygon):
+#        print 'WARNING: interior polygon %d is outside bounding polygon' %(i)
+#        count += 1
+
+#if count == 0:
+#    print 'interior regions OK'
+#else:
+#    print 'check out your interior polygons'
+#    print 'check %s in production directory' %figname
+#    import sys; sys.exit()
+
+    if interior_holes is not None:        
+        # Test that all the interior polygons are inside the bounding_poly
+        for interior_polygon in interior_holes:
+
+            # Test that we have a polygon
+            if len(num.array(interior_polygon).flat) < 6:
+                msg = 'Interior hole polygon %s has too few (<3) points.\n' \
+                    %(str(interior_polygon))
+                msg = msg + '(Insure that you have specified a LIST of interior hole polygons)'
+                raise PolygonError(msg)
+                    
+            indices = inside_polygon(interior_polygon, bounding_polygon,
+                                     closed = True, verbose = False)
+
+    
+            if len(indices) <> len(interior_polygon): 
+                msg = 'Interior polygon %s is outside bounding polygon: %s'\
+                      %(str(interior_polygon), str(bounding_polygon))
+                raise PolygonError(msg)
+
+    # Resolve geo referencing        
+    if mesh_geo_reference is None:
+        xllcorner = min(bounding_polygon[:,0])
+        yllcorner = min(bounding_polygon[:,1])    
+        #
+        if poly_geo_reference is None:
+            zone = DEFAULT_ZONE
+        else:
+            zone = poly_geo_reference.get_zone()
+            [(xllcorner,yllcorner)] = poly_geo_reference.get_absolute( \
+            [(xllcorner,yllcorner)])
+        # create a geo_ref, based on the llc of the bounding_polygon
+        mesh_geo_reference = Geo_reference(xllcorner = xllcorner,
+                                           yllcorner = yllcorner,
+                                           zone = zone)
+
+    m = Mesh(geo_reference=mesh_geo_reference)
+
+    # build a list of discrete segments from the breakline polygons
+    if breaklines is not None:
+        points, verts = polylist2points_verts(breaklines)
+        m.add_points_and_segments(points, verts)
+
+    # Do bounding polygon
+    m.add_region_from_polygon(bounding_polygon,
+                              segment_tags=boundary_tags,
+                              geo_reference=poly_geo_reference)
+
+    # Find one point inside region automatically
+    if interior_regions is not None:
+        excluded_polygons = []        
+        for polygon, res in interior_regions:
+            excluded_polygons.append( polygon )
+    else:
+        excluded_polygons = None
+
+    # Convert bounding poly to absolute values
+    # this sort of thing can be fixed with the geo_points class
+    if poly_geo_reference is not None:
+        bounding_polygon_absolute = \
+            poly_geo_reference.get_absolute(bounding_polygon)
+    else:
+        bounding_polygon_absolute = bounding_polygon
+   
+    inner_point = point_in_polygon(bounding_polygon_absolute)
+    inner = m.add_region(inner_point[0], inner_point[1])
+    inner.setMaxArea(maximum_triangle_area)
+
+    # Do interior regions
+#    if interior_regions is not None:    
+#        for polygon, res in interior_regions:
+#            m.add_region_from_polygon(polygon,
+#                                      geo_reference=poly_geo_reference)
+#            # convert bounding poly to absolute values
+#            if poly_geo_reference is not None:
+#                polygon_absolute = \
+#                    poly_geo_reference.get_absolute(polygon)
+#            else:
+#                polygon_absolute = polygon
+#            inner_point = point_in_polygon(polygon_absolute)
+#            region = m.add_region(inner_point[0], inner_point[1])
+#            region.setMaxArea(res)
+            
+            
+    if interior_regions is not None:    
+        for polygon, res in interior_regions:
+            m.add_region_from_polygon(polygon,
+                                      max_triangle_area=res,
+                                      geo_reference=poly_geo_reference)
+    
+            
+    # Do interior holes
+    if interior_holes is not None:    
+        for n, polygon in enumerate(interior_holes):
+            try:
+                tags = hole_tags[n]
+            except:
+                tags = {}
+            m.add_hole_from_polygon(polygon,
+                                    segment_tags=tags,
+                                    geo_reference=poly_geo_reference)
+
+
+    # 22/04/2014
+    # Add user-specified point-based regions with max area
+    if(regionPtArea is not None):
+        for i in range(len(regionPtArea)):
+            inner = m.add_region(regionPtArea[i][0], regionPtArea[i][1])
+            inner.setMaxArea(regionPtArea[i][2])
+        
+               
+
+
+    # NOTE (Ole): This was moved here as it is annoying if mesh is always
+    # stored irrespective of whether the computation
+    # was cached or not. This caused Domain to
+    # recompute as it has meshfile as a dependency
+
+    # Decide whether to store this mesh or return it 
+    
+    
+    if filename is None:
+        return m
+    else:
+        if verbose: log.critical("Generating mesh to file '%s'" % filename)
+      
+        m.generate_mesh(minimum_triangle_angle=minimum_triangle_angle,
+                        verbose=verbose)
+        m.export_mesh_file(filename)
+
+        return m
+        

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/mesh_quadtree.py

@@ -0,0 +1,130 @@
+"""
+    Quadtree representation of 2D mesh geometry.
+
+   Ole Nielsen, Stephen Roberts, Duncan Gray
+   Geoscience Australia, 2006.
+
+
+   PADARN NOTE 06/12/12: This quad tree has been
+   replaced by a C quad tree. Save the old code
+   somewhere?
+
+   PADARN NOTE: Most of the functionality of the
+   old quad tree has been emulated. However, some
+   methods inherrited from cell have not been. This
+   causes a few of the unit tests to fail, and thus
+   can easily be identified if it is felt the are
+   needed.
+
+"""
+
+from anuga.config import max_float
+
+from anuga.geometry.quad import Cell
+from anuga.geometry.aabb import AABB
+
+import numpy as num
+from anuga.utilities.numerical_tools import ensure_numeric
+import anuga.fit_interpolate.fitsmooth as fitsmooth
+
+
+# PADARN NOTE: I don't think much from Cell is used anymore, if
+# anything, this dependency could be removed.
+class MeshQuadtree(Cell):
+    """ A quadtree constructed from the given mesh.
+        This class is the root node of a quadtree,
+        and derives from a Cell.
+        It contains optimisations and search patterns specific to meshes.
+    """
+
+    def __init__(self, mesh, verbose=False):
+        """Build quad tree for mesh.
+
+        All vertex indices in the mesh are stored in a quadtree.
+        """
+        self.mesh = mesh
+
+        self.set_extents()
+        self.add_quad_tree()
+
+        Cell.__init__(self, self.extents, None)  # root has no parent
+
+
+    def __getstate__(self):
+        dic = self.__dict__
+        if (dic.has_key('root')):
+            dic.pop('root')
+        return dic
+
+    def set_extents(self):
+        extents = AABB(*self.mesh.get_extent(absolute=True))
+        extents.grow(1.001)  # To avoid round off error
+        numextents = [extents.xmin, extents.xmax, extents.ymin, extents.ymax]
+        self.extents = num.array(numextents, num.float)
+        #print self.extents
+
+    def add_quad_tree(self):
+
+        V = self.mesh.get_vertex_coordinates(absolute=True)
+        
+        self.set_extents()
+        #print self.extents
+        self.root = fitsmooth.build_quad_tree(self.mesh.triangles, V, self.extents)
+
+
+    # PADARN NOTE: This function does not properly emulate the old functionality -
+    # it seems uneeded though. Check this.
+    def search(self, point):
+        return self.search_fast(point)
+
+    # PADARN NOTE: Although this function emulates the functionality of the old
+    # quad tree, it cannot be called on the sub-trees anymore.
+    def count(self):
+        if not hasattr(self, 'root'):
+            self.add_quad_tree()
+        return fitsmooth.items_in_tree(self.root)
+
+    def search_fast(self, point):
+        """
+        Find the triangle (element) that the point x is in.
+
+        Does a coherent quadtree traversal to return a single triangle that the
+        point falls within. The traversal begins at the last triangle found.
+        If this fails, it checks the triangles beneath it in the tree, and then
+        begins traversing up through the tree until it reaches the root.
+
+        This results in performance which varies between constant time and O(n),
+        depending on the geometry.
+
+        Inputs:
+            point:    The point to test
+
+        Return:
+            element_found, sigma0, sigma1, sigma2, k
+
+            where
+            element_found: True if a triangle containing x was found
+            sigma0, sigma1, sigma2: The interpolated values
+            k: Index of triangle (if found)
+
+        """
+
+        # PADARN NOTE: Adding checks on the input point to make sure it is a float.
+
+        if not hasattr(self, 'root'):
+            self.add_quad_tree()
+
+        point = ensure_numeric(point, num.float)
+
+        [found, sigma, index] = fitsmooth.individual_tree_search(self.root, point)
+
+        if found == 1:
+            element_found = True
+        else:
+            element_found = False
+
+        return element_found, sigma[0], sigma[1], sigma[2], index
+
+    # PADARN NOTE: Only here to pass unit tests - does nothing.
+    def set_last_triangle(self):
+        pass

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/run_setup.py

@@ -0,0 +1,43 @@
+import os
+import string
+import sys
+import shutil
+
+
+# Work out the directory the pyd will go.
+_s = string.split( sys.version )[0]
+#print "_s",_s
+version_info = tuple( map(int, string.split(_s, '.') ) )
+del _s
+#print "version_info", version_info
+#print "sys.executable",sys.executable 
+pyd_in_dir = 'build/lib.%s-%s.%s/'  %(sys.platform,version_info[0],version_info[1])
+
+# See if the pyd has already been compiled.
+try:
+    _ = os.listdir(pyd_in_dir)
+except WindowsError:
+    # The build hasn't got the files we want
+    print "Removing the current build directory"
+    try:
+        shutil.rmtree('build')
+    except:
+        pass
+
+    
+
+if sys.platform == 'win32':  #Windows
+    win32_extra = '-cmingw32'
+
+command = '%s setup.py build %s' %(sys.executable,win32_extra) 
+os.system(command)
+    
+
+# 
+
+#print "file_in_dir", file_in_dir 
+for file in os.listdir(pyd_in_dir):
+    if os.path.splitext(file)[1] == ".pyd":
+        shutil.copy(os.path.join(pyd_in_dir,file), '.')
+
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/setup.py

@@ -0,0 +1,22 @@
+from __future__ import division, print_function
+
+import os
+import sys
+
+from os.path import join
+
+def configuration(parent_package='',top_path=None):
+    
+    from numpy.distutils.misc_util import Configuration
+    from numpy.distutils.system_info import get_info
+    
+    config = Configuration('pmesh', parent_package, top_path)
+
+    config.add_data_dir('tests')
+    config.add_data_dir('icons')    
+
+    return config
+    
+if __name__ == '__main__':
+    from numpy.distutils.core import setup
+    setup(configuration=configuration)