anuga 1.3.5__zip

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

@@ -0,0 +1,302 @@
+import mesh
+from   tkSimpleDialog import Dialog,askfloat, askinteger, askstring
+from Tkinter import  FALSE,TRUE, Frame,X, LEFT,YES,BOTH,ALL,Widget,CURRENT, Label,W, Entry, E, ACTIVE, NORMAL, StringVar
+from tkMessageBox import showerror
+
+class vAbstract:
+    """
+    Define the visualisation of a mesh object
+    """
+    def __init__(self, association):
+        # The association is the class oncanvas will hold ie mesh.Vertex
+        self.association = association 
+        self.oncanvas = {} 
+
+    def visualise(self, meshobject, uniqueID, canvas, scale):
+        """
+        draws a mesh object and add it the the canvas data structure.
+        Note: a guiID attribute is added to each point object thats visualised.
+        This is used in zooming.
+
+        meshobject is from mesh.py, eg vertex, hole
+        """
+        meshobject.guiID = uniqueID 
+        meshobject.draw(canvas, uniqueID, scale =scale)
+        self.oncanvas[uniqueID] = meshobject
+        return meshobject
+
+    def unvisualise(self, meshobject, canvas):
+        """
+        delete a visual mesh object and
+        delete it from the canvas mesh data structure
+        """
+        canvas.delete(meshobject.guiID)
+        del self.oncanvas[meshobject.guiID]
+
+    def hasKey(self, key):
+        """
+        returns true if the key is in the canvas list
+        """
+        if self.oncanvas.has_key(key):
+            return True
+        else:
+            return False
+ 
+    def getMeshObject(self, key):
+        """
+        returns the mesh object,
+        given it's key.
+
+        precon:  The key is valid
+        """
+        return self.oncanvas[key]
+
+    def editWindow(self, canvas, selMeshObject,userMeshChanged):
+        print "Not implimented"
+        return userMeshChanged
+
+    def defaultWindow(self, canvas):
+        print "Not implimented"
+
+    def draw (self):
+        """
+        This method must be overriden
+        """
+        pass
+
+    def __add__(self, other):
+        return VMesh([self,other])
+
+    def __repr__(self):
+        return str(self.__class__)
+    
+class vPoints(vAbstract):
+    """
+    Define the visualisation of a point
+    """
+
+    def draw(self,x,y,mesh,uniqueID,scale,canvas,event):
+        """
+        draw a point object, plus add it to the mesh data structure
+
+        event isn't used
+        """
+        point = mesh.addUserPoint(self.association,x/scale,y/scale)
+        self.visualise(point, uniqueID, canvas, scale)
+        return point
+ 
+class vRegions(vPoints):
+    """
+    Define the visualisation of a region
+    """ 
+    def editWindow(self, canvas, selMeshObject,userMeshChanged):
+        dialog = EditRegionDialog (canvas,
+                                   selMeshObject.getTag(),
+                                   selMeshObject.getMaxArea() )
+        if dialog.ValueOk:
+            selMeshObject.setTag(dialog.tag)
+            if dialog.maxArea != 0.0: #using 0.0 to mean no max area (hacky)
+                selMeshObject.setMaxArea(dialog.maxArea)
+            else:
+                selMeshObject.deleteMaxArea()
+            userMeshChanged = True
+        return userMeshChanged
+            
+class EditRegionDialog(Dialog):
+    """
+    Dialog box for editing region info
+    """
+    # initial values, hard coded.
+    # should be values associated with the current mesh
+
+
+    def __init__(self,
+                 parent,
+                 tag,
+                 maxArea):
+
+
+        self.tag = tag
+        self.maxArea = maxArea
+
+        Dialog.__init__(self, parent)
+
+        
+    def body(self, master):
+        """
+        GUI description
+        """
+        self.title("Edit Region")
+        
+        Label(master,
+              text='tag:').grid(row=0, sticky=W)
+        Label(master,
+              text='Maximum Triangle Area').grid(row=1, sticky=W)
+
+
+        tagVar = StringVar()
+        tagVar.set(self.tag)
+        self.tagstr   = Entry(master,
+                                   width = 16,
+                                   textvariable = tagVar,
+                                   takefocus=1)
+
+    
+        maxAreaVar = StringVar()
+        if self.maxArea == None:
+          self.maxArea = ""  
+        maxAreaVar.set(self.maxArea)
+        self.maxAreastr   = Entry(master,
+                                   width = 16,
+                                   textvariable = maxAreaVar,
+                                   takefocus=1)
+
+        self.tagstr.grid(row=0, column=1, sticky=W)
+        self.maxAreastr.grid(row=1, column=1, sticky=W)
+
+        self.tag  = -1
+        self.maxArea  = -1
+        self.ValueOk = False
+
+
+    def apply(self):
+        """
+        check entered values
+        """
+        self.goodMaxArea = self.goodtag = True
+        self.ValueOk = True
+        try:
+            self.tag = self.tagstr.get()
+        except ValueError:
+            self.ValueOk = False
+            showerror('Bad mesh generation values',
+                                   ' Values are not numbers.')
+
+        if not self.maxAreastr.get() == "":
+            try:    
+                self.maxArea = float(self.maxAreastr.get())
+                #MeshGenDialog.lastMaxArea =self.maxArea
+            except ValueError:
+                self.ValueOk = False
+                showerror('Bad mesh generation values',
+                                   ' Values are not numbers.')
+        else:
+            self.maxArea = 0.0
+
+        try: 
+            # value checking
+            if self.goodMaxArea == True and self.maxArea < 0.0:
+                raise IOError
+            
+        except IOError:
+            self.ValueOk = False
+            showerror('Bad mesh generation values',
+                                   'Values are out of range.')
+
+       
+class vSegments(vAbstract):
+    """
+    Define the visualisation of a segment
+    """
+
+    def draw(self,v1,v2,mesh,uniqueID,scale,canvas,event):
+        """
+        draw a segment object, plus add it to the mesh data structure
+
+        event isn't used
+        """
+        segment = mesh.addUserSegment(v1,v2)
+        self.visualise(segment, uniqueID, canvas, scale)
+        return segment    
+  
+    def editWindow_int(self, canvas, selMeshObject):
+        ask_int = askinteger("Edit Segment", "Tag",
+                             minvalue=0, initialvalue= selMeshObject.tag)
+        if ask_int >= 0:
+            selMeshObject.tag = ask_int
+            
+    def editWindow(self, canvas, selMeshObject, userMeshChanged):
+        ask_string = askstring("Edit Segment Tag", "Tag",
+                              initialvalue= str(selMeshObject.tag))
+        if ask_string != None:
+            selMeshObject.tag = ask_string
+            userMeshChanged = True
+        return userMeshChanged
+    
+    def defaultWindow(self, canvas):
+        ask_string = askstring("Edit Default Segment Tag", "Tag",
+                     initialvalue= str(self.association.get_default_tag()))
+        if ask_string != None:
+            self.association.set_default_tag(ask_string)
+        
+class vTriangles(vAbstract):
+    """
+    Define the visualisation of a triangle
+    """
+
+    def draw(self,mesh,uniqueID,scale,canvas,event):
+        """
+        currently triangles have no draw function
+        """
+        raise TypeError
+
+
+class vMesh(vAbstract):
+    """
+    Define the visualisation of a collection of mesh object dictionaries (eg vSegments)
+    """
+    def __init__(self,MeshObjects):
+        self.association = mesh.MeshObject
+        self.MeshObjectsList = MeshObjects
+
+    def visualise(self, meshobject, uniqueID, canvas, scale):
+        """
+        This should find the right vAbstract instance and call visualise
+        """
+        raise Exception
+
+    def unvisualise(self, MeshObject, canvas):
+        """
+        delete a visual object and
+        delete it from the canvas mesh data structure
+        """
+        for MeshObjects in self.MeshObjectsList:
+            if isinstance(MeshObject,MeshObjects.association):
+                MeshObjects.unvisualise(MeshObject, canvas)
+                break
+            
+    def hasKey(self, key):
+        """
+        returns true if the key is in the canvas list
+        """
+        for MeshObjects in self.MeshObjectsList:
+            if MeshObjects.oncanvas.has_key(key):
+                return True
+        return False
+
+    def getMeshObject(self, key):
+        """
+        returns the mesh object,
+        given it's key.
+
+        precon:  The key is valid
+        """
+        for MeshObjects in self.MeshObjectsList:
+            try:
+                return MeshObjects.oncanvas[key]
+            except KeyError:
+                pass
+        raise KeyError
+
+    def editWindow(self, canvas, selMeshObject, userMeshChanged):
+        for MeshObjects in self.MeshObjectsList:
+            if isinstance(selMeshObject,MeshObjects.association):
+                userMeshChanged =MeshObjects.editWindow(canvas, selMeshObject,userMeshChanged)
+                break
+        return userMeshChanged
+    
+    def defaultWindow(self, canvas, MeshClass):
+        for MeshObjects in self.MeshObjectsList:
+            if MeshClass == MeshObjects.association:
+                MeshObjects.defaultWindow(canvas)
+                break 

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pymetis/__init__.py

@@ -0,0 +1,6 @@
+"""Make directory available as a Python package
+"""
+
+from numpy.testing import Tester
+test = Tester().test
+

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

@@ -0,0 +1,54 @@
+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('pymetis', parent_package, top_path)
+
+    config.add_data_dir('tests')
+
+    if parent_package is '':
+        anuga_dir = '..'
+    else:
+        anuga_dir = '.'
+        
+    METIS_DIR = 'metis-4.0'
+    
+    metis_src = [join(METIS_DIR,'*.c')]
+    metis_headers = [join(METIS_DIR,'*.h')]
+    include_dir = METIS_DIR 
+    
+    #print(metis_headers)
+    #print(metis_src)
+    #print(include_dir)
+    
+    config.add_include_dirs([include_dir])
+    
+    config.add_library('metis', sources=metis_src)
+    
+    
+    src_files = ['metis_ext.c', 'metis_bridge.c']
+    if sys.platform == 'win32':
+        src_files = src_files + ['random.c']
+        
+    
+
+    config.add_extension('metis_ext',
+                         sources=src_files,
+                         include_dirs = [include_dir],
+                         depends=(metis_src + metis_headers),
+                         extra_compile_args=['-I'+include_dir],
+                         libraries = ['metis', 'm'])
+
+    return config
+    
+if __name__ == '__main__':
+    from numpy.distutils.core import setup
+    setup(configuration=configuration)

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pymetis/tests/__init__.py

@@ -0,0 +1,8 @@
+"""Make directory available as a Python package
+"""
+
+pass
+
+
+
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pymetis/tests/test_metis.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python
+from os import sep
+from sys import path
+import sys
+
+from numpy import array, allclose
+
+import unittest
+
+# path.append('..' + sep + 'pymetis')
+
+import anuga.pymetis.metis_ext as metis
+
+class TestMetis(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def test_Hexmesh(self):
+        # Hexagonal mesh
+        #
+        #   1---2  
+        #  / \ / \
+        # 6---0---3
+        #  \ / \ /
+        #   5---4
+        #
+        # Divided 3 ways
+        # Calling order is: elements, verticies, edge list
+        # element type, number parts
+        edgecut, epart, npart = metis.partMeshNodal(6, 7,\
+                                                    [0, 1, 2,\
+                                                     0, 2, 3,\
+                                                     0, 3, 4,\
+                                                     0, 4, 5,\
+                                                     0, 5, 6,\
+                                                     0, 6, 1],\
+                                                    1,\
+                                                    3,)
+        #print edgecut
+        #print epart
+        #print npart
+        if sys.platform == 'win32':
+            epart_expected = array([2, 2, 1, 1, 1, 1], 'i')
+            npart_expected = array([1, 2, 2, 2, 1, 1, 1], 'i')
+            self.assert_(edgecut == 5)
+            assert allclose(epart, epart_expected)
+            assert allclose(npart, npart_expected)  
+        else:
+            epart_expected = array([2, 2, 0, 0, 0, 0], 'i')
+            npart_expected = array([0, 2, 2, 2, 0, 0, 0], 'i')
+            self.assert_(edgecut == 5)
+            assert allclose(epart, epart_expected)
+            assert allclose(npart, npart_expected)        
+
+
+    def test_Hexmesh2(self):
+        # Hexagonal mesh
+        #
+        #   1---2  
+        #  / \ / \
+        # 6---0---3
+        #  \ / \ /
+        #   5---4
+        #
+        # Divided 2 ways
+        # Calling order is: elements, verticies, edge list
+        # element type, number parts
+        edgecut, epart, npart = metis.partMeshNodal(6, 7,\
+                                                    [0, 2, 1,\
+                                                     0, 3, 2,\
+                                                     0, 4, 3,\
+                                                     0, 5, 4,\
+                                                     0, 6, 5,\
+                                                     0, 1, 6],\
+                                                    1,\
+                                                    2,)
+        #print edgecut
+        #print epart
+        #print npart
+        if sys.platform == 'win32':
+            epart_expected = array([1, 1, 1, 1, 1, 1], 'i')
+            npart_expected = array([1, 1, 1, 1, 1, 1, 1], 'i')
+            self.assert_(edgecut == 0)
+            assert allclose(epart, epart_expected)
+            assert allclose(npart, npart_expected)  
+        else:  
+            epart_expected = array([1, 0, 0, 0, 1, 1], 'i')
+            npart_expected = array([0, 1, 1, 0, 0, 0, 1], 'i')
+            self.assert_(edgecut == 5)
+            assert allclose(epart, epart_expected)
+            assert allclose(npart, npart_expected)
+      
+
+    def test_Hexmesh3(self):
+        # Hexagonal mesh
+        #
+        #   1---2---7 
+        #  /5\0/1\6/7\
+        # 6---0---3---8
+        #  \4/3\2/9\8/
+        #   5---4---9
+        #
+        # Divided 2 ways
+        # Calling order is: elements, verticies, edge list
+        # element type, number parts
+        edgecut, epart, npart = metis.partMeshNodal(10, 10,\
+                                                    [0, 2, 1,\
+                                                     0, 3, 2,\
+                                                     0, 4, 3,\
+                                                     0, 5, 4,\
+                                                     0, 6, 5,\
+                                                     0, 1, 6,\
+													 3, 2, 7,\
+													 3, 7, 8,\
+													 3, 8, 9,\
+													 3, 9, 4],\
+                                                    1,\
+                                                    3,)
+        #print edgecut
+        #print epart
+        #print npart
+        if sys.platform == 'win32':
+            epart_expected = array([2, 0, 2, 2, 1, 1, 0, 0, 0, 0], 'i')
+            npart_expected = array([2, 1, 0, 0, 2, 1, 1, 0, 2, 0], 'i')
+            self.assert_(edgecut == 12)
+            assert allclose(epart, epart_expected)
+            assert allclose(npart, npart_expected)  
+        else:  
+            epart_expected = array([0, 0, 0, 1, 2, 2, 2, 2, 1, 1], 'i')
+            npart_expected = array([0, 2, 0, 2, 1, 1, 2, 2, 0, 1], 'i')
+            self.assert_(edgecut == 14)
+            assert allclose(epart, epart_expected)
+            assert allclose(npart, npart_expected)
+                
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(TestMetis,'test_')
+    runner = unittest.TextTestRunner()
+    runner.run(suite)
+
+

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

@@ -0,0 +1,49 @@
+from __future__ import division, print_function, absolute_import
+
+import sys
+
+
+def configuration(parent_package='',top_path=None):
+
+    from numpy.distutils.misc_util import Configuration
+
+    config = Configuration('anuga',parent_package,top_path)
+    config.add_subpackage('abstract_2d_finite_volumes')
+    config.add_subpackage('advection')
+    config.add_subpackage('alpha_shape')
+    config.add_subpackage('caching')
+    config.add_subpackage('coordinate_transforms')
+    config.add_subpackage('culvert_flows')
+    config.add_subpackage('damage_modelling')
+    config.add_subpackage('file')
+    config.add_subpackage('file_conversion')
+    config.add_subpackage('fit_interpolate')
+    config.add_subpackage('geometry')
+    config.add_subpackage('geospatial_data')
+    config.add_subpackage('lib')
+    config.add_subpackage('load_mesh')
+    config.add_subpackage('mesh_engine')
+    config.add_subpackage('operators')
+    config.add_subpackage('parallel')
+    config.add_subpackage('pmesh')
+    config.add_subpackage('pymetis')
+    config.add_subpackage('shallow_water')
+    config.add_subpackage('structures')
+    config.add_subpackage('tsunami_source')
+    config.add_subpackage('utilities')
+    config.add_subpackage('validation_utilities')
+
+    try:
+        import vtk
+        config.add_subpackage('visualiser')
+    except:
+        pass
+        
+    config.make_config_py()
+    
+    return config
+
+if __name__ == '__main__':
+    print('This is the wrong setup.py file to run')
+    #from numpy.distutils.core import setup
+    #setup(**configuration(top_path='').todict())

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/shallow_water/__init__.py

@@ -0,0 +1,12 @@
+""" Shallow Water Wave Module.
+
+    This module performs the shallow water wave simulation, and is a
+    specialisation of the ANUGA domain. It contains supporting modules and
+    extra boundary classes to do with this specific domain.
+"""
+
+from numpy.testing import Tester
+test = Tester().test
+
+
+