anuga 1.3.5__zip

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

@@ -0,0 +1,189 @@
+import unittest
+import numpy as num
+
+from anuga.geometry.aabb import AABB
+from anuga.geometry.quad import Cell
+from anuga.pmesh.mesh_quadtree import MeshQuadtree
+from anuga.abstract_2d_finite_volumes.general_mesh import General_mesh as Mesh
+
+import sys
+
+#-------------------------------------------------------------
+
+class Test_Quad(unittest.TestCase):
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_build_quadtree(self):
+
+        a = [3, 7]
+        b = [5, 7]
+        c = [5, 5]
+        d = [7, 7]
+        e = [15, 15]
+        f = [15, 30]
+        g = [30, 10]
+        h = [30, 30]
+
+        points = [a, b, c, d, e, f, g, h]
+        
+        #bac, bce, ecf, dbe, daf, dae
+        vertices = [[1,0,2], [1,3,4], [1,2,3], [5,4,7], [4,6,7]]
+
+        mesh = Mesh(points, vertices)
+    
+        Q = MeshQuadtree(mesh)
+        #Q.show()
+        #print Q.count()
+        self.assertEqual(Q.count(), len(vertices))
+
+        # test a point that falls within a triangle
+        result = Q.search([10, 10])
+        assert isinstance(result, (list, tuple)), 'should be a list'
+         
+        # Padarn Note: The result of Q.search is no longer in 
+        # the same format, and so this test fails. However, the 
+        # old functionality does not seem to be needed.                    
+        #self.assertEqual(result[0][0][0], 1)
+
+
+    def test_build_quadtreeII(self):
+
+        self.cell = Cell(AABB(100, 140, 0, 40), 'cell')
+
+        p0 = [34.6292076111,-7999.92529297]
+        p1 = [8000.0, 7999.0]
+        p2 = [-7999.96630859, 7999.0]
+        p3 = [34, 7999.97021484]
+
+        points = [p0,p1,p2, p3]
+        #bac, bce, ecf, dbe, daf, dae
+        vertices = [[0,1,2],[0,3,2]]
+
+        mesh = Mesh(points, vertices)
+
+        #This was causing round off error
+        Q = MeshQuadtree(mesh)
+        
+    def NOtest_interpolate_one_point_many_triangles(self):
+        # this test has 10 triangles that share the same vert.
+        # If the number of points per cell in  a quad tree is less
+        # than 10 it should crash 
+        z0 = [2.0, 5.0]
+        z1 = [2.0, 5.0]
+        z2 = [2.0, 5.0]
+        z3 = [2.0, 5.0]
+        z4 = [2.0, 5.0]
+        z5 = [2.0, 5.0]
+        z6 = [2.0, 5.0]
+        z7 = [2.0, 5.0]
+        z8 = [2.0, 5.0]
+        z9 = [2.0, 5.0]
+        z10 = [2.0, 5.0]
+        
+        v0 = [0.0, 0.0]
+        v1 = [1.0, 0.0]
+        v2 = [2.0, 0.0]
+        v3 = [3.0, 0.0]
+        v4 = [4.0, 0.0]
+        v5 = [0.0, 10.0]
+        v6 = [1.0, 10.0]
+        v7 = [2.0, 10.0]
+        v8 = [3.0, 10.0]
+        v9 = [4.0, 10.0]
+
+        vertices = [z0,v0, v1, v2, v3,v4 ,v5, v6, v7, v8, v9,
+                    z1, z2, z3, z4, z5, z6, z7, z8, z9]
+        triangles = [
+                      [11,1,2],
+                      [12,2,3],
+                      [13,3,4],
+                      [14,4,5],
+                      [7,6,15],
+                      [8,7,16],
+                      [9,8,17],
+                      [10,9,18],
+                      [6,1,19],
+                      [5,10,0]
+                      ]
+        
+        mesh = Mesh(vertices, triangles)
+        try:
+            Q = MeshQuadtree(mesh, max_points_per_cell = 9)
+        except RuntimeError:
+            pass
+        else:
+            self.assertTrue(0 ==1,  'many verts at the same position no  \
+            longer causes as error')
+    
+    def test_retrieve_triangles(self):
+
+        cell = Cell(AABB(0, 6, 0, 6), 'cell')
+
+        p0 = [2,1]
+        p1 = [4,1]
+        p2 = [4.,4]
+        p3 = [2,4]
+        p4 = [5,4]
+
+        points = [p0,p1,p2, p3, p4]
+        #
+        vertices = [[0,1,2],[0,2,3],[1,4,2]]
+
+        mesh = Mesh(points, vertices)
+
+        Q = MeshQuadtree(mesh)
+        results = Q.search([4.5, 3])
+        # Padarn Note: The result of Q.search is no longer in 
+        # the same format, and so this test fails. However, the 
+        # old functionality does not seem to be needed. 
+        #assert len(results) == 1
+        #self.assertEqual(results[0][0][0], 2)
+        #results = Q.search([5,4.])
+        #self.assertEqual(len(results),1)
+        #self.assertEqual(results[0][0][0], 2)
+        
+    def NOtest_num_visits(self):
+        """ Test optimisation code.
+        """
+        a = [3, 7]
+        b = [5, 7]
+        c = [5, 5]
+        d = [7, 7]
+        e = [15, 15]
+        f = [15, 30]
+        g = [30, 10]
+        h = [30, 30]
+
+        points = [a, b, c, d, e, f, g, h]
+        
+        #bac, bce, ecf, dbe, daf, dae
+        vertices = [[1,0,2], [1,3,4], [1,2,3], [5,4,7], [4,6,7]]
+
+        mesh = Mesh(points, vertices)
+
+        Q = MeshQuadtree(mesh)    
+
+
+        results = Q.search_fast([5.5, 5.5])
+        print 'visits: ', Q.count_visits()
+        
+        Q.clear_visits()
+        results = Q.search_fast([30, 10])
+        print 'visits: ', Q.count_visits()
+        
+        print 'second time:'
+
+        Q.clear_visits()        
+        results = Q.search_fast([5.5, 5.5])
+        print 'visits: ', Q.count_visits()
+################################################################################
+
+if __name__ == "__main__":
+    mysuite = unittest.makeSuite(Test_Quad,'test')
+    runner = unittest.TextTestRunner()
+    runner.run(mysuite)

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

@@ -0,0 +1,150 @@
+"""
+Script to measure how long pmesh spends doing various methods
+"""
+from mesh import *
+from anuga.pmesh import *
+import time
+ 
+def mem_usage():
+    '''
+    returns the rss.
+
+  RSS  The total amount of physical memory used by  the  task,  in  kilo-
+            bytes,  is  shown  here.  For ELF processes used library pages are
+            counted here, for a.out processes not.
+            
+    Only works on nix systems.
+    '''
+    import string
+    p=os.popen('ps uwp %s'%os.getpid()) 
+    lines=p.readlines()
+    #print "lines", lines
+    status=p.close() 
+    if status or len(lines)!=2 or sys.platform == 'win32': 
+        return None 
+    return int(string.split(lines[1])[4]) 
+
+
+
+#draw = Draw()
+#draw.run()
+n = 2
+maxArea = 0.00005
+#maxArea = 0.1
+times = []
+tinitial = time.time()
+mem_initial = mem_usage()
+print "mem_initial", mem_initial
+#------------------------------------------
+mesh = Mesh()
+id = 0
+for i in range(n):
+    for j in range(n):
+       v = mesh.addUserVertex(i,j)
+       v.guiID = id
+       id += 1
+v1 = mesh.addUserVertex(-1,-1)
+v1.guiID = id
+id += 1
+v2 = mesh.addUserVertex(-1,n)
+v2.guiID = id
+id += 1
+v3 = mesh.addUserVertex(n,n)
+v3.guiID = id
+id += 1
+v4 = mesh.addUserVertex(n,-1)
+v4.guiID = id
+id += 1
+mesh.addUserSegment(v1,v2)
+mesh.addUserSegment(v2,v3)
+mesh.addUserSegment(v3,v4)
+mesh.addUserSegment(v4,v1)
+mem_now =mem_usage()
+#print "mem_now", mem_now
+if mem_now is not None:
+    mem = mem_now - mem_initial
+else:
+    mem = 0.0
+times.append(("user_outline_created",time.time() - tinitial, mem ))
+#------------------------------------------
+mesh.generateMesh(mode = "Q",maxArea = maxArea)
+mem_now =mem_usage()
+#print "mem_now", mem_now
+if mem_now is not None:
+    mem = mem_now - mem_initial
+else:
+    mem = 0.0
+times.append(("mesh_generated",time.time()- tinitial - times[0][1], mem))
+#------------------------------------------
+mesh.export_mesh_file("dump.msh")
+mem_now =mem_usage()
+#print "mem_now", mem_now
+if mem_now is not None:
+    mem = mem_now - mem_initial
+else:
+    mem = 0.0
+times.append(("export_mesh_file",time.time()- tinitial - times[1][1], mem))
+
+#---------------------
+print "Number of user verts. ", n
+print "maxArea",maxArea
+print "funtion     time   memory usage, cumulative, for nix machines"
+for time in times:
+    print "%s   %0.2f   %0.2f" %(time[0],  time[1], time[2])
+
+"""
+#Results - mesh.py ver   1.84 	       	1.85	
+# N	400	
+# initial			0		0
+# user_outline_created	1.467999935	1.609999895
+# mesh_generated       	21.70300007	22.3440001
+#zoomed			32.81299996	33.5940001
+
+# results on dsg's pc dell precision 390.
+# anuga version 4897
+Number of user verts.  2
+maxArea 0.0001
+user_outline_created   0.00
+mesh_generated   4.92
+export_mesh_file   16.30
+
+Number of user verts.  2
+maxArea 0.0001
+user_outline_created   0.00
+mesh_generated   4.92
+export_mesh_file   16.30
+
+Number of user verts.  2
+maxArea 5e-005
+user_outline_created   0.00
+mesh_generated   15.53
+export_mesh_file   41.39
+
+version 4903
+mem_initial None
+Number of user verts.  2
+maxArea 5e-005
+funtion     time   memory usage, cumulative, for nix machines
+user_outline_created   0.49   0.00
+mesh_generated   1.94   0.00
+export_mesh_file   2.75   0.00
+
+# anuga version 4897 
+Results of tornado head node
+Number of user verts.  2
+maxArea 5e-05
+funtion     time   memory usage, cumulative, for nix machines
+user_outline_created   0.14   32.00
+mesh_generated   18.81   378304.00
+export_mesh_file   17.79   380620.00
+
+version 4903
+mem_initial 77816
+Number of user verts.  2
+maxArea 5e-05
+funtion     time   memory usage, cumulative, for nix machines
+user_outline_created   0.15   32.00
+mesh_generated   1.26   27224.00
+export_mesh_file   0.82   27224.00
+
+"""

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

@@ -0,0 +1,80 @@
+from Tkinter import *
+import string, time
+from os.path import join
+
+class ToolBarButton(Label):
+    def __init__(self, top, parent, tag=None, image=None, command=None,
+                 statushelp='', balloonhelp='', height=21, width=21,
+                 bd=1, activebackground='lightgrey', padx=0, pady=0,
+                 state='normal', bg='grey', home_dir=''):
+        Label.__init__(self, parent, height=height, width=width,
+                       relief='flat', bd=bd, bg=bg)
+
+
+        self.bg = bg 
+        self.activebackground = activebackground
+        if image != None:
+            if string.splitfields(image, '.')[1] == 'bmp':
+                self.Icon = BitmapImage(file=join(home_dir,'icons/%s' % image))
+            else:
+                self.Icon = PhotoImage(file=join(home_dir,'icons/%s' % image))
+        else:
+                self.Icon = PhotoImage(file=join(home_dir,'icons/blank.gif'))
+        self.config(image=self.Icon)
+        self.tag = tag
+        self.icommand = command
+        self.command  = self.activate
+        self.bind("<Enter>",           self.buttonEnter)
+        self.bind("<Leave>",           self.buttonLeave)
+        self.bind("<ButtonPress-1>",   self.buttonDown)
+        self.bind("<ButtonRelease-1>", self.buttonUp)
+        self.pack(side='left', anchor=NW, padx=padx, pady=pady)
+        if balloonhelp or statushelp:
+            top.balloon().bind(self, balloonhelp, statushelp)
+        self.state = state    
+      
+    def activate(self):
+        self.icommand(self.tag)
+
+    def buttonEnter(self, event):
+        if self.state != 'disabled':
+            self.config(relief='raised', bg=self.bg)
+
+    def buttonLeave(self, event):
+        if self.state != 'disabled':
+            self.config(relief='flat', bg=self.bg)
+
+    def buttonDown(self, event):
+        if self.state != 'disabled':
+            self.config(relief='sunken', bg=self.activebackground)
+    
+    def buttonUp(self, event):
+        if self.state != 'disabled':
+            if self.command != None:
+                self.command()
+            time.sleep(0.05)
+            if (self in ToolBarButton.cyclelist):
+                if (ToolBarButton.sunkenbutton) and ToolBarButton.sunkenbutton != self:
+                    ToolBarButton.sunkenbutton.config(relief='flat', bg=self.bg)
+                ToolBarButton.sunkenbutton = self
+            else:
+                self.config(relief='flat', bg=self.bg)  
+
+    def enable(self):
+        self.state = 'normal'
+
+    def disable(self):
+        self.state = 'disabled'
+
+    def cycle(self, name):
+        """Add button to list of buttons where one is left sunken, untill
+        the next button is pressed."""
+        ToolBarButton.cyclelist.append(self)
+    def setInitialSunkenButton(self, name):
+        if not ToolBarButton.sunkenbutton:
+            ToolBarButton.sunkenbutton = self
+            self.config(relief='sunken', bg=self.activebackground)
+            
+    #class variable
+    cyclelist = []
+    sunkenbutton = None

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

@@ -0,0 +1,69 @@
+
+#-------------------------------------------------------------
+if __name__ == "__main__":
+
+        import tempfile
+        import os
+    
+        from anuga.shallow_water import Domain, Reflective_boundary, \
+                            Dirichlet_boundary
+       
+        from anuga.pmesh.mesh_interface import create_mesh_from_regions
+        
+        # Create a scenario outline.
+        polygon = [[0,0],[100,0],[100,100],[0,100]]
+        
+        boundary_tags = {'wall':[0,1,3],'wave':[2]}
+        
+        inner1_polygon = [[10,10],[20,10],[20,20],[10,20]]
+        
+
+        inner2_polygon = [[30,30],[40,30],[40,40],[30,40]]
+        
+        
+        max_area = 1
+        interior_regions = [(inner1_polygon, 5),(inner2_polygon, 10)]
+        m = create_mesh_from_regions(polygon,
+                                     boundary_tags,
+                                     max_area,
+                                     interior_regions=interior_regions)
+
+        # Create an ungenerate file            
+        fileName = tempfile.mktemp(".txt")
+        file = open(fileName,"w")
+        file.write("         1       ??      ??\n\
+       90.0       90.0\n\
+       81.0       90.0\n\
+       81.0       81.0\n\
+       90.0       81.0\n\
+       90.0       90.0\n\
+END\n\
+         2      ?? ??\n\
+       10.0       80.0\n\
+       10.0       90.0\n\
+       20.0       90.0\n\
+       10.0       80.0\n\
+END\n\
+END\n")
+        file.close() 
+
+        # import the ungenerate file
+        m.import_ungenerate_file(fileName) 
+        os.remove(fileName)
+	
+        m.generate_mesh(maximum_triangle_area=max_area,verbose=False)
+        mesh_filename = "mesh.tsh"
+        m.export_mesh_file(mesh_filename)
+
+	# Run a simulation on the mesh
+        domain = Domain(mesh_filename, use_cache = False)
+        
+        Br = Reflective_boundary(domain)
+        Bd = Dirichlet_boundary([3,0,0]) 
+        domain.set_boundary( {'wall': Br, 'wave': Bd} )
+        yieldstep = 0.1
+        finaltime = 20
+        for t in domain.evolve(yieldstep, finaltime):    
+            domain.write_time()
+
+            

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

@@ -0,0 +1,47 @@
+"""
+Script to view tsh file using faster vpython graphics
+"""
+import sys
+from os import sep, path
+sys.path.append('..'+sep+'pyvolution')
+
+
+from shallow_water import Domain
+from anuga.pyvolution.pmesh2domain import pmesh_to_domain_instance
+from anuga.pyvolution.util import file_function
+from anuga.geometry.polygon import read_polygon
+from anuga.geometry.polygon_function import Polygon_function
+from realtime_visualisation_new import *
+
+#-------
+# Domain
+
+
+#-------------------------------------------------------------
+if __name__ == "__main__":
+    """
+    View a mesh and data points with attributes.
+    """
+    import os, sys
+    usage = "usage: %s mesh_input.tsh scale_z"%os.path.basename(sys.argv[0])
+
+    #print len(sys.argv)
+    #print sys.argv
+
+    if len(sys.argv) < 2:
+        print usage
+    else:
+        mesh_file = sys.argv[1]
+
+        scale_z = 1.0
+        if len(sys.argv) > 2:
+            scale_z = float(sys.argv[2])
+
+
+
+    print 'Creating domain from', mesh_file
+    domain = pmesh_to_domain_instance(mesh_file, Domain)
+    print "Number of triangles = ", len(domain)
+
+    visualiser =  Visualiser(domain, scale_z = scale_z)
+    visualiser.update_quantity('stage')