Changeset 4872


Ignore:
Timestamp:
Dec 3, 2007, 4:21:04 PM (17 years ago)
Author:
duncan
Message:

fitting benchmark update. Investigating adding neighbour triangles in fitting.

Files:
7 edited

Legend:

Unmodified
Added
Removed

  • anuga_core/source/anuga/abstract_2d_finite_volumes/neighbour_mesh.py

    r4836 r4872  
    893893               
    894894        return
     895
     896
     897    def get_triangle_neighbours(self, tri_id):
     898        """ Given a triangle id, Return an array of the
     899        3 neighbour triangle id's.
     900
     901        Negative returned triangle id's represent a boundary as a neighbour.
     902       
     903        If the given triangle id is bad, return an empty list.
     904        """
     905
     906        try:
     907            return self.neighbours[tri_id,:]
     908        except IndexError:
     909            return []
     910       

  • anuga_core/source/anuga/abstract_2d_finite_volumes/quantity.py

    r4839 r4872  
    841841            raise msg
    842842
    843         if True:  # FIXME (Ole): True takes less memory,
    844                    # but appears to be slower.
     843        if True: 
    845844            vertex_attributes = fit_to_mesh(filename,
    846845                                            mesh=self.domain, 

  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_neighbour_mesh.py

    r4856 r4872  
    12301230            id = mesh.get_triangle_containing_point(point)
    12311231            assert id == i       
    1232            
     1232
     1233    def test_get_triangle_neighbours(self):
     1234        a = [0.0, 0.0]
     1235        b = [0.0, 2.0]
     1236        c = [2.0,0.0]
     1237        e = [2.0, 2.0]
     1238        points = [a, b, c, e]
     1239        vertices = [ [1,0,2], [1,2,3] ]   #bac, bce
     1240        mesh = Mesh(points, vertices)
     1241
     1242        neighbours = mesh.get_triangle_neighbours(0)
     1243        assert allclose(neighbours, [-1,1,-1])
     1244        neighbours = mesh.get_triangle_neighbours(-10)
     1245        assert neighbours == []
     1246        neighbours = mesh.get_triangle_neighbours(2)
     1247        assert neighbours == []   
     1248
    12331249#-------------------------------------------------------------
    12341250if __name__ == "__main__":
    1235     #suite = unittest.makeSuite(Test_Mesh,'test_get_triangle_containing_point')
     1251    #suite = unittest.makeSuite(Test_Mesh,'test_two_triangles')
    12361252    suite = unittest.makeSuite(Test_Mesh,'test')
    12371253    runner = unittest.TextTestRunner()

  • anuga_core/source/anuga/fit_interpolate/benchmark_least_squares.py

    r4859 r4872  
    127127              num_of_points=20000,
    128128              maxArea=1000,
    129               max_points_per_cell=4,
     129              max_points_per_cell=13,
    130130              is_fit=True,
    131131              use_file_type=None,
    … …  
    135135              verbose=False,
    136136              run_profile=False,
    137               gridded=True):
     137              gridded=True,
     138              geo_ref=True):
    138139        '''
    139140        num_of_points
    … …  
    142143        #print "maxArea",maxArea
    143144        #print "max_points_per_cell", max_points_per_cell
    144 
    145         geo = None #Geo_reference(xllcorner = 2.0, yllcorner = 2.0)
     145        if geo_ref is True:
     146            geo = Geo_reference(xllcorner = 2.0, yllcorner = 2.0)
     147        else:
     148            geo = None
    146149        mesh_dict = self._build_regular_mesh_dict(maxArea=maxArea,
    147150                                                  is_segments=segments_in_mesh,

  • anuga_core/source/anuga/fit_interpolate/run_long_benchmark.py

    r4861 r4872  
    1818
    1919# a maxArea of 0.00001 gives 155195 triangles
    20 # Simulating Cairns. Seemed to take too long to run.  Need to Try again.
     20# Simulating Cairns.
    2121 
    22 maxArea_list = [0.00001]
    23 num_of_points_list = [1863558]
     22#maxArea_list = [0.00001]
     23#num_of_points_list = [1863558]
     24
     25# Simulating 1 tenth of Cairns.
     26 
     27#maxArea_list = [0.0001]
     28#num_of_points_list = [186558]
    2429
    2530# a maxArea of 0.0001 gives 15568 triangles
    … …  
    4045# 132 points/tri is 42108
    4146#maxArea_list = [0.005]
    42 #num_of_points_list = [957,6380,42108]
     47num_of_points_list = [957,6380,42108]
    4348
    4449# a maxArea of 0.01 gives 150 triangles
    … …  
    5055
    5156# Quick check
    52 # maxArea_list = [0.61]
     57#maxArea_list = [0.61]
    5358#num_of_points_list = [4]
     59
     60# the auto-validate benchmark fit
     61maxArea_list = [0.0001]
     62num_of_points_list = [1000]
    5463
    5564
    5665
    57 
    58 max_points_per_cell_list = [13]
     66max_points_per_cell_list = [4]
    5967use_file_type_list = ['pts']
    60 run_profile =   True #False # True #True # False #
    61 gridded_list = [True] #, False]
    62 
     68run_profile =  False # True #True # False #
     69gridded_list = [True, False]
     70geo_ref_list = [True, False]
    6371
    6472if run_profile is True:
    … …  
    7684         "is_fit" + delimiter +
    7785         "is_gridded" + delimiter +
     86         "has_geo_ref" + delimiter +
    7887         "search_one_cell_time" + delimiter +
    7988         "search_more_cells_time" + delimiter +
    … …  
    8594for is_fit in is_fit_list:
    8695    for gridded in gridded_list:
    87         for maxArea in maxArea_list:
    88             for use_file_type in use_file_type_list:
    89                 for num_of_points in num_of_points_list:
    90                     for max_points_per_cell in max_points_per_cell_list:
     96        for geo_ref in geo_ref_list:
     97            for maxArea in maxArea_list:
     98                for use_file_type in use_file_type_list:
     99                    for num_of_points in num_of_points_list:
     100                        for max_points_per_cell in max_points_per_cell_list:
    91101   
    92                         time, mem, num_tri, one_t, more_t, quad_t = ben.trial(
    93                             num_of_points=num_of_points
    94                             ,maxArea=maxArea
    95                             ,max_points_per_cell=max_points_per_cell
    96                             ,is_fit=is_fit
    97                             ,segments_in_mesh=False
    98                             ,use_file_type=use_file_type
    99                             ,save=True
    100                             ,verbose=False
    101                             ,run_profile=run_profile
    102                             ,gridded=gridded
    103                         )
    104                     print "time",time
    105                     print "mem", mem
    106                     print "num_tri", num_tri
    107                     fd.write(str(use_file_type) + delimiter +
    108                              str(num_of_points) + delimiter +
    109                              str(maxArea) + delimiter +
    110                              str(num_tri) + delimiter +
    111                              str(max_points_per_cell) + delimiter +
    112                              str(is_fit) + delimiter +
    113                              str(gridded) + delimiter +
    114                              str(one_t) + delimiter +
    115                              str(more_t) + delimiter +
    116                              str(quad_t) + delimiter +
    117                              str(mem)  + delimiter +
    118                              str(time) + delimiter + "\n")
     102                            time, mem, num_tri, one_t, more_t, quad_t = ben.trial(
     103                                num_of_points=num_of_points
     104                                ,maxArea=maxArea
     105                                ,max_points_per_cell=max_points_per_cell
     106                                ,is_fit=is_fit
     107                                ,segments_in_mesh=False
     108                                ,use_file_type=use_file_type
     109                                ,save=True
     110                                ,verbose=False
     111                                ,run_profile=run_profile
     112                                ,gridded=gridded
     113                                ,geo_ref=geo_ref
     114                                )
     115                            print "time",time
     116                            print "mem", mem
     117                            print "num_tri", num_tri
     118                            fd.write(str(use_file_type) + delimiter +
     119                                     str(num_of_points) + delimiter +
     120                                     str(maxArea) + delimiter +
     121                                     str(num_tri) + delimiter +
     122                                     str(max_points_per_cell) + delimiter +
     123                                     str(is_fit) + delimiter +
     124                                     str(gridded) + delimiter +
     125                                     str(geo_ref) + delimiter +
     126                                     str(one_t) + delimiter +
     127                                     str(more_t) + delimiter +
     128                                     str(quad_t) + delimiter +
     129                                     str(mem)  + delimiter +
     130                                     str(time) + delimiter + "\n")
    119131fd.close()                         

  • anuga_core/source/anuga/fit_interpolate/search_functions.py

    r4859 r4872  
    5656    # Search the last triangle first
    5757    element_found, sigma0, sigma1, sigma2, k = \
    58                    _search_triangles_of_vertices(mesh,
    59                                                  last_triangle, x)
     58                   _search_triangles_of_vertices(mesh,last_triangle, x)
    6059    #print "last_triangle", last_triangle
    6160    if element_found is True:
    6261        #print "last_triangle", last_triangle
    6362        return element_found, sigma0, sigma1, sigma2, k
    64        
    65    
    66    
     63
     64    # This was only slightly faster than just checking the
     65    # last triangle and it significantly slowed down
     66    # non-gridded fitting
     67    # If the last element was a dud, search its neighbours
     68    #print "last_triangle[0][0]", last_triangle[0][0]
     69    #neighbours = mesh.get_triangle_neighbours(last_triangle[0][0])
     70    #print "neighbours", neighbours
     71    #neighbours = []
     72  #   for k in neighbours:
     73#         if k >= 0:
     74#             tri = mesh.get_vertex_coordinates(k,
     75#                                                    absolute=True)
     76#             n0 = mesh.get_normal(k, 0)
     77#             n1 = mesh.get_normal(k, 1)
     78#             n2 = mesh.get_normal(k, 2)
     79#             triangle =[[k,(tri, (n0, n1, n2))]]
     80#             element_found, sigma0, sigma1, sigma2, k = \
     81#                            _search_triangles_of_vertices(mesh,
     82#                                                          triangle, x)
     83#             if element_found is True:
     84#                 return element_found, sigma0, sigma1, sigma2, k
     85           
    6786    #t0 = time.time()
    6887    # Get triangles in the cell that the point is in.

  • anuga_validation/automated_validation_tests/fitting/validate_benchmark_fit.py

    r4866 r4872  
    2020    # FIXME test the time to put .pts elevation into a domain object
    2121    # FIXME do tests for interpolate as well.
     22
     23    # A version round 4872 has slower times.
     24    # That's because v4872 is using geo-ref, whereas the
     25    # previous version did not.
    2226    def test_fit_time_and_mem(self):
    2327        import socket
    … …  
    3741        if host.find('tornado') == 0 or host.find('compute-1') == 0:
    3842            # Tornado headnode or node
    39             time_standard = 11.5
     43            time_standard = 14.5
    4044            self.assert_(time<time_standard*1.2)
    41             mem_standard = 21280
     45            mem_standard = 21340
    4246            self.assert_(mem<mem_standard*1.2)
    4347           
    4448        elif host.find('compute-0') == 0: # cyclone node
    45             time_standard = 17.0
     49            time_standard = 19.0
    4650            self.assert_(time<time_standard*1.2)
    47             mem_standard = 21168
     51            mem_standard = 21300
    4852            self.assert_(mem<mem_standard*1.2)
    4953
    5054        elif host.find('cyclone') == 0: # cyclone headnode
    51             time_standard = 11.8
     55            time_standard = 13.3
    5256            self.assert_(time<time_standard*1.2)
    53             mem_standard = 20500
     57            mem_standard = 20560
    5458            self.assert_(mem<mem_standard*1.2)
    5559
    … …  
    6165
    6266        elif host.find('pc-31569') == 0: # DSG's PC
    63             time_standard = 26.1
     67            time_standard = 31.6
    6468            self.assert_(time<time_standard*1.2)
    6569           
Note: See TracChangeset for help on using the changeset viewer.