Changeset 1969

Timestamp:

Oct 25, 2005, 10:49:31 AM (19 years ago)

Author:

duncan

Message:

still in development. testing memory measurement.

File:

• inundation/fit_interpolate/benchmark_least_squares.py (modified) (4 diffs)

inundation/fit_interpolate/benchmark_least_squares.py

@@ -2 +2 @@
 
    measure the speed of least squares.
+
+   ________________________
+   General comments
+   
+   The max_points_per_cell does effect the time spent solving a
+   problem.  The best value to use is probably dependent on the number
+   of triangles.  Maybe develop a simple imperical algorithm, based on
+   test results.
    
    Ole Nielsen, Stephen Roberts, Duncan Gray, Christopher Zoppou
@@ -15 +23 @@
 from pyvolution.least_squares import Interpolation
 from Numeric import allclose, array, transpose
-
-from coordinate_transforms.geo_reference import Geo_reference
-
-def distance(x, y):
-    return sqrt( sum( (array(x)-array(y))**2 ))
-
-def linear_function(point):
-    point = array(point)
-    return point[:,0]+point[:,1]
+import os
+
+def report_memory(i):
+    pid = os.getpid()
+    a2 = os.popen('ps -p %d -o rss,sz' % pid).readlines()
+    print i, '  ', a2[1],
+    return int(a2[1].split()[1])
+
+
+def showmem(): os.system("ps axm | head -1 ; ps axm | grep py | grep -v grep")
+
+def mem_usage(pid):
+    import string
+    p=os.popen('ps uwp %s'%pid) 
+    lines=p.readlines()
+    print "lines", lines
+    status=p.close() 
+    if status or len(lines)!=2: 
+        return None 
+    return int(string.split(lines[1])[4]) 
+
+
 
 
@@ -34 +55 @@
         pass
 
-    def test_expand_search2(self):
+    def ztest_expand_search2(self):
         from random import seed, random
         from pmesh.mesh import Mesh
@@ -75 +96 @@
         #print 'points', points
         t0 = time.time()
+
         interp = Interpolation(mesh_dict['vertices'],
                                mesh_dict['triangles'], points,
-                               alpha=0.2, expand_search=False, #True,
+                               alpha=0.2, expand_search=True,
                                verbose = False,
                                max_points_per_cell = 4)
         calc = interp.fit_points(point_atts )
+        #print "interp.expanded_quad_searches", interp.expanded_quad_searches
         #print "calc", calc
         print 'That took %.2f seconds' %(time.time()-t0)
+
+        
+    def test_expand_search3(self):
+        from random import seed, random
+        from pmesh.mesh import Mesh
+
+        # takes 7.73 seconds
+        #num_of_points = 20000
+        #maxArea = 1000
+        #max_points_per_cell = 4
+
+        # took 9.84 secs
+        #num_of_points = 20000
+        #maxArea = 100
+        #max_points_per_cell = 4
+
+        # 16.61 secs
+        num_of_points = 20000
+        maxArea = 10 #836 basis functions
+        #max_points_per_cell = 4 #16.61 sec
+        
+        #max_points_per_cell = 30 #31.17 sec
+        #max_points_per_cell = 2 #16.125 sec
+        max_points_per_cell = 8 #17.66 sec
+
+        
+        # 16.61 secs
+        num_of_points = 20000
+        maxArea = 1 #7917 basis functions
+        max_points_per_cell = 4 # 76.047 sec
+        
+        #max_points_per_cell = 30 #
+        #max_points_per_cell = 2 #78.97 sec
+        #max_points_per_cell = 16 # 82.33 sec
+        #max_points_per_cell = 8 #77.984 sec
+        
+        # 8.44 secs
+        #num_of_points = 20000
+        #maxArea = 1
+        
+        
+        seed(2)
+        m = Mesh()
+        m.addUserVertex(0,0)
+        m.addUserVertex(100,0)
+        m.addUserVertex(0,100)
+        m.addUserVertex(100,100)
+        
+        m.autoSegment(alpha = 100 )
+        
+        dict = {}
+        dict['points'] = [[10,10],[90,20]]
+        dict['segments'] = [[0,1]] 
+        dict['segment_tags'] = ['wall1']   
+        m.addVertsSegs(dict)
+    
+        dict = {}
+        dict['points'] = [[10,90],[40,20]]
+        dict['segments'] = [[0,1]] 
+        dict['segment_tags'] = ['wall2']   
+        m.addVertsSegs(dict)
+        
+        dict = {}
+        dict['points'] = [[20,90],[60,60]]
+        dict['segments'] = [[0,1]] 
+        dict['segment_tags'] = ['wall3'] 
+        m.addVertsSegs(dict)
+        
+        dict = {}
+        dict['points'] = [[60,20],[90,90]]
+        dict['segments'] = [[0,1]] 
+        dict['segment_tags'] = ['wall4']   
+        m.addVertsSegs(dict)
+        
+        m.addVertsSegs(dict)
+        m.generateMesh(mode = "Q", maxArea = maxArea)
+        m.export_mesh_file("aaaa.tsh")
+        mesh_dict =  m.Mesh2IOTriangulationDict()
+
+        points = []
+        point_atts = []
+        for point in range(num_of_points):
+            points.append([random()*100, random()*100])
+            point_atts.append(10.0)
+        #m.autoSegment(alpha = 100 )
+
+        #print 'points', points
+        t0 = time.time()
+        interp = Interpolation(mesh_dict['vertices'],
+                               mesh_dict['triangles'], points,
+                               alpha=0.2, expand_search=True,
+                               verbose = True, #False,
+                               max_points_per_cell = max_points_per_cell)
+        calc = interp.fit_points(point_atts )
+        print "interp.expanded_quad_searches", interp.expanded_quad_searches
+        #print "calc", calc
+        print 'That took %.2f seconds' %(time.time()-t0)
         
 #-------------------------------------------------------------
 if __name__ == "__main__":
+    import os
+    #val = report_memory(1)
+    show_me = 'ps v %d' % os.getpid()
+    os.system(show_me)
     suite = unittest.makeSuite(Test_Least_Squares,'test')
     runner = unittest.TextTestRunner(verbosity=1)
-    runner.run(suite)
+    #runner.run(suite)
+    os.system(show_me)
+    #end = report_memory(2)
+    val = mem_usage(os.getpid())
+    print 'val', val