Changeset 4650

Timestamp:

Aug 1, 2007, 12:14:07 PM (17 years ago)

Author:

duncan

Message:

changing what the benchmark tests.

Location:

anuga_core/source/anuga/fit_interpolate

Files:

• benchmark_least_squares.py (modified) (4 diffs)
• fit.py (modified) (1 diff)
• ticket178_benchmark.py (modified) (1 diff)

anuga_core/source/anuga/fit_interpolate/benchmark_least_squares.py

@@ -28 +28 @@
 from anuga.pmesh.mesh import Mesh
 from anuga.geospatial_data.geospatial_data import Geospatial_data
+#from anuga.shallow_water import Domain
 
 def mem_usage():
@@ -68 +69 @@
               max_points_per_cell=4,
               is_fit=True,
-              use_least_squares=False,
               use_file_type=None,
               blocking_len=500000,
@@ -86 +86 @@
                                                   save=save)
         points_dict = self._build_points_dict(num_of_points=num_of_points)
-            
-        #Initial time and memory
-        t0 = time.time()
-        #m0 = None on windows
-        m0 = mem_usage()
+
+
         if is_fit is True:
             op = "Fit_"
@@ -100 +97 @@
                        ".txt"
                        
-        if use_least_squares is True:
-            from anuga.where.least_squares import Interpolation
-            interp = Interpolation(mesh_dict['vertices'],
-                                   mesh_dict['triangles'],
-                                   points_dict['points'],
-                                   expand_search=True,
-                                   verbose = False,
-                                   max_points_per_cell = max_points_per_cell) 
-            if is_fit is True:
-                print "Fit in least squares"
-                calc = interp.fit_points(points_dict['point_attributes'])
+        #Initial time and memory
+        t0 = time.time()
+        #m0 = None on windows
+        m0 = mem_usage()
+        
+        #domain = Domain(mesh_dict['vertices'], mesh_dict['triangles'],
+         #               use_cache=False, verbose=False)
+        if is_fit is True:
+            from anuga.fit_interpolate.fit import Fit, fit_to_mesh
+
+            print "Fit in Fit"
+            if use_file_type == None:
+                points = points_dict['points']
+                point_attributes = points_dict['point_attributes']
+            else:
+                #check that the type
+                fileName = tempfile.mktemp("." + use_file_type)
+                G1 = Geospatial_data(points_dict['points'],
+                                     points_dict['point_attributes'])
+                G1.export_points_file(fileName, absolute=True)
+                points = fileName
+                point_attributes = None
                 
+            if run_profile is True:
+                    
+                s = """fit_to_mesh(mesh_dict['vertices'], mesh_dict['triangles'],points,point_attributes)"""
+                pobject = profile.Profile()
+                presult = pobject.runctx(s,
+                                         vars(sys.modules[__name__]),
+                                         vars())
+                prof_file = tempfile.mktemp(".prof")
+                presult.dump_stats(prof_file)
+                #
+                # Let process these results
+                S = pstats.Stats(prof_file)
+                saveout = sys.stdout 
+                pfile = open(profile_file, "w")
+                sys.stdout = pfile
+                s = S.sort_stats('cumulative').print_stats(30)
+                sys.stdout = saveout 
+                pfile.close()
+                os.remove(prof_file)
             else:
-                # run an interploate problem.
-                print "Interpolate!"
-                calc = interp.interpolate(mesh_dict['vertex_attributes'])
-        else: 
-            if is_fit is True:
-                from anuga.fit_interpolate.fit import Fit
-                interp = Fit(mesh_dict['vertices'],
+                fit_to_mesh(mesh_dict['vertices'],
+                            mesh_dict['triangles'],
+                            points, # this can also be a points file name
+                            point_attributes)
+            if not use_file_type == None:
+                os.remove(fileName)
+                    
+        else:
+            # run an interploate problem.
+            print "Interpolate!"
+            
+            interp = Interpolate(mesh_dict['vertices'],
                                  mesh_dict['triangles'], 
                                  max_vertices_per_cell = max_points_per_cell)
-                print "Fit in Fit"
-                if use_file_type == None:
-                    calc = interp.fit(points_dict['points'],
-                                      points_dict['point_attributes'])
-                else:
-                    #check that the type
-                    fileName = tempfile.mktemp("." + use_file_type)
-                    G1 = Geospatial_data(points_dict['points'],
-                                         points_dict['point_attributes'])
-                    G1.export_points_file(fileName, absolute=True)
-
-                    if run_profile:
-                    
-                        s = """interp.fit(fileName, verbose=verbose)"""
-                        pobject = profile.Profile()
-                        presult = pobject.runctx(s,
-                                                 vars(sys.modules[__name__]),
-                                                 vars())
-                        prof_file = tempfile.mktemp(".prof")
-                        presult.dump_stats(prof_file)
-                        #
-                        # Let process these results
-                        S = pstats.Stats(prof_file)
-                        saveout = sys.stdout 
-                        pfile = open(profile_file, "w")
-                        sys.stdout = pfile
-                        s = S.sort_stats('cumulative').print_stats(30)
-                        sys.stdout = saveout 
-                        pfile.close()
-                        os.remove(prof_file)
-                    else:
-                        interp.fit(fileName, verbose=verbose)
-                    os.remove(fileName)
+            
+            if run_profile:
+                s="""calc=interp.interpolate(mesh_dict['vertex_attributes']
+                ,points_dict['points'],start_blocking_len=blocking_len)"""
+                pobject = profile.Profile()
+                presult = pobject.runctx(s,
+                                         vars(sys.modules[__name__]),
+                                         vars())
+                prof_file = tempfile.mktemp(".prof")
+                presult.dump_stats(prof_file)
+                #
+                # Let process these results
+                S = pstats.Stats(prof_file)
+                saveout = sys.stdout 
+                pfile = open(profile_file, "w")
+                sys.stdout = pfile
+                s = S.sort_stats('cumulative').print_stats(30)
+                sys.stdout = saveout 
+                pfile.close()
+                os.remove(prof_file)
                     
             else:
-                # run an interploate problem.
-                print "Interpolate!"
-                
-                interp = Interpolate(mesh_dict['vertices'],
-                                     mesh_dict['triangles'], 
-                                 max_vertices_per_cell = max_points_per_cell)
-                
-                if run_profile:
-                    s="""calc=interp.interpolate(mesh_dict['vertex_attributes']
-                    ,points_dict['points'],start_blocking_len=blocking_len)"""
-                    pobject = profile.Profile()
-                    presult = pobject.runctx(s,
-                                             vars(sys.modules[__name__]),
-                                             vars())
-                    prof_file = tempfile.mktemp(".prof")
-                    presult.dump_stats(prof_file)
-                    #
-                    # Let process these results
-                    S = pstats.Stats(prof_file)
-                    saveout = sys.stdout 
-                    pfile = open(profile_file, "w")
-                    sys.stdout = pfile
-                    s = S.sort_stats('cumulative').print_stats(30)
-                    sys.stdout = saveout 
-                    pfile.close()
-                    os.remove(prof_file)
-                    
-                else:
-                    calc = interp.interpolate(mesh_dict['vertex_attributes']
+                calc = interp.interpolate(mesh_dict['vertex_attributes']
                                           ,points_dict['points']
                                           ,start_blocking_len = 500000)
-                
+            
         time_taken_sec = (time.time()-t0)
         m1 = mem_usage()

anuga_core/source/anuga/fit_interpolate/fit.py

@@ -465 +465 @@
         if isinstance(point_coordinates, basestring):
             # We assume that point_coordinates is the name of a .csv/.txt
-            # file which must be passed onto caching as a dependency (in case it
-            # has changed on disk)
+            # file which must be passed onto caching as a dependency 
+            # (in case it has changed on disk)
             dep = [point_coordinates]
         else:

anuga_core/source/anuga/fit_interpolate/ticket178_benchmark.py

@@ -21 +21 @@
 max_points_per_cell_list = [2,4,8,16,30,64]
 use_file_type_list = ['pts']
-#num_of_points_list = [3, 200]
+num_of_points_list = [10]
 maxArea_list = [ 0.008]
 max_points_per_cell_list = [30]